@thatopen/components 2.0.9 → 2.0.11

package/dist/core/Clipper/index.d.ts

@@ -4,26 +4,47 @@ import { SimplePlane } from "./src";
 import { Components } from "../Components";
 export * from "./src";
 /**
- * A lightweight component to easily create and handle
- * [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes).
+ * A lightweight component to easily create and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes).
  *
  * @param components - the instance of {@link Components} used.
  * E.g. {@link SimplePlane}.
  */
 export declare class Clipper extends Component implements Createable, Disposable, Hideable {
+    /**
+     * 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";
-    /** {@link Createable.onAfterCreate} */
-    readonly onAfterCreate: Event<SimplePlane>;
-    /** {@link Createable.onAfterDelete} */
-    readonly onAfterDelete: Event<SimplePlane>;
     /** 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>;
+    /**
+     * Event that fires when the user starts creating a clipping plane.
+     */
     readonly onBeforeCreate: Event<unknown>;
+    /**
+     * Event that fires when the user cancels the creation of a clipping plane.
+     */
     readonly onBeforeCancel: Event<unknown>;
+    /**
+     * Event that fires after the user cancels the creation of a clipping plane.
+     */
     readonly onAfterCancel: Event<unknown>;
+    /**
+     * Event that fires when the user starts deleting a clipping plane.
+     */
     readonly onBeforeDelete: Event<unknown>;
+    /**
+     * Event that fires after a clipping plane has been created.
+     * @param plane - The newly created clipping plane.
+     */
+    readonly onAfterCreate: Event<SimplePlane>;
+    /**
+     * Event that fires after a clipping plane has been deleted.
+     * @param plane - The deleted clipping plane.
+     */
+    readonly onAfterDelete: Event<SimplePlane>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
     /**
@@ -39,7 +60,14 @@ export declare class Clipper extends Component implements Createable, Disposable
      * 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;

package/dist/core/Clipper/src/simple-plane.d.ts

@@ -2,7 +2,7 @@ import * as THREE from "three";
 import { Hideable, Disposable, Event, World } from "../../Types";
 import { Components } from "../../Components";
 /**
- * Each of the planes created by {@link SimpleClipper}.
+ * 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. */
@@ -11,21 +11,40 @@ export declare class SimplePlane implements Disposable, Hideable {
     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;
-    components: Components;
-    world: World;
     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;
-    /** {@link Component.enabled} */
+    /**
+     * 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;
@@ -41,8 +60,25 @@ export declare class SimplePlane implements Disposable, Hideable {
     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;

package/dist/core/Components/index.d.ts

@@ -1,34 +1,58 @@
 import { Component, Disposable, Event } from "../Types";
 /**
- * The entry point of the Components library.
- * It can:
- * - Create and access all the components of the library.
- * - Update all the updatable components automatically.
- * - Dispose all the components, preventing memory leaks.
+ * 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.
  */
 export declare class Components implements Disposable {
-    static readonly release = "1.4.21";
+    /**
+     * The version of the @thatopen/components library.
+     */
+    static readonly release = "2.0.11";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<void>;
-    /** The list of components created in this app. */
+    /**
+     * The list of components created in this app.
+     * The keys are UUIDs and the values are instances of the components.
+     */
     readonly list: Map<string, Component>;
-    /** If disabled, the animation loop will be stopped. */
+    /**
+     * If disabled, the animation loop will be stopped.
+     * Default value is false.
+     */
     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
+     */
     add(uuid: string, instance: Component): void;
     /**
-     * Retrieves a component. If it already exists in this app, it returns the instance of the component. If it
-     * doesn't exist, it will instance it automatically.
+     * 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.
      *
-     * @param Component - The component to get or create.
+     * @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();
     /**
-     * Initializes the library. It should be called at the start of the app after
-     * initializing the scene, the renderer and the
-     * camera. Additionally, if any component that need a raycaster is
-     * used, the {@link raycaster} will need to be initialized.
+     * Initializes the Components instance.
+     * This method starts the animation loop, sets the enabled flag to true,
+     * and calls the update method.
+     *
+     * @returns {void}
      */
     init(): void;
     /**
@@ -39,7 +63,7 @@ export declare class Components implements Disposable {
      * called. This is especially relevant in Single Page Applications (React,
      * Angular, Vue, etc).
      *
-     * - Any of the objects of this instance (meshes, geometries, etc) is
+     * - 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

package/dist/core/Cullers/index.d.ts

@@ -3,50 +3,46 @@ import { MeshCullerRenderer, CullerRendererSettings } from "./src";
 import { Component, Event, Disposable, World } from "../Types";
 export * from "./src";
 /**
- * A tool to handle big scenes efficiently by automatically hiding the objects
- * that are not visible to the camera.
+ * A component that manages and provides culling functionality for meshes in a 3D scene.
  */
 export declare class Cullers extends Component implements Disposable {
     /**
-     * A unique identifier for the Cullers component.
+     * 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";
     /**
-     * Indicates whether the Cullers component is enabled.
-     */
+   * 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);
     /**
-     * An event that is triggered when the Cullers component is disposed.
-     */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Gets the enabled state of the Cullers component.
+     * Creates a new MeshCullerRenderer for the given world.
+     * If a MeshCullerRenderer already exists for the world, it will return the existing one.
      *
-     * @returns The current enabled state.
+     * @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.
      */
-    get enabled(): boolean;
+    create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
     /**
-     * Sets the enabled state of the Cullers component.
-     * Also sets the enabled state of all MeshCullerRenderer instances.
+     * 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 value - The new enabled state.
+     * @param world - The world for which to delete the MeshCullerRenderer.
+     *
+     * @returns {void}
      */
-    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;
     delete(world: World): void;
     /** {@link Disposable.dispose} */
     dispose(): void;

package/dist/core/Cullers/src/culler-renderer.d.ts

@@ -1,14 +1,33 @@
 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
+ * A base renderer to determine visibility on screen.
  */
 export declare class CullerRenderer {
     /** {@link Disposable.onDisposed} */
@@ -19,7 +38,9 @@ export declare class CullerRenderer {
      * just before but not anymore.
      */
     readonly onViewUpdated: Event<any> | AsyncEvent<any>;
-    /** {@link Component.enabled} */
+    /**
+     * 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.
@@ -31,8 +52,11 @@ export declare class CullerRenderer {
      * 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;

package/dist/core/Cullers/src/mesh-culler-renderer.d.ts

@@ -1,17 +1,33 @@
 import * as THREE from "three";
 import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
 import { Components } from "../../Components";
-import { Event, World } from "../../Types";
+import { Event, World, Disposable } from "../../Types";
 /**
- * A renderer to determine a mesh visibility on screen
+ * A renderer to determine a mesh visibility on screen.
  */
-export declare class MeshCullerRenderer extends CullerRenderer {
-    threshold: number;
+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;
@@ -20,8 +36,20 @@ export declare class MeshCullerRenderer extends CullerRenderer {
     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;

package/dist/core/Disposer/index.d.ts

@@ -2,18 +2,20 @@ 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).
+ * 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);
     /**
-     * {@link Component.uuid}.
-     * @return the list of UUIDs of deleted components.
+     * Return the UUIDs of all disposed components.
      */
     get(): Set<string>;
     /**

package/dist/core/Grids/index.d.ts

@@ -1,15 +1,49 @@
 import { Component, Disposable, World, Event } from "../Types";
 import { GridConfig, SimpleGrid } from "./src";
 import { Components } from "../Components";
+/**
+ * A component that manages and provides access to multiple grid instances. Each grid is associated with a unique world.
+ */
 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: "d1e814d5-b81c-4452-87a2-f039375e0489";
+    /**
+     * A map of world UUIDs to their corresponding grid instances.
+     */
     list: Map<string, SimpleGrid>;
-    readonly onDisposed: Event<unknown>;
+    /**
+     * The default configuration for grid creation.
+     */
     config: Required<GridConfig>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /** {@link Component.enabled} */
     enabled: boolean;
     constructor(components: Components);
+    /**
+   * 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.
+   *
+   * @throws Will throw an error if a grid already exists for the given world.
+   */
     create(world: World): SimpleGrid;
+    /**
+     * Deletes the grid associated with the given world.
+     * If a grid does not exist for the given world, this method does nothing.
+     *
+     * @param world - The world for which to delete the grid.
+     *
+     * @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.
+     */
     delete(world: World): void;
+    /** {@link Disposable.dispose} */
     dispose(): void;
 }

package/dist/core/Grids/src/simple-grid.d.ts

@@ -16,7 +16,9 @@ export interface GridConfig {
 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;
@@ -34,6 +36,7 @@ export declare class SimpleGrid implements Hideable, Disposable {
      * 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);

package/dist/core/MiniMap/index.d.ts

@@ -1,16 +1,47 @@
 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;
 }

package/dist/core/MiniMap/src/index.d.ts

@@ -1,16 +1,47 @@
 import * as THREE from "three";
 import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
+/**
+ * A class representing a 2D minimap in 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;
+    /**
+     * 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;
@@ -20,15 +51,39 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable {
     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;
 }