vim-web 0.3.43 → 0.3.44-dev.0

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,7 @@
 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;
@@ -66,6 +67,7 @@ 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;
@@ -144,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

@@ -11,6 +11,7 @@ import { RpcSafeClient, VimSource } from './rpcSafeClient';
 import { ISimpleEvent } from 'ste-simple-events';
 import { IReadonlyVimCollection } from './vimCollection';
 import { IRenderer } from './renderer';
+import { SectionBox } from './sectionBox';
 export declare const INVALID_HANDLE = 4294967295;
 /**
  * The main Viewer class responsible for managing VIM files,
@@ -66,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.

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,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 { Skybox } from './skybox';
 import { Renderer } from '../rendering/renderer';

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 {

package/dist/types/core-viewers/webgl/viewer/gizmos/sectionBox/SectionBoxMesh.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+/**
+ * Defines the box mesh for the section box.
+ */
+export declare class SectionBoxMesh extends THREE.Mesh {
+    constructor();
+    /**
+     * Resize the mesh to the given box.
+     */
+    fitBox(box: THREE.Box3): void;
+    /**
+     * Disposes of all resources.
+     */
+    dispose(): void;
+}

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

@@ -1,18 +1,21 @@
 /**
- @module viw-webgl-viewer/gizmos/sectionBox
-*/
+ * @module viw-webgl-viewer/gizmos/sectionBox
+ */
 import { Viewer } from '../../viewer';
 import * as THREE from 'three';
 /**
- * Gizmo for section box, serving as a proxy between the renderer and the user.
+ * Manages a section box gizmo, serving as a proxy between the renderer and the user.
+ *
+ * This class:
+ *  - Maintains a Three.js `Box3` that defines the clipping region.
+ *  - Handles user interaction via {@link BoxInputs}.
+ *  - Updates a {@link SectionBoxGizmo} to visualize the clipping box.
+ *  - Dispatches signals when the box is resized or interaction state changes.
  */
 export declare class SectionBox {
     private _viewer;
+    private _gizmos;
     private _inputs;
-    private _cube;
-    private _outline;
-    private _highlight;
-    private _normal;
     private _clip;
     private _visible;
     private _interactive;
@@ -20,51 +23,82 @@ export declare class SectionBox {
     private _onBoxConfirm;
     private _onHover;
     /**
-     * Signal dispatched when clip, show, or interactive are updated.
+     * @internal
+     * A convenience getter to the viewer's renderer.
+     */
+    private get renderer();
+    /**
+     * @internal
+     * A convenience getter to the `Section` module in the renderer.
+     */
+    private get section();
+    /**
+     * Dispatches when any of the following properties change:
+     * - {@link clip} (clipping planes active)
+     * - {@link visible} (gizmo visibility)
+     * - {@link interactive} (pointer inputs active)
      */
     get onStateChanged(): import("ste-signals").ISignal;
     /**
-     * Signal dispatched when user is done manipulating the box.
+     * Dispatches when the user finishes manipulating (dragging) the box.
+     * The payload is the final {@link THREE.Box3} used for clipping.
      */
     get onBoxConfirm(): import("ste-simple-events").ISimpleEvent<THREE.Box3>;
     /**
-     * Signal dispatched with true when pointer enters box and false when pointer leaves.
+     * Dispatches a boolean indicating pointer hover state on the box handles:
+     *  - `true` if the pointer has entered a handle
+     *  - `false` if it has left or no handle is hovered
      */
     get onHover(): import("ste-simple-events").ISimpleEvent<boolean>;
-    private get renderer();
-    private get section();
+    /**
+     * Creates a new SectionBox gizmo controller.
+     *
+     * @param viewer - The parent {@link Viewer} in which the section box is rendered.
+     */
     constructor(viewer: Viewer);
     /**
-     * Section bounding box, to update the box use fitBox.
+     * The shared bounding box that defines the section region.
+     *
+     * To programmatically update the box, see {@link fitBox}.
      */
     get box(): THREE.Box3;
     /**
-     * Determines whether the section gizmo will section the model with clipping planes.
+     * Determines whether the section gizmo applies clipping planes to the model.
+     *
+     * When `true`, `renderer.section.active` is enabled.
      */
     get clip(): boolean;
     set clip(value: boolean);
     /**
-     * Determines whether the gizmo reacts to user inputs.
+     * Determines whether the gizmo is interactive (i.e. responds to pointer events).
+     *
+     * When `true`, pointer events are registered and box handles can be dragged.
      */
     get interactive(): boolean;
     set interactive(value: boolean);
     /**
-     * Determines whether the gizmo will be rendered.
+     * Determines whether the section box gizmo is visible in the scene.
      */
     get visible(): boolean;
     set visible(value: boolean);
     /**
-     * Sets the section gizmo size to match the given box.
-     * @param {THREE.Box3} box - The box to match the section gizmo size to.
-     * @param {number} [padding=1] - The padding to apply to the box.
+     * Resizes the section gizmo to match the given box, optionally expanded by a padding.
+     * After resizing, this method also updates the renderer's clipping box.
+     *
+     * @param box - The bounding box to match (required).
+     * @param padding - The scalar amount by which to expand the bounding box. Default is `1`.
      */
     fitBox(box: THREE.Box3, padding?: number): void;
     /**
-     * Call this if there were direct changes to renderer.section
+     * Updates the section box to match the current size of `this.section.box`.
+     *
+     * Call this if the renderer's section box is changed by code outside this class.
      */
     update(): void;
     /**
-     * Removes gizmo from rendering and inputs and dispose all resources.
+     * Disposes of the gizmo and input event listeners, cleaning up related resources.
+     *
+     * After disposal, this `SectionBox` instance should no longer be used.
      */
     dispose(): void;
 }

package/dist/types/core-viewers/webgl/viewer/gizmos/sectionBox/sectionBoxGizmo.d.ts

@@ -1,47 +1,17 @@
-/**
- * @module viw-webgl-viewer/gizmos/sectionBox
- */
 import * as THREE from 'three';
-/**
- * Defines the thin outline on the edges of the section box.
- */
-export declare class BoxOutline extends THREE.LineSegments {
-    constructor();
-    /**
-     * Resize the outline to the given box.
-     */
+import { SectionBoxMesh } from './SectionBoxMesh';
+import { SectionBoxOutline } from './sectionBoxOutline';
+import { SectionBoxHandles } from './sectionBoxHandles';
+import { Renderer } from '../../rendering/renderer';
+export declare class SectionBoxGizmo {
+    private _renderer;
+    readonly cube: SectionBoxMesh;
+    readonly outline: SectionBoxOutline;
+    readonly handles: SectionBoxHandles;
+    private _visible;
+    get visible(): boolean;
+    set visible(value: boolean);
+    constructor(renderer: Renderer);
     fitBox(box: THREE.Box3): void;
-    /**
-     * Disposes of all resources.
-     */
-    dispose(): void;
-}
-/**
- * Defines the box mesh for the section box.
- */
-export declare class BoxMesh extends THREE.Mesh {
-    constructor();
-    /**
-     * Resize the mesh to the given box.
-     */
-    fitBox(box: THREE.Box3): void;
-    /**
-     * Disposes of all resources.
-     */
-    dispose(): void;
-}
-/**
- * Defines the face highlight on hover for the section box.
- */
-export declare class BoxHighlight extends THREE.Mesh {
-    constructor();
-    /**
-     * Sets the face to highlight
-     * @param normal a direction vector from theses options (X,-X, Y,-Y, Z,-Z)
-     */
-    highlight(box: THREE.Box3, normal: THREE.Vector3): void;
-    /**
-     * Disposes all resources.
-     */
     dispose(): void;
 }

package/dist/types/core-viewers/webgl/viewer/gizmos/sectionBox/sectionBoxHandle.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+export type Axis = 'x' | 'y' | 'z';
+export declare class SectionBoxHandle extends THREE.Mesh {
+    readonly axis: Axis;
+    readonly sign: number;
+    private _forward;
+    private _color;
+    private _highlightColor;
+    private _materials;
+    constructor(axes: Axis, sign: number, size: number, color?: THREE.Color);
+    setPosition(position: THREE.Vector3): void;
+    get forward(): THREE.Vector3;
+    highlight(value: boolean): void;
+    dispose(): void;
+}

package/dist/types/core-viewers/webgl/viewer/gizmos/sectionBox/sectionBoxHandles.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @module viw-webgl-viewer/gizmos/sectionBox
+ */
+import * as THREE from 'three';
+import { SectionBoxHandle } from './sectionBoxHandle';
+export declare class SectionBoxHandles {
+    readonly up: SectionBoxHandle;
+    readonly down: SectionBoxHandle;
+    readonly left: SectionBoxHandle;
+    readonly right: SectionBoxHandle;
+    readonly front: SectionBoxHandle;
+    readonly back: SectionBoxHandle;
+    readonly meshes: THREE.Group;
+    constructor();
+    get visible(): boolean;
+    set visible(value: boolean);
+    fitBox(box: THREE.Box3): void;
+    dispose(): void;
+}