vim-web 0.3.42 → 0.3.44-dev.0

package/dist/types/core-viewers/ultra/index.d.ts

@@ -5,5 +5,5 @@ export * from './viewer/vim';
 export * from './utils/math3d';
 export * from './viewer/color';
 export type { ILoadRequest, VimRequestErrorType } from './viewer/loadRequest';
-export type { ClientState } from './viewer/socketClient';
+export type { ClientState, ConnectionSettings } from './viewer/socketClient';
 export type { VimSource } from './viewer/rpcSafeClient';

package/dist/types/core-viewers/ultra/viewer/camera.d.ts

@@ -77,19 +77,7 @@ export declare class Camera implements ICamera {
      * Handles camera initialization when connection is established
      */
     onConnect(): void;
-    /**
-     * Starts tracking camera position at regular intervals
-     */
-    startTracking(): void;
-    /**
-     * Stops tracking camera position
-     */
-    stopTracking(): void;
-    /**
-     * Updates the stored camera position
-     * @private
-     */
-    private update;
+    onCameraPose(pose: Segment): void;
     /**
      * Pauses or resumes rendering
      * @param value - True to pause rendering, false to resume

package/dist/types/core-viewers/ultra/viewer/marshal.d.ts

@@ -12,6 +12,13 @@ export type VimStatus = {
     status: number;
     progress: number;
 };
+export type SectionBoxState = {
+    enabled: boolean;
+    visible: boolean;
+    interactible: boolean;
+    clip: boolean;
+    box: Box3;
+};
 export type Vector4 = {
     x: number;
     y: number;
@@ -20,55 +27,61 @@ export type Vector4 = {
 };
 export declare class Marshal {
     private buffer;
-    private dataView;
-    private readOffset;
-    private writeOffset;
+    private _dataView;
+    private _offset;
     constructor(initialSize?: number);
     getBuffer(): ArrayBuffer;
     private ensureCapacity;
     writeData(data: ArrayBuffer): void;
     writeMatrix44(data: Matrix44): void;
-    readMatrix44(): Matrix44;
     writeBoolean(value: boolean): void;
-    readBoolean(): boolean;
     writeInt(value: number): void;
-    readInt(): number;
     writeUInt(value: number): void;
-    readUInt(): number;
     writeFloat(value: number): void;
-    readFloat(): number;
     writeString(value: string): void;
-    readString(): string;
     writeHitCheckResult(data: HitCheckResult): void;
-    readHitCheckResult(): HitCheckResult;
     writeVimStatus(data: VimStatus): void;
-    readVimStatus(): VimStatus;
     writeVector2(data: Vector2): void;
-    readVector2(): Vector2;
     writeVector3(data: Vector3): void;
-    readVector3(): Vector3;
     writeVector4(data: Vector4): void;
-    readVector4(): Vector4;
     writeRGBA(color: RGBA): void;
-    readRGBA(): RGBA;
     writeRGB(color: RGBA): void;
-    readRGB(): RGB;
     writeRGBA32(color: RGBA32): void;
-    readRGBA32(): RGBA32;
     writeSegment(segment: Segment): void;
-    readSegment(): Segment;
     writeBox3(data: Box3): void;
-    readBox3(): Box3;
+    writeSectionBoxState(data: SectionBoxState): void;
     writeArrayOfInt(values: number[]): void;
-    readArrayOfInt(): number[];
     writeArrayOfUInt(values: number[]): void;
-    readArrayOfUInt(): number[];
     writeArrayOfFloat(values: number[]): void;
-    readArrayOfFloat(): number[];
     writeArrayOfBool(values: boolean[]): void;
-    readArrayOfBool(): boolean[];
     writeArrayOfRGBA32(values: RGBA32[]): void;
-    readArrayOfRGBA32(): RGBA32[];
     writeArray<T>(data: T[], sizeT: number, write: (data: T) => void): void;
+}
+export declare class ReadMarshal {
+    private _dataView;
+    private _offset;
+    constructor(buffer: ArrayBuffer);
+    readMatrix44(): Matrix44;
+    readInt(): number;
+    readUInt(): number;
+    readFloat(): number;
+    readBoolean(): boolean;
+    readString(): string;
+    readHitCheckResult(): HitCheckResult;
+    readVimStatus(): VimStatus;
+    readVector2(): Vector2;
+    readVector3(): Vector3;
+    readVector4(): Vector4;
+    readRGBA(): RGBA;
+    readRGB(): RGB;
+    readRGBA32(): RGBA32;
+    readBox3(): Box3;
+    readSegment(): Segment;
+    readSectionBoxState(): SectionBoxState;
+    readArrayOfInt(): number[];
+    readArrayOfUInt(): number[];
+    readArrayOfFloat(): number[];
+    readArrayOfBool(): boolean[];
+    readArrayOfRGBA32(): RGBA32[];
     readArray<T>(read: () => T): T[];
 }

package/dist/types/core-viewers/ultra/viewer/rpcClient.d.ts

@@ -1,5 +1,5 @@
 import type { SocketClient } from './socketClient';
-import { HitCheckResult, VimStatus } from './marshal';
+import { HitCheckResult, VimStatus, SectionBoxState } from './marshal';
 import { Box3, RGBA, RGBA32, Segment, Vector2, Vector3, Matrix44 } from '../utils/math3d';
 export type MaterialHandle = 4294967295 | 6 | 2 | 0 | 1 | 3 | 4 | 5 | 7 | 8;
 export declare class MaterialHandles {
@@ -16,11 +16,11 @@ export declare class MaterialHandles {
 }
 export declare const materialHandles: MaterialHandle[];
 export declare class RpcClient {
-    private readonly _messenger;
-    get url(): string;
+    private readonly _socket;
     get connected(): boolean;
-    constructor(_messenger: SocketClient);
-    readonly API_VERSION = "5.0.0";
+    get url(): string;
+    constructor(_socket: SocketClient);
+    readonly API_VERSION = "5.1.0";
     RPCAddNodeFlags(componentHandle: number, nodes: number[], flags: number): void;
     RPCClearMaterialOverrides(componentHandle: number): void;
     RPCClearScene(): void;
@@ -28,16 +28,18 @@ export declare class RpcClient {
     RPCCreateText(position: Vector3, color: RGBA32, text: string): Promise<number>;
     RPCDestroyMaterialInstances(materialInstanceHandle: number[]): void;
     RPCDestroyText(componentHandle: number): void;
-    RPCEnableSectionBox(enable: boolean): void;
     RPCFrameAll(blendTime: number): Promise<Segment>;
     RPCFrameBox(box: Box3, blendTime: number): Promise<Segment>;
     RPCFrameInstances(componentHandle: number, nodes: number[], blendTime: number): Promise<Segment>;
     RPCFrameVim(componentHandle: number, blendTime: number): Promise<Segment>;
     RPCGetAPIVersion(): Promise<string>;
     RPCGetBoundingBox(componentHandle: number, nodes: number[]): Promise<Box3>;
+    RPCGetBoundingBoxAll(componentHandle: number): Promise<Box3>;
     RPCGetCameraPosition(): Promise<Segment>;
     RPCGetIblRotation(): Promise<Matrix44>;
     RPCGetLastError(): Promise<string>;
+    RPCGetSceneAABB(): Promise<Box3>;
+    RPCGetSectionBox(): Promise<SectionBoxState>;
     RPCGetVimLoadingState(componentHandle: number): Promise<VimStatus>;
     RPCGhost(componentHandle: number, nodes: number[]): void;
     RPCGhostAll(componentHandle: number): void;
@@ -68,7 +70,7 @@ export declare class RpcClient {
     RPCSetLighting(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RGBA): void;
     RPCSetMaterialOverrides(componentHandle: number, nodes: number[], materialInstanceHandles: number[]): void;
     RPCSetMoveSpeed(speed: number): void;
-    RPCSetSectionBox(aabb: Box3): void;
+    RPCSetSectionBox(state: SectionBoxState): void;
     RPCShow(componentHandle: number, nodes: number[]): void;
     RPCShowAABBs(componentHandle: number, nodes: number[], colors: RGBA32[]): void;
     RPCShowAll(componentHandle: number): void;

package/dist/types/core-viewers/ultra/viewer/rpcSafeClient.d.ts

@@ -1,5 +1,5 @@
 import { Box3, RGBA, RGBA32, Segment, Vector2, Vector3 } from "../utils/math3d";
-import { HitCheckResult } from "./marshal";
+import { HitCheckResult, SectionBoxState } from "./marshal";
 import { MaterialHandle, RpcClient } from "./rpcClient";
 export type VimSource = {
     url: string;
@@ -137,6 +137,12 @@ export declare class RpcSafeClient {
      * @throws {Error} If the component handle is invalid
      */
     RPCDestroyText(componentHandle: number): void;
+    /*******************************************************************************
+     * SECTION BOX METHODS
+     * Methods for controlling section box visibility and position.
+     ******************************************************************************/
+    RPCSetSectionBox(state: SectionBoxState): void;
+    RPCGetSectionBox(): Promise<SectionBoxState | undefined>;
     /*******************************************************************************
      * CAMERA AND VIEW METHODS
      * Methods for controlling camera position, movement, framing, and view settings.
@@ -153,6 +159,7 @@ export declare class RpcSafeClient {
      * @throws {Error} If segment is invalid or blendTime is negative
      */
     RPCSetCameraPosition(segment: Segment, blendTime: number): void;
+    RPCGetBoundingBoxAll(componentHandle: number): Promise<any>;
     /**
      * Calculates the bounding box for specified nodes in a component.
      * Large node arrays are automatically processed in batches for better performance.

package/dist/types/core-viewers/ultra/viewer/sectionBox.d.ts

@@ -0,0 +1,31 @@
+import { Box3 } from "../utils/math3d";
+import { RpcSafeClient } from "./rpcSafeClient";
+export declare class SectionBox {
+    private _enabled;
+    private _visible;
+    private _interactible;
+    private _clip;
+    private _box;
+    private _rpc;
+    private _interval;
+    private _animationFrame;
+    private _onUpdate;
+    get onUpdate(): import("ste-signals").ISignal;
+    private get needUpdate();
+    constructor(rpc: RpcSafeClient);
+    onConnect(): Promise<void>;
+    scheduleUpdate(): void;
+    private pull;
+    private push;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    get visible(): boolean;
+    set visible(value: boolean);
+    get interactible(): boolean;
+    set interactible(value: boolean);
+    get clip(): boolean;
+    set clip(value: boolean);
+    fitBox(box: Box3): void;
+    getBox(): Box3;
+    dispose(): void;
+}

package/dist/types/core-viewers/ultra/viewer/socketClient.d.ts

@@ -1,6 +1,14 @@
 import * as Protocol from './protocol';
-import { Marshal } from './marshal';
+import { Marshal, ReadMarshal } from './marshal';
 import { ILogger } from './logger';
+import { Segment } from '../utils/math3d';
+export declare const DEFAULT_LOCAL_ULTRA_SERVER_URL = "ws://localhost:8123";
+export type ConnectionSettings = {
+    url?: string;
+    retries?: number;
+    timeout?: number;
+    retryDelay?: number;
+};
 export type ClientState = ClientStateConnecting | ClientStateConnected | ClientStateDisconnected | ClientStateValidating | ClientError;
 export type ClientError = ClientStateCompatibilityError | ClientStateConnectionError | ClientStreamError;
 export type ClientStateConnecting = {
@@ -59,8 +67,11 @@ export declare class SocketClient {
      * @param msg - The video frame message received from the server.
      */
     onVideoFrame: (msg: Protocol.VideoFrameMessage) => void;
+    onCameraPose: (msg: Segment) => void;
     private _state;
     private _onStatusUpdate;
+    private _connectPromise;
+    private _connectionSettings;
     /**
      * Event that is triggered when the connection status updates.
      * @returns An event dispatcher for connection status updates.
@@ -76,8 +87,6 @@ export declare class SocketClient {
      * @param state - The new connection state.
      */
     private updateState;
-    private _connectPromise;
-    private _connectingUrl;
     /**
      * Gets the URL to which the messenger is currently connecting or connected.
      * @returns The WebSocket URL as a string, or undefined if not set.
@@ -94,7 +103,7 @@ export declare class SocketClient {
      * @param url - The WebSocket URL to connect to.
      * @returns A promise that resolves when the connection is established.
      */
-    connect(url: string): Promise<void>;
+    connect(settings: ConnectionSettings): Promise<boolean>;
     /**
      * Disconnects from the current WebSocket server.
      */
@@ -137,7 +146,7 @@ export declare class SocketClient {
      * @param marshal - The Marshal containing the request data.
      * @returns A promise that resolves with the response data.
      */
-    sendRPCWithReturn(marshal: Marshal): Promise<Marshal>;
+    sendRPCWithReturn(marshal: Marshal): Promise<ReadMarshal>;
     /**
      * Sends an RPC request without expecting a response.
      * @param marshal - The Marshal containing the request data.

package/dist/types/core-viewers/ultra/viewer/viewer.d.ts

@@ -1,5 +1,5 @@
 import { IInputs } from './inputs/inputs';
-import { ClientState } from './socketClient';
+import { ClientState, ConnectionSettings } from './socketClient';
 import { IDecoder } from './decoder';
 import { Vim } from './vim';
 import { ILoadRequest } from './loadRequest';
@@ -11,7 +11,7 @@ import { RpcSafeClient, VimSource } from './rpcSafeClient';
 import { ISimpleEvent } from 'ste-simple-events';
 import { IReadonlyVimCollection } from './vimCollection';
 import { IRenderer } from './renderer';
-export declare const DEFAULT_LOCAL_ULTRA_SERVER_URL = "ws://localhost:8123";
+import { SectionBox } from './sectionBox';
 export declare const INVALID_HANDLE = 4294967295;
 /**
  * The main Viewer class responsible for managing VIM files,
@@ -67,6 +67,10 @@ export declare class Viewer {
      * @returns The current ClientStatus.
      */
     get state(): ClientState;
+    /**
+     * The section box API for controlling the section box.
+     */
+    readonly sectionBox: SectionBox;
     /**
      * Creates a Viewer instance with a new canvas element appended to the given parent element.
      * @param parent - The parent HTML element to which the canvas will be appended.
@@ -97,7 +101,7 @@ export declare class Viewer {
      * @param url - The server URL to connect to. Defaults to 'ws://localhost:8123'.
      * @returns A promise that resolves when the connection is established.
      */
-    connect(url?: string): Promise<void>;
+    connect(settings?: ConnectionSettings): Promise<boolean>;
     /**
      * Disconnects from the current VIM Ultra server.
      */

package/dist/types/core-viewers/webgl/loader/materials/ghostMaterial.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @module vim-loader/materials
+ * This module provides materials for rendering specific visualization modes in VIM.
+ */
+import * as THREE from 'three';
+/**
+ * Creates a material for the ghost effect in isolation mode.
+ *
+ * - **Non-visible items**: Rendered as transparent objects using a customizable fill color.
+ * - **Visible items**: Completely excluded from rendering.
+ * - Designed for use with instanced or merged meshes.
+ * - Includes clipping plane support, vertex colors, and transparency.
+ *
+ * @returns {THREE.ShaderMaterial} A custom shader material for the ghost effect.
+ */
+export declare function createGhostMaterial(): THREE.ShaderMaterial;

package/dist/types/core-viewers/webgl/loader/materials/simpleMaterial.d.ts

@@ -1,12 +1,17 @@
 /**
  * @module vim-loader/materials
+ * This module provides custom materials for visualizing and isolating objects in VIM.
  */
 import * as THREE from 'three';
 /**
- * Material for isolation mode
- * Non visible item appear as transparent.
- * Visible items are flat shaded with a basic pseudo lighting.
- * Supports object coloring for visible objects.
- * Non-visible objects use fillColor.
+ * Creates a material for isolation mode.
+ *
+ * - **Non-visible items**: Completely excluded from rendering by pushing them out of view.
+ * - **Visible items**: Rendered with flat shading and basic pseudo-lighting.
+ * - **Object coloring**: Supports both instance-based and vertex-based coloring for visible objects.
+ *
+ * This material is optimized for both instanced and merged meshes, with support for clipping planes.
+ *
+ * @returns {THREE.ShaderMaterial} A custom shader material for isolation mode.
  */
 export declare function createSimpleMaterial(): THREE.ShaderMaterial;

package/dist/types/core-viewers/webgl/loader/materials/viewerMaterials.d.ts

@@ -7,6 +7,7 @@ import { OutlineMaterial } from './outlineMaterial';
 import { ViewerSettings } from '../../viewer/settings/viewerSettings';
 import { MergeMaterial } from './mergeMaterial';
 import { SkyboxMaterial } from './skyboxMaterial';
+export type ModelMaterial = THREE.Material | THREE.Material[] | undefined;
 /**
  * Defines the materials to be used by the vim loader and allows for material injection.
  */
@@ -33,7 +34,7 @@ export declare class ViewerMaterials {
     /**
      * Material used to show traces of hidden objects.
      */
-    readonly isolation: THREE.Material;
+    readonly ghost: THREE.Material;
     /**
      * Material used to filter out what is not selected for selection outline effect.
      */
@@ -57,7 +58,7 @@ export declare class ViewerMaterials {
     private _focusIntensity;
     private _focusColor;
     private _onUpdate;
-    constructor(opaque?: StandardMaterial, transparent?: StandardMaterial, simple?: THREE.Material, wireframe?: THREE.LineBasicMaterial, isolation?: THREE.Material, mask?: THREE.ShaderMaterial, outline?: OutlineMaterial, merge?: MergeMaterial, skyBox?: SkyboxMaterial);
+    constructor(opaque?: StandardMaterial, transparent?: StandardMaterial, simple?: THREE.Material, wireframe?: THREE.LineBasicMaterial, ghost?: THREE.Material, mask?: THREE.ShaderMaterial, outline?: OutlineMaterial, merge?: MergeMaterial, skyBox?: SkyboxMaterial);
     /**
      * Updates material settings based on the provided configuration.
      * @param {ViewerSettings} settings - The settings to apply to the materials.
@@ -73,15 +74,15 @@ export declare class ViewerMaterials {
     get modelColor(): THREE.Color;
     set modelColor(color: THREE.Color);
     /**
-     * Determines the opacity of the isolation material.
+     * Determines the opacity of the ghost material.
      */
-    get isolationOpacity(): number;
-    set isolationOpacity(opacity: number);
+    get ghostOpacity(): number;
+    set ghostOpacity(opacity: number);
     /**
-     * Determines the color of the isolation material.
+     * Determines the color of the ghost material.
      */
-    get isolationColor(): THREE.Color;
-    set isolationColor(color: THREE.Color);
+    get ghostColor(): THREE.Color;
+    set ghostColor(color: THREE.Color);
     /**
      * Determines the color intensity of the highlight effect on mouse hover.
      */

package/dist/types/core-viewers/webgl/loader/mesh.d.ts

@@ -5,6 +5,7 @@ import * as THREE from 'three';
 import { InsertableSubmesh } from './progressive/insertableSubmesh';
 import { Vim } from './vim';
 import { InstancedSubmesh } from './progressive/instancedSubmesh';
+import { ModelMaterial } from './materials/viewerMaterials';
 /**
  * Wrapper around THREE.Mesh
  * Keeps track of what VIM instances are part of this mesh.
@@ -53,7 +54,7 @@ export declare class Mesh {
     /**
      * Overrides mesh material, set to undefine to restore initial material.
      */
-    setMaterial(value: THREE.Material): void;
+    setMaterial(value: ModelMaterial): void;
     /**
      * Returns submesh for given index.
      */

package/dist/types/core-viewers/webgl/loader/progressive/insertableMesh.d.ts

@@ -7,6 +7,7 @@ import { InsertableGeometry } from './insertableGeometry';
 import { InsertableSubmesh } from './insertableSubmesh';
 import { G3dMeshOffsets } from './g3dOffsets';
 import { Vim } from '../vim';
+import { ModelMaterial } from '../materials/viewerMaterials';
 export declare class InsertableMesh {
     offsets: G3dMeshOffsets;
     mesh: THREE.Mesh;
@@ -55,5 +56,5 @@ export declare class InsertableMesh {
     /**
      * Overrides mesh material, set to undefine to restore initial material.
      */
-    setMaterial(value: THREE.Material): void;
+    setMaterial(value: ModelMaterial): void;
 }

package/dist/types/core-viewers/webgl/loader/progressive/instancedMesh.d.ts

@@ -5,6 +5,7 @@ import * as THREE from 'three';
 import { Vim } from '../vim';
 import { InstancedSubmesh } from './instancedSubmesh';
 import { G3d, G3dMesh } from 'vim-format';
+import { ModelMaterial } from '../materials/viewerMaterials';
 export declare class InstancedMesh {
     g3dMesh: G3dMesh | G3d;
     vim: Vim;
@@ -15,6 +16,7 @@ export declare class InstancedMesh {
     boxes: THREE.Box3[];
     ignoreSceneMaterial: boolean;
     private _material;
+    readonly size: number;
     constructor(g3d: G3dMesh | G3d, mesh: THREE.InstancedMesh, instances: Array<number>);
     get merged(): boolean;
     /**
@@ -25,7 +27,7 @@ export declare class InstancedMesh {
      * Returns all submeshes for given index.
      */
     getSubmeshes(): InstancedSubmesh[];
-    setMaterial(value: THREE.Material): void;
+    setMaterial(value: ModelMaterial): void;
     private computeBoundingBoxes;
     private importBoundingBoxes;
     computeBoundingBox(boxes: THREE.Box3[]): THREE.Box3;

package/dist/types/core-viewers/webgl/loader/scene.d.ts

@@ -6,6 +6,7 @@ import { Mesh, Submesh } from './mesh';
 import { Vim } from './vim';
 import { InsertableMesh } from './progressive/insertableMesh';
 import { InstancedMesh } from './progressive/instancedMesh';
+import { ModelMaterial } from './materials/viewerMaterials';
 /**
  * Interface for a renderer object, providing methods to add and remove objects from a scene, update bounding boxes, and notify scene updates.
  */
@@ -76,11 +77,11 @@ export declare class Scene {
     /**
      * Gets the current material override or undefined if none.
      */
-    get material(): THREE.Material | undefined;
+    get material(): ModelMaterial;
     /**
      * Sets and apply a material override to the scene, set to undefined to remove override.
      */
-    set material(value: THREE.Material | undefined);
+    set material(value: ModelMaterial);
     /**
      * Unloads and disposes all meshes and leaves the scene ready to add new ones.
      */

package/dist/types/core-viewers/webgl/viewer/camera/ICamera.d.ts

@@ -0,0 +1,102 @@
+import { ISignal } from 'ste-signals';
+import * as THREE from 'three';
+import { CameraMovement } from './cameraMovement';
+/**
+ * Interface representing a camera with various properties and methods for controlling its behavior.
+ */
+export interface ICamera {
+    /**
+     * A signal that is dispatched when camera settings change.
+     */
+    onSettingsChanged: ISignal;
+    /**
+     * A signal that is dispatched when camera moves.
+     */
+    onMoved: ISignal;
+    /**
+     * True if the camera has moved this frame.
+     */
+    get hasMoved(): boolean;
+    /**
+     * Represents allowed movement along each axis using a Vector3 object.
+     * Each component of the Vector3 should be either 0 or 1 to enable/disable movement along the corresponding axis.
+     */
+    allowedMovement: THREE.Vector3;
+    /**
+     * Represents allowed rotation using a Vector2 object.
+     * Each component of the Vector2 should be either 0 or 1 to enable/disable rotation around the corresponding axis.
+     */
+    allowedRotation: THREE.Vector2;
+    /**
+     * The default forward direction that can be used to initialize the camera.
+     */
+    defaultForward: THREE.Vector3;
+    /**
+     * Interface for instantaneously moving the camera.
+     * @param {boolean} [force=false] - Set to true to ignore locked axis and rotation.
+     * @returns {CameraMovement} The camera movement api.
+     */
+    snap(force?: boolean): CameraMovement;
+    /**
+     * Interface for smoothly moving the camera over time.
+     * @param {number} [duration=1] - The duration of the camera movement animation.
+     * @param {boolean} [force=false] - Set to true to ignore locked axis and rotation.
+     * @returns {CameraMovement} The camera movement api.
+     */
+    lerp(duration: number, force?: boolean): CameraMovement;
+    /**
+     * Calculates the frustum size at a given point in the scene.
+     * @param {THREE.Vector3} point - The point in the scene to calculate the frustum size at.
+     * @returns {number} The frustum size at the specified point.
+     */
+    frustrumSizeAt(point: THREE.Vector3): THREE.Vector2;
+    /**
+     * The current THREE Camera
+     */
+    get three(): THREE.Camera;
+    /**
+     * The quaternion representing the orientation of the object.
+     */
+    get quaternion(): THREE.Quaternion;
+    /**
+    * The position of the camera.
+    */
+    get position(): THREE.Vector3;
+    /**
+     * The matrix representing the transformation of the camera.
+     */
+    get matrix(): THREE.Matrix4;
+    /**
+     * The forward direction of the camera.
+     */
+    get forward(): THREE.Vector3;
+    get isLerping(): boolean;
+    /**
+     * The camera speed factor.
+     */
+    speed: number;
+    /**
+     * The current or target velocity of the camera.
+     */
+    localVelocity: THREE.Vector3;
+    /**
+     * Immediately stops the camera movement.
+     */
+    stop(): void;
+    /**
+     * The target at which the camera is looking at and around which it rotates.
+     */
+    get target(): THREE.Vector3;
+    /**
+     * The distance from the camera to the target.
+     */
+    get orbitDistance(): number;
+    /**
+     * Saves current camera orientation to restore on next reset.
+     */
+    save(): void;
+    /**
+     * Represents whether the camera projection is orthographic.
+     */
+    orthographic: boolean;
+}

package/dist/types/core-viewers/webgl/viewer/environment/cameraLight.d.ts

@@ -2,7 +2,7 @@
  * @module viw-webgl-viewer
  */
 import * as THREE from 'three';
-import { ICamera } from '../camera/camera';
+import { ICamera } from '../camera/ICamera';
 export declare class CameraLight {
     readonly light: THREE.DirectionalLight;
     private readonly _camera;

package/dist/types/core-viewers/webgl/viewer/environment/environment.d.ts

@@ -3,9 +3,8 @@
  */
 import * as THREE from 'three';
 import { ViewerSettings } from '../settings/viewerSettings';
-import { ICamera } from '../camera/camera';
+import { ICamera } from '../camera/ICamera';
 import { ViewerMaterials } from '../../loader/materials/viewerMaterials';
-import { GroundPlane } from './groundPlane';
 import { Skybox } from './skybox';
 import { Renderer } from '../rendering/renderer';
 import { CameraLight } from './cameraLight';
@@ -23,10 +22,6 @@ export declare class Environment {
      * The array of directional lights in the scene.
      */
     readonly sunLights: ReadonlyArray<CameraLight>;
-    /**
-     * The ground plane under the model in the scene.
-     */
-    readonly groundPlane: GroundPlane;
     readonly skybox: Skybox;
     constructor(camera: ICamera, renderer: Renderer, viewerMaterials: ViewerMaterials, settings: ViewerSettings);
     /**
@@ -36,7 +31,6 @@ export declare class Environment {
     private createSkyLight;
     private createSunLights;
     private addObjectsToRenderer;
-    private setupRendererListeners;
     /**
      * Dispose of all resources.
      */

package/dist/types/core-viewers/webgl/viewer/environment/skybox.d.ts

@@ -3,7 +3,7 @@
  */
 import * as THREE from 'three';
 import { ViewerSettings } from '../settings/viewerSettings';
-import { ICamera } from '../camera/camera';
+import { ICamera } from '../camera/ICamera';
 import { ViewerMaterials } from '../../loader/materials/viewerMaterials';
 import { Renderer } from '../rendering/renderer';
 export declare class Skybox {