vim-web 0.3.44-dev.9 → 0.4.1-dev.0

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

@@ -28,10 +28,8 @@ export declare class BoxInputs {
     private _raycaster;
     /** The box state before the current drag. */
     private _lastBox;
-    /** A collection of unregister callbacks for event listeners. */
-    private _unregisters;
-    /** The ID of the pointer that is captured, if any. */
-    private _capturedPointerId;
+    /** A callback to restore the original input listeners after unregistering. */
+    private _restoreOriginalInputs;
     /**
      * Called when the pointer enters or leaves a handle face.
      * @param normal - The normal (forward) vector of the hovered handle, or a zero vector if none.
@@ -65,35 +63,6 @@ export declare class BoxInputs {
      * and resetting drag state.
      */
     unregister(): void;
-    /**
-     * Indicates if a pointer is currently captured for dragging.
-     */
-    get pointerCaptured(): boolean;
-    /**
-     * A helper method to attach an event listener and store its unregister callback.
-     *
-     * @param handler - The DOM element or Window to attach the listener to.
-     * @param type - The pointer event type, e.g. 'pointerdown'.
-     * @param listener - The event handler function.
-     */
-    private reg;
-    /**
-     * Called when the pointer leaves the canvas. If not dragging,
-     * invokes {@link onFaceEnter} to indicate no active handle is hovered.
-     *
-     * @param event - The pointerleave event.
-     */
-    private onPointerLeave;
-    /**
-     * Sets pointer capture on the canvas for a specific pointer (ID).
-     *
-     * @param pointerId - The pointer ID to capture.
-     */
-    private capturePointer;
-    /**
-     * Releases any captured pointer on the canvas, if present.
-     */
-    private releasePointer;
     /**
      * Handles pointer movement events.
      * - If dragging, calls {@link onDrag}.
@@ -131,13 +100,6 @@ export declare class BoxInputs {
      * @returns A **new** `Box3` instance with updated min/max coordinates.
      */
     private stretch;
-    /**
-     * Prepares the internal raycaster for a given 2D pointer position.
-     *
-     * @param position - The pointer position in canvas coordinates.
-     * @returns The updated raycaster pointing from the camera through this position.
-     */
-    private getRaycaster;
     /**
      * Raycasts into the handle meshes from the given pointer position.
      *
@@ -152,4 +114,5 @@ export declare class BoxInputs {
      * @returns The intersection point in 3D space, or `null` if none.
      */
     private raycastPlane;
+    private setupRaycaster;
 }

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

@@ -0,0 +1,10 @@
+export * from './viewer';
+export * from './settings';
+export { Layers } from './raycaster';
+export type * from './environment';
+export type * from './gizmos';
+export type * from './raycaster';
+export type * from './selection';
+export type * from './viewport';
+export type * from './rendering';
+export type * from './camera';

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

@@ -0,0 +1,3 @@
+import { InputHandler } from "../../shared/inputHandler";
+import { Viewer } from "./viewer";
+export declare function createInputHandler(viewer: Viewer): InputHandler;

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

@@ -2,88 +2,68 @@
  * @module viw-webgl-viewer
  */
 import * as THREE from 'three';
-import { Object3D } from '../loader/object3D';
+import { Element3D } from '../loader/element3d';
 import { RenderScene } from './rendering/renderScene';
-import { Viewport } from './viewport';
 import { Camera } from './camera/camera';
 import { Renderer } from './rendering/renderer';
-import { GizmoMarker } from './gizmos/markers/gizmoMarker';
+import { Marker } from './gizmos/markers/gizmoMarker';
+import type { IRaycaster as IRaycasterBase, IRaycastResult as IRaycastResultBase } from '../../shared';
 /**
- * Type alias for THREE intersection array
+ * Type alias for an array of THREE.Intersection objects.
  */
 export type ThreeIntersectionList = THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[];
-export type ActionType = 'main' | 'double' | 'idle';
-export type ActionModifier = 'none' | 'shift' | 'ctrl';
+export type RaycastableObject = Element3D | Marker;
+export type IRaycastResult = IRaycastResultBase<RaycastableObject>;
+export type IRaycaster = IRaycasterBase<RaycastableObject>;
+export declare enum Layers {
+    Default = 0,
+    NoRaycast = 1
+}
 /**
- * Highlevel aggregate of information about a raycast result
+ * A simple container for raycast results.
  */
-export declare class RaycastResult {
-    object: Object3D | GizmoMarker | undefined;
+export declare class RaycastResult implements IRaycastResult {
+    object: Element3D | Marker | undefined;
     intersections: ThreeIntersectionList;
     firstHit: THREE.Intersection | undefined;
-    constructor(intersections: ThreeIntersectionList);
-    private GetFirstVimHit;
-    private GetFirstMarkerHit;
-    private getVimObjectFromHit;
-    get isHit(): boolean;
-    get distance(): number;
-    get position(): THREE.Vector3;
-    get threeId(): number;
-    get faceIndex(): number;
+    get worldNormal(): THREE.Vector3;
+    get worldPosition(): THREE.Vector3;
+    constructor(intersections: ThreeIntersectionList, firstHit?: THREE.Intersection, object?: Element3D | Marker);
 }
-export declare class Raycaster {
-    private _viewport;
+/**
+ * Performs raycasting operations.
+ */
+export declare class Raycaster implements IRaycaster {
     private _camera;
     private _scene;
     private _renderer;
     private _raycaster;
-    constructor(viewport: Viewport, camera: Camera, scene: RenderScene, renderer: Renderer);
+    constructor(camera: Camera, scene: RenderScene, renderer: Renderer);
     /**
-     * Performs a raycast by projecting a ray from the camera position to a screen position.
-     * @param {THREE.Vector2} position - The screen position for raycasting.
+     * Performs a raycast from the camera using normalized screen coordinates.
+     * Coordinates must be within [0, 1] for both x and y.
      */
-    raycast2(position: THREE.Vector2): RaycastResult;
-    private filterHits;
+    raycastFromScreen(position: THREE.Vector2): Promise<RaycastResult>;
     /**
-     * Performs a raycast by projecting a ray from the camera position to a world position.
-     * @param {THREE.Vector3} position - The world position for raycasting.
+     * Performs a raycast from the camera towards a specified world position.
      */
-    raycast3(position: THREE.Vector3): RaycastResult;
+    raycastFromWorld(position: THREE.Vector3): Promise<RaycastResult>;
+    private filterHits;
     /**
-     * Performs a raycast by projecting a ray from the camera center.
+     * Processes the list of intersections to determine the first valid hit.
+     * It first checks for a marker hit, then for a model object hit.
      */
-    raycastForward(): RaycastResult;
+    private processIntersections;
     /**
-     * Returns a THREE.Raycaster projecting a ray from camera position to screen position
+     * Extracts the core model object from a raycast hit.
      */
-    fromPoint2(position: THREE.Vector2, target?: THREE.Raycaster): THREE.Raycaster;
+    private getVimObjectFromHit;
     /**
-     * Returns a THREE.Raycaster projecting a ray from the camera position to a screen position.
-     * @param {THREE.Vector2} position - The screen position for raycasting.
-     * @returns {THREE.Raycaster} A raycaster object for performing raycasting.
+     * Creates a WebglRaycastResult from a list of intersections by processing the hits.
      */
-    fromPoint3(position: THREE.Vector3, target?: THREE.Raycaster): THREE.Raycaster;
+    private createResultFromIntersections;
 }
 /**
- * Represents an input action with its position and modifiers.
+ * Converts normalized screen coordinates (0-1 range) into Three.js NDC ([-1, 1] range).
  */
-export declare class InputAction {
-    readonly position: THREE.Vector2;
-    readonly modifier: ActionModifier;
-    readonly type: ActionType;
-    private _raycaster;
-    constructor(type: ActionType, modifier: ActionModifier, position: THREE.Vector2, raycaster: Raycaster);
-    private _raycast;
-    /**
-     * A THREE.Raycaster object for custom raycasting.
-     */
-    get raycaster(): THREE.Raycaster;
-    /**
-     * Performs raycasting for VIM objects at the current point. This operation can be computationally expensive.
-     */
-    get raycast(): RaycastResult;
-    /**
-     * Returns the object at the current point. This operation can cause a computationally expensive raycast evaluation.
-     */
-    get object(): Object3D | GizmoMarker;
-}
+export declare function threeNDCFromVector2(position: THREE.Vector2): THREE.Vector2;

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

@@ -0,0 +1,4 @@
+export type * from './renderingSection';
+export type * from './renderer';
+export type * from './renderScene';
+export type * from './renderingComposer';

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

@@ -3,14 +3,14 @@
  */
 import * as THREE from 'three';
 import { Pass } from 'three/examples/jsm/postprocessing/Pass';
-import { ViewerMaterials } from '../../loader/materials/viewerMaterials';
+import { Materials } from '../../loader/materials/materials';
 /**
  * Merges a source buffer into the the current write buffer.
  */
 export declare class MergePass extends Pass {
     private _fsQuad;
     private _material;
-    constructor(source: THREE.Texture, materials?: ViewerMaterials);
+    constructor(source: THREE.Texture, materials?: Materials);
     get source(): THREE.Texture;
     set source(value: THREE.Texture);
     dispose(): void;

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

@@ -3,32 +3,32 @@
  */
 import * as THREE from 'three';
 import { Scene } from '../../loader/scene';
-import { ModelMaterial } from '../../loader/materials/viewerMaterials';
+import { ModelMaterial } from '../../loader/materials/materials';
 import { InstancedMesh } from '../../loader/progressive/instancedMesh';
 /**
  * Wrapper around the THREE scene that tracks bounding box and other information.
  */
 export declare class RenderScene {
-    scene: THREE.Scene;
+    threeScene: THREE.Scene;
     boxUpdated: boolean;
     smallGhostThreshold: number | undefined;
     private _vimScenes;
     private _boundingBox;
     private _memory;
     private _2dCount;
+    private _outlineCount;
     private _modelMaterial;
-    get meshes(): (import("../..").InsertableMesh | import("../../loader/mesh").Mesh | InstancedMesh)[];
+    get meshes(): (import("../..").InsertableMesh | import("../..").Mesh | InstancedMesh)[];
     constructor();
     get estimatedMemory(): number;
     has2dObjects(): boolean;
-    hasOutline(): boolean;
     /** Clears the scene updated flags */
     clearUpdateFlags(): void;
     /**
      * Returns the bounding box encompasing all rendererd objects.
      * @param target box in which to copy result, a new instance is created if undefined.
      */
-    getBoundingBox(target?: THREE.Box3): THREE.Box3;
+    getBoundingBox(target?: THREE.Box3): THREE.Box3 | undefined;
     /**
      * Returns the bounding box of the average center of all meshes.
      * Less precise but is more stable against outliers.

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

@@ -5,7 +5,7 @@ import * as THREE from 'three';
 import { IRenderer, Scene } from '../../loader/scene';
 import { Viewport } from '../viewport';
 import { RenderScene } from './renderScene';
-import { ModelMaterial, ViewerMaterials } from '../../loader/materials/viewerMaterials';
+import { ModelMaterial, Materials } from '../../loader/materials/materials';
 import { CSS2DRenderer } from 'three/examples/jsm/renderers/CSS2DRenderer';
 import { Camera } from '../camera/camera';
 import { RenderingSection } from './renderingSection';
@@ -41,6 +41,7 @@ export declare class Renderer implements IRenderer {
     private _onBoxUpdated;
     private _sceneUpdated;
     private maxMemory;
+    private _outlineCount;
     /**
      * Indicates whether the scene should be re-rendered on change only.
      */
@@ -51,7 +52,7 @@ export declare class Renderer implements IRenderer {
      */
     get needsUpdate(): boolean;
     set needsUpdate(value: boolean);
-    constructor(scene: RenderScene, viewport: Viewport, materials: ViewerMaterials, camera: Camera, settings: ViewerSettings);
+    constructor(scene: RenderScene, viewport: Viewport, materials: Materials, camera: Camera, settings: ViewerSettings);
     /**
      * Removes all objects from rendering and disposes the WebGL context.
      */
@@ -83,7 +84,7 @@ export declare class Renderer implements IRenderer {
      * @param target - Box in which to copy the result. A new instance is created if undefined.
      * @returns The bounding box encompassing all rendered objects.
      */
-    getBoundingBox(target?: THREE.Box3): THREE.Box3;
+    getBoundingBox(target?: THREE.Box3): THREE.Box3 | undefined;
     /**
      * Updates the global rendering bounding box.
      * @param box - The new bounding box.
@@ -93,6 +94,8 @@ export declare class Renderer implements IRenderer {
      * Notifies that a scene was updated this frame.
      */
     notifySceneUpdate(): void;
+    addOutline(): void;
+    removeOutline(): void;
     /**
      * Renders what is in the camera's view.
      */

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

@@ -4,7 +4,7 @@
 import * as THREE from 'three';
 import { Viewport } from '../viewport';
 import { RenderScene } from './renderScene';
-import { ViewerMaterials } from '../../loader/materials/viewerMaterials';
+import { Materials } from '../../loader/materials/materials';
 import { Camera } from '../camera/camera';
 /**
  * Composer for managing the rendering pipeline including anti-aliasing and outline effects.
@@ -39,7 +39,7 @@ export declare class RenderingComposer {
      * @param materials - Materials used for rendering including outline and mask materials
      * @param camera - The camera used for rendering
      */
-    constructor(renderer: THREE.WebGLRenderer, scene: RenderScene, viewport: Viewport, materials: ViewerMaterials, camera: Camera);
+    constructor(renderer: THREE.WebGLRenderer, scene: RenderScene, viewport: Viewport, materials: Materials, camera: Camera);
     /**
      * Initializes the main scene rendering pipeline
      * Creates render targets and sets up the main render pass

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

@@ -2,7 +2,7 @@
  * @module viw-webgl-viewer/rendering
  */
 import * as THREE from 'three';
-import { ViewerMaterials } from '../../loader/materials/viewerMaterials';
+import { Materials } from '../../loader/materials/materials';
 import { Renderer } from './renderer';
 /**
  * Manages a section box from renderer clipping planes
@@ -22,7 +22,7 @@ export declare class RenderingSection {
     private maxZ;
     private minZ;
     private planes;
-    constructor(renderer: Renderer, materials: ViewerMaterials);
+    constructor(renderer: Renderer, materials: Materials);
     /**
      * Resizes the section box to match the dimensions of the provided bounding box.
      * @param box The bounding box to match the section box to.

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

@@ -1,92 +1,9 @@
 /**
  * @module viw-webgl-viewer
  */
-import * as THREE from 'three';
-import { Vim } from '../loader/vim';
-import { ViewerMaterials } from '../loader/materials/viewerMaterials';
-import { GizmoMarker } from './gizmos/markers/gizmoMarker';
-import { Object3D } from '../loader/object3D';
-export type SelectableObject = Object3D | GizmoMarker;
-/**
- * Provides selection behaviour for the viewer
- * Supports multi-selection as long as all objects are from the same vim.
- */
-export declare class Selection {
-    private _materials;
-    private _objects;
-    private _focusedObject;
-    private _vim;
-    private _lastFocusTime;
-    private _onValueChanged;
-    private _unsub;
-    constructor(materials: ViewerMaterials);
-    /**
-     * Event called when selection changes or is cleared
-     */
-    get onValueChanged(): import("ste-signals").ISignal;
-    /**
-     * Returns the Vim instance from which elements are selected.
-     * Cross-Vim selection is not supported.
-     */
-    get vim(): Vim;
-    /**
-     * Returns selected object as an iterator.
-     */
-    get objects(): SetIterator<SelectableObject>;
-    /**
-     * Retrieves the bounding box of the selection. Returns `undefined` if there's no selection.
-     * @param {THREE.Box3} [target] Optional parameter to specify a box to use for the result.
-     * @returns {THREE.Box3 | undefined} The bounding box of the selection or `undefined` if no selection exists.
-     */
-    getBoundingBox(target?: THREE.Box3): THREE.Box3 | undefined;
-    /**
-     * Adds focus highlight to a single object. Pass `undefined` to remove the highlight.
-     * @param {IObject | undefined} object The object to focus on, or `undefined` to remove the highlight.
-     */
-    focus(object: SelectableObject | undefined): void;
-    /**
-     * Selects the given objects and unselects all other objects.
-     * Pass `null`, `undefined`, or an empty array as argument to clear selection.
-     * @param {IObject | IObject[] | undefined} object The object or array of objects to select,
-     *        or `null`, `undefined`, or an empty array to clear the selection.
-     */
-    select(object: SelectableObject | SelectableObject[] | undefined): void;
-    any(): boolean;
-    /**
-     * Returns true if the given object is currently selected.
-     * @param {IObject} object The object to check for selection.
-     * @returns {boolean} True if the object is selected, false otherwise.
-     */
-    has(object: SelectableObject): boolean;
-    /**
-     * Returns the current count of selected objects.
-     */
-    get count(): number;
-    /**
-     * Adds the given objects to the current selection.
-     * @param {...IObject[]} objects The objects to add to the selection.
-     */
-    add(...objects: SelectableObject[]): void;
-    /**
-     * Removes the given objects from the current selection.
-     * @param {...IObject[]} objects The objects to remove from the selection.
-     */
-    remove(...objects: SelectableObject[]): void;
-    /**
-     * Toggles the selection state of the given objects:
-     * - Adds unselected elements of the given objects to the selection.
-     * - Removes selected elements of the given objects from the selection.
-     * @param {...IObject[]} objects The objects to toggle selection for.
-     */
-    toggle(...objects: SelectableObject[]): void;
-    /**
-     * Clears the current selection.
-     */
-    clear(): void;
-    /**
-     * Disposes of all resources and stops animations.
-     */
-    dispose(): void;
-    private clearOnNewVim;
-    update(): void;
-}
+import { Marker } from './gizmos/markers/gizmoMarker';
+import { Element3D } from '../loader/element3d';
+import { Selection } from '../../shared/selection';
+export type Selectable = Element3D | Marker;
+export type ISelection = Selection<Selectable>;
+export declare function createSelection(): Selection<Selectable>;

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

@@ -0,0 +1,3 @@
+export * from './viewerDefaultSettings';
+export * from './viewerSettings';
+export * from './viewerSettingsParsing';

package/dist/types/core-viewers/webgl/viewer/settings/{defaultViewerSettings.d.ts → viewerDefaultSettings.d.ts}

@@ -2,4 +2,4 @@ import { ViewerSettings } from './viewerSettings';
 /**
  * Defines the default values for the VIM Viewer settings.
  */
-export declare const defaultViewerSettings: ViewerSettings;
+export declare function getDefaultViewerSettings(): ViewerSettings;

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

@@ -3,15 +3,8 @@
 */
 import * as THREE from 'three';
 import { AxesSettings } from '../gizmos/axes/axesSettings';
+import { RecursivePartial } from '../../../../utils/partial';
 export type TextureEncoding = 'url' | 'base64' | undefined;
-export { AxesSettings } from '../gizmos/axes/axesSettings';
-/**
- * Makes all field optional recursively
- * https://stackoverflow.com/questions/41980195/recursive-partialt-in-typescript
- */
-export type RecursivePartial<T> = {
-    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object ? RecursivePartial<T[P]> : T[P];
-};
 /** Viewer related options independant from vims */
 export type ViewerSettings = {
     /**
@@ -309,4 +302,4 @@ export type PartialViewerSettings = RecursivePartial<ViewerSettings>;
  * Returns a full viewer settings where all unassigned values are replaced with the default values.
  * @param settings optional values to use instead of default.
  */
-export declare function getViewerSettings(settings?: PartialViewerSettings): ViewerSettings;
+export declare function createViewerSettings(settings?: PartialViewerSettings): ViewerSettings;

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

@@ -6,4 +6,4 @@ import { PartialViewerSettings } from './viewerSettings';
  * @param url URL string with standard parameters.
  * @returns A PartialSettings object that can further be merged with default values.
  */
-export declare function getViewerSettingsFromUrl(url?: string, settings?: PartialViewerSettings): PartialViewerSettings;
+export declare function createViewerSettingsFromUrl(url?: string, settings?: PartialViewerSettings): PartialViewerSettings;

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

@@ -1,18 +1,18 @@
 /**
  @module viw-webgl-viewer
 */
-import { ViewerSettings, PartialViewerSettings } from './settings/viewerSettings';
-import { ICamera } from './camera/ICamera';
-import { Input } from './inputs/input';
-import { Selection } from './selection';
+import { Camera } from './camera/camera';
 import { Environment } from './environment/environment';
-import { Raycaster } from './raycaster';
-import { Viewport } from './viewport';
 import { Gizmos } from './gizmos/gizmos';
-import { Renderer } from './rendering/renderer';
+import { IRaycaster } from './raycaster';
+import { ISelection } from './selection';
+import { PartialViewerSettings, ViewerSettings } from './settings/viewerSettings';
+import { Viewport } from './viewport';
 import { ISignal } from 'ste-signals';
-import { ViewerMaterials } from '../loader/materials/viewerMaterials';
+import type { InputHandler } from '../../shared';
+import { Materials } from '../loader/materials/materials';
 import { Vim } from '../loader/vim';
+import { Renderer } from './rendering/renderer';
 /**
  * Viewer and loader for vim files.
  */
@@ -32,19 +32,19 @@ export declare class Viewer {
     /**
      * The interface for managing viewer selection.
      */
-    readonly selection: Selection;
+    readonly selection: ISelection;
     /**
      * The interface for manipulating default viewer inputs.
      */
-    readonly inputs: Input;
+    readonly inputs: InputHandler;
     /**
      * The interface for performing raycasting into the scene to find objects.
      */
-    readonly raycaster: Raycaster;
+    readonly raycaster: IRaycaster;
     /**
      * The materials used by the viewer to render the vims.
      */
-    readonly materials: ViewerMaterials;
+    readonly materials: Materials;
     /**
      * The environment of the viewer, including the ground plane and lights.
      */
@@ -52,7 +52,7 @@ export declare class Viewer {
     /**
      * The interface for manipulating the viewer's camera.
      */
-    get camera(): ICamera;
+    get camera(): Camera;
     /**
      * The collection of gizmos available for visualization and interaction within the viewer.
      */

package/dist/types/index.d.ts

@@ -1,4 +1,3 @@
-export * as WebglViewer from './core-viewers/webgl';
-export * as UltraViewer from './core-viewers/ultra';
-export * from './react-viewers';
+export * as Core from './core-viewers';
+export * as React from './react-viewers';
 export * as THREE from 'three';

package/dist/types/react-viewers/bim/bimInfoData.d.ts

@@ -3,7 +3,7 @@
  * and data handling of a BIM info panel. The hook provides references for customizing
  * how data is processed and rendered in different sections of the BIM info panel.
  */
-import * as VIM from '../../core-viewers/webgl/index';
+import * as Core from '../../core-viewers';
 /**
  * Represents an entry in the BIM info panel, such as a key-value pair in a header or body section.
  */
@@ -76,7 +76,7 @@ export type Data = {
  * @param source - The VIM.Object or VIM.Vim instance from which the data was originally extracted.
  * @returns A promise that resolves to the modified Data object.
  */
-export type DataCustomization = (data: Data, source: VIM.Vim | VIM.Object3D) => Promise<Data>;
+export type DataCustomization = (data: Data, source: Core.Webgl.Vim | Core.Webgl.Element3D) => Promise<Data>;
 /**
  * A rendering customization function that takes props containing data and a standard
  * rendering function, and returns a custom JSX element. This function enables developers

package/dist/types/react-viewers/bim/bimInfoObject.d.ts

@@ -1,12 +1,12 @@
-import * as VIM from '../../core-viewers/webgl/index';
+import * as Core from '../../core-viewers';
 import * as BIM from './bimInfoData';
 import { AugmentedElement } from '../helpers/element';
-export declare type ElementParameter = {
+export type ElementParameter = {
     name: string | undefined;
     value: string | undefined;
     group: string | undefined;
     isInstance: boolean;
 };
-export declare function getObjectData(object: VIM.Object3D, elements: AugmentedElement[]): Promise<BIM.Data>;
+export declare function getObjectData(object: Core.Webgl.Element3D, elements: AugmentedElement[]): Promise<BIM.Data>;
 export declare function getHeader(info: AugmentedElement | undefined): BIM.Entry[] | undefined;
-export declare function getBody(object: VIM.Object3D): Promise<BIM.Section[]>;
+export declare function getBody(object: Core.Webgl.Element3D): Promise<BIM.Section[]>;

package/dist/types/react-viewers/bim/bimInfoPanel.d.ts

@@ -1,9 +1,9 @@
-import * as VIM from '../../core-viewers/webgl/index';
+import * as Core from '../../core-viewers';
 import { AugmentedElement } from '../helpers/element';
 import { BimInfoPanelRef } from './bimInfoData';
 export declare function BimInfoPanel(props: {
-    object: VIM.Object3D;
-    vim: VIM.Vim;
+    object: Core.Webgl.Element3D;
+    vim: Core.Webgl.Vim;
     elements: AugmentedElement[];
     full: boolean;
     bimInfoRef: BimInfoPanelRef;

package/dist/types/react-viewers/bim/bimInfoVim.d.ts

@@ -1,5 +1,5 @@
-import * as VIM from '../../core-viewers/webgl/index';
+import * as Core from '../../core-viewers';
 import * as BIM from './bimInfoData';
-export declare function getVimData(vim: VIM.Vim): Promise<BIM.Data>;
-export declare function getHeader(vim: VIM.Vim): Promise<BIM.Entry[]>;
-export declare function getBody(vim: VIM.Vim): Promise<BIM.Section[] | undefined>;
+export declare function getVimData(vim: Core.Webgl.Vim): Promise<BIM.Data>;
+export declare function getHeader(vim: Core.Webgl.Vim): Promise<BIM.Entry[]>;
+export declare function getBody(vim: Core.Webgl.Vim): Promise<BIM.Section[] | undefined>;