@thatopen/components 2.0.10 → 2.0.11

package/dist/namespace.d.ts

@@ -1,49 +1,4 @@
 declare namespace OBC {
-import * as THREE from "three";
-import { Components } from "../Components";
-import { Component } from "../Types";
-/**
- * A tool to safely remove meshes and geometries from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
- */
-export declare class Disposer extends Component {
-    private _disposedComponents;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
-    constructor(components: Components);
-    /**
-     * Return the UUIDs of all disposed components.
-     */
-    get(): Set<string>;
-    /**
-     * Removes a mesh, its geometry and its materials from memory. If you are
-     * using any of these in other parts of the application, make sure that you
-     * remove them from the mesh before disposing it.
-     *
-     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
-     * to remove.
-     *
-     * @param materials - whether to dispose the materials of the mesh.
-     *
-     * @param recursive - whether to recursively dispose the children of the mesh.
-     */
-    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
-    /**
-     * Disposes a geometry from memory.
-     *
-     * @param geometry - the
-     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
-     * to remove.
-     */
-    disposeGeometry(geometry: THREE.BufferGeometry): void;
-    private disposeGeometryAndMaterials;
-    private disposeChildren;
-    private static disposeMaterial;
-}
 import { Component, Disposable, Event } from "../Types";
 /**
  * The entry point of the Components library. It can create and access all the components of the library globally, update all the updatable components automatically and dispose all the components, preventing memory leaks.
@@ -52,7 +7,7 @@ export declare class Components implements Disposable {
     /**
      * The version of the @thatopen/components library.
      */
-    static readonly release = "2.0.8";
+    static readonly release = "2.0.11";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<void>;
     /**
@@ -67,30 +22,30 @@ export declare class Components implements Disposable {
     enabled: boolean;
     private _clock;
     /**
-   * 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
-   */
+     * 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
+     */
     add(uuid: string, instance: Component): void;
     /**
-   * Retrieves a component instance by its constructor function.
-   * If the component does not exist in the list, it will be created and added.
-   *
-   * @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
-   */
+     * Retrieves a component instance by its constructor function.
+     * If the component does not exist in the list, it will be created and added.
+     *
+     * @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
+     */
     get<U extends Component>(Component: new (components: Components) => U): U;
     constructor();
     /**
@@ -120,6 +75,51 @@ export declare class Components implements Disposable {
     private update;
     private static setupBVH;
 }
+import * as THREE from "three";
+import { Components } from "../Components";
+import { Component } from "../Types";
+/**
+ * A tool to safely remove meshes and geometries from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+ */
+export declare class Disposer extends Component {
+    private _disposedComponents;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
+    constructor(components: Components);
+    /**
+     * Return the UUIDs of all disposed components.
+     */
+    get(): Set<string>;
+    /**
+     * Removes a mesh, its geometry and its materials from memory. If you are
+     * using any of these in other parts of the application, make sure that you
+     * remove them from the mesh before disposing it.
+     *
+     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
+     * to remove.
+     *
+     * @param materials - whether to dispose the materials of the mesh.
+     *
+     * @param recursive - whether to recursively dispose the children of the mesh.
+     */
+    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
+    /**
+     * Disposes a geometry from memory.
+     *
+     * @param geometry - the
+     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
+     * to remove.
+     */
+    disposeGeometry(geometry: THREE.BufferGeometry): void;
+    private disposeGeometryAndMaterials;
+    private disposeChildren;
+    private static disposeMaterial;
+}
 import { Component, Disposable, World, Event } from "../Types";
 import { SimpleRaycaster } from "./src";
 import { Components } from "../Components";
@@ -417,40 +417,6 @@ import * as THREE from "three";
 export declare class MaterialsUtils {
     static isTransparent(material: THREE.Material): boolean;
 }
-export declare class UUID {
-    private static _pattern;
-    private static _lut;
-    static create(): string;
-    static validate(uuid: string): void;
-}
-import * as THREE from "three";
-import { Component, Components, Event, World } from "../core";
-export interface VertexPickerConfig {
-    showOnlyVertex: boolean;
-    snapDistance: number;
-    previewElement: HTMLElement;
-}
-export declare class VertexPicker extends Component {
-    onVertexFound: Event<THREE.Vector3>;
-    onVertexLost: Event<THREE.Vector3>;
-    components: Components;
-    private _pickedPoint;
-    private _config;
-    private _enabled;
-    private _workingPlane;
-    set enabled(value: boolean);
-    get enabled(): boolean;
-    constructor(components: Components, config?: Partial<VertexPickerConfig>);
-    set workingPlane(plane: THREE.Plane | null);
-    get workingPlane(): THREE.Plane | null;
-    set config(value: Partial<VertexPickerConfig>);
-    get config(): Partial<VertexPickerConfig>;
-    dispose(): void;
-    get(world: World): THREE.Vector3 | null;
-    private getClosestVertex;
-    private getVertices;
-    private getVertex;
-}
 import { Components } from "../Components";
 import { MeshCullerRenderer, CullerRendererSettings } from "./src";
 import { Component, Event, Disposable, World } from "../Types";
@@ -499,53 +465,6 @@ export declare class Cullers extends Component implements Disposable {
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
-import { MiniMap } from "./src";
-import { Component, Updateable, World, Event, Disposable } from "../Types";
-import { Components } from "../Components";
-/**
- * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID.
- */
-export declare class MiniMaps extends Component implements Updateable, Disposable {
-    /**
-   * A unique identifier for the component.
-   * This UUID is used to register the component within the Components system.
-   */
-    static readonly uuid: "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;
-    /**
-   * 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}
-   */
-    delete(id: string): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(): void;
-}
 import * as THREE from "three";
 import { Components } from "../Components";
 import { SimpleCamera } from "..";
@@ -610,99 +529,98 @@ export declare class OrthoPerspectiveCamera extends SimpleCamera {
     private newOrthoCamera;
     private setOrthoPerspCameraAspect;
 }
-import * as WEBIFC from "web-ifc";
-import * as FRAG from "@thatopen/fragments";
-import { Component, Components } from "../../core";
+import { MiniMap } from "./src";
+import { Component, Updateable, World, Event, Disposable } from "../Types";
+import { Components } from "../Components";
 /**
- * Object to export all the properties from an IFC to a JS object.
+ * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID.
  */
-export declare class IfcJsonExporter extends Component {
-    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
+export declare class MiniMaps extends Component implements Updateable, Disposable {
+    /**
+   * A unique identifier for the component.
+   * This UUID is used to register the component within the Components system.
+   */
+    static readonly uuid: "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;
+    /**
+   * A collection of {@link MiniMap} instances, each associated with a unique world ID.
+   */
+    list: Map<string, MiniMap>;
     constructor(components: Components);
     /**
-     * Exports all the properties of an IFC into an array of JS objects.
-     * @param webIfc The instance of [web-ifc]{@link https://github.com/ThatOpen/engine_web-ifc} to use.
-     * @param modelID ID of the IFC model whose properties to extract.
-     * @param indirect whether to get the indirect relationships as well.
-     * @param recursiveSpatial whether to get the properties of spatial items recursively
-     * to make the location data available (e.g. absolute position of building).
-     */
-    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
+   * 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}
+   */
+    delete(id: string): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(): void;
 }
-import * as WEBIFC from "web-ifc";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Disposable, Event, Components } from "../../core";
-type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
-type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
-type NumericPropTypes = "IfcInteger" | "IfcReal";
-interface ChangeMap {
-    [modelID: string]: Set<number>;
+import * as THREE from "three";
+import { Component, Components } from "../../core";
+export interface MeasureEdge {
+    distance: number;
+    points: THREE.Vector3[];
 }
-interface AttributeListener {
-    [modelID: string]: {
-        [expressID: number]: {
-            [attributeName: string]: Event<String | Boolean | Number>;
-        };
+export declare class MeasurementUtils extends Component {
+    enabled: boolean;
+    static uuid: string;
+    constructor(components: Components);
+    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    private getFaceData;
+    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
     };
+    private round;
 }
-export declare class IfcPropertiesManager extends Component implements Disposable {
-    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    readonly onRequestFile: Event<unknown>;
-    ifcToExport: ArrayBuffer | null;
-    readonly onElementToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        elementID: number;
-    }>;
-    readonly onPropToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        propID: number;
-    }>;
-    readonly onPsetRemoved: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-    }>;
-    readonly onDataChanged: Event<{
-        model: FragmentsGroup;
-        expressID: number;
-    }>;
-    wasm: {
-        path: string;
-        absolute: boolean;
-    };
+import * as WEBIFC from "web-ifc";
+import * as FRAG from "@thatopen/fragments";
+import { Component, Components } from "../../core";
+/**
+ * Object to export all the properties from an IFC to a JS object.
+ */
+export declare class IfcJsonExporter extends Component {
+    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
+    /** {@link Component.enabled} */
     enabled: boolean;
-    attributeListeners: AttributeListener;
-    selectedModel?: FragmentsGroup;
-    changeMap: ChangeMap;
     constructor(components: Components);
-    dispose(): void;
-    private increaseMaxID;
-    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
-    private newGUID;
-    private getOwnerHistory;
-    private registerChange;
-    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
-    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;
-    }>;
-    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
-    private newSingleProperty;
-    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
-    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
-    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
-    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
-    addElementToPset(model: FragmentsGroup, psetID: number, ...elementID: number[]): Promise<void>;
-    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
-    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
-    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
+    /**
+     * Exports all the properties of an IFC into an array of JS objects.
+     * @param webIfc The instance of [web-ifc]{@link https://github.com/ThatOpen/engine_web-ifc} to use.
+     * @param modelID ID of the IFC model whose properties to extract.
+     * @param indirect whether to get the indirect relationships as well.
+     * @param recursiveSpatial whether to get the properties of spatial items recursively
+     * to make the location data available (e.g. absolute position of building).
+     */
+    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
 }
-export {};
 import * as WEBIFC from "web-ifc";
 import { FragmentsGroup } from "@thatopen/fragments";
 import { Disposable, Event, Component, Components } from "../../core";
@@ -835,47 +753,122 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
     dispose(): void;
 }
 export type { InverseAttribute, RelationsMap } from "./src/types";
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Disposable, Component, Event, Components } from "../../core";
-export interface Classification {
-    [system: string]: {
-        [className: string]: FRAGS.FragmentIdMap;
+import * as WEBIFC from "web-ifc";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Component, Disposable, Event, Components } from "../../core";
+type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
+type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
+type NumericPropTypes = "IfcInteger" | "IfcReal";
+interface ChangeMap {
+    [modelID: string]: Set<number>;
+}
+interface AttributeListener {
+    [modelID: string]: {
+        [expressID: number]: {
+            [attributeName: string]: Event<String | Boolean | Number>;
+        };
     };
 }
-export declare class Classifier extends Component implements Disposable {
-    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    list: Classification;
+export declare class IfcPropertiesManager extends Component implements Disposable {
+    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    readonly onDisposed: Event<string>;
+    readonly onRequestFile: Event<unknown>;
+    ifcToExport: ArrayBuffer | null;
+    readonly onElementToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        elementID: number;
+    }>;
+    readonly onPropToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        propID: number;
+    }>;
+    readonly onPsetRemoved: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+    }>;
+    readonly onDataChanged: Event<{
+        model: FragmentsGroup;
+        expressID: number;
+    }>;
+    wasm: {
+        path: string;
+        absolute: boolean;
+    };
+    enabled: boolean;
+    attributeListeners: AttributeListener;
+    selectedModel?: FragmentsGroup;
+    changeMap: ChangeMap;
     constructor(components: Components);
-    private onFragmentsDisposed;
     dispose(): void;
-    remove(guid: string): void;
-    find(filter?: {
-        [name: string]: string[];
-    }): FRAGS.FragmentIdMap;
-    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
-    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
-    byEntity(group: FRAGS.FragmentsGroup): void;
-    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
-    bySpatialStructure(model: FRAGS.FragmentsGroup): Promise<void>;
-    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
-    resetColor(items: FRAGS.FragmentIdMap): void;
-    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number): void;
+    private increaseMaxID;
+    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
+    private newGUID;
+    private getOwnerHistory;
+    private registerChange;
+    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
+    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;
+    }>;
+    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
+    private newSingleProperty;
+    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
+    addElementToPset(model: FragmentsGroup, psetID: number, ...elementID: number[]): Promise<void>;
+    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
+    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
+    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
 }
-import * as FRAGS from "@thatopen/fragments";
-import { Components, Component } from "../../core";
-export declare class Hider extends Component {
-    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
-    enabled: boolean;
-    constructor(components: Components);
-    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
+export {};
+export declare class UUID {
+    private static _pattern;
+    private static _lut;
+    static create(): string;
+    static validate(uuid: string): void;
+}
+import * as THREE from "three";
+import { Component, Components, Event, World } from "../core";
+export interface VertexPickerConfig {
+    showOnlyVertex: boolean;
+    snapDistance: number;
+    previewElement: HTMLElement;
+}
+export declare class VertexPicker extends Component {
+    onVertexFound: Event<THREE.Vector3>;
+    onVertexLost: Event<THREE.Vector3>;
+    components: Components;
+    private _pickedPoint;
+    private _config;
+    private _enabled;
+    private _workingPlane;
+    set enabled(value: boolean);
+    get enabled(): boolean;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    set workingPlane(plane: THREE.Plane | null);
+    get workingPlane(): THREE.Plane | null;
+    set config(value: Partial<VertexPickerConfig>);
+    get config(): Partial<VertexPickerConfig>;
+    dispose(): void;
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
+}
+import * as WEBIFC from "web-ifc";
+export interface IfcItemsCategories {
+    [itemID: number]: number;
+}
+export declare class IfcCategories {
+    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
 }
+export declare const IfcElements: {
+    [key: number]: string;
+};
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
 import { FragmentsGroup } from "@thatopen/fragments";
@@ -924,36 +917,46 @@ export declare class Exploder extends Component implements Disposable {
     dispose(): void;
     set(active: boolean): void;
 }
-import * as WEBIFC from "web-ifc";
+import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
-import { IfcFragmentSettings } from "./src";
-import { Component, Components, Event, Disposable } from "../../core";
-export declare class IfcLoader extends Component implements Disposable {
-    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
-    readonly onIfcStartedLoading: Event<void>;
-    readonly onSetup: Event<void>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    settings: IfcFragmentSettings;
+import { Disposable, Component, Event, Components } from "../../core";
+export interface Classification {
+    [system: string]: {
+        [className: string]: FRAGS.FragmentIdMap;
+    };
+}
+export declare class Classifier extends Component implements Disposable {
+    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
+    /** {@link Component.enabled} */
     enabled: boolean;
-    webIfc: WEBIFC.IfcAPI;
-    private _material;
-    private _spatialTree;
-    private _metaData;
-    private _fragmentInstances;
-    private _civil;
-    private _visitedFragments;
-    private _materialT;
+    list: Classification;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     constructor(components: Components);
+    private onFragmentsDisposed;
     dispose(): void;
-    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
-    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
-    readIfcFile(data: Uint8Array): Promise<number>;
-    private getAllGeometries;
-    cleanUp(): void;
-    private getMesh;
-    private getGeometry;
-    private autoSetWasm;
+    remove(guid: string): void;
+    find(filter?: {
+        [name: string]: string[];
+    }): FRAGS.FragmentIdMap;
+    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
+    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
+    byEntity(group: FRAGS.FragmentsGroup): void;
+    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
+    bySpatialStructure(model: FRAGS.FragmentsGroup): Promise<void>;
+    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
+    resetColor(items: FRAGS.FragmentIdMap): void;
+    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number): void;
+}
+import * as FRAGS from "@thatopen/fragments";
+import { Components, Component } from "../../core";
+export declare class Hider extends Component {
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    enabled: boolean;
+    constructor(components: Components);
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
 }
 import { Fragment, FragmentsGroup } from "@thatopen/fragments";
 import * as THREE from "three";
@@ -1029,6 +1032,37 @@ export declare class FragmentsManager extends Component implements Disposable {
     coordinate(models?: FragmentsGroup[]): void;
 }
 import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+import { IfcFragmentSettings } from "./src";
+import { Component, Components, Event, Disposable } from "../../core";
+export declare class IfcLoader extends Component implements Disposable {
+    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
+    readonly onIfcStartedLoading: Event<void>;
+    readonly onSetup: Event<void>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    settings: IfcFragmentSettings;
+    enabled: boolean;
+    webIfc: WEBIFC.IfcAPI;
+    private _material;
+    private _spatialTree;
+    private _metaData;
+    private _fragmentInstances;
+    private _civil;
+    private _visitedFragments;
+    private _materialT;
+    constructor(components: Components);
+    dispose(): void;
+    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
+    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
+    readIfcFile(data: Uint8Array): Promise<number>;
+    private getAllGeometries;
+    cleanUp(): void;
+    private getMesh;
+    private getGeometry;
+    private autoSetWasm;
+}
+import * as WEBIFC from "web-ifc";
 import { Components, Disposable, Event, Component } from "../../core";
 import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
 export declare class IfcGeometryTiler extends Component implements Disposable {
@@ -1094,38 +1128,7 @@ export declare class IfcPropertiesTiler extends Component implements Disposable
     private streamAllProperties;
     private cleanUp;
 }
-import * as THREE from "three";
-import { Component, Components } from "../../core";
-export interface MeasureEdge {
-    distance: number;
-    points: THREE.Vector3[];
-}
-export declare class MeasurementUtils extends Component {
-    enabled: boolean;
-    static uuid: string;
-    constructor(components: Components);
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
-    private getFaceData;
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
-    private round;
-}
-import * as WEBIFC from "web-ifc";
-export interface IfcItemsCategories {
-    [itemID: number]: number;
-}
-export declare class IfcCategories {
-    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
-}
-export declare const IfcElements: {
+export declare const IfcCategoryMap: {
     [key: number]: string;
 };
 import * as FRAGS from "@thatopen/fragments";
@@ -1153,9 +1156,7 @@ export declare class IfcPropertiesUtils {
     static attributeExists(model: FRAGS.FragmentsGroup, expressID: number, attribute: string): Promise<boolean>;
     static groupEntitiesByType(model: FRAGS.FragmentsGroup, expressIDs: Set<number> | number[]): Promise<Map<number, Set<number>>>;
 }
-export declare const IfcCategoryMap: {
-    [key: number]: string;
-};
+export declare const GeometryTypes: Set<number>;
 import * as THREE from "three";
 import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
 /**
@@ -1245,12 +1246,19 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable {
     resize(size?: THREE.Vector2): void;
     private updatePlanes;
 }
-export declare const GeometryTypes: Set<number>;
 import { InverseAttribute } from "./types";
 export declare const relToAttributesMap: Map<number, {
     forRelating: InverseAttribute;
     forRelated: InverseAttribute;
 }>;
+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;
+}
 /**
  * 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.
  */
@@ -1279,18 +1287,33 @@ export declare class Event<T> {
     reset(): void;
     private handlers;
 }
-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.
+ * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
  */
-export declare abstract class Component extends Base {
+export declare class AsyncEvent<T> {
     /**
-     * Whether this component is active or not. The behaviour can vary depending
-     * on the type of component. E.g. a disabled dimension tool will stop creating
-     * dimensions, while a disabled camera will stop moving. A disabled component
-     * will not be updated automatically each frame.
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
      */
-    abstract enabled: boolean;
+    add(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
+    /**
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
+     */
+    remove(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
+    /** Triggers all the callbacks assigned to this event. */
+    trigger: (data?: T) => Promise<void>;
+    /** Gets rid of all the suscribed events. */
+    reset(): void;
+    private handlers;
 }
 import * as THREE from "three";
 import CameraControls from "camera-controls";
@@ -1400,13 +1423,18 @@ 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.
+ */
+export declare abstract class Component extends Base {
+    /**
+     * Whether this component is active or not. The behaviour can vary depending
+     * on the type of component. E.g. a disabled dimension tool will stop creating
+     * dimensions, while a disabled camera will stop moving. A disabled component
+     * will not be updated automatically each frame.
+     */
+    abstract enabled: boolean;
 }
 import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
 import { Components } from "../../Components";
@@ -1427,34 +1455,6 @@ export declare abstract class Base {
     /** Whether is component is {@link Configurable}. */
     isConfigurable: () => this is Configurable<any>;
 }
-/**
- * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
- */
-export declare class AsyncEvent<T> {
-    /**
-     * Add a callback to this event instance.
-     * @param handler - the callback to be added to this event.
-     */
-    add(handler: T extends void ? {
-        (): Promise<void>;
-    } : {
-        (data: T): Promise<void>;
-    }): void;
-    /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
-     */
-    remove(handler: T extends void ? {
-        (): Promise<void>;
-    } : {
-        (data: T): Promise<void>;
-    }): void;
-    /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => Promise<void>;
-    /** Gets rid of all the suscribed events. */
-    reset(): void;
-    private handlers;
-}
 import { Base } from "./base";
 import { World } from "./world";
 import { Event } from "./event";
@@ -1626,148 +1626,199 @@ export interface World extends Disposable, Updateable {
     isDisposing: boolean;
 }
 import * as THREE from "three";
-import { Hideable, Disposable, Event, World } from "../../Types";
 import { Components } from "../../Components";
+import { AsyncEvent, Event, World } from "../../Types";
 /**
- * Each of the planes created by the clipper.
+ * Interface for settings to configure the CullerRenderer.
  */
-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>;
+export interface CullerRendererSettings {
     /**
-     * The normal vector of the clipping plane.
+     * Interval in milliseconds at which the visibility check should be performed.
+     * Default value is 1000.
      */
-    readonly normal: THREE.Vector3;
+    updateInterval?: number;
     /**
-     * The origin point of the clipping plane.
+     * Width of the render target used for visibility checks.
+     * Default value is 512.
      */
-    readonly origin: THREE.Vector3;
+    width?: number;
     /**
-     * The THREE.js Plane object representing the clipping plane.
+     * Height of the render target used for visibility checks.
+     * Default value is 512.
      */
-    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;
+    height?: number;
     /**
-     * Getter for the enabled state of the clipping plane.
-     * @returns {boolean} The current enabled state.
+     * Whether the visibility check should be performed automatically.
+     * Default value is true.
      */
-    get enabled(): boolean;
+    autoUpdate?: boolean;
+}
+/**
+ * A base renderer to determine visibility on screen.
+ */
+export declare class CullerRenderer {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * 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.
+     * Fires after making the visibility check to the meshes. It lists the
+     * meshes that are currently visible, and the ones that were visible
+     * just before but not anymore.
      */
-    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);
+    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
     /**
-   * 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);
+     * Whether this renderer is active or not. If not, it won't render anything.
+     */
+    enabled: 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;
+     * Needs to check whether there are objects that need to be hidden or shown.
+     * You can bind this to the camera movement, to a certain interval, etc.
+     */
+    needsUpdate: boolean;
+    /**
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
+     */
+    renderDebugFrame: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /** The world instance to which this renderer belongs. */
+    readonly world: World;
+    /** The THREE.js renderer used to make the visibility test. */
+    readonly renderer: THREE.WebGLRenderer;
+    protected autoUpdate: boolean;
+    protected updateInterval: number;
+    protected readonly worker: Worker;
+    protected readonly scene: THREE.Scene;
+    private _width;
+    private _height;
+    private _availableColor;
+    private readonly renderTarget;
+    private readonly bufferSize;
+    private readonly _buffer;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
     /** {@link Disposable.dispose} */
     dispose(): void;
-    private reset;
-    protected toggleControls(state: boolean): void;
-    private newTransformControls;
-    private initializeControls;
-    private createArrowBoundingBox;
-    private changeDrag;
-    private notifyDraggingChanged;
-    private preventCameraMovement;
-    private newHelper;
-    private static newPlaneMesh;
+    /**
+     * The function that the culler uses to reprocess the scene. Generally it's
+     * better to call needsUpdate, but you can also call this to force it.
+     * @param force if true, it will refresh the scene even if needsUpdate is
+     * not true.
+     */
+    updateVisibility: (force?: boolean) => Promise<void>;
+    protected getAvailableColor(): {
+        r: number;
+        g: number;
+        b: number;
+        code: string;
+    };
+    protected increaseColor(): void;
+    protected decreaseColor(): void;
+    private applySettings;
 }
 import * as THREE from "three";
-import { Hideable, Event, World, Disposable } from "../../Types";
+import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
 import { Components } from "../../Components";
-export interface GridConfig {
-    color: THREE.Color;
-    size1: number;
-    size2: number;
-    distance: number;
-}
+import { Event, World, Disposable } from "../../Types";
 /**
- * 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).
+ * A renderer to determine a mesh visibility on screen.
  */
-export declare class SimpleGrid implements Hideable, Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** The world instance to which this Raycaster belongs. */
-    world: World;
-    /** The components instance to which this grid belongs. */
-    components: Components;
-    /** {@link Hideable.visible} */
-    get visible(): boolean;
-    /** {@link Hideable.visible} */
-    set visible(visible: boolean);
-    /** The material of the grid. */
-    get material(): THREE.ShaderMaterial;
+export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Event triggered when the visibility of meshes is updated.
+     * Contains two sets: seen and unseen.
      */
-    get fade(): boolean;
+    readonly onViewUpdated: Event<{
+        seen: Set<THREE.Mesh>;
+        unseen: Set<THREE.Mesh>;
+    }>;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Pixels in screen a geometry must occupy to be considered "seen".
+     * Default value is 100.
      */
-    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);
+    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;
-    private setupEvents;
-    private updateZoom;
+    /**
+     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
+     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+     * @returns {void}
+     */
+    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    /**
+   * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
+   * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
+   * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+   * @returns {void}
+   */
+    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    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 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;
+    autoSetWasm: boolean;
+    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
+}
+import * as THREE from "three";
+import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+export declare class CivilReader {
+    defLineMat: THREE.LineBasicMaterial;
+    read(webIfc: WEBIFC.IfcAPI): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    get(civilItems: any): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    private getCurves;
+}
+import * as WEBIFC from "web-ifc";
+export declare class IfcMetadataReader {
+    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
 }
 import * as THREE from "three";
 import { BaseScene, Configurable, Event } from "../../Types";
@@ -2004,24 +2055,236 @@ export declare class SimpleRenderer extends BaseRenderer {
     private onContextBack;
 }
 import * as THREE from "three";
-import { Disposable, Event } from "../../Types";
+import { Hideable, Event, World, Disposable } from "../../Types";
+import { Components } from "../../Components";
+export interface GridConfig {
+    color: THREE.Color;
+    size1: number;
+    size2: number;
+    distance: number;
+}
 /**
- * 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.
+ * 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 Mouse implements Disposable {
-    dom: HTMLCanvasElement;
-    private _event?;
-    private _position;
+export declare class SimpleGrid implements Hideable, Disposable {
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
-    constructor(dom: HTMLCanvasElement);
+    /** 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;
     /**
-     * The real position of the mouse of the Three.js canvas.
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
      */
-    get position(): THREE.Vector2;
+    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 { Hideable, Disposable, Event, World } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * Each of the 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";
+/** Configuration of the IFC-fragment streaming. */
+export declare class IfcStreamingSettings extends IfcFragmentSettings {
+    minGeometrySize: number;
+    minAssetsSize: number;
+}
+/** Configuration of the IFC-fragment streaming. */
+export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+    propertiesSize: number;
+}
+export interface StreamedGeometries {
+    [id: number]: {
+        boundingBox: Float32Array;
+        hasHoles: boolean;
+        geometryFile?: string;
+    };
+}
+export interface StreamedAsset {
+    id: number;
+    geometries: {
+        geometryID: number;
+        transformation: number[];
+        color: number[];
+    }[];
+}
+import * as WEBIFC from "web-ifc";
+import { AsyncEvent, Component, Disposable, Event } from "../../../core";
+import { PropertiesStreamingSettings } from "./streaming-settings";
+export declare class FragmentPropsStreamConverter extends Component implements Disposable {
+    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
+    onPropertiesStreamed: AsyncEvent<{
+        type: number;
+        data: {
+            [id: number]: any;
+        };
+    }>;
+    onProgress: AsyncEvent<number>;
+    onIndicesStreamed: AsyncEvent<number[][]>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    enabled: boolean;
+    settings: PropertiesStreamingSettings;
+    webIfc: WEBIFC.IfcAPI;
+    dispose(): Promise<void>;
+    streamFromBuffer(data: Uint8Array): Promise<void>;
+    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
+    private readIfcFile;
+    private streamIfcFile;
+    private streamAllProperties;
+    private getIndices;
+    private cleanUp;
+}
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
+ */
+export declare class FirstPersonMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "FirstPerson";
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private setupFirstPersonCamera;
+}
+import * as THREE from "three";
+import { 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;
@@ -2083,170 +2346,6 @@ export declare class SimpleRaycaster implements Disposable {
     private intersect;
     private filterClippingPlanes;
 }
-import * as THREE from "three";
-import { Components } from "../../Components";
-import { AsyncEvent, Event, World } from "../../Types";
-/**
- * Interface for settings to configure the CullerRenderer.
- */
-export interface CullerRendererSettings {
-    /**
-     * Interval in milliseconds at which the visibility check should be performed.
-     * Default value is 1000.
-     */
-    updateInterval?: number;
-    /**
-     * Width of the render target used for visibility checks.
-     * Default value is 512.
-     */
-    width?: number;
-    /**
-     * Height of the render target used for visibility checks.
-     * Default value is 512.
-     */
-    height?: number;
-    /**
-     * Whether the visibility check should be performed automatically.
-     * Default value is true.
-     */
-    autoUpdate?: boolean;
-}
-/**
- * A base renderer to determine visibility on screen.
- */
-export declare class CullerRenderer {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Fires after making the visibility check to the meshes. It lists the
-     * meshes that are currently visible, and the ones that were visible
-     * just before but not anymore.
-     */
-    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
-    /**
-     * Whether this renderer is active or not. If not, it won't render anything.
-     */
-    enabled: boolean;
-    /**
-     * Needs to check whether there are objects that need to be hidden or shown.
-     * You can bind this to the camera movement, to a certain interval, etc.
-     */
-    needsUpdate: boolean;
-    /**
-     * Render the internal scene used to determine the object visibility. Used
-     * for debugging purposes.
-     */
-    renderDebugFrame: boolean;
-    /** The components instance to which this renderer belongs. */
-    components: Components;
-    /** The world instance to which this renderer belongs. */
-    readonly world: World;
-    /** The THREE.js renderer used to make the visibility test. */
-    readonly renderer: THREE.WebGLRenderer;
-    protected autoUpdate: boolean;
-    protected updateInterval: number;
-    protected readonly worker: Worker;
-    protected readonly scene: THREE.Scene;
-    private _width;
-    private _height;
-    private _availableColor;
-    private readonly renderTarget;
-    private readonly bufferSize;
-    private readonly _buffer;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * The function that the culler uses to reprocess the scene. Generally it's
-     * better to call needsUpdate, but you can also call this to force it.
-     * @param force if true, it will refresh the scene even if needsUpdate is
-     * not true.
-     */
-    updateVisibility: (force?: boolean) => Promise<void>;
-    protected getAvailableColor(): {
-        r: number;
-        g: number;
-        b: number;
-        code: string;
-    };
-    protected increaseColor(): void;
-    protected decreaseColor(): void;
-    private applySettings;
-}
-import * as THREE from "three";
-import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-/**
- * A renderer to determine a mesh visibility on screen.
- */
-export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
-    /**
-     * Event triggered when the visibility of meshes is updated.
-     * Contains two sets: seen and unseen.
-     */
-    readonly onViewUpdated: Event<{
-        seen: Set<THREE.Mesh>;
-        unseen: Set<THREE.Mesh>;
-    }>;
-    /**
-     * Pixels in screen a geometry must occupy to be considered "seen".
-     * Default value is 100.
-     */
-    threshold: number;
-    /**
-     * Map of color code to THREE.InstancedMesh.
-     * Used to keep track of color-coded meshes.
-     */
-    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
-    /**
-     * Flag to indicate if the renderer is currently processing.
-     * Used to prevent concurrent processing.
-     */
-    isProcessing: boolean;
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private _intervalID;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
-     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     * @returns {void}
-     */
-    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    /**
-   * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
-   * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
-   * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-   * @returns {void}
-   */
-    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    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 { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
- */
-export declare class FirstPersonMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "FirstPerson";
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private setupFirstPersonCamera;
-}
 import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
 /**
@@ -2354,104 +2453,15 @@ export interface NavigationMode {
     /** Whether this navigation mode is active or not. */
     enabled: boolean;
 }
-import * as THREE from "three";
-import * as WEBIFC from "web-ifc";
-import * as FRAGS from "@thatopen/fragments";
-export declare class CivilReader {
-    defLineMat: THREE.LineBasicMaterial;
-    read(webIfc: WEBIFC.IfcAPI): {
-        alignments: Map<number, FRAGS.Alignment>;
-        coordinationMatrix: THREE.Matrix4;
-    } | undefined;
-    get(civilItems: any): {
-        alignments: Map<number, FRAGS.Alignment>;
-        coordinationMatrix: THREE.Matrix4;
-    } | undefined;
-    private getCurves;
-}
-import * 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;
-    autoSetWasm: boolean;
-    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
-}
 import * as WEBIFC from "web-ifc";
-export declare class IfcMetadataReader {
-    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-}
-import { IfcFragmentSettings } from "../../IfcLoader/src";
-/** Configuration of the IFC-fragment streaming. */
-export declare class IfcStreamingSettings extends IfcFragmentSettings {
-    minGeometrySize: number;
-    minAssetsSize: number;
-}
-/** Configuration of the IFC-fragment streaming. */
-export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
-    propertiesSize: number;
-}
-export interface StreamedGeometries {
-    [id: number]: {
-        boundingBox: Float32Array;
-        hasHoles: boolean;
-        geometryFile?: string;
-    };
-}
-export interface StreamedAsset {
-    id: number;
-    geometries: {
-        geometryID: number;
-        transformation: number[];
-        color: number[];
-    }[];
-}
-import * as WEBIFC from "web-ifc";
-import { AsyncEvent, Component, Disposable, Event } from "../../../core";
-import { PropertiesStreamingSettings } from "./streaming-settings";
-export declare class FragmentPropsStreamConverter extends Component implements Disposable {
-    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
-    onPropertiesStreamed: AsyncEvent<{
-        type: number;
-        data: {
-            [id: number]: any;
-        };
-    }>;
-    onProgress: AsyncEvent<number>;
-    onIndicesStreamed: AsyncEvent<number[][]>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    enabled: boolean;
-    settings: PropertiesStreamingSettings;
-    webIfc: WEBIFC.IfcAPI;
-    dispose(): Promise<void>;
-    streamFromBuffer(data: Uint8Array): Promise<void>;
-    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
-    private readIfcFile;
-    private streamIfcFile;
-    private streamAllProperties;
-    private getIndices;
-    private cleanUp;
+import * as THREE from "three";
+export declare class Units {
+    factor: number;
+    complement: number;
+    apply(matrix: THREE.Matrix4): void;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    private getLengthUnits;
+    private getScaleMatrix;
 }
 export type RelationsMap = Map<number, Map<number, number[]>>;
 export interface ModelsRelationMap {
@@ -2477,16 +2487,6 @@ export type InverseAttributes = [
     "ContainsElements"
 ];
 export type InverseAttribute = InverseAttributes[number];
-import * as WEBIFC from "web-ifc";
-import * as THREE from "three";
-export declare class Units {
-    factor: number;
-    complement: number;
-    apply(matrix: THREE.Matrix4): void;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    private getLengthUnits;
-    private getScaleMatrix;
-}
 import { BufferGeometry } from "three";
 import * as THREE from "three";
 export declare class TransformHelper {