viral-viewer-2 6.2.6 → 6.2.7

package/dist/components/animation/viral-animation.d.ts

@@ -0,0 +1,9 @@
+import { Clock } from "three";
+import { ViralViewerApi } from "../../viral-viewer-api";
+export declare class ViralAnimation {
+    viralViewerApi: ViralViewerApi;
+    clock: Clock;
+    constructor(viralViewerApi: ViralViewerApi);
+    devAnimation(): void;
+    animation(): void;
+}

package/dist/components/bvh/viral-bvh.d.ts

@@ -0,0 +1,5 @@
+import { BufferGeometry } from "three";
+export declare class ViralBVH {
+    constructor();
+    applyThreeMeshBVH(geometry: BufferGeometry): void;
+}

package/dist/components/camera/viral-camera.d.ts

@@ -0,0 +1,40 @@
+import CameraControls from "camera-controls";
+import { ViralCameraEventType, ViralViewerState } from "../../types";
+import { ViralViewerApi } from "../../viral-viewer-api";
+import { Vector3, Raycaster, PerspectiveCamera, Object3D } from 'three';
+export declare class ViralCamera {
+    viralViewerApi: ViralViewerApi;
+    raycaster: Raycaster;
+    camera: PerspectiveCamera | null;
+    cameraControls: CameraControls | null;
+    targetElement: HTMLElement;
+    onUsing: boolean;
+    constructor(viralViewerApi: ViralViewerApi);
+    setupCamera(): void;
+    /**
+     * resize canvas by resize div
+     */
+    resizeCanvas(): void;
+    /**
+     * focuse model
+     * @param objectName :model name
+     */
+    focusModelByName(objectName?: string): void;
+    getState(): ViralViewerState | null;
+    restoreState(state: ViralViewerState): void;
+    clientToWorld(): import("three").Intersection<Object3D<import("three").Object3DEventMap>>[] | null;
+    worldToClient(point: Vector3): Vector3 | null;
+    private castRay;
+    updateMainCamera(): void;
+    private cameraWakeQueuedEvents;
+    private cameraSleepQueuedEvents;
+    /**
+     *
+     * @param type Mouse type event
+     * @param key key of action
+     * @param resolve callback
+     */
+    addEventListener(type: ViralCameraEventType, key: string, resolve: () => void): void;
+    removeEventListener(type: ViralCameraEventType, key: string): void;
+    getAllEventListener(): void;
+}

package/dist/components/compress/viral-compress.processor.d.ts

@@ -0,0 +1,3 @@
+export declare class ViralCompressProcessor {
+    pakoUnzip(buffer: ArrayBuffer): string;
+}

package/dist/components/custom-objects/index.d.ts

@@ -0,0 +1,2 @@
+import { ViralInstancedMesh } from "./viral-instanced-mesh";
+export { ViralInstancedMesh };

package/dist/components/custom-objects/viral-instanced-mesh.d.ts

@@ -0,0 +1,31 @@
+import { BufferGeometry, InstancedMesh, Material, Mesh } from "three";
+import { Dictionary } from "../../types";
+export declare class ViralInstancedMesh extends InstancedMesh {
+    private _originMesh;
+    private _isOrigin;
+    overrideHoverMeshes: Mesh<BufferGeometry, Material>[];
+    overrideSelectMeshes: Mesh<BufferGeometry, Material>[];
+    _tempHoveredIndexs: number[];
+    hoveredIndexs: Dictionary<number, Material>;
+    _tempSelectedIndexs: number[];
+    selectedIndexs: Dictionary<number, Material>;
+    /**
+     *
+     * @param geometry geometry for instanced mesh
+     * @param materials materials for instanced mesh, can be both 1 or array
+     * @param count number of instance in mesh
+     * @param _host share the same logic with parent, when we push temp mesh into scene, we must binding original viral instanced mesh to host to recall/ reprogress later
+     */
+    constructor(geometry: BufferGeometry, materials: Material[] | Material, count: number);
+    hideAts(indexs: number[]): void;
+    hideObjects(reverseToOriginal?: boolean): void;
+    isolateAts(indexs: number[]): void;
+    isolateObjects(reverseToOriginal?: boolean): void;
+    hoverAts(indexs: number[], material: Material): void;
+    selectAts(indexs: number[], material: Material): void;
+    overrideObjects(reverseToOriginal?: boolean): void;
+    totalSelectedIndex(): number[];
+    reverseIndex(clearHoverIndexs?: boolean, clearSelectIndexs?: boolean): void;
+    reverseToOriginal(reverseHoverMeshes?: boolean, reverseSelectMeshes?: boolean): void;
+    getDistinctNumbers(numbers: number[]): number[];
+}

package/dist/components/data-manager/viral-data-manager.d.ts

@@ -0,0 +1,18 @@
+import { ViralViewerApi } from "../..";
+export declare class ViralDataManager {
+    viralViewerApi: ViralViewerApi;
+    elementData: {
+        [key: number]: any;
+    };
+    private fetchDataWorker;
+    constructor(viralViewerApi: ViralViewerApi);
+    normalFetch(url: string, byteRangeStart?: number, byteRangeEnd?: number): Promise<Response>;
+    /**
+     * worker fetch can only return json or arraybuffer value
+     * @param url
+     * @param callbackOnSuccess
+     * @param byteRangeStart
+     * @param byteRangeEnd
+     */
+    workerFetch(url: string, callbackOnSuccess?: (response: ArrayBuffer) => void, byteRangeStart?: number, byteRangeEnd?: number): void;
+}

package/dist/components/event-handler/base/event-dispatcher.d.ts

@@ -0,0 +1,9 @@
+import { ViralutionEvent } from "../../../types";
+type EventHandler = (...args: any[]) => void;
+export declare class EventDispatcher {
+    private events;
+    on(event: ViralutionEvent, handler: EventHandler): void;
+    off(event: ViralutionEvent, handler: EventHandler): void;
+    emit(event: ViralutionEvent, ...args: any[]): void;
+}
+export {};

package/dist/components/event-handler/keyboard/viral-keyboard.d.ts

@@ -0,0 +1,17 @@
+import { ViralKeyboardEventType, ViralViewerApi } from "../../..";
+export declare class ViralKeyboard {
+    viralViewerApi: ViralViewerApi;
+    constructor(viralViewerApi: ViralViewerApi);
+    private setupKeyPress;
+    private keydownQueuedEvents;
+    private keyupQueuedEvents;
+    /**
+     *
+     * @param type Mouse type event
+     * @param key key of action
+     * @param resolve callback
+     */
+    addEventListener(type: ViralKeyboardEventType, key: string, resolve: (evt: KeyboardEvent) => void): void;
+    removeEventListener(type: ViralKeyboardEventType, key: string): void;
+    getAllEventListener(): void;
+}

package/dist/components/event-handler/mouse/viral-mouse.d.ts

@@ -0,0 +1,31 @@
+import { Vector2 } from "three";
+import { ViralViewerApi } from "../../../viral-viewer-api";
+import { ViralMouseEventType } from "../../../types";
+export declare class ViralMouse {
+    viralViewerApi: ViralViewerApi;
+    position: Vector2;
+    rawPosition: Vector2;
+    private mouseMoveQueuedEvents;
+    private mouseDownLeftQueuedEvents;
+    private mouseUpLeftQueuedEvents;
+    private mouseDownRightQueuedEvents;
+    private mouseUpRightQueuedEvents;
+    constructor(viralViewerApi: ViralViewerApi);
+    private setupMousePositionUpdate;
+    /**
+     *
+     * @param type Mouse type event
+     * @param key key of action
+     * @param resolve callback
+     */
+    addEventListener(type: ViralMouseEventType, key: string, resolve: (result: any) => void): void;
+    removeEventListener(type: ViralMouseEventType, key: string): void;
+    getAllEventListener(): void;
+    private hoverMeshes;
+    private hover;
+    private reverseColor;
+    private setupMouseDown;
+    private handleClick;
+    private setupMouseUp;
+    private handleMouseUp;
+}

package/dist/components/event-handler/viral-centralized-event-handler.d.ts

@@ -0,0 +1,12 @@
+import { ViralViewerApi } from "../../viral-viewer-api";
+export declare class ViralCentralizedEventHandler {
+    viralViewerApi: ViralViewerApi;
+    private _visibilityManager;
+    constructor(viralViewerApi: ViralViewerApi);
+    private contextMenuEventHandler;
+    windowHandler(): void;
+    hoverElementHandler(): void;
+    selectElementHandler(): void;
+    isShiftPressed: boolean;
+    keyboardHandler(): void;
+}

package/dist/components/event-handler/viral-lifecycle-event-handler.d.ts

@@ -0,0 +1,13 @@
+import { ViewerOptions } from "../../types";
+import { EventDispatcher } from "./base/event-dispatcher";
+export declare class ViralLifecycleEventHandler {
+    private eventDispatcher;
+    options: ViewerOptions;
+    constructor(eventDispatcher: EventDispatcher, options: ViewerOptions);
+    private loadedScene;
+    private loadedMaterialManager;
+    private loadedRenderer;
+    private loadedCamera;
+    private loadedCube;
+    private loadedTools;
+}

package/dist/components/loader/viral-point-cloud.loader.d.ts

@@ -0,0 +1,16 @@
+import { Potree, PointCloudOctree } from "potree-core-viral";
+import { ViralViewerApi } from "../../viral-viewer-api";
+export declare class ViralPointCloudLoader {
+    viralViewerApi: ViralViewerApi;
+    potree: Potree;
+    pointClouds: PointCloudOctree[];
+    constructor(viralViewerApi: ViralViewerApi);
+    /**
+     *
+     * @param metadataUrl endpoint to download metadata.json
+     * @param urlOcbinTree endpoint to download octree.bin
+     * @param urlHierarchy endpoint to download hierarchy.bin
+     * @param pointBudget
+     */
+    load(metadataUrl: string, urlOcbinTree: string, urlHierarchy: string, pointBudget?: number, callbackOnSuccess?: (pco: PointCloudOctree) => void): void;
+}

package/dist/components/loader/viral-revit.loader.d.ts

@@ -0,0 +1,11 @@
+import { ViralViewerRevitProject } from "../../types";
+import { ViralViewerApi } from "../../viral-viewer-api";
+export declare class ViralRevitLoader {
+    viralViewerApi: ViralViewerApi;
+    constructor(viralViewerApi: ViralViewerApi);
+    loadRevit(model: ViralViewerRevitProject): void;
+    private progressStructuralGeometries;
+    private progressNoneStructuralGeometries;
+    private addCustomMesh3;
+    private addCustomMesh4;
+}

package/dist/components/loader/viral-three.loader.d.ts

@@ -0,0 +1,11 @@
+import { ObjectLoader } from "three";
+import { ViralViewerApi } from "../../viral-viewer-api";
+import { GLTF, GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
+export declare class ViralThreeLoader {
+    viralViewerApi: ViralViewerApi;
+    objectLoader: ObjectLoader;
+    gltfLoader: GLTFLoader;
+    constructor(viralViewerApi: ViralViewerApi);
+    parseObject(data: any): import("three").Object3D<import("three").Object3DEventMap>;
+    loadGLTF(url: string, onLoad?: (data: GLTF) => void, onProgress?: (data: ProgressEvent<EventTarget>) => void, onError?: (data: unknown) => void): void;
+}

package/dist/components/loader/viral.loader.d.ts

@@ -0,0 +1,11 @@
+import { ViralViewerApi } from "../../viral-viewer-api";
+import { ViralPointCloudLoader } from "./viral-point-cloud.loader";
+import { ViralRevitLoader } from "./viral-revit.loader";
+import { ViralThreeLoader } from "./viral-three.loader";
+export declare class ViralLoader {
+    viralViewerApi: ViralViewerApi;
+    viralRevitLoader: ViralRevitLoader;
+    pointCloudLoader: ViralPointCloudLoader;
+    threeLoader: ViralThreeLoader;
+    constructor(viralViewerApi: ViralViewerApi);
+}

package/dist/components/material/viral-material-manager.d.ts

@@ -0,0 +1,14 @@
+import { LineBasicMaterial, Material, MeshPhongMaterial, ShaderMaterial } from "three";
+import { ViralViewerApi } from "../../viral-viewer-api";
+import { Dictionary } from "../../types";
+export declare class ViralMaterialManager {
+    private viralViewerApi;
+    hoverMaterial: MeshPhongMaterial;
+    selectedMaterial: MeshPhongMaterial;
+    lineMaterial: LineBasicMaterial;
+    vertexShader: string;
+    fragmentShader: string;
+    outlineMaterial: ShaderMaterial;
+    materials: Dictionary<number, Material>;
+    constructor(viralViewerApi: ViralViewerApi);
+}

package/dist/components/post-processing/post-processing-renderer.d.ts

@@ -0,0 +1,19 @@
+import { Camera, Scene, WebGLRenderer } from "three";
+import { N8AOPass } from "../../threejs-addon/n8ao/n8ao";
+import { EffectComposer } from "three/examples/jsm/postprocessing/EffectComposer";
+import { SMAAPass } from "three/examples/jsm/postprocessing/SMAAPass";
+import { ShaderPass } from "three/examples/jsm/postprocessing/ShaderPass";
+export declare class PostProcessingRenderer {
+    private renderer;
+    composer: EffectComposer;
+    renderPass: any;
+    gammaPass: ShaderPass | null;
+    na8oPass: N8AOPass | null;
+    smaaPass: SMAAPass | null;
+    constructor(renderer: WebGLRenderer);
+    render(): void;
+    initRenderPass(scene: Scene, camera: Camera): void;
+    initGammaPass(): void;
+    initN8aoPass(scene: Scene, camera: Camera): void;
+    initSMAAPass(): void;
+}

package/dist/components/renderer/viral-renderer.d.ts

@@ -0,0 +1,11 @@
+import { WebGLRenderer } from "three";
+import { ViralViewerApi } from "../../viral-viewer-api";
+import { PostProcessingRenderer } from "../post-processing/post-processing-renderer";
+export declare class ViralRenderer {
+    viralViewerApi: ViralViewerApi;
+    renderer: WebGLRenderer;
+    postProcessingRenderer: PostProcessingRenderer;
+    constructor(viralViewerApi: ViralViewerApi);
+    updateSize(width: number, height: number): void;
+    render(): void;
+}

package/dist/components/scene/viral-scene.d.ts

@@ -0,0 +1,27 @@
+import { Scene, Mesh, Object3D, Light, CameraHelper } from "three";
+import { ViralViewerApi } from "../../viral-viewer-api";
+import { TransformControls } from "three/examples/jsm/controls/TransformControls";
+export declare class ViralScene {
+    viralViewerApi: ViralViewerApi;
+    scene: Scene;
+    objects: Object3D[];
+    models: Object3D[];
+    mainModel: Mesh;
+    isolateModel: Mesh;
+    selectables: Object3D[];
+    edges: Object3D[];
+    lights: Light[];
+    transformControls: TransformControls | null;
+    lightHelpers: CameraHelper[];
+    constructor(viralViewerApi: ViralViewerApi);
+    addObject(object: Object3D): void;
+    addModel(object: Object3D): void;
+    addEdge(object: Object3D): void;
+    getObjectByName(name: string): Object3D<import("three").Object3DEventMap> | undefined;
+    addLights(): void;
+    addPivotPoint(): void;
+    addTransformControls(): void;
+    addCube(): void;
+    addAxes(): void;
+    enableLightHelper(value: boolean): void;
+}

package/dist/components/stats/viral-stats.d.ts

@@ -0,0 +1,6 @@
+import { ViralViewerApi } from "../../viral-viewer-api";
+export declare class ViralStats {
+    viralViewerApi: ViralViewerApi;
+    stats: Stats | null;
+    constructor(viralViewerApi: ViralViewerApi);
+}

package/dist/components/visibility-manager/viral-visibility-manager.d.ts

@@ -0,0 +1,20 @@
+import { Mesh } from "three";
+import { ViralViewerApi } from "../../viral-viewer-api";
+import { ViralInstancedMesh } from "../..";
+export declare class ViralVisibilityManager {
+    private viralViewerApi;
+    constructor(viralViewerApi: ViralViewerApi);
+    hoverMeshes: Mesh<any, any>[];
+    hoverInstancedMesh: ViralInstancedMesh | null;
+    reverseColor(): void;
+    selectedMeshes: Mesh<any, any>[];
+    selectedInstancedMeshes: ViralInstancedMesh[];
+    reverseSelectedColor(): void;
+    isolateMeshes: Mesh<any, any>[];
+    isolateInstancedMeshes: ViralInstancedMesh[];
+    hiddenMeshes: Mesh<any, any>[];
+    hiddenInstancedMeshes: ViralInstancedMesh[];
+    showAll(): void;
+    hide(): void;
+    isolate(): void;
+}

package/dist/components/worker/base/worker-pool.d.ts

@@ -0,0 +1,23 @@
+export declare class WorkerThreadPool {
+    private maximumNumberOfWorker;
+    private scriptPath;
+    private _workers;
+    private _free;
+    private _busy;
+    private _queue;
+    /**
+     *
+     * @param maxSize maximum number of worker
+     * @param scriptPath javascript path for worker execute
+     */
+    constructor(maxSize: number, scriptPath: string);
+    get length(): number;
+    get busy(): boolean;
+    /**
+     *
+     * @param inputData Input data send to worker
+     * @param resolve callback from worker
+     */
+    Enqueue<T, M>(inputData: T, resolve: (result: M) => void): void;
+    private _PumpQueue;
+}

package/dist/components/worker/base/worker-thread.d.ts

@@ -0,0 +1,10 @@
+export declare class WorkerThread {
+    private _worker;
+    private _resolve;
+    _id: number;
+    constructor(s: string);
+    private _OnMessage;
+    get id(): number;
+    postMessage(data: any, resolve: (data: any) => void): void;
+    dispose(): void;
+}

package/dist/components/worker/fetch-data.worker.d.ts

@@ -0,0 +1,12 @@
+import { WorkerThreadPool } from "./base/worker-pool";
+export declare class FetchDataWorker {
+    workerPool: WorkerThreadPool;
+    constructor();
+    fetch(url: string, callbackOnSuccess?: (response: any) => void, byteRangeStart?: number, byteRangeEnd?: number): void;
+}
+export declare class FetchRequest {
+    url: string;
+    byteRangeStart?: number;
+    byteRangeEnd?: number;
+    constructor(url: string, byteRangeStart?: number, byteRangeEnd?: number);
+}

package/dist/components/worker/viral-viewer-2.worker.d.ts

@@ -0,0 +1,17 @@
+import { ViralViewerApi } from "../../viral-viewer-api";
+import { Dictionary, RenderMaterial, ViralViewerRevitNoneStructuralGeometry, ViralViewerRevitStructuralGeometry } from "../../types";
+import { Mesh, MeshPhongMaterial } from "three";
+import { WorkerThreadPool } from "./base/worker-pool";
+export declare class ViralViewerWorker2 {
+    viralViewerApi: ViralViewerApi;
+    workerPool: WorkerThreadPool;
+    materials: RenderMaterial[];
+    mainModel: Mesh | null;
+    threejsMaterials: Dictionary<number, MeshPhongMaterial>;
+    private readonly maxPolygonPerObject;
+    private readonly maxPolygonForEdge;
+    constructor(viralViewerApi: ViralViewerApi, scriptUrl?: string);
+    initial(materials: RenderMaterial[]): void;
+    loadStructuralGeometry(model: ViralViewerRevitStructuralGeometry, callbackOnSuccess?: () => void): void;
+    loadNoneStructuralGeometry(model: ViralViewerRevitNoneStructuralGeometry, callbackOnSuccess?: () => void): void;
+}

package/dist/components/worker/viral-viewer-3.worker.d.ts

@@ -0,0 +1,14 @@
+import { ViralViewerApi } from "../../viral-viewer-api";
+import { RenderMaterial, ViralViewerRevitNoneStructuralGeometry, ViralViewerRevitStructuralGeometry } from "../../types";
+import { Mesh } from "three";
+import { WorkerThreadPool } from "./base/worker-pool";
+export declare class ViralViewerWorker3 {
+    viralViewerApi: ViralViewerApi;
+    workerPool: WorkerThreadPool;
+    materials: RenderMaterial[];
+    mainModel: Mesh | null;
+    constructor(viralViewerApi: ViralViewerApi, scriptUrl?: string);
+    initial(materials: RenderMaterial[]): void;
+    loadStructuralGeometry(model: ViralViewerRevitStructuralGeometry, callbackOnSuccess?: () => void): void;
+    loadNoneStructuralGeometry(model: ViralViewerRevitNoneStructuralGeometry, callbackOnSuccess?: () => void): void;
+}

package/dist/components/worker/viral-viewer-4.worker.d.ts

@@ -0,0 +1,10 @@
+import { ViralViewerApi } from "../../viral-viewer-api";
+import { RenderMaterial, ViralutionElement } from "../../types";
+import { WorkerThreadPool } from "./base/worker-pool";
+export declare class ViralViewerWorker4 {
+    viralViewerApi: ViralViewerApi;
+    workerPool: WorkerThreadPool;
+    constructor(viralViewerApi: ViralViewerApi);
+    initial(materials: RenderMaterial[]): void;
+    loadElement(elements: ViralutionElement[], callbackOnSuccess?: () => void): void;
+}

package/dist/components/worker/viral-viewer.worker.d.ts

@@ -0,0 +1,8 @@
+import { ViralViewerApi } from "../../viral-viewer-api";
+import { ViralViewerRevitProject } from "../../types";
+export declare class ViralViewerWorker {
+    viralViewerApi: ViralViewerApi;
+    worker: Worker;
+    constructor(viralViewerApi: ViralViewerApi, scriptUrl?: string);
+    loadModel(model: ViralViewerRevitProject, callbackOnSuccess?: () => void): void;
+}

package/dist/components/worker-script/fetch-data-worker.script.d.ts

@@ -0,0 +1 @@
+export declare const workerCode: any;

package/dist/components/worker-script/load-model-worker-2.script.d.ts

@@ -0,0 +1 @@
+export declare const workerCode: any;

package/dist/components/worker-script/load-model-worker-3.script.d.ts

@@ -0,0 +1 @@
+export function workerCode(): void;

package/dist/components/worker-script/load-model-worker.script.d.ts

@@ -0,0 +1 @@
+export declare const workerCode: any;

package/dist/components/worker-script/threejs.types.d.ts

@@ -0,0 +1 @@
+export function workerCode(): void;

package/dist/const/colors.d.ts

@@ -0,0 +1,13 @@
+export declare const LightTheme: {
+    background: string;
+    primary: string;
+    secondary: string;
+    accent: string;
+    accent2: string;
+};
+export declare const DarkTheme: {
+    background: string;
+    primary: string;
+    secondary: string;
+    accent: string;
+};

package/dist/const/fonts.d.ts

@@ -0,0 +1,7 @@
+export declare class FontIndentity {
+    importLink: string;
+    fontFamily: string;
+}
+export declare const fonts: {
+    [key: string]: FontIndentity;
+};

package/dist/gui/context-menu/viral-context-menu.d.ts

@@ -0,0 +1,17 @@
+import { ViralViewerApi } from "../../viral-viewer-api";
+export declare class ViralContextMenu {
+    viralViewerApi: ViralViewerApi;
+    private contextMenu;
+    private contextItems;
+    constructor(viralViewerApi: ViralViewerApi);
+    private injectContextMenu;
+    showContextMenu(top: number, left: number, itemKeys: number[]): void;
+    hideContextMenu(): void;
+    private initContent;
+    /**
+     *
+     * @param itemName
+     * @param resolve callback when user click
+     */
+    addContextItem(itemKey: number, itemName: string, resolve: (result: any) => void): void;
+}

package/dist/gui/draggable-modal/viral-draggable-modal.d.ts

@@ -0,0 +1,11 @@
+import { ViralViewerApi } from "../../viral-viewer-api";
+export declare class ViralDraggableModal {
+    viralViewerApi: ViralViewerApi;
+    private rawModal;
+    private rawModalStyle;
+    isDragging: boolean;
+    offsetX: number;
+    offsetY: number;
+    constructor(viralViewerApi: ViralViewerApi);
+    inject(): void;
+}

package/dist/gui/fonts/fonts.d.ts

@@ -0,0 +1,2 @@
+export declare const injectFonts: (fontKey: string) => void;
+export declare const applyFonts: (element: HTMLElement, fontKey: string) => void;

package/dist/gui/navigation-cube/components/cube-camera.d.ts

@@ -0,0 +1,15 @@
+import CameraControls from "camera-controls";
+import { Vector3, PerspectiveCamera } from 'three';
+import { ViralNavigationCube } from "../viral-navigation-cube";
+export declare class CubeCamera {
+    viralNavigationCube: ViralNavigationCube;
+    camera: PerspectiveCamera | null;
+    cameraControls: CameraControls | null;
+    cameraControlOldPosition: Vector3;
+    cameraControlNewPosition: Vector3;
+    cameraControlHasMoved: boolean;
+    constructor(viralNavigationCube: ViralNavigationCube);
+    setupCamera(): void;
+    updateCubeCamera(): void;
+    setupHandle(): void;
+}

package/dist/gui/navigation-cube/components/cube-renderer.d.ts

@@ -0,0 +1,9 @@
+import { WebGLRenderer } from "three";
+import { ViralNavigationCube } from "../viral-navigation-cube";
+export declare class CubeRenderer {
+    viralNavigationCube: ViralNavigationCube;
+    renderer: WebGLRenderer;
+    constructor(viralNavigationCube: ViralNavigationCube);
+    setupRenderer(): void;
+    render(): void;
+}

package/dist/gui/navigation-cube/components/cube-scene.d.ts

@@ -0,0 +1,13 @@
+import { Scene, Mesh, Object3D, MeshBasicMaterial, BufferGeometry } from 'three';
+import { ViralNavigationCube } from '../viral-navigation-cube';
+export declare class CubeScene {
+    viralNavigationCube: ViralNavigationCube;
+    scene: Scene;
+    objects: Object3D[];
+    cube: Mesh | null;
+    activePlane: Mesh<BufferGeometry, MeshBasicMaterial> | null;
+    constructor(viralNavigationCube: ViralNavigationCube);
+    addObject(object: Object3D): void;
+    addCube(): void;
+    addPlanes(): void;
+}

package/dist/gui/navigation-cube/components/cube.mouse.d.ts

@@ -0,0 +1,9 @@
+import { ViralNavigationCube } from "../viral-navigation-cube";
+export declare class CubeMouse {
+    viralNavigationCube: ViralNavigationCube;
+    constructor(viralNavigationCube: ViralNavigationCube);
+    private setupMouseClick;
+    private handleClick;
+    private setupMouseMove;
+    private handleMove;
+}

package/dist/gui/navigation-cube/viral-navigation-cube.d.ts

@@ -0,0 +1,16 @@
+import { ViralViewerApi } from "../../viral-viewer-api";
+import { CubeCamera } from "./components/cube-camera";
+import { CubeRenderer } from "./components/cube-renderer";
+import { CubeScene } from "./components/cube-scene";
+import { CubeMouse } from "./components/cube.mouse";
+export declare class ViralNavigationCube {
+    viralViewerApi: ViralViewerApi;
+    targetElement: HTMLElement | null;
+    cubeScene: CubeScene | null;
+    cubeRenderer: CubeRenderer | null;
+    cubeCamera: CubeCamera | null;
+    cubeMouse: CubeMouse | null;
+    constructor(viralViewerApi: ViralViewerApi);
+    private injectCubeWrapperElement;
+    private handleClick;
+}

package/dist/gui/spinner/viral-spinner.d.ts

@@ -0,0 +1,10 @@
+import { ViralViewerApi } from "../../viral-viewer-api";
+export declare class ViralSpinner {
+    viralViewerApi: ViralViewerApi;
+    private spinner;
+    private logo;
+    constructor(viralViewerApi: ViralViewerApi);
+    private injectSpinner;
+    showSpinner(): void;
+    hideSpinner(): void;
+}

package/dist/gui/tools/tools/viral-tool-ambient-occlusion.d.ts

@@ -0,0 +1,7 @@
+import { ViralViewerTool } from "../../../types";
+import { ViralTools } from "../viral-tools";
+export declare class ViralToolAmbientOcclusion {
+    viralTools: ViralTools;
+    constructor(viralTools: ViralTools);
+    activate(input: ViralViewerTool): void;
+}