vim-web 0.6.0-dev.0 → 0.6.0-dev.10

package/dist/vim-web.d.ts

@@ -0,0 +1,3364 @@
+import * as THREE from 'three';
+export { THREE };
+import * as BIM from 'vim-format';
+import { IElement, VimHelpers, VimHeader, VimDocument } from 'vim-format';
+export { BIM };
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React, { ReactNode } from 'react';
+
+/**
+ * @module vim-loader
+ */
+/**
+ * Determines how to draw (or not) transparent and opaque objects
+ */
+type TransparencyMode = 'opaqueOnly' | 'transparentOnly' | 'allAsOpaque' | 'all';
+
+/**
+ * @module vim-loader
+ */
+
+/**
+ * Per-model transform and rendering settings, passed to `viewer.load(source, settings)`.
+ * Controls how an individual VIM file is positioned, rotated, and scaled in the scene.
+ * Not to be confused with {@link ViewerSettings} (renderer config) or WebglSettings (UI toggles).
+ *
+ * @example
+ * viewer.load({ url }, { position: new THREE.Vector3(100, 0, 0), scale: 2 })
+ */
+type VimSettings = {
+    /**
+     * The positional offset for the vim object, in Z-up space (X = right, Y = forward, Z = up).
+     */
+    position: THREE.Vector3;
+    /**
+     * The XYZ rotation applied to the vim object, in degrees.
+     */
+    rotation: THREE.Vector3;
+    /**
+     * The scaling factor applied to the vim object.
+     */
+    scale: number;
+    /**
+     * The matrix representation of the vim object's position, rotation, and scale.
+     * Setting this will override individual position, rotation, and scale properties.
+     */
+    matrix: THREE.Matrix4;
+    /**
+     * Determines whether objects are drawn based on their transparency.
+     */
+    transparency: TransparencyMode;
+    /**
+     * Set to true to enable verbose HTTP logging.
+     */
+    verboseHttp: boolean;
+};
+/**
+ * Represents a partial configuration of settings for a vim object.
+ */
+type VimPartialSettings = Partial<VimSettings>;
+
+interface AxesSettings {
+    size: number;
+    padding: number;
+    bubbleSizePrimary: number;
+    bubbleSizeSecondary: number;
+    lineWidth: number;
+    fontPxSize: number;
+    fontFamily: string;
+    fontWeight: string;
+    fontColor: string;
+    className: string;
+    colorX: string;
+    colorY: string;
+    colorZ: string;
+    colorXSub: string;
+    colorYSub: string;
+    colorZSub: string;
+}
+
+/**
+ * Makes all field optional recursively
+ * https://stackoverflow.com/questions/41980195/recursive-partialt-in-typescript
+ */
+type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object ? RecursivePartial<T[P]> : T[P];
+};
+
+/**
+ @module viw-webgl-viewer
+*/
+
+type MaterialSettings = {
+    /**
+     * Use fast simple materials instead of standard Lambert materials
+     * - Enables: Significantly faster rendering (no Lambert lighting calculations)
+     * - Trade-off: Simpler pseudo-lighting using screen-space derivatives
+     * - Useful for: Performance-critical scenarios, large models, lower-end hardware
+     * Default: false
+     */
+    useFastMaterials: boolean;
+    /**
+    * Default color of standard material
+    */
+    standard: {
+        color: THREE.Color;
+    };
+    /**
+    * Ghost material options
+    */
+    ghost: {
+        /**
+        * Ghost material color
+        * Default: rgb(78, 82, 92)
+        */
+        color: THREE.Color;
+        /**
+        * Ghost material opacity
+        * Default: 0.08
+        */
+        opacity: number;
+    };
+    /**
+    * Section box intersection highlight options
+    */
+    section: {
+        /**
+        * Intersection highlight stroke width.
+        * Default: 0.01
+        */
+        strokeWidth: number;
+        /**
+        * Intersection highlight stroke falloff.
+        * Default: 0.75
+        */
+        strokeFalloff: number;
+        /**
+        * Intersection highlight stroke color.
+        * Default: rgb(246, 246, 246)
+        */
+        strokeColor: THREE.Color;
+    };
+    /**
+    * Selection outline options
+    */
+    outline: {
+        /**
+        * Selection outline opacity (0 = invisible, 1 = fully opaque).
+        * Default: 1
+        */
+        opacity: number;
+        /**
+        * Selection outline color.
+        * Default: rgb(0, 255, 255)
+        */
+        color: THREE.Color;
+        /**
+        * Scale factor for outline render target resolution (0-1).
+        * Lower = faster, higher = sharper outlines.
+        * Default: 0.75
+        */
+        scale: number;
+        /**
+        * Outline thickness in pixels (of the outline render target).
+        * Higher values sample more pixels per fragment (4 fetches per level).
+        * Range: 1-5. Default: 2
+        */
+        thickness: number;
+    };
+};
+/**
+ * Core renderer configuration, passed to `Core.Webgl.createViewer(settings)` at initialization.
+ * Controls camera defaults, lighting, materials, canvas, and rendering pipeline.
+ * Not to be confused with {@link VimSettings} (per-model transform) or WebglSettings (React UI toggles).
+ *
+ * @example
+ * const viewer = Core.Webgl.createViewer({
+ *   camera: { orthographic: true, fov: 50 },
+ *   materials: { useFastMaterials: true }
+ * })
+ */
+type ViewerSettings = {
+    /**
+     * Webgl canvas related options
+     */
+    canvas: {
+        /**
+         * Canvas dom model id. If none provided a new canvas will be created
+         * Default: undefined.
+         */
+        id: string | undefined;
+        /**
+         * Limits how often canvas will be resized if window is resized in ms.
+         * Default: 200
+         */
+        resizeDelay: number;
+    };
+    /**
+     * Three.js camera related options
+     */
+    camera: {
+        /**
+         * Start with orthographic camera
+         * Default: false
+         */
+        orthographic: boolean;
+        /**
+         * Movement lock per axis in Z-up space (X = right, Y = forward, Z = up).
+         * Each component should be 0 (locked) or 1 (free).
+         * Default: THREE.Vector3(1, 1, 1)
+         */
+        lockMovement: THREE.Vector3;
+        /**
+         * Rotation lock per axis. x = yaw (around Z), y = pitch (up/down).
+         * Each component should be 0 (locked) or 1 (free).
+         * Default: THREE.Vector2(1, 1)
+         */
+        lockRotation: THREE.Vector2;
+        /**
+         * Near clipping plane distance
+         * Default: 0.01
+         */
+        near: number;
+        /**
+         * Far clipping plane distance
+         * Default: 15000
+         */
+        far: number;
+        /**
+         * Fov angle in degrees
+         * Default: 50
+         */
+        fov: number;
+        /**
+         * Camera zoom level
+         * Default: 1
+         */
+        zoom: number;
+        /**
+         * Initial forward vector of the camera in Z-up space (X = right, Y = forward, Z = up).
+         * Default: THREE.Vector3(1, -1, 1)
+         */
+        forward: THREE.Vector3;
+        /** Camera controls related options */
+        controls: {
+            /**
+             * <p>Set true to start in orbit mode.</p>
+             * <p>Camera has two modes: First person and orbit</p>
+             * <p>First person allows to moves the camera around freely</p>
+             * <p>Orbit rotates the camera around a focus point</p>
+             * Default: true
+             */
+            orbit: boolean;
+            /**
+             * Camera rotation speed factor
+             * Default: 1
+             */
+            rotateSpeed: number;
+            /**
+             * Camera orbit rotation speed factor.
+             * Default: 1
+             */
+            orbitSpeed: number;
+            /**
+             * Camera movement speed factor
+             * Default: 1
+             */
+            moveSpeed: number;
+            /**
+             * Camera movement speed factor on mouse scroll
+             * Default: 1
+             * Range: [0.1, 10]
+             */
+            scrollSpeed: number;
+        };
+        /** Camera gizmo related options */
+        gizmo: {
+            /**
+            * Enables/Disables camera gizmo.
+            * Default: true
+            */
+            enable: boolean;
+            /**
+            * Size of camera gizmo as fraction of screen (0-1).
+            * Default: 0.1
+            */
+            size: number;
+            /**
+            * Color of vertical rings (great circles).
+            * Default: THREE.Color(0x0590cc) - VIM blue
+            */
+            color: THREE.Color;
+            /**
+            * Color of horizontal rings (latitude circles).
+            * Default: THREE.Color(0x58b5dd) - Primary_300
+            */
+            colorHorizontal: THREE.Color;
+            /**
+            * Opacity of the camera gizmo when in front of objects.
+            * Default: 0.5
+            */
+            opacity: number;
+            /**
+            * Opacity of the camera gizmo when behind objects.
+            * Default: 0.1
+            */
+            opacityAlways: number;
+        };
+    };
+    /**
+     * Rendering background options
+     */
+    background: {
+        /**
+         * Color of the cavas background
+         * Default: THREE.Color('#96999f')
+         */
+        color: THREE.Color;
+    };
+    /**
+     * Skybox options
+     */
+    skybox: {
+        /**
+         * Enables/Disables skybox.
+         */
+        enable: boolean;
+        /**
+         * Color for the lower part of the skybox.
+         */
+        groundColor: THREE.Color;
+        /**
+         * Color for the upper part of the skybox.
+         */
+        skyColor: THREE.Color;
+        /**
+         * Controls the gradient transition between the sky and the ground.
+         */
+        sharpness: number;
+    };
+    /**
+    * Material options
+    */
+    materials: MaterialSettings;
+    /**
+     * Axes gizmo options
+     */
+    axes: Partial<AxesSettings>;
+    /**
+     * Skylight (hemisphere light) options
+     */
+    skylight: {
+        /**
+        * Skylight sky Color.
+        * Default: THREE.Color(153, 204, 255)
+        */
+        skyColor: THREE.Color;
+        /**
+        * Skylight ground color.
+        * Default: THREE.Color(242, 213, 181)
+        */
+        groundColor: THREE.Color;
+        /**
+        * Skylight intensity.
+        * Default: 0.8
+        */
+        intensity: number;
+    };
+    /**
+     * Sunlight (directional light) options
+     * Two Blue-Green lights at odd angles. See defaultViewerSettings.
+     */
+    sunlights: {
+        followCamera: boolean;
+        /** Light position. */
+        position: THREE.Vector3;
+        /** Light color. */
+        color: THREE.Color;
+        /** Light intensity. */
+        intensity: number;
+    }[];
+    rendering: {
+        /**
+         * When true, only renders when changes are detected. When false, renders every frame.
+         * Default: true
+         */
+        autoRender: boolean;
+    };
+};
+/**
+ * Same as the Setting type but any field can be undefined.
+ */
+type PartialViewerSettings = RecursivePartial<ViewerSettings>;
+
+/**
+ * @module vim-loader/materials
+ *
+ * MaterialSet provides a cleaner API for managing material overrides.
+ * Instead of confusing arrays [visible, hidden], we explicitly name each material type.
+ */
+
+/**
+ * A set of materials for different geometry types and visibility states.
+ *
+ * This replaces the confusing array-based system where [material0, material1]
+ * was ambiguous (opaque/transparent? visible/hidden?).
+ *
+ * Now we explicitly name each material:
+ * - opaque: For solid geometry (undefined = don't render opaque meshes)
+ * - transparent: For see-through geometry (undefined = don't render transparent meshes)
+ * - hidden: For ghosted/hidden objects (undefined = don't render ghost)
+ */
+declare class MaterialSet {
+    readonly opaque?: THREE.Material;
+    readonly transparent?: THREE.Material;
+    readonly hidden?: THREE.Material;
+    constructor(opaque?: THREE.Material, transparent?: THREE.Material, hidden?: THREE.Material);
+    /**
+     * Get material for opaque meshes.
+     * Returns a single material, or a `[visible, hidden]` array when a ghost material is set.
+     * Returns `undefined` if no opaque material exists (mesh should be hidden).
+     */
+    getOpaque(): THREE.Material | THREE.Material[] | undefined;
+    /**
+     * Get material for transparent meshes.
+     * Returns a single material, or a `[visible, hidden]` array when a ghost material is set.
+     * Returns `undefined` if no transparent material exists (mesh should be hidden).
+     */
+    getTransparent(): THREE.Material | THREE.Material[] | undefined;
+    private _resolve;
+    /**
+     * Check if this MaterialSet is equivalent to another.
+     * Used to avoid unnecessary material updates.
+     */
+    equals(other: MaterialSet | undefined): boolean;
+}
+
+/**
+ * @module vim-loader/materials
+ */
+
+/**
+ * Public API for material configuration.
+ * Users interact with this interface via `viewer.materials`.
+ *
+ * Raw THREE materials are exposed for building MaterialSet.
+ * All property mutation goes through flat proxy getters/setters.
+ */
+interface IMaterials {
+    /** The opaque model material. Used as the opaque slot when building a MaterialSet. */
+    readonly modelOpaqueMaterial: THREE.Material;
+    /** The transparent model material. Used as the transparent slot when building a MaterialSet. */
+    readonly modelTransparentMaterial: THREE.Material;
+    /** The ghost material used to render hidden/ghosted elements. */
+    readonly ghostMaterial: THREE.Material;
+    /** Base color tint applied to opaque and transparent model materials. */
+    modelColor: THREE.Color;
+    /** Opacity of the ghost material (0 = invisible, 1 = fully opaque). */
+    ghostOpacity: number;
+    /** Color of the ghost material. */
+    ghostColor: THREE.Color;
+    /** Opacity of the selection outline (0 = invisible, 1 = fully opaque). */
+    outlineOpacity: number;
+    /** Thickness of the selection outline in pixels (of the outline render target). Range: 1-5. */
+    outlineThickness: number;
+    /** Color of the selection outline post-process effect. */
+    outlineColor: THREE.Color;
+    /** Width of the stroke rendered where the section box intersects the model. */
+    sectionStrokeWidth: number;
+    /** Gradient falloff of the section box intersection stroke. */
+    sectionStrokeFalloff: number;
+    /** Color of the section box intersection stroke. */
+    sectionStrokeColor: THREE.Color;
+    /** Clipping planes applied to all materials. Set to undefined to disable clipping. */
+    clippingPlanes: THREE.Plane[] | undefined;
+    /** Applies a full set of material settings from the viewer configuration. */
+    applySettings(settings: MaterialSettings): void;
+}
+
+/**
+ * @module vim-loader
+ */
+
+/** Public-facing interface for vim.scene. Represents loaded geometry in the renderer. */
+interface IScene {
+    /** The world transform matrix applied to all meshes in this scene. */
+    readonly matrix: THREE.Matrix4;
+    /** Bounding box of currently loaded geometry in Z-up world space (X = right, Y = forward, Z = up). Undefined if nothing loaded yet. */
+    getBoundingBox(target?: THREE.Box3): THREE.Box3 | undefined;
+    /** Bounding box using average mesh centers, in Z-up world space. More stable against outliers. */
+    getAverageBoundingBox(): THREE.Box3;
+    /** Material override for all meshes in this scene. */
+    material: MaterialSet;
+}
+
+/**
+ * A signal with no payload.
+ * Subscribe to be notified when the signal fires.
+ */
+interface ISignal {
+    /** Number of active subscriptions. */
+    readonly count: number;
+    /** Subscribe to the signal. Returns a function that unsubscribes. */
+    subscribe(fn: () => void): () => void;
+    /** Alias for {@link subscribe}. */
+    sub(fn: () => void): () => void;
+    /** Subscribe once — automatically removed after first fire. */
+    one(fn: () => void): () => void;
+    /** Remove a subscription by handler reference. */
+    unsubscribe(fn: () => void): void;
+    /** Check whether a handler is currently subscribed. */
+    has(fn: () => void): boolean;
+    /** Remove all subscriptions. */
+    clear(): void;
+}
+/**
+ * A signal that carries a payload of type `T`.
+ * Subscribers receive the payload as their first argument.
+ */
+interface ISimpleEvent<T> {
+    /** Number of active subscriptions. */
+    readonly count: number;
+    /** Subscribe to the event. Returns a function that unsubscribes. */
+    subscribe(fn: (args: T) => void): () => void;
+    /** Alias for {@link subscribe}. */
+    sub(fn: (args: T) => void): () => void;
+    /** Subscribe once — automatically removed after first fire. */
+    one(fn: (args: T) => void): () => void;
+    /** Remove a subscription by handler reference. */
+    unsubscribe(fn: (args: T) => void): void;
+    /** Check whether a handler is currently subscribed. */
+    has(fn: (args: T) => void): boolean;
+    /** Remove all subscriptions. */
+    clear(): void;
+}
+
+/**
+ * Interface for a Vim element.
+ */
+interface IVimElement {
+    /**
+     * The vim from which this object came.
+     */
+    vim: IVim<IVimElement> | undefined;
+    /**
+     * The bounding box of the object.
+     */
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
+}
+/**
+ * Interface for a Vim object.
+ * @template T - The type of element contained in the Vim.
+ */
+interface IVim<T extends IVimElement> {
+    /**
+     * Stable index assigned by the viewer (0-254).
+     * Used by VimCollection for O(1) lookup.
+     */
+    readonly vimIndex: number;
+    /**
+     * Retrieves the element associated with the specified instance index.
+     * @param instance - The instance index of the of one of the instance included in the element.
+     * @returns The object corresponding to the instance, or undefined if not found.
+     */
+    getElement(instance: number): T | undefined;
+    /**
+     * Retrieves the element associated with the specified id.
+     * @param id - The element ID to retrieve objects for (number or bigint).
+     * @returns An array of element corresponding to the given id.
+     */
+    getElementsFromId(id: number | bigint): T[];
+    /**
+     * Retrieves the element associated with the given index.
+     * @param element - The index of the element.
+     * @returns The element corresponding to the element index, or undefined if not found.
+     */
+    getElementFromIndex(element: number): T | undefined;
+    /**
+     * Retrieves all elements within the Vim.
+     * @returns An array of all Vim objects.
+     */
+    getAllElements(): T[];
+}
+
+/**
+ * Public interface for the selection manager.
+ *
+ * In the WebGL viewer, `T` is {@link ISelectable} — a union of `IElement3D` and `IMarker`.
+ * Use the `type` discriminant (`'Element3D'` or `'Marker'`) to narrow:
+ *
+ * @example
+ * ```ts
+ * const selected = viewer.core.selection.getAll()
+ * for (const item of selected) {
+ *   if (item.type === 'Element3D') {
+ *     // item is IElement3D — has .hasMesh, .getBimElement(), etc.
+ *   }
+ * }
+ *
+ * // Common operations
+ * viewer.core.selection.select(element)              // Replace selection
+ * viewer.core.selection.add(element)                 // Add to selection
+ * viewer.core.selection.clear()                      // Clear all
+ * viewer.core.selection.onSelectionChanged.sub(() => { ... })  // React to changes
+ * ```
+ */
+interface ISelection<T extends IVimElement> {
+    /** If true, selecting an already-selected single object toggles it off. */
+    toggleOnRepeatSelect: boolean;
+    /** If false, all selection operations are no-ops. */
+    enabled: boolean;
+    /** Returns true if the target is currently selected. */
+    has(target: T): boolean;
+    /** Returns the number of currently selected objects. */
+    count(): number;
+    /** Returns true if at least one object is selected. */
+    any(): boolean;
+    /** Signal that fires whenever the selection changes. */
+    readonly onSelectionChanged: ISignal;
+    /** Replaces the entire selection with the given object. */
+    select(object: T): void;
+    /** Replaces the entire selection with the given objects. */
+    select(objects: T[]): void;
+    /** Toggles the selection state of the given object. */
+    toggle(object: T): void;
+    /** Toggles the selection state of the given objects. */
+    toggle(objects: T[]): void;
+    /** Adds the given object to the selection. */
+    add(object: T): void;
+    /** Adds the given objects to the selection. */
+    add(objects: T[]): void;
+    /** Removes the given object from the selection. */
+    remove(object: T): void;
+    /** Removes the given objects from the selection. */
+    remove(objects: T[]): void;
+    /** Clears the entire selection. */
+    clear(): void;
+    /** Returns an array of all currently selected objects. */
+    getAll(): T[];
+    /** Returns all selected objects belonging to a specific VIM model. */
+    getFromVim(vim: IVim<T>): T[];
+    /** Removes all selected objects that belong to a specific VIM model. */
+    removeFromVim(vim: IVim<T>): void;
+    /** Computes the bounding box encompassing all selected objects, in Z-up world space (X = right, Y = forward, Z = up). */
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
+}
+
+/**
+ * @module viw-webgl-viewer
+ */
+
+/**
+ * Selectable object in the WebGL viewer. Both {@link IElement3D} and {@link IMarker} implement this.
+ *
+ * Use the `type` discriminant to narrow:
+ * - `'Element3D'` → {@link IElement3D} (BIM element with geometry, color, BIM data)
+ * - `'Marker'` → {@link IMarker} (sprite gizmo in the scene)
+ *
+ * @example
+ * ```ts
+ * const items = viewer.core.selection.getAll()  // ISelectable[]
+ * for (const item of items) {
+ *   if (item.type === 'Element3D') {
+ *     const el = item as IElement3D
+ *     console.log(el.hasMesh, el.elementId)
+ *   }
+ * }
+ * ```
+ */
+interface ISelectable extends IVimElement {
+    /** Discriminant: `'Element3D'` for BIM elements, `'Marker'` for gizmo markers. */
+    readonly type: string;
+    /** The BIM element index, or undefined for markers without an associated element. */
+    readonly element: number | undefined;
+    /** Whether to render selection outline for this object. */
+    outline: boolean;
+    /** Whether to render this object. */
+    visible: boolean;
+    /** True if this object is a room element. Always false for markers. */
+    readonly isRoom: boolean;
+    /** The geometry instances associated with this object, if any. */
+    readonly instances: number[] | undefined;
+}
+type IWebglSelection = ISelection<ISelectable>;
+/**
+ * Type guard to narrow an {@link ISelectable} to an `IElement3D`.
+ *
+ * @example
+ * ```ts
+ * const items = viewer.core.selection.getAll()
+ * const elements = items.filter(isElement3D)  // IElement3D[]
+ * ```
+ */
+declare function isElement3D(item: ISelectable): item is ISelectable & {
+    type: 'Element3D';
+};
+
+/**
+ * @module vim-loader
+ */
+
+/**
+ * Public interface for a loaded BIM element with geometry and visual state.
+ *
+ * Obtained via `vim.getElementFromIndex(index)` or `vim.getAllElements()`.
+ *
+ * @example
+ * ```ts
+ * const element = vim.getElementFromIndex(301)
+ * element.color = new THREE.Color(0xff0000)
+ * element.visible = false
+ * const params = await element.getBimParameters()
+ * ```
+ */
+interface IElement3D extends ISelectable {
+    readonly type: 'Element3D';
+    /** The vim from which this element came. */
+    readonly vim: IWebglVim;
+    /** The BIM element index. */
+    readonly element: number;
+    /** The unique element ID. */
+    readonly elementId: bigint;
+    /** The geometry instances associated with this element. */
+    readonly instances: number[] | undefined;
+    /** True if this element has associated geometry. */
+    readonly hasMesh: boolean;
+    /** True if this element is a room. */
+    readonly isRoom: boolean;
+    /** Whether to render selection outline for this element. */
+    outline: boolean;
+    /** Whether to render focus highlight for this element. */
+    focused: boolean;
+    /** Whether to render this element. */
+    visible: boolean;
+    /** The display color override. Set to undefined to revert to default. */
+    color: THREE.Color | undefined;
+    /** Retrieves BIM data for this element. */
+    getBimElement(): Promise<IElement>;
+    /**
+     * Retrieves all BIM parameters for this element.
+     * @returns Array of `{ name: string, value: string, group: string }` objects.
+     * Type is `VimHelpers.ElementParameter` from vim-format (accessible via `VIM.BIM.VimHelpers`).
+     */
+    getBimParameters(): Promise<VimHelpers.ElementParameter[]>;
+    /** Retrieves the bounding box in Z-up world space (X = right, Y = forward, Z = up), or undefined if the element has no geometry. */
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
+    /** Retrieves the center position in Z-up world space, or undefined if the element has no geometry. */
+    getCenter(target?: THREE.Vector3): Promise<THREE.Vector3 | undefined>;
+}
+
+/**
+ * @module vim-loader
+ */
+/** Filter mode for subset operations. Only exports modes that are actually implemented. */
+type SubsetFilter = 'instance' | 'mesh';
+/**
+ * A filtered view of geometry instances for progressive loading.
+ * Obtained via `vim.subset()`, then refined with `filter()`, `except()`, and `chunks()`.
+ *
+ * @example
+ * ```ts
+ * // Load all geometry
+ * await vim.load()
+ *
+ * // Or load progressively in chunks
+ * const all = vim.subset()
+ * const chunks = all.chunks(500_000)        // Split into ~500K index chunks
+ * for (const chunk of chunks) {
+ *   await vim.load(chunk)
+ * }
+ *
+ * // Or load a filtered subset
+ * const sub = vim.subset().filter('instance', [0, 1, 2, 3])
+ * await vim.load(sub)
+ * ```
+ */
+interface ISubset {
+    /** Total instance count in this subset. */
+    getInstanceCount(): number;
+    /** Split into smaller subsets by index count threshold (for chunked loading). */
+    chunks(count: number): ISubset[];
+    /** Return a new subset excluding instances matching the filter. */
+    except(mode: SubsetFilter, filter: number[] | Set<number>): ISubset;
+    /** Return a new subset including only instances matching the filter. */
+    filter(mode: SubsetFilter, filter: number[] | Set<number>): ISubset;
+}
+
+/**
+ * @module vim-loader
+ */
+
+/**
+ * Public API for a loaded VIM model, accessed via `viewer.vims`.
+ *
+ * Provides element queries, BIM data access, scene/material control,
+ * and progressive geometry loading.
+ *
+ * **Cleanup:** Do not call dispose directly — use `viewer.unload(vim)` to remove
+ * a vim from the viewer. Use `vim.clear()` only to remove loaded geometry
+ * while keeping the vim (e.g., before reloading a different subset).
+ *
+ * @example
+ * ```ts
+ * const vim = await viewer.load({ url }).getVim()
+ *
+ * // Query elements
+ * const element = vim.getElementFromIndex(301)
+ * const all = vim.getAllElements()
+ *
+ * // Modify visibility
+ * element.visible = false
+ * element.color = new THREE.Color(0xff0000)
+ *
+ * // BIM data (types from vim-format, accessible via VIM.BIM)
+ * const bimElement = await element.getBimElement()   // VIM.BIM.IElement
+ * const params = await element.getBimParameters()    // VIM.BIM.VimHelpers.ElementParameter[]
+ *
+ * // Progressive loading
+ * const sub = vim.subset().filter('instance', [0, 1, 2])
+ * await vim.load(sub)
+ *
+ * // Cleanup
+ * viewer.unload(vim)  // Remove from viewer (do NOT call vim.dispose())
+ * ```
+ */
+interface IWebglVim extends IVim<IElement3D> {
+    readonly type: 'webgl';
+    /** The URL this vim was loaded from, if applicable. */
+    readonly source: string | undefined;
+    /** The VIM file header (from vim-format, accessible via `VIM.BIM.VimHeader`). */
+    readonly header: VimHeader | undefined;
+    /** BIM document for querying element properties, categories, levels, etc. (from vim-format, accessible via `VIM.BIM.VimDocument`). */
+    readonly bim: VimDocument | undefined;
+    /** The scene containing this vim's geometry. */
+    readonly scene: IScene;
+    /** The bounding box of all loaded geometry in Z-up world space (X = right, Y = forward, Z = up), or undefined if nothing loaded. */
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
+    /** Returns a subset representing all instances, for use with {@link load} and filtering. */
+    subset(): ISubset;
+    /**
+     * Loads geometry for the given subset, or all geometry if no subset is provided.
+     * Caller is responsible for not loading the same subset twice.
+     * @param subset - The subset to load. Omit to load everything.
+     */
+    load(subset?: ISubset): Promise<void>;
+    /** Removes all loaded geometry from the renderer (does NOT unload the vim from the viewer). */
+    clear(): void;
+}
+
+interface ILoadSuccess<T> {
+    readonly isSuccess: true;
+    readonly isError: false;
+    readonly vim: T;
+}
+interface ILoadError {
+    readonly isSuccess: false;
+    readonly isError: true;
+    readonly error: string;
+    readonly details?: string;
+}
+type ProgressType = 'bytes' | 'percent';
+interface IProgress {
+    type: ProgressType;
+    current: number;
+    total?: number;
+}
+type LoadResult<TValue, TError extends ILoadError = ILoadError> = ILoadSuccess<TValue> | TError;
+/**
+ * Interface for load requests that can be used as a type constraint.
+ */
+interface ILoadRequest<TVim, TError extends ILoadError = ILoadError> {
+    /** Whether the load has finished (successfully or with error). */
+    readonly isCompleted: boolean;
+    /** Yields progress updates as they arrive. Use with `for await`. */
+    getProgress(): AsyncGenerator<IProgress>;
+    /**
+     * Returns the final load result (success or error).
+     * Awaits completion if still loading. Use `result.isSuccess` to discriminate.
+     */
+    getResult(): Promise<LoadResult<TVim, TError>>;
+    /**
+     * Convenience method that awaits the result and returns the vim directly.
+     * @throws Error if the load failed.
+     */
+    getVim(): Promise<TVim>;
+    /** Cancels the load request. Pending getVim()/getResult() promises will reject/resolve with error. */
+    abort(): void;
+}
+
+/**
+ * Core VIM parsing entry point. Loads a VIM file (BFast container) and produces
+ * a Vim object with G3d geometry, BIM document, element mapping, and mesh factory.
+ * The Vim is created WITHOUT geometry — call vim.load() or vim.load(subset)
+ * separately to build Three.js meshes.
+ */
+
+type RequestSource = {
+    url?: string;
+    buffer?: ArrayBuffer;
+    headers?: Record<string, string>;
+};
+type IWebglLoadRequest = ILoadRequest<IWebglVim>;
+
+/**
+ * ## Coordinate System
+ * All camera operations use **Z-up**: X = right, Y = forward, Z = up.
+ * This differs from Three.js's default Y-up convention.
+ *
+ * @module camera
+ */
+
+/**
+ * Public interface for camera movement operations.
+ *
+ * Obtained via `camera.snap()` (instant) or `camera.lerp(duration)` (animated).
+ *
+ * @example
+ * ```ts
+ * camera.lerp(1).frame(element)           // Animate to frame element
+ * camera.snap().set(position, target)     // Instant position/target
+ * camera.lerp(0.5).orbit(new THREE.Vector2(45, 0))  // Animated orbit
+ * ```
+ */
+interface ICameraMovement {
+    /**
+     * Moves the camera along a single axis.
+     * @param axis The Z-up axis to move along ('X' = right, 'Y' = forward, 'Z' = up).
+     * @param amount The distance to move.
+     * @param space 'local' to move relative to camera orientation, 'world' for absolute axes.
+     */
+    move(axis: 'X' | 'Y' | 'Z', amount: number, space: 'local' | 'world'): void;
+    /**
+     * Moves the camera along two axes.
+     * @param axes The Z-up plane to move in (e.g. 'XY' = ground, 'XZ' = vertical).
+     * @param vector The 2D displacement, components mapped to the specified axes.
+     * @param space 'local' to move relative to camera orientation, 'world' for absolute axes.
+     */
+    move(axes: 'XY' | 'XZ' | 'YZ', vector: THREE.Vector2, space: 'local' | 'world'): void;
+    /**
+     * Moves the camera along all three axes.
+     * @param axes Must be 'XYZ'.
+     * @param vector The 3D displacement in Z-up convention (X = right, Y = forward, Z = up).
+     * @param space 'local' to move relative to camera orientation, 'world' for absolute axes.
+     */
+    move(axes: 'XYZ', vector: THREE.Vector3, space: 'local' | 'world'): void;
+    /**
+     * Rotates the camera in place by the given angles.
+     * @param angle - x: yaw (around Z), y: pitch (up/down), in degrees.
+     */
+    rotate(angle: THREE.Vector2): void;
+    /**
+     * Changes the distance between the camera and its target by a specified factor.
+     * @param amount - The zoom factor (e.g., 2 to zoom in / halve the distance, 0.5 to zoom out / double the distance).
+     */
+    zoom(amount: number): void;
+    /**
+     * Zooms the camera toward a specific world point while preserving camera orientation.
+     * The orbit target is updated to the world point for future orbit operations.
+     * @param amount - The zoom factor (e.g., 2 to zoom in / move closer, 0.5 to zoom out / move farther).
+     * @param worldPoint - The world position to zoom toward (Z-up).
+     * @param screenPoint - Screen position of the world point, used to keep the target pinned under the cursor.
+     */
+    zoomTowards(amount: number, worldPoint: THREE.Vector3, screenPoint?: THREE.Vector2): void;
+    /**
+     * Orbits the camera around its target while maintaining the distance.
+     * @param angle - x: azimuth change, y: elevation change, in degrees.
+     */
+    orbit(angle: THREE.Vector2): void;
+    /**
+     * Orbits the camera around its target to align with the given direction.
+     * @param direction - The direction towards which the camera should be oriented (Z-up).
+     */
+    orbitTowards(direction: THREE.Vector3): void;
+    /**
+     * Orients the camera to look at the given point. The orbit target is updated.
+     * @param target - The target element or world position (Z-up) to look at.
+     */
+    lookAt(target: IElement3D | THREE.Vector3): Promise<void>;
+    /**
+     * Moves the orbit target without moving the camera or changing orientation.
+     * @param target - The new orbit target (element or world position in Z-up).
+     */
+    setTarget(target: IElement3D | THREE.Vector3): Promise<void>;
+    /**
+     * Resets the camera to its last saved position and orientation.
+     */
+    reset(): void;
+    /**
+     * Sets the camera position and target, orienting the camera to look at the target.
+     * Elevation is clamped to avoid gimbal lock at poles.
+     * @param position - The new camera position (Z-up).
+     * @param target - The new orbit target (Z-up). Defaults to the current target.
+     */
+    set(position: THREE.Vector3, target?: THREE.Vector3): void;
+    /**
+     * Sets the camera's orientation and position to focus on the specified target.
+     * @param target - The target to frame, or 'all' to frame everything.
+     * @param forward - Optional forward direction after framing (Z-up).
+     */
+    frame(target: ISelectable | IWebglVim | THREE.Sphere | THREE.Box3 | 'all', forward?: THREE.Vector3): Promise<void>;
+}
+/**
+ * Interface representing a camera with various properties and methods for controlling its behavior.
+ */
+interface IWebglCamera {
+    /**
+     * 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;
+    /**
+     * Movement lock per axis in Z-up space (X = right, Y = forward, Z = up).
+     * Each component should be 0 (locked) or 1 (free).
+     */
+    lockMovement: THREE.Vector3;
+    /**
+     * Rotation lock per axis. x = yaw (around Z), y = pitch (up/down).
+     * Each component should be 0 (locked) or 1 (free).
+     */
+    lockRotation: THREE.Vector2;
+    /**
+     * The default forward direction in Z-up space (X = right, Y = forward, Z = up).
+     */
+    defaultForward: THREE.Vector3;
+    /**
+     * Interface for instantaneously moving the camera.
+     * @param {boolean} [force=false] - Set to true to ignore locked axis and rotation.
+     * @returns {ICameraMovement} The camera movement api.
+     */
+    snap(force?: boolean): ICameraMovement;
+    /**
+     * 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 {ICameraMovement} The camera movement api.
+     */
+    lerp(duration: number, force?: boolean): ICameraMovement;
+    /**
+     * 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 {THREE.Vector2} The frustum size (width, height) at the specified point.
+     */
+    frustumSizeAt(point: THREE.Vector3): THREE.Vector2;
+    /**
+     * Returns the world-space direction from the camera through the given screen position.
+     * @param screenPos Screen position in 0-1 range (0,0 is top-left).
+     */
+    screenToDirection(screenPos: THREE.Vector2): THREE.Vector3;
+    /**
+     * The current THREE Camera
+     */
+    get three(): THREE.Camera;
+    /**
+     * The quaternion representing the camera's orientation.
+     */
+    get quaternion(): THREE.Quaternion;
+    /**
+    * The position of the camera in Z-up world space.
+    */
+    get position(): THREE.Vector3;
+    /**
+     * The matrix representing the transformation of the camera.
+     */
+    get matrix(): THREE.Matrix4;
+    /**
+     * The forward direction of the camera in Z-up world space.
+     */
+    get forward(): THREE.Vector3;
+    get isLerping(): boolean;
+    /**
+     * 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, in Z-up world space.
+     */
+    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;
+}
+
+/**
+ * @module viw-webgl-viewer/gizmos
+ */
+/**
+ * Public interface for the axis gizmo.
+ */
+interface IGizmoAxes {
+    /** The canvas on which the axes are drawn. */
+    readonly canvas: HTMLCanvasElement;
+    /** Resizes the gizmo to the given pixel size. */
+    resize(size: number): void;
+}
+
+/**
+ * @module viw-webgl-viewer/gizmos
+ */
+
+/**
+ * Public interface for the orbit target gizmo.
+ */
+interface IGizmoOrbit {
+    /** Whether the orbit gizmo is enabled. */
+    enabled: boolean;
+    /** Updates the size of the orbit gizmo (fraction of screen 0-1). */
+    setSize(size: number): void;
+    /** Updates the colors of the orbit gizmo. */
+    setColors(color: THREE.Color, colorHorizontal: THREE.Color): void;
+    /** Updates the opacities of the orbit gizmo. */
+    setOpacity(opacity: number, opacityAlways: number): void;
+}
+
+/**
+ * @module viw-webgl-viewer/gizmos/measure
+ */
+
+/**
+ * Interacts with the measure tool.
+ */
+interface IMeasure {
+    /**
+     * Start point of the current measure or undefined if no active measure.
+     */
+    get startPoint(): THREE.Vector3 | undefined;
+    /**
+     * End point of the current measure or undefined if no active measure.
+     */
+    get endPoint(): THREE.Vector3 | undefined;
+    /**
+     * Vector from start to end of the current measure or undefined if no active measure.
+     */
+    get measurement(): THREE.Vector3 | undefined;
+    /**
+     * Stage of the current measure or undefined if no active measure.
+     */
+    get stage(): MeasureStage | undefined;
+    /**
+     * Starts a new measure flow where the two next click are overriden.
+     * Currently running flow if any will be aborted.
+     * Promise is resolved if flow is succesfully completed, rejected otherwise.
+     * Do not override viewer.onMouseClick while this flow is active.
+     */
+    start(): Promise<void>;
+    /**
+     * Aborts the current measure flow, fails the related promise.
+     */
+    abort(): void;
+    /**
+     * Clears meshes.
+     */
+    clear(): void;
+}
+type MeasureStage = 'ready' | 'active' | 'done' | 'failed';
+
+/**
+ * @module viw-webgl-viewer/gizmos/sectionBox
+ */
+
+/**
+ * Public interface for the section box gizmo.
+ *
+ * @example
+ * ```ts
+ * const sb = viewer.gizmos.sectionBox
+ * sb.active = true              // Enable clipping
+ * sb.visible = true             // Show gizmo
+ * sb.setBox(await vim.getBoundingBox())  // Fit to model
+ * sb.onBoxConfirm.sub((box) => console.log('Confirmed:', box))
+ * ```
+ */
+interface IWebglSectionBox {
+    /** Dispatches when active, visible, or interactive change. */
+    readonly onStateChanged: ISignal;
+    /** Dispatches when the user finishes manipulating the box. */
+    readonly onBoxConfirm: ISimpleEvent<THREE.Box3>;
+    /** Dispatches boolean indicating pointer hover state on box handles. */
+    readonly onHover: ISimpleEvent<boolean>;
+    /** Returns a copy of the current section box. */
+    getBox(): THREE.Box3;
+    /** Whether clipping planes are applied to the model. */
+    active: boolean;
+    /** Whether the gizmo responds to pointer events. */
+    interactive: boolean;
+    /** Whether the section box gizmo is visible. */
+    visible: boolean;
+    /** Resizes the section gizmo to match the given box. */
+    setBox(box: THREE.Box3): void;
+}
+
+/**
+ * Public interface for a marker gizmo in the scene.
+ *
+ * Obtained via `viewer.gizmos.markers.add(position)`.
+ */
+interface IMarker extends ISelectable {
+    readonly type: 'Marker';
+    /** The Vim object from which this marker came, if any. */
+    vim: IWebglVim | undefined;
+    /** The BIM element index, if associated with a Vim element. */
+    element: number | undefined;
+    /** The geometry instances, if derived from multiple instances. */
+    instances: number[] | undefined;
+    /** The index of the marker in the marker collection. */
+    readonly index: number;
+    /** Always false for markers. */
+    readonly isRoom: boolean;
+    /** Always false; marker is a gizmo, not an actual mesh. */
+    readonly hasMesh: boolean;
+    /** Whether the marker is outlined (highlighted). */
+    outline: boolean;
+    /** Whether the marker is visible in the scene. */
+    visible: boolean;
+    /** Whether the marker is focused (enlarged). */
+    focused: boolean;
+    /** The color override for the marker. */
+    color: THREE.Color | undefined;
+    /** The uniform scale factor applied to the marker. */
+    size: number;
+    /** The world position of the marker in Z-up space (X = right, Y = forward, Z = up). */
+    position: THREE.Vector3;
+    /** Retrieves the bounding box of the marker in Z-up world space. */
+    getBoundingBox(): Promise<THREE.Box3>;
+}
+
+/**
+ * Public interface for adding and managing sprite markers in the scene.
+ */
+interface IGizmoMarkers {
+    getMarkerFromIndex(index: number): IMarker | undefined;
+    add(position: THREE.Vector3): IMarker;
+    remove(marker: IMarker): void;
+    clear(): void;
+}
+
+/**
+ * Public interface for the gizmo collection.
+ * Exposes only the members needed by API consumers.
+ */
+interface IGizmos {
+    /** The interface to start and manage measure tool interaction. */
+    readonly measure: IMeasure;
+    /** The section box gizmo. */
+    readonly sectionBox: IWebglSectionBox;
+    /** The camera orbit target gizmo. */
+    readonly orbit: IGizmoOrbit;
+    /** The axis gizmos of the viewer. */
+    readonly axes: IGizmoAxes;
+    /** The interface for adding and managing sprite markers in the scene. */
+    readonly markers: IGizmoMarkers;
+}
+
+interface IRaycastResult<T> {
+    /** The model Object hit */
+    object: T | undefined;
+    /** The 3D world position of the hit point, in Z-up space (X = right, Y = forward, Z = up). */
+    worldPosition: THREE.Vector3;
+    /** The surface normal at the hit point, in Z-up space. */
+    worldNormal: THREE.Vector3;
+}
+/**
+ * Interface for raycasting against a 3D scene.
+ * @template T - The type of object to raycast against.
+ */
+interface IRaycaster<T> {
+    /**
+     * Raycasts from camera to the screen position to find the first object hit.
+     * @param position - The screen position to raycast from.
+     * @returns A promise that resolves to the raycast result, or undefined if no hit.
+     */
+    raycastFromScreen(position: THREE.Vector2): Promise<IRaycastResult<T> | undefined>;
+    /**
+     * Raycasts from camera to world position to find the first object hit.
+     * @param position - The world position to raycast through (Z-up).
+     * @returns A promise that resolves to the raycast result, or undefined if no hit.
+     */
+    raycastFromWorld(position: THREE.Vector3): Promise<IRaycastResult<T> | undefined>;
+}
+
+/**
+ * @module viw-webgl-viewer
+ */
+
+type IWebglRaycastResult = IRaycastResult<ISelectable>;
+type IWebglRaycaster = IRaycaster<ISelectable>;
+
+/**
+ @module viw-webgl-viewer
+*/
+
+/**
+ * Public interface for the viewport.
+ * Exposes only the members needed by API consumers.
+ */
+interface IWebglViewport {
+    /** HTML Canvas on which the model is rendered. */
+    readonly canvas: HTMLCanvasElement;
+    /** The parent element of the canvas. */
+    readonly parent: HTMLElement | null;
+    /** Moves the canvas to a new parent element. */
+    reparent(parent: HTMLElement): void;
+    /** Returns the pixel size of the parent element. */
+    getParentSize(): THREE.Vector2;
+    /** Returns the pixel size of the canvas. */
+    getSize(): THREE.Vector2;
+    /** Returns the aspect ratio (width / height) of the parent element. */
+    getAspectRatio(): number;
+    /** Triggers a resize to match parent dimensions. */
+    resizeToParent(): void;
+    /** Signal dispatched when the canvas is reparented. */
+    readonly onReparent: ISignal;
+    /** Signal dispatched when the canvas is resized. */
+    readonly onResize: ISignal;
+}
+
+/**
+ * @module viw-webgl-viewer/inputs
+ */
+/**
+ * Public API for keyboard input, accessed via `viewer.inputs.keyboard`.
+ *
+ * Supports per-key overrides with automatic restore, and an `active` toggle
+ * to temporarily disable all keyboard handling (e.g., when a text input has focus).
+ *
+ * @example
+ * ```ts
+ * // Override the F key (key up)
+ * const restore = viewer.inputs.keyboard.override('KeyF', 'up', () => myAction())
+ * // Later: restore()
+ *
+ * // Chain with the original handler
+ * viewer.inputs.keyboard.override('KeyF', 'up', (original) => {
+ *   original?.()
+ *   myExtraAction()
+ * })
+ *
+ * // Disable keyboard while typing
+ * viewer.inputs.keyboard.active = false
+ * // Re-enable
+ * viewer.inputs.keyboard.active = true
+ * ```
+ */
+interface IKeyboardInput {
+    /** Whether keyboard event listeners are active. Set to `false` to suspend all keyboard handling. */
+    active: boolean;
+    /**
+     * Overrides a key handler. Returns a function that restores the previous handler.
+     *
+     * @param code - The `KeyboardEvent.code` (e.g., `'KeyF'`, `'Escape'`) or an array of codes.
+     * @param on - Whether to intercept key `'down'` or `'up'` events.
+     * @param handler - Callback invoked on the event. Receives the previous handler as `original`.
+     * @returns A function that restores the previous handler when called.
+     */
+    override(code: string | string[], on: 'down' | 'up', handler: (original?: () => void) => void): () => void;
+}
+
+/**
+ * Drag tracking helper with zero-allocation delta calculation.
+ *
+ * Tracks pointer drag operations and calculates movement deltas
+ * without creating new objects.
+ */
+
+/**
+ * Callback type for drag events.
+ * @param delta - Movement delta since last frame (reusable vector - do not store!)
+ * @param button - Button being dragged (0=left, 1=middle, 2=right)
+ */
+type DragCallback = (delta: THREE.Vector2, button: number) => void;
+
+/**
+ * Mouse and pointer input handler.
+ *
+ * See INPUT.md for architecture, coordinate systems, and performance patterns.
+ */
+
+type ClickHandler = (position: THREE.Vector2, ctrl: boolean) => void;
+type DoubleClickHandler = (position: THREE.Vector2) => void;
+type PointerButtonHandler = (pos: THREE.Vector2, button: number) => void;
+type MoveHandler = (pos: THREE.Vector2) => void;
+type WheelHandler = (value: number, ctrl: boolean, clientX: number, clientY: number) => void;
+type ContextMenuHandler = (position: THREE.Vector2) => void;
+/**
+ * Public API for mouse input, accessed via `viewer.inputs.mouse`.
+ *
+ * Supports overriding any mouse callback with automatic restore. Each override
+ * handler receives the original callback as its first parameter for chaining.
+ *
+ * @example
+ * ```ts
+ * // Override click to add custom logic
+ * const restore = viewer.inputs.mouse.override({
+ *   onClick: (original, pos, ctrl) => {
+ *     if (myCondition) myAction(pos)
+ *     else original(pos, ctrl)
+ *   }
+ * })
+ * // Later: restore()
+ * ```
+ */
+interface IMouseInput {
+    /** Whether mouse event listeners are active. Set to `false` to suspend all mouse handling. */
+    active: boolean;
+    /**
+     * Temporarily overrides mouse callbacks. Only provided handlers are replaced;
+     * others keep their current behavior. Each handler receives the original as its first param.
+     *
+     * @param handlers - Partial set of callbacks to override.
+     * @returns A function that restores all overridden callbacks when called.
+     */
+    override(handlers: MouseOverrides): () => void;
+}
+/**
+ * Partial set of mouse callbacks for use with {@link IMouseInput.override}.
+ * Each handler receives the original callback as its first parameter.
+ * All positions are canvas-relative, normalized to [0, 1].
+ */
+type MouseOverrides = {
+    onClick?: (original: ClickHandler, pos: THREE.Vector2, ctrl: boolean) => void;
+    onDoubleClick?: (original: DoubleClickHandler, pos: THREE.Vector2) => void;
+    onDrag?: (original: DragCallback, delta: THREE.Vector2, button: number) => void;
+    onPointerDown?: (original: PointerButtonHandler, pos: THREE.Vector2, button: number) => void;
+    onPointerUp?: (original: PointerButtonHandler, pos: THREE.Vector2, button: number) => void;
+    onPointerMove?: (original: MoveHandler, pos: THREE.Vector2) => void;
+    onWheel?: (original: WheelHandler, value: number, ctrl: boolean, clientX: number, clientY: number) => void;
+    onContextMenu?: (original: ContextMenuHandler, pos: THREE.Vector2) => void;
+};
+
+/**
+ * Touch input handler with support for tap, pinch, and pan gestures.
+ *
+ * See INPUT.md for gesture recognition, state management, and performance patterns.
+ */
+
+type TapHandler = (position: THREE.Vector2) => void;
+type DragHandler = (delta: THREE.Vector2) => void;
+type PinchStartHandler = (screenCenter: THREE.Vector2) => void;
+type PinchHandler = (totalRatio: number) => void;
+/**
+ * Public API for touch input, accessed via `viewer.inputs.touch`.
+ *
+ * Supports overriding any touch callback with automatic restore. Each override
+ * handler receives the original callback as its first parameter for chaining.
+ *
+ * @example
+ * ```ts
+ * const restore = viewer.inputs.touch.override({
+ *   onTap: (original, pos) => { myAction(pos) }
+ * })
+ * // Later: restore()
+ * ```
+ */
+interface ITouchInput {
+    /** Whether touch event listeners are active. Set to `false` to suspend all touch handling. */
+    active: boolean;
+    /**
+     * Temporarily overrides touch callbacks. Only provided handlers are replaced;
+     * others keep their current behavior. Each handler receives the original as its first param.
+     *
+     * @param handlers - Partial set of callbacks to override.
+     * @returns A function that restores all overridden callbacks when called.
+     */
+    override(handlers: TouchOverrides): () => void;
+}
+/**
+ * Partial set of touch callbacks for use with {@link ITouchInput.override}.
+ * Each handler receives the original callback as its first parameter.
+ * All positions are canvas-relative, normalized to [0, 1].
+ */
+type TouchOverrides = {
+    /** Single-finger tap. */
+    onTap?: (original: TapHandler, pos: THREE.Vector2) => void;
+    /** Double tap. */
+    onDoubleTap?: (original: TapHandler, pos: THREE.Vector2) => void;
+    /** Single-finger drag. Delta is normalized to canvas size. */
+    onDrag?: (original: DragHandler, delta: THREE.Vector2) => void;
+    /** Two-finger drag (pan). Delta is normalized to canvas size. */
+    onDoubleDrag?: (original: DragHandler, delta: THREE.Vector2) => void;
+    /** Two-finger pinch/spread started. Center is canvas-relative position. */
+    onPinchStart?: (original: PinchStartHandler, center: THREE.Vector2) => void;
+    /** Two-finger pinch/spread. Ratio is cumulative distance relative to start (1.0 = no change). */
+    onPinchOrSpread?: (original: PinchHandler, ratio: number) => void;
+};
+
+/**
+ * Input coordinator that routes device events to viewer-specific adapters.
+ *
+ * See INPUT.md for architecture, pointer modes, and customization patterns.
+ */
+
+/**
+ * Determines how left-drag (mouse) or single-finger drag (touch) is interpreted.
+ *
+ * - `ORBIT` — Rotate camera around its target point.
+ * - `LOOK` — Rotate camera in place (first-person).
+ * - `PAN` — Slide camera laterally.
+ * - `ZOOM` — Dolly camera forward/backward.
+ * - `RECT` — Rectangle selection (reserved).
+ */
+declare enum PointerMode {
+    ORBIT = "orbit",
+    LOOK = "look",
+    PAN = "pan",
+    ZOOM = "zoom",
+    RECT = "rect"
+}
+/**
+ * Public API for the input system, accessed via `viewer.inputs`.
+ *
+ * Provides access to the three device handlers (keyboard, mouse, touch),
+ * pointer mode control, and speed settings.
+ *
+ * @example
+ * ```ts
+ * // Change pointer mode to pan
+ * viewer.inputs.pointerMode = PointerMode.PAN
+ *
+ * // Override a keyboard binding
+ * const restore = viewer.inputs.keyboard.override('KeyF', 'up', () => myFrameLogic())
+ * // Later: restore()
+ *
+ * // Override mouse click behavior
+ * const restore = viewer.inputs.mouse.override({
+ *   onClick: (original, pos, ctrl) => { myLogic(pos); original(pos, ctrl) }
+ * })
+ * ```
+ */
+interface IInputHandler {
+    /** Keyboard input handler. Override key bindings via {@link IKeyboardInput.override}. */
+    keyboard: IKeyboardInput;
+    /** Mouse input handler. Override callbacks via {@link IMouseInput.override}. */
+    mouse: IMouseInput;
+    /** Touch input handler. Override callbacks via {@link ITouchInput.override}. */
+    touch: ITouchInput;
+    /** The active pointer mode controlling how left-drag is interpreted. */
+    pointerMode: PointerMode;
+    /** Temporary pointer mode during drag (e.g., right-drag = LOOK). Read-only. */
+    readonly pointerOverride: PointerMode | undefined;
+    /** Fires when {@link pointerMode} or {@link pointerOverride} changes. */
+    readonly onPointerModeChanged: ISignal;
+    /** WASD move speed. Exponential scale: actual speed = 1.25^moveSpeed. Range: [-10, +10]. */
+    moveSpeed: number;
+    /** Scroll wheel zoom speed. Higher = faster zoom per scroll tick. */
+    scrollSpeed: number;
+    /** Fires when any speed setting changes (moveSpeed, scrollSpeed). */
+    readonly onSettingsChanged: ISignal;
+    /** Fires when a right-click context menu should be shown. Payload is client-space position. */
+    readonly onContextMenu: ISimpleEvent<THREE.Vector2 | undefined>;
+}
+
+/** Creates a headers object with a Bearer authorization token. */
+declare function authHeaders(token: string): Record<string, string>;
+
+/**
+ * @module viw-webgl-viewer/rendering
+ */
+
+/**
+ * Public interface for section box management.
+ * Exposes only the members needed by API consumers.
+ */
+interface IRenderingSection {
+    readonly box: THREE.Box3;
+    fitBox(box: THREE.Box3): void;
+    active: boolean;
+    readonly clippingPlanes: THREE.Plane[];
+}
+
+/**
+ * @module viw-webgl-viewer/rendering
+ */
+
+/**
+ * Public interface for the WebGL renderer.
+ * Exposes only the members needed by API consumers.
+ */
+interface IWebglRenderer {
+    /** The THREE WebGL renderer. */
+    readonly three: THREE.WebGLRenderer;
+    /** Interface to interact with section box directly without using the gizmo. */
+    readonly section: IRenderingSection;
+    /** Whether a re-render has been requested for the current frame. */
+    readonly needsUpdate: boolean;
+    /**
+     * Flags the scene as dirty so it will be re-rendered on the next animation frame.
+     * Selection, visibility, camera, and material changes call this automatically.
+     * Only needed when making direct Three.js changes the renderer can't detect.
+     */
+    requestRender(): void;
+    /**
+     * Immediately renders the current frame.
+     * For screenshots: call `requestRender()`, then `render()`, then read `canvas.toDataURL()`.
+     */
+    render(): void;
+    /** Gets or sets the background color or texture of the scene. */
+    background: THREE.Color | THREE.Texture;
+    /** Gets or sets the material used to render models. */
+    modelMaterial: MaterialSet;
+    /** The target MSAA sample count. Higher = better quality. */
+    samples: number;
+    /** Scale factor for outline/selection render target resolution (0-1). */
+    outlineScale: number;
+    /** Signal dispatched once per render frame if the scene was updated. */
+    readonly onSceneUpdated: ISignal;
+    /** Signal dispatched when bounding box is updated. */
+    readonly onBoxUpdated: ISignal;
+    /** Whether text rendering is enabled. */
+    textEnabled: boolean;
+    /** Instance count below which ghosted meshes are hidden entirely. */
+    smallGhostThreshold: number;
+    /** Returns the bounding box encompassing all rendered objects. */
+    getBoundingBox(target?: THREE.Box3): THREE.Box3 | undefined;
+    /** When true (default), only renders when dirty (`requestRender()` was called). When false, renders every frame. */
+    autoRender: boolean;
+}
+
+/**
+ @module viw-webgl-viewer
+*/
+
+/**
+ * Public interface for the WebGL viewer.
+ * Consumers should use this instead of the concrete class.
+ *
+ * **Lifecycle:** Call `load()` to add VIM models (auto-populates `vims`),
+ * `unload(vim)` to remove one, `clear()` to remove all, and `dispose()` to
+ * tear down the viewer entirely. Do not call `dispose()` on individual vims —
+ * always go through `unload()`.
+ *
+ * @example
+ * ```ts
+ * const viewer = Core.Webgl.createViewer()
+ * const vim = await viewer.load({ url: 'model.vim' }).getVim()
+ * console.log(viewer.vims.length)  // 1
+ *
+ * viewer.unload(vim)               // Remove one vim
+ * viewer.clear()                   // Remove all vims
+ * viewer.dispose()                 // Tear down viewer
+ * ```
+ */
+interface IWebglViewer {
+    readonly type: 'webgl';
+    readonly settings: ViewerSettings;
+    readonly renderer: IWebglRenderer;
+    readonly viewport: IWebglViewport;
+    readonly selection: IWebglSelection;
+    readonly inputs: IInputHandler;
+    readonly raycaster: IWebglRaycaster;
+    readonly materials: IMaterials;
+    readonly camera: IWebglCamera;
+    readonly gizmos: IGizmos;
+    /** Fires when a vim finishes loading and is added to the scene. */
+    readonly onVimLoaded: ISignal;
+    /** All loaded VIM models. Auto-populated on load, auto-removed on unload. */
+    readonly vims: IWebglVim[];
+    /** Loads a VIM file. The resulting vim is added to `vims` on success. */
+    load(source: RequestSource, settings?: VimPartialSettings): IWebglLoadRequest;
+    /** Removes a vim from the viewer and disposes its resources. */
+    unload(vim: IWebglVim): void;
+    /** Removes and disposes all loaded vims. */
+    clear(): void;
+    /** Tears down the viewer entirely — releases WebGL context, DOM elements, and all resources. */
+    dispose(): void;
+}
+/**
+ * Creates a headless WebGL viewer without React UI.
+ * Use this for programmatic-only usage or custom UI frameworks.
+ * For a full React UI viewer, use `React.Webgl.createViewer()` instead.
+ *
+ * @param settings - Optional renderer config (camera, materials, lighting). See {@link ViewerSettings}.
+ * @returns A new WebGL viewer.
+ *
+ * @example
+ * const viewer = Core.Webgl.createViewer({ camera: { orthographic: true } })
+ * document.body.appendChild(viewer.viewport.canvas)
+ * const vim = await viewer.load({ url: 'model.vim' }).getVim()
+ */
+declare function createCoreWebglViewer(settings?: PartialViewerSettings): IWebglViewer;
+
+declare namespace Core_Webgl {
+  export { MaterialSet, createCoreWebglViewer as createViewer, isElement3D };
+  export type { AxesSettings, ICameraMovement, IElement3D, IGizmoAxes, IGizmoMarkers, IGizmoOrbit, IGizmos, IMarker, IMaterials, IMeasure, IRenderingSection, IScene, ISelectable, ISubset, IWebglCamera, IWebglLoadRequest, IWebglRaycastResult, IWebglRaycaster, IWebglRenderer, IWebglSectionBox, IWebglSelection, IWebglViewport, IWebglVim, MaterialSettings, MeasureStage, PartialViewerSettings, RequestSource, SubsetFilter, TransparencyMode, IWebglViewer as Viewer, ViewerSettings, VimPartialSettings, VimSettings };
+}
+
+/**
+ * Public interface for an Ultra Vim's scene.
+ * Provides cached geometry information and spatial queries.
+ */
+interface IUltraScene {
+    /** Bounding box of the loaded geometry in Z-up world space (X = right, Y = forward, Z = up). Undefined before load or if empty. */
+    getBoundingBox(): THREE.Box3 | undefined;
+    /** Returns elements whose bounding boxes intersect the given box. Box coordinates are in Z-up world space. */
+    getObjectsInBox(box: THREE.Box3): IUltraElement3D[];
+    /** Returns the combined bounding box for the given elements (or all), in Z-up world space. */
+    getBoundingBoxForElements(elements: number[] | 'all'): Promise<THREE.Box3 | undefined>;
+}
+
+type VimRequestErrorType = 'loadingError' | 'downloadingError' | 'serverDisconnected' | 'unknown' | 'cancelled';
+interface IUltraLoadError extends ILoadError {
+    readonly type: VimRequestErrorType;
+}
+type IUltraLoadRequest = ILoadRequest<IUltraVim, IUltraLoadError>;
+
+/**
+ * Describes the source location and optional authentication for loading a VIM file.
+ */
+type VimSource = {
+    /**
+     * URL to the VIM file.
+     * Can be a local path (file://) or remote URL (http:// or https://).
+     */
+    url: string;
+    /**
+     * Optional HTTP headers for authentication and other purposes.
+     * Use {@link authHeaders} to create Bearer token headers.
+     */
+    headers?: Record<string, string>;
+};
+/**
+ * Represents the loading state and progress for a single vim.
+ */
+type VimLoadingState = {
+    /**
+     * Current loading status.
+     */
+    status: VimLoadingStatus;
+    /**
+     * Loading progress as a percentage from 0 to 100.
+     */
+    progress: number;
+};
+/**
+ * Defines supported input modes for camera control in the viewer.
+ */
+declare enum InputMode {
+    /**
+     * Orbit mode — rotates around a fixed point.
+     */
+    Orbit = "orbit",
+    /**
+     * Free mode — allows unrestricted movement.
+     */
+    Free = "free"
+}
+/**
+ * Scene-wide rendering and lighting configuration options.
+ */
+type SceneSettings = {
+    /**
+     * White point for tone mapping (clamped between 0 and 1).
+     */
+    toneMappingWhitePoint: number;
+    /**
+     * Global HDR intensity multiplier (floored to 0).
+     */
+    hdrScale: number;
+    /**
+     * HDR scale for the background (clamped between 0 and 1).
+     */
+    hdrBackgroundScale: number;
+    /**
+     * Background saturation (clamped between 0 and 1).
+     */
+    hdrBackgroundSaturation: number;
+    /**
+     * Background blur strength (clamped between 0 and 1).
+     */
+    backgroundBlur: number;
+    /**
+     * Background color in linear RGB format.
+     */
+    backgroundColor: THREE.Color;
+};
+/**
+ * Default scene settings used when none are explicitly provided.
+ */
+declare const defaultSceneSettings: SceneSettings;
+/**
+ * Enumerates the possible states of VIM file loading.
+ */
+declare enum VimLoadingStatus {
+    /**
+     * No known loading activity.
+     */
+    Unknown = 0,
+    /**
+     * Actively loading VIM data.
+     */
+    Loading = 1,
+    /**
+     * Downloading VIM file from a remote source.
+     */
+    Downloading = 2,
+    /**
+     * Load completed successfully.
+     */
+    Done = 3,
+    /**
+     * Download failed (e.g., due to network or permission issues).
+     */
+    FailedToDownload = 4,
+    /**
+     * VIM file could not be parsed or initialized correctly.
+     */
+    FailedToLoad = 5
+}
+
+/**
+ * Public interface for an Ultra Vim model (server-side rendered).
+ * Provides access to elements, visibility state, and scene queries.
+ *
+ * **Cleanup:** Do not call dispose directly — use `viewer.unload(vim)`.
+ *
+ * @example
+ * ```ts
+ * const vim = await viewer.load({ url: 'model.vim' }).getVim()
+ *
+ * // Query elements
+ * const element = vim.getElementFromIndex(301)
+ * element.visible = false
+ * element.outline = true
+ * element.ghosted = true
+ * element.color = new THREE.Color(0xff0000)
+ *
+ * // Scene queries
+ * const box = vim.scene.getBoundingBox()
+ *
+ * // Cleanup
+ * viewer.unload(vim)
+ * ```
+ */
+interface IUltraVim extends IVim<IUltraElement3D> {
+    readonly type: 'ultra';
+    /** The source URL and headers this vim was loaded from. */
+    readonly source: VimSource;
+    /** Scene providing bounding box and spatial queries. */
+    readonly scene: IUltraScene;
+    /** The server-side handle for this vim. */
+    readonly handle: number;
+    /** Whether this vim is currently connected to the server. */
+    readonly connected: boolean;
+    /** Reconnects this vim to the server. */
+    connect(): IUltraLoadRequest;
+    /** Disconnects this vim from the server. */
+    disconnect(): void;
+}
+
+/**
+ * Public interface for an Ultra 3D element.
+ * Provides visual state control (visibility, outline, color) and bounding box queries.
+ *
+ * **WebGL vs Ultra parity:** Ultra elements do NOT expose BIM data methods
+ * (`getBimElement`, `getBimParameters`), geometry metadata (`hasMesh`, `isRoom`,
+ * `elementId`, `instances`), or `getCenter()`. The Ultra viewer renders server-side,
+ * so BIM data is not available on the client. For BIM queries, use the WebGL viewer.
+ *
+ * @example
+ * ```ts
+ * element.visible = false                          // Hide
+ * element.outline = true                           // Highlight
+ * element.ghosted = true                           // Ghosted appearance
+ * element.color = new THREE.Color(0xff0000)        // Override color
+ * const box = await element.getBoundingBox()       // Get bounding box
+ * ```
+ */
+interface IUltraElement3D extends IVimElement {
+    /** The parent vim this element belongs to. */
+    readonly vim: IUltraVim;
+    /** The BIM element index. */
+    readonly element: number;
+    /** The handle of the parent vim on the server. */
+    readonly vimHandle: number;
+    /** Whether the element is visible (not hidden). Preserves highlight state. */
+    visible: boolean;
+    /** Whether the element has an outline highlight. Preserves visibility state. */
+    outline: boolean;
+    /** Whether the element is rendered as a ghost. Preserves highlight state. */
+    ghosted: boolean;
+    /** The display color override. Set to undefined to revert to default. */
+    color: THREE.Color | undefined;
+    /** Retrieves the bounding box in Z-up world space (X = right, Y = forward, Z = up), or undefined if the element is abstract. */
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
+}
+
+declare class Segment {
+    origin: THREE.Vector3;
+    target: THREE.Vector3;
+    constructor(origin?: THREE.Vector3, target?: THREE.Vector3);
+    static fromArray(array: number[]): Segment;
+    toArray(): number[];
+    isValid(): boolean;
+    equals(segment: Segment): boolean;
+}
+
+/**
+ * Camera movement operations obtained via `camera.snap()` or `camera.lerp(duration)`.
+ *
+ * All positions use **Z-up**: X = right, Y = forward, Z = up.
+ *
+ * @example
+ * ```ts
+ * camera.lerp(1).frame(element)          // Animated frame
+ * camera.snap().set(position, target)    // Instant position/target
+ * camera.lerp(0.5).frame('all')          // Animated frame all
+ * ```
+ */
+interface IUltraCameraMovement {
+    /**
+     * Frames the camera to fit the specified target.
+     * @param target - Element, vim, bounding box, or 'all' to frame everything.
+     */
+    frame(target: IUltraElement3D | IUltraVim | THREE.Box3 | 'all'): Promise<Segment | undefined>;
+    /**
+     * Sets the camera position and target.
+     * @param position - The new camera position (Z-up).
+     * @param target - The new look-at target (Z-up).
+     */
+    set(position: THREE.Vector3, target: THREE.Vector3): void;
+    /**
+     * Resets the camera to its last saved position.
+     */
+    reset(): void;
+}
+/**
+ * Public interface for the Ultra camera.
+ * Uses the same snap/lerp pattern as the WebGL camera.
+ */
+interface IUltraCamera {
+    /**
+     * Returns a camera movement interface that executes instantly (blendTime = 0).
+     */
+    snap(): IUltraCameraMovement;
+    /**
+     * Returns a camera movement interface that animates over the given duration.
+     * @param duration - Animation duration in seconds. Defaults to 0.5.
+     */
+    lerp(duration?: number): IUltraCameraMovement;
+    /**
+     * Saves the current camera position for later restoration via `reset()`.
+     * @param segment - Optional specific camera position to save.
+     */
+    save(segment?: Segment): void;
+    /**
+     * Controls the rendering state of the viewer.
+     * @param value - True to pause, false to resume rendering.
+     */
+    pause(value: boolean): void;
+}
+
+/**
+ * Interface defining the basic decoder operations
+ */
+interface IUltraDecoder {
+    /** Indicates if the decoder is ready to process frames */
+    ready: boolean;
+    /** Indicates if the decoder is currently paused */
+    paused: boolean;
+    /** Stops the decoder operations */
+    stop(): void;
+    /** Starts the decoder operations */
+    start(): void;
+}
+
+interface ILogger {
+    log(message: string, obj?: any): void;
+    error(message: string, e: unknown): void;
+}
+
+type IUltraRaycastResult = IRaycastResult<IUltraElement3D>;
+type IUltraRaycaster = IRaycaster<IUltraElement3D>;
+
+/**
+ * Render settings that extend SceneSettings with additional rendering-specific properties
+ */
+type RenderSettings = SceneSettings & {
+    /** Color used for ghost/transparent rendering */
+    ghostColor: THREE.Color;
+    ghostOpacity: number;
+};
+/**
+ * Default rendering settings
+ */
+declare const defaultRenderSettings: RenderSettings;
+/**
+ * Interface defining the basic renderer capabilities
+ */
+interface IUltraRenderer {
+    onSceneUpdated: ISignal;
+    ghostColor: THREE.Color;
+    ghostOpacity: number;
+    hdrScale: number;
+    toneMappingWhitePoint: number;
+    hdrBackgroundScale: number;
+    hdrBackgroundSaturation: number;
+    backgroundBlur: number;
+    backgroundColor: THREE.Color;
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
+}
+
+/**
+ * Public interface for the Ultra section box.
+ * Controls clipping, visibility, and interactivity of the section box.
+ *
+ * @example
+ * ```ts
+ * const sb = viewer.sectionBox
+ * sb.active = true              // Enable clipping
+ * sb.visible = true             // Show gizmo
+ * sb.setBox(await vim.getBoundingBox())  // Fit to model
+ * ```
+ */
+interface IUltraSectionBox {
+    readonly onUpdate: ISignal;
+    visible: boolean;
+    interactive: boolean;
+    active: boolean;
+    setBox(box: THREE.Box3): void;
+    getBox(): THREE.Box3 | undefined;
+}
+
+type IUltraSelection = ISelection<IUltraElement3D>;
+
+type ConnectionSettings = {
+    url?: string;
+    retries?: number;
+    timeout?: number;
+    retryDelay?: number;
+};
+type ClientState = ClientStateConnecting | ClientStateConnected | ClientStateDisconnected | ClientStateValidating | ClientError;
+type ClientError = ClientStateCompatibilityError | ClientStateConnectionError | ClientStateStreamError;
+type ClientStateConnecting = {
+    status: 'connecting';
+};
+type ClientStateValidating = {
+    status: 'validating';
+};
+type ClientStateConnected = {
+    status: 'connected';
+};
+type ClientStateDisconnected = {
+    status: 'disconnected';
+};
+type ClientStateCompatibilityError = {
+    status: 'error';
+    error: 'compatibility';
+    serverUrl: string;
+    serverVersion: string;
+    clientVersion: string;
+};
+type ClientStateConnectionError = {
+    status: 'error';
+    error: 'connection';
+    serverUrl: string;
+};
+type ClientStateStreamError = {
+    status: 'error';
+    error: 'stream';
+    serverUrl: string;
+    details: string;
+};
+
+/**
+ * Interface defining viewport functionality
+ */
+interface IUltraViewport {
+    /** The HTML canvas element used for rendering */
+    canvas: HTMLCanvasElement;
+    /** Updates the aspect ratio of the viewport on the server */
+    update(): void;
+    /** Resizes the viewport to match its parent's dimensions */
+    resizeToParent(): void;
+}
+
+declare const INVALID_HANDLE = 4294967295;
+/**
+ * Public interface for the Ultra viewer (server-side rendering via WebSocket).
+ * Consumers should use this instead of the concrete class.
+ *
+ * **Lifecycle:** Call `connect()` first, then `load()` to stream VIM models
+ * (auto-populates `vims`). Use `unload(vim)` to remove one, `clear()` to
+ * remove all, `disconnect()` to close the server connection, and `dispose()`
+ * to tear down the viewer entirely.
+ *
+ * @example
+ * ```ts
+ * const viewer = Core.Ultra.createViewer(parentDiv)
+ * await viewer.connect({ url: 'wss://server:8080' })
+ * const vim = await viewer.load({ url: 'model.vim' }).getVim()
+ *
+ * viewer.unload(vim)               // Remove one vim
+ * viewer.disconnect()              // Close server connection
+ * viewer.dispose()                 // Tear down viewer
+ * ```
+ */
+interface IUltraViewer {
+    readonly type: 'ultra';
+    readonly camera: IUltraCamera;
+    readonly inputs: IInputHandler;
+    /** All loaded VIM models. Auto-populated on load, auto-removed on unload. */
+    readonly vims: IUltraVim[];
+    readonly viewport: IUltraViewport;
+    readonly renderer: IUltraRenderer;
+    readonly decoder: IUltraDecoder;
+    readonly raycaster: IUltraRaycaster;
+    readonly selection: IUltraSelection;
+    /** The server URL this viewer is connected to, or undefined if not connected. */
+    readonly serverUrl: string | undefined;
+    /** Fires when the connection state changes (connecting, connected, disconnected, error). */
+    readonly onStateChanged: ISimpleEvent<ClientState>;
+    /** The current connection state. */
+    readonly connectionState: ClientState;
+    readonly sectionBox: IUltraSectionBox;
+    /**
+     * Connects to the Ultra rendering server. Must be awaited before calling `load()`.
+     * Returns true on success, false on failure. Subscribe to `onStateChanged` for progress.
+     */
+    connect(settings?: ConnectionSettings): Promise<boolean>;
+    /** Disconnects from the server. Loaded vims become inoperable. */
+    disconnect(): void;
+    /**
+     * Loads a VIM file via the server. Requires a successful `connect()` first.
+     * The resulting vim is added to `vims` on success.
+     */
+    load(source: VimSource): IUltraLoadRequest;
+    /** Removes a vim from the viewer and disposes its resources. */
+    unload(vim: IUltraVim): void;
+    /** Removes and disposes all loaded vims. */
+    clear(): void;
+    /** Tears down the viewer entirely — releases canvas, connection, and all resources. */
+    dispose(): void;
+}
+/**
+ * Creates a headless Ultra viewer without React UI.
+ * Use this for programmatic-only usage or custom UI frameworks.
+ * For a full React UI viewer, use `React.Ultra.createViewer()` instead.
+ *
+ * @param parent - The parent HTML element to which the canvas will be appended.
+ * @param logger - Optional logger for logging messages.
+ * @returns A new Ultra viewer.
+ *
+ * @example
+ * const viewer = Core.Ultra.createViewer(document.getElementById('app'))
+ * await viewer.connect({ url: 'wss://server:8080' })
+ * viewer.load({ url: 'model.vim' })
+ */
+declare function createCoreUltraViewer(parent: HTMLElement, logger?: ILogger): IUltraViewer;
+
+/**
+ * Represents the possible states an element can have in the UltraVim system.
+ */
+declare enum VisibilityState {
+    VISIBLE = 0,
+    HIDDEN = 1,
+    GHOSTED = 2,
+    HIGHLIGHTED = 16,
+    HIDDEN_HIGHLIGHTED = 17,
+    GHOSTED_HIGHLIGHTED = 18
+}
+/**
+ * Public interface for visibility state management.
+ * Accessed via `vim.visibility` on Ultra Vim instances.
+ */
+interface IVisibilitySynchronizer {
+    areAllInState(state: VisibilityState | VisibilityState[]): boolean;
+    getElementState(elementIndex: number): VisibilityState;
+    getElementsInState(state: VisibilityState): number[] | 'all';
+    getDefaultState(): VisibilityState;
+    setStateForElement(elementIndex: number, state: VisibilityState): void;
+    setStateForAll(state: VisibilityState): void;
+    replaceState(fromState: VisibilityState | VisibilityState[], toState: VisibilityState): void;
+    reapplyStates(): void;
+}
+
+declare namespace Core_Ultra {
+  export { INVALID_HANDLE, InputMode, Segment, VimLoadingStatus, VisibilityState, createCoreUltraViewer as createViewer, defaultRenderSettings, defaultSceneSettings };
+  export type { ClientError, ClientState, ClientStateCompatibilityError, ClientStateConnected, ClientStateConnecting, ClientStateConnectionError, ClientStateDisconnected, ClientStateStreamError, ClientStateValidating, ConnectionSettings, ILogger, IUltraCamera, IUltraCameraMovement, IUltraDecoder, IUltraLoadRequest, IUltraRaycastResult, IUltraRaycaster, IUltraRenderer, IUltraScene, IUltraSectionBox, IUltraSelection, IUltraViewport, IUltraVim, IVisibilitySynchronizer, RenderSettings, SceneSettings, IUltraViewer as Viewer, VimLoadingState, VimRequestErrorType, VimSource };
+}
+
+declare namespace Core {
+  export { PointerMode, Core_Ultra as Ultra, Core_Webgl as Webgl, authHeaders };
+  export type { ClickHandler, ContextMenuHandler, DoubleClickHandler, DragCallback, DragHandler, IInputHandler, IKeyboardInput, ILoadError, ILoadRequest, ILoadSuccess, IMouseInput, IProgress, ISignal, ISimpleEvent, ITouchInput, IVim, IVimElement, LoadResult, MouseOverrides, MoveHandler, PinchHandler, PinchStartHandler, PointerButtonHandler, ProgressType, TapHandler, TouchOverrides, WheelHandler };
+}
+
+/**
+ * @module public-api
+ */
+/**
+ * Basic HTML structure that the webgl viewer expects
+ */
+type Container = {
+    /**
+     * Root of the viewer, all viewer ui should have this as an acestor.
+     */
+    root: HTMLElement;
+    /**
+     * Div where to instantiate ui elements.
+     */
+    ui: HTMLDivElement;
+    /**
+     * Div to hold viewer canvases and ui
+     */
+    gfx: HTMLDivElement;
+    dispose: () => void;
+};
+/**
+ * Creates a default container for the vim viewer around a vim viewer
+ * The element is created if not provided. The element will be made position:absolute.
+ * @element optional HTML element to use as root
+ */
+declare function createContainer(element?: HTMLElement): Container;
+
+/**
+ * Observable state container. Read, write, and subscribe to changes.
+ *
+ * @example
+ * state.get()                           // Read current value
+ * state.set(true)                       // Update value
+ * state.onChange.subscribe(v => ...)     // Subscribe (returns unsubscribe fn)
+ */
+interface StateRef<T> {
+    /**
+     * Returns the current state value.
+     */
+    get(): T;
+    /**
+     * Updates the state to the provided value.
+     * @param value - The new state value.
+     */
+    set(value: T): void;
+    /**
+     * Confirms the current state (potentially applying a confirmation transformation).
+     */
+    confirm(): void;
+    onChange: ISimpleEvent<T>;
+}
+/**
+ * Creates a standalone StateRef<T> without React hooks.
+ * Use this when you need observable state outside of React components.
+ */
+declare function createState<T>(initial: T): StateRef<T>;
+/**
+ * A callable function reference with middleware support.
+ * All ref types (sync, async, with/without args) use this single interface.
+ *
+ * When `TArg` is `void`, `call()` can be invoked without arguments.
+ * For async functions, use `FuncRef<void, Promise<T>>`.
+ *
+ * @example
+ * ```ts
+ * ref.call()                                    // Execute (no-arg)
+ * ref.call(box)                                 // Execute (with arg)
+ * ref.set(() => newImpl())                      // Replace implementation
+ * ref.update(prev => (...args) => {             // Wrap with middleware
+ *   console.log('before')
+ *   const result = prev(...args)
+ *   console.log('after')
+ *   return result
+ * })
+ * ```
+ */
+interface FuncRef<TArg, TReturn> {
+    /** Invokes the stored function. When `TArg` is `void`, no argument is needed. */
+    call(arg: TArg): TReturn;
+    /** Returns the current function. */
+    get(): (arg: TArg) => TReturn;
+    /** Replaces the stored function. */
+    set(fn: (arg: TArg) => TReturn): void;
+    /**
+     * Wraps the stored function with a transform.
+     * Use this to inject behavior before/after the original function.
+     *
+     * @example
+     * ```ts
+     * // Append behavior
+     * ref.update(prev => async () => { await prev(); doAfter() })
+     * // Prepend behavior
+     * ref.update(prev => async () => { doBefore(); return await prev() })
+     * ```
+     */
+    update(transform: (prev: (arg: TArg) => TReturn) => (arg: TArg) => TReturn): void;
+}
+
+/**
+ * Controls the section box clipping volume.
+ * Shared between WebGL and Ultra viewers.
+ *
+ * @example
+ * viewer.sectionBox.active.set(true)
+ * viewer.sectionBox.sectionSelection.call()  // Fit to selection
+ * viewer.sectionBox.sectionScene.call()      // Fit to scene
+ */
+interface SectionBoxApi {
+    active: StateRef<boolean>;
+    visible: StateRef<boolean>;
+    auto: StateRef<boolean>;
+    sectionSelection: FuncRef<void, Promise<void>>;
+    sectionScene: FuncRef<void, Promise<void>>;
+    sectionBox: FuncRef<THREE.Box3, void>;
+    getBox: () => THREE.Box3;
+    showOffsetPanel: StateRef<boolean>;
+    topOffset: StateRef<number>;
+    sideOffset: StateRef<number>;
+    bottomOffset: StateRef<number>;
+    getSelectionBox: FuncRef<void, Promise<THREE.Box3 | undefined>>;
+    getSceneBox: FuncRef<void, Promise<THREE.Box3 | undefined>>;
+}
+
+/**
+ * @module viw-webgl-react
+ */
+
+/**
+ * High-level framing controls for the React viewer.
+ * Provides semantic operations like "frame selection" and "frame scene".
+ *
+ * For low-level camera movement (orbit, pan, zoom, snap/lerp), use
+ * `viewer.core.camera` which exposes {@link IWebglCamera}.
+ *
+ * @example
+ * // Frame the current selection with animation
+ * viewer.framing.frameSelection.call()
+ *
+ * // For direct camera manipulation, use the core camera:
+ * viewer.core.camera.lerp(1).frame('all')
+ * viewer.core.camera.snap().set(position, target)
+ */
+interface FramingApi {
+    /** When true, automatically frames the camera on the selection whenever it changes. */
+    autoCamera: StateRef<boolean>;
+    /** Resets the camera to its last saved position. */
+    reset: FuncRef<void, void>;
+    /** Frames the camera on the current selection (or scene if nothing selected). */
+    frameSelection: FuncRef<void, Promise<void>>;
+    /** Frames the camera to show all loaded geometry. */
+    frameScene: FuncRef<void, Promise<void>>;
+    /** Returns the bounding box of the current selection, or undefined if nothing selected. */
+    getSelectionBox: FuncRef<void, Promise<THREE.Box3 | undefined>>;
+    /** Returns the bounding box of all loaded geometry. */
+    getSceneBox: FuncRef<void, Promise<THREE.Box3 | undefined>>;
+}
+
+/**
+ * @module viw-webgl-react
+ */
+
+type AugmentedElement = BIM.IElement & {
+    bimDocumentName: string;
+    categoryName: string;
+    familyTypeName: string;
+    levelName: string;
+    worksetName: string;
+};
+
+type VisibilityStatus = 'all' | 'allButSelection' | 'onlySelection' | 'some' | 'none';
+/**
+ * Controls element visibility and isolation in the viewer.
+ * Shared between WebGL and Ultra viewers.
+ *
+ * @example
+ * viewer.isolation.isolateSelection()  // Show only selected elements
+ * viewer.isolation.showAll()           // Reset visibility
+ * viewer.isolation.showGhost.set(true) // Show hidden elements as ghosts
+ */
+interface IsolationApi {
+    /** Current visibility status (observable). */
+    visibility: StateRef<VisibilityStatus>;
+    /** Whether auto-isolate is enabled (observable). When true, selecting an element auto-isolates it. */
+    autoIsolate: StateRef<boolean>;
+    /** Whether the isolation settings panel is shown (observable). */
+    showPanel: StateRef<boolean>;
+    /** Whether hidden elements are rendered as ghosts (observable). */
+    showGhost: StateRef<boolean>;
+    /** Ghost material opacity 0-1 (observable). */
+    ghostOpacity: StateRef<number>;
+    /** Whether transparent materials are rendered (observable). */
+    transparency: StateRef<boolean>;
+    /** Whether room elements are shown (observable). */
+    showRooms: StateRef<boolean>;
+    /** Hook called when auto-isolate triggers. Use `update()` to add middleware. */
+    onAutoIsolate: FuncRef<void, void>;
+    /** Hook called when visibility changes. Use `update()` to add middleware. */
+    onVisibilityChange: FuncRef<void, void>;
+    /** Returns true if any elements are selected. */
+    hasSelection(): boolean;
+    /** Returns true if any selected elements are currently visible. */
+    hasVisibleSelection(): boolean;
+    /** Returns true if any selected elements are currently hidden. */
+    hasHiddenSelection(): boolean;
+    /** Clears the current selection. */
+    clearSelection(): void;
+    /** Shows only selected elements, hiding everything else. */
+    isolateSelection(): void;
+    /** Hides the currently selected elements. */
+    hideSelection(): void;
+    /** Makes the currently selected elements visible. */
+    showSelection(): void;
+    /** Isolates elements by their instance indices (only these will be visible). */
+    isolate(instances: number[]): void;
+    /** Shows elements by their instance indices. */
+    show(instances: number[]): void;
+    /** Hides elements by their instance indices. */
+    hide(instances: number[]): void;
+    /** Hides all elements. */
+    hideAll(): void;
+    /** Resets visibility — makes all elements visible. */
+    showAll(): void;
+}
+
+type MessageBoxProps = {
+    title: string;
+    body: string | JSX.Element;
+    icon?: JSX.Element;
+    footer?: string | JSX.Element;
+    canClose?: boolean;
+    minimize?: boolean;
+    onClose?: () => void;
+};
+type MessageBoxPropsTyped = MessageBoxProps & {
+    type: 'message';
+};
+
+type ProgressMode = 'percent' | 'bytes';
+/**
+ * Interface for message information displayed in the LoadingBox.
+ * @property message - Optional main message text.
+ * @property info - Optional additional information or tooltip text.
+ * @property progress - The progress of an operation.
+ */
+type LoadingBoxProps = {
+    message?: string;
+    progress?: number;
+    mode?: ProgressMode;
+    more?: ReactNode;
+};
+type LoadingBoxPropsTyped = LoadingBoxProps & {
+    type: 'loading';
+};
+
+/**
+ * @module viw-webgl-react
+ */
+type HelpPropsTyped = {
+    type: 'help';
+};
+
+type ModalProps = (MessageBoxPropsTyped | LoadingBoxPropsTyped | HelpPropsTyped) & {
+    canClose?: boolean;
+    onClose?: () => void;
+};
+type ModalApi = {
+    getActiveState(): ModalProps | undefined;
+    loading(content: LoadingBoxProps | undefined): void;
+    message(content: MessageBoxProps | undefined): void;
+    help(show: boolean): void;
+};
+
+/**
+ * Reference to manage context menu functionality in the viewer.
+ */
+type ContextMenuApi = {
+    /**
+     * Defines a callback function to dynamically customize the context menu.
+     * @param customization The configuration object specifying the customization options for the context menu.
+     */
+    customize: (customization: ContextMenuCustomization) => void;
+};
+/**
+ * Represents a button in the context menu. It can't be clicked triggering given action.
+ */
+interface IContextMenuButton {
+    type: 'button';
+    id: string;
+    label: string;
+    keyboard?: string;
+    action: (e: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    enabled: boolean;
+}
+/**
+ * Represents a divider in the context menu. It can't be clicked.
+ */
+interface IContextMenuDivider {
+    type: 'divider';
+    id: string;
+    enabled: boolean;
+}
+type ContextMenuElement = IContextMenuButton | IContextMenuDivider;
+/**
+ * A map function that changes the context menu.
+ */
+type ContextMenuCustomization = (e: ContextMenuElement[]) => ContextMenuElement[];
+
+/**
+ * @fileoverview This file exports types and a React hook for customizing the rendering
+ * 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.
+ */
+
+/**
+ * Represents an entry in the BIM info panel, such as a key-value pair in a header or body section.
+ */
+type Entry = {
+    /**
+     * The key of the entry, often used as a label or an identifier for the data.
+     */
+    key: string | undefined;
+    /**
+     * The label or display name for the entry, shown to the user.
+     */
+    label: string | undefined;
+    /**
+     * The value of the entry, displayed to the user.
+     */
+    value: string | undefined;
+};
+/**
+ * Represents a group of entries within a body section of the BIM info panel.
+ */
+type Group = {
+    /**
+     * The unique identifier for this group.
+     */
+    key: string | undefined;
+    /**
+     * The title or name displayed for this group.
+     */
+    title: string | undefined;
+    /**
+     * An array of entries that belong to this group.
+     */
+    content: Entry[];
+};
+/**
+ * Represents a section of the body, containing one or more groups of entries.
+ */
+type Section = {
+    /**
+     * The unique identifier for this section.
+     */
+    key: string | undefined;
+    /**
+     * The title displayed for this section.
+     */
+    title: string;
+    /**
+     * An array of groups that this section contains.
+     */
+    content: Group[];
+};
+/**
+ * Represents the entire data set for the BIM info panel, including the header and body sections.
+ */
+type Data = {
+    /**
+     * The header of the BIM info panel, typically a list of entries summarizing key information.
+     */
+    header: Entry[] | undefined;
+    /**
+     * The body of the BIM info panel, typically containing one or more sections of grouped entries.
+     */
+    body: Section[] | undefined;
+};
+/**
+ * A customization function for modifying the panel data before rendering. It allows
+ * developers to transform, filter, or augment the data pulled from a VIM source.
+ *
+ * @param data - The data to customize.
+ * @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.
+ */
+type DataCustomization = (data: Data, source: IWebglVim | IElement3D) => 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
+ * to override how data is rendered in different parts of the BIM info panel.
+ *
+ * @typeParam T - The type of data to render.
+ * @param props.data - The data to render.
+ * @param props.standard - The standard rendering function for the data.
+ * @returns A custom JSX element to render, or `undefined` to use the default rendering.
+ */
+type DataRender<T> = ((props: {
+    data: T;
+    standard: () => JSX.Element;
+}) => JSX.Element) | undefined;
+/**
+ * A reference object exposing multiple customization callbacks for transforming data and rendering
+ * different parts of the BIM info panel. These callbacks can be updated at runtime and will be used
+ * the next time the panel re-renders.
+ */
+type BimInfoPanelApi = {
+    /**
+     * A function that customizes the data before it is rendered in the BIM info panel.
+     */
+    onData: DataCustomization;
+    /**
+     * A function that customizes the rendering of the header of the BIM info panel.
+     */
+    onRenderHeader: DataRender<Entry[]>;
+    /**
+     * A function that customizes the rendering of each header entry in the BIM info panel.
+     */
+    onRenderHeaderEntry: DataRender<Entry>;
+    /**
+     * A function that customizes the rendering of each entry value of the header in the BIM info panel.
+     */
+    onRenderHeaderEntryValue: DataRender<Entry>;
+    /**
+     * A function that customizes the rendering for the body section of the BIM info panel.
+     */
+    onRenderBody: DataRender<Section[]>;
+    /**
+     * A function that customizes the rendering of each section of the body in the BIM info panel.
+     */
+    onRenderBodySection: DataRender<Section>;
+    /**
+     * A function that customizes the rendering of each group of the body in the BIM info panel.
+     */
+    onRenderBodyGroup: DataRender<Group>;
+    /**
+     * A function that customizes the rendering for each entry of the body in the BIM info panel.
+     */
+    onRenderBodyEntry: DataRender<Entry>;
+    /**
+     * A function that customizes the rendering of each value for a single body entry in the info panel.
+     */
+    onRenderBodyEntryValue: DataRender<Entry>;
+};
+
+/**
+ * @module icons
+ */
+/**
+ * Common Icon Options.
+ */
+type IconOptions = {
+    height?: number | string;
+    width?: number | string;
+    fill?: string;
+    className?: string;
+};
+declare function pointer({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function filter({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function slidersHoriz({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function settings({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function help({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function trash({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function checkmark({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function undo({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function closeIcon({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function home({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function fullScreen({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function minimize({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function treeView({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function more({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function collapse({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function arrowLeft({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function fullArrowLeft({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function visible({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function hidden({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function frameScene({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function autoCamera({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function orbit({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function look({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function perspective({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function orthographic({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function camera({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function pan({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function zoom({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function frameRect({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function frameSelection({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function showAll({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function showSelection({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function hideSelection({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function isolateSelection({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function autoIsolate({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function toggleIsolation({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function measure({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function sectionBoxSettings({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function sectionBoxAuto({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function sectionBoxVisible({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function sectionBox({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function sectionBoxDisable({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function sectionBoxClip({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function sectionBoxIgnore({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function sectionBoxReset({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function sectionBoxShrink({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function sectionBoxShrink2({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function ghost({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+declare function ghostDead({ height, width, fill, className }?: IconOptions): react_jsx_runtime.JSX.Element;
+
+declare namespace React_Icons {
+  export { arrowLeft, autoCamera, autoIsolate, camera, checkmark, closeIcon, collapse, filter, frameRect, frameScene, frameSelection, fullArrowLeft, fullScreen, ghost, ghostDead, help, hidden, hideSelection, home, isolateSelection, look, measure, minimize, more, orbit, orthographic, pan, perspective, pointer, sectionBox, sectionBoxAuto, sectionBoxClip, sectionBoxDisable, sectionBoxIgnore, sectionBoxReset, sectionBoxSettings, sectionBoxShrink, sectionBoxShrink2, sectionBoxVisible, settings, showAll, showSelection, slidersHoriz, toggleIsolation, trash, treeView, undo, visible, zoom };
+  export type { IconOptions };
+}
+
+interface IControlBarButton {
+    id: string;
+    enabled?: (() => boolean) | undefined;
+    tip: string;
+    action: () => void;
+    icon: (options?: IconOptions) => JSX.Element;
+    isOn?: () => boolean;
+    style?: (on: boolean) => string;
+}
+
+interface IControlBarSection {
+    id: string;
+    enable?: (() => boolean) | undefined;
+    buttons: (IControlBarButton)[];
+    style?: string;
+}
+
+/**
+ * Reference to manage control bar functionality in the viewer.
+ */
+type ControlBarApi = {
+    /**
+     * Defines a callback function to dynamically customize the control bar.
+     * @param customization The configuration object specifying the customization options for the control bar.
+     */
+    customize: (customization: ControlBarCustomization) => void;
+};
+/**
+ * A map function that customizes the control bar sections.
+ */
+type ControlBarCustomization = (e: IControlBarSection[]) => IControlBarSection[];
+
+/**
+ * A boolean setting that can be locked by the host application.
+ * - `true` / `false` — user-toggleable default value, shown in settings UI.
+ * - `"AlwaysTrue"` / `"AlwaysFalse"` — locked value, hidden from settings UI.
+ */
+type UserBoolean = boolean | 'AlwaysTrue' | 'AlwaysFalse';
+/**
+ * Checks if a UserBoolean value is effectively true
+ * @param {UserBoolean | boolean} value - The value to check
+ * @returns {boolean} True if the value is true or 'AlwaysTrue'
+ */
+declare function isTrue(value: UserBoolean | boolean): value is true | "AlwaysTrue";
+/**
+ * Checks if a UserBoolean value is effectively false
+ * @param {UserBoolean | boolean} value - The value to check
+ * @returns {boolean} True if the value is false or 'AlwaysFalse'
+ */
+declare function isFalse(value: UserBoolean | boolean): value is false | "AlwaysFalse";
+
+declare const baseSectionStyle = "vc-flex vc-items-center vc-rounded-full vc-mb-2 vc-shadow-md";
+declare const sectionDefaultStyle: string;
+declare const sectionBlueStyle: string;
+declare const sectionNoPadStyle: string;
+declare const buttonBaseStyle = "vim-control-bar-button vc-rounded-full vc-items-center vc-justify-center vc-flex vc-transition-all hover:vc-scale-110";
+declare function buttonDefaultStyle(on: boolean): string;
+declare function buttonExpandStyle(on: boolean): string;
+declare function buttonDisableStyle(on: boolean): string;
+declare function buttonDisableDefaultStyle(on: boolean): string;
+declare function buttonBlueStyle(on: boolean): string;
+
+declare namespace React_ControlBar_Style {
+  export {
+    baseSectionStyle,
+    buttonBaseStyle,
+    buttonBlueStyle,
+    buttonDefaultStyle,
+    buttonDisableDefaultStyle,
+    buttonDisableStyle,
+    buttonExpandStyle,
+    sectionBlueStyle,
+    sectionDefaultStyle,
+    sectionNoPadStyle,
+  };
+}
+
+type PartialUltraSettings = RecursivePartial<UltraSettings>;
+/**
+ * React UI feature toggles for the Ultra viewer, passed to `React.Ultra.createViewer(container, settings)`.
+ * Controls which UI panels and toolbar buttons are shown.
+ * Access at runtime via `viewer.settings.update(s => { s.ui.panelControlBar = false })`.
+ *
+ * @example
+ * const viewer = await React.Ultra.createViewer(div, {
+ *   ui: { panelControlBar: true, miscHelp: false }
+ * })
+ */
+type UltraSettings = {
+    ui: ControlBarCameraSettings & ControlBarCursorSettings & ControlBarSectionBoxSettings & ControlBarVisibilitySettings & {
+        panelLogo: UserBoolean;
+        panelControlBar: UserBoolean;
+        miscSettings: UserBoolean;
+        miscHelp: UserBoolean;
+    };
+};
+declare function getDefaultUltraSettings(): UltraSettings;
+
+type ControlBarSectionBoxSettings = {
+    sectioningEnable: UserBoolean;
+    sectioningFitToSelection: UserBoolean;
+    sectioningReset: UserBoolean;
+    sectioningShow: UserBoolean;
+    sectioningAuto: UserBoolean;
+    sectioningSettings: UserBoolean;
+};
+type ControlBarCursorSettings = {
+    cursorOrbit: UserBoolean;
+    cursorLookAround: UserBoolean;
+    cursorPan: UserBoolean;
+    cursorZoom: UserBoolean;
+};
+type ControlBarMeasureSettings = {
+    measureEnable: UserBoolean;
+};
+type ControlBarCameraSettings = {
+    cameraAuto: UserBoolean;
+    cameraFrameSelection: UserBoolean;
+    cameraFrameScene: UserBoolean;
+};
+type ControlBarVisibilitySettings = {
+    visibilityClearSelection: UserBoolean;
+    visibilityShowAll: UserBoolean;
+    visibilityToggle: UserBoolean;
+    visibilityIsolate: UserBoolean;
+    visibilityAutoIsolate: UserBoolean;
+    visibilitySettings: UserBoolean;
+};
+
+type PartialWebglSettings = RecursivePartial<WebglSettings>;
+/**
+ * React UI feature toggles, passed to `React.Webgl.createViewer(container, settings)`.
+ * Controls which UI panels and toolbar buttons are shown.
+ * Access at runtime via `viewer.settings.update(s => { s.ui.panelBimTree = false })`.
+ * Not to be confused with {@link ViewerSettings} (renderer config) or {@link VimSettings} (per-model transform).
+ *
+ * @example
+ * const viewer = await React.Webgl.createViewer(div, {
+ *   ui: { panelBimTree: false, miscHelp: false }
+ * })
+ */
+type WebglSettings = {
+    capacity: {
+        canFollowUrl: boolean;
+        canGoFullScreen: boolean;
+        canDownload: boolean;
+        canReadLocalStorage: boolean;
+    };
+    ui: ControlBarCameraSettings & ControlBarCursorSettings & ControlBarSectionBoxSettings & ControlBarVisibilitySettings & ControlBarMeasureSettings & {
+        panelLogo: UserBoolean;
+        panelBimTree: UserBoolean;
+        panelBimInfo: UserBoolean;
+        panelPerformance: UserBoolean;
+        panelAxes: UserBoolean;
+        panelControlBar: UserBoolean;
+        axesOrthographic: UserBoolean;
+        axesHome: UserBoolean;
+        miscProjectInspector: UserBoolean;
+        miscSettings: UserBoolean;
+        miscHelp: UserBoolean;
+        miscMaximise: UserBoolean;
+    };
+};
+/**
+ * Default settings configuration for the React Webgl Vim viewer
+ * @constant
+ * @type {WebglSettings}
+ */
+declare function getDefaultSettings(): WebglSettings;
+
+/**
+ * @module viw-webgl-react
+ */
+
+type AddSettings = {
+    /**
+     * Controls whether to frame the camera on a vim everytime it is updated.
+     * Default: true
+     */
+    autoFrame?: boolean;
+};
+type OpenSettings = VimPartialSettings & AddSettings;
+
+interface GenericTextEntry {
+    type: "text";
+    id: string;
+    label: string;
+    enabled?: () => boolean;
+    visible?: () => boolean;
+    state: StateRef<string>;
+}
+interface GenericNumberEntry {
+    type: "number";
+    id: string;
+    label: string;
+    enabled?: () => boolean;
+    visible?: () => boolean;
+    state: StateRef<number>;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+interface GenericBoolEntry {
+    type: "bool";
+    id: string;
+    label: string;
+    enabled?: () => boolean;
+    visible?: () => boolean;
+    state: StateRef<boolean>;
+}
+type GenericEntryType = GenericTextEntry | GenericBoolEntry | GenericNumberEntry;
+
+type GenericPanelApi = {
+    customize(fn: (entries: GenericEntryType[]) => GenericEntryType[]): void;
+};
+
+/**
+ * @module viw-webgl-react
+ * Contains settings and type definitions for the Vim web viewer
+ */
+
+type AnySettings = WebglSettings | UltraSettings;
+
+type SettingsCustomization<T extends AnySettings> = (items: SettingsItem<T>[]) => SettingsItem<T>[];
+type SettingsItem<T extends AnySettings> = SettingsSubtitle | SettingsToggle<T> | SettingsBox<T> | SettingsElement;
+type SettingsSubtitle = {
+    type: 'subtitle';
+    key: string;
+    title: string;
+};
+type SettingsToggle<T extends AnySettings> = {
+    type: 'toggle';
+    key: string;
+    label: string;
+    getter: (settings: T) => UserBoolean;
+    setter: (settings: T, b: boolean) => void;
+};
+type SettingsBox<T extends AnySettings> = {
+    type: 'box';
+    key: string;
+    label: string;
+    info: string;
+    transform: (value: number) => number;
+    getter: (settings: T) => number;
+    setter: (settings: T, b: number) => void;
+};
+type SettingsElement = {
+    type: 'element';
+    key: string;
+    element: JSX.Element;
+};
+
+/**
+* Settings API managing settings applied to the viewer.
+*/
+type SettingsApi<T extends AnySettings> = {
+    /**
+     * Allows updating settings by providing a callback function.
+     * @param updater A function that updates the current settings.
+     */
+    update: (updater: (settings: T) => void) => void;
+    /**
+     * Registers a callback function to be notified when settings are updated.
+     * @param callback A function to be called when settings are updated, receiving the updated settings.
+     */
+    register: (callback: (settings: T) => void) => void;
+    /**
+     * Customizes the settings panel by providing a customizer function.
+     * @param customizer A function that modifies the settings items.
+     */
+    customize: (customizer: (items: SettingsItem<T>[]) => SettingsItem<T>[]) => void;
+};
+
+/**
+ * @module public-api
+ */
+
+/**
+ * Root-level API of the Vim viewer.
+ */
+type WebglViewerApi = {
+    /**
+     * Discriminant to distinguish WebGL from Ultra viewer.
+     */
+    type: 'webgl';
+    /**
+     * HTML structure containing the viewer.
+     */
+    container: Container;
+    /**
+     * The underlying WebGL core viewer. Provides direct access to low-level 3D operations.
+     *
+     * Common uses:
+     * - `viewer.core.camera.lerp(1).frame(element)` — animated camera movement
+     * - `viewer.core.camera.snap().set(pos, target)` — instant camera placement
+     * - `viewer.core.selection.select(element)` — programmatic selection
+     * - `viewer.core.inputs.pointerMode` — change interaction mode
+     * - `viewer.core.gizmos.sectionBox` — direct section box manipulation
+     * - `viewer.core.renderer.requestRender()` — force re-render
+     */
+    core: IWebglViewer;
+    /**
+     * Loads a vim file with all geometry for immediate viewing.
+     * Wraps core.load() with progress UI (loading modal), auto-framing on completion,
+     * and error reporting. For headless loading without UI, use core.load() directly.
+     * @param source The url or buffer of the vim file
+     * @param settings Optional settings for transforms and auto-framing
+     * @returns LoadRequest to track progress and get result
+     */
+    load: (source: RequestSource, settings?: OpenSettings) => IWebglLoadRequest;
+    /**
+     * Opens a vim file without loading geometry.
+     * Wraps core.load() without building geometry. Use for BIM-only queries or
+     * selective loading via vim.load(subset). For headless opening, use core.load() directly.
+     * @param source The url or buffer of the vim file
+     * @param settings Optional settings
+     * @returns LoadRequest to track progress and get result
+     */
+    open: (source: RequestSource, settings?: OpenSettings) => IWebglLoadRequest;
+    /**
+     * Unloads a vim from the viewer and disposes it.
+     * @param vim The vim to unload
+     */
+    unload: (vim: IWebglVim) => void;
+    /**
+     * Isolation API managing isolation state in the viewer.
+     */
+    isolation: IsolationApi;
+    /**
+     * Section box API managing the section box in the viewer.
+     */
+    sectionBox: SectionBoxApi;
+    /**
+     * Context menu API managing the content and behavior of the context menu.
+     */
+    contextMenu: ContextMenuApi;
+    /**
+     * Control bar API managing the content and behavior of the control bar.
+     */
+    controlBar: ControlBarApi;
+    /**
+     * Settings API managing settings applied to the viewer.
+     */
+    settings: SettingsApi<WebglSettings>;
+    /**
+     * Message API to interact with the loading box.
+     */
+    modal: ModalApi;
+    /**
+     * High-level framing API with semantic operations (frame selection, auto-camera).
+     * For low-level camera control (orbit, pan, zoom, snap/lerp), use {@link core}.camera instead.
+     * @see {@link FramingApi}
+     */
+    framing: FramingApi;
+    /**
+     * API To interact with the BIM info panel.
+     */
+    bimInfo: BimInfoPanelApi;
+    /**
+     * API to interact with the isolation panel.
+     */
+    isolationPanel: GenericPanelApi;
+    /**
+     * API to interact with the section box panel.
+     */
+    sectionBoxPanel: GenericPanelApi;
+    /**
+     * Cleans up and releases resources used by the viewer.
+     */
+    dispose: () => void;
+};
+
+/**
+ * Creates a WebGL viewer with full React UI (BIM tree, context menu, control bar, etc.).
+ * Returns a {@link WebglViewerApi} for programmatic interaction.
+ *
+ * @param container An optional container or DOM element. If none is provided, one will be created.
+ * @param settings React UI feature toggles (panels, buttons). See {@link WebglSettings}.
+ * @param coreSettings Core renderer config (camera, materials, lighting). See {@link ViewerSettings}.
+ * @returns A promise resolving to the viewer API.
+ *
+ * @example
+ * const viewer = await React.Webgl.createViewer(document.getElementById('app'))
+ * const vim = await viewer.load({ url: 'model.vim' }).getVim()
+ * viewer.framing.frameScene.call()
+ */
+declare function createWebglViewer(container?: Container | HTMLElement, settings?: PartialWebglSettings, coreSettings?: PartialViewerSettings): Promise<WebglViewerApi>;
+/**
+ * Represents a React viewer providing UI for the Vim viewer.
+ * @param container The container object containing root, gfx, and UI elements for the Vim viewer.
+ * @param viewer The Vim viewer instance for which UI is provided.
+ * @param onMount A callback function triggered when the viewer is mounted. Receives a reference to the Vim viewer.
+ * @param settings Optional settings for configuring the Vim viewer's behavior.
+ */
+declare function WebglViewerComponent(props: {
+    container: Container;
+    viewer: IWebglViewer;
+    onMount: (viewer: WebglViewerApi) => void;
+    settings?: PartialWebglSettings;
+}): react_jsx_runtime.JSX.Element;
+
+declare namespace React_Webgl {
+  export { WebglViewerComponent as ViewerComponent, createWebglViewer as createViewer, getDefaultSettings };
+  export type { OpenSettings, PartialWebglSettings, WebglViewerApi as ViewerApi, WebglSettings };
+}
+
+type UltraViewerApi = {
+    /**
+     * Discriminant to distinguish Ultra from WebGL viewer.
+     */
+    type: 'ultra';
+    /**
+     * HTML structure containing the viewer.
+     */
+    container: Container;
+    /**
+     * The underlying Ultra core viewer. Provides direct access to the server connection,
+     * camera, selection, raycaster, renderer, and section box.
+     *
+     * Common uses:
+     * - `viewer.core.camera.lerp(1).frame(element)` — animated camera movement
+     * - `viewer.core.camera.snap().set(pos, target)` — instant camera placement
+     * - `viewer.core.selection.select(element)` — programmatic selection
+     * - `viewer.core.inputs.pointerMode` — change interaction mode
+     * - `viewer.core.sectionBox` — direct section box manipulation
+     * - `viewer.core.renderer.ghostColor` — ghost rendering settings
+     */
+    core: IUltraViewer;
+    /**
+     * API to manage the modal dialog.
+     */
+    modal: ModalApi;
+    /**
+     * API to manage the section box.
+     */
+    sectionBox: SectionBoxApi;
+    /**
+     * API to customize the control.
+     */
+    controlBar: ControlBarApi;
+    /**
+     * High-level framing API with semantic operations (frame selection, auto-camera).
+     * For low-level camera control (snap/lerp, set position), use {@link core}.camera instead.
+     * @see {@link FramingApi}
+     */
+    framing: FramingApi;
+    /**
+     * Isolation API managing element visibility and isolation state.
+     * @see {@link IsolationApi}
+     */
+    isolation: IsolationApi;
+    /**
+     * Settings API managing UI feature toggles applied to the viewer.
+     * Use `update()` to modify settings at runtime.
+     */
+    settings: SettingsApi<UltraSettings>;
+    /**
+     * API to interact with the isolation panel.
+     */
+    isolationPanel: GenericPanelApi;
+    /**
+     * API to interact with the section box panel.
+     */
+    sectionBoxPanel: GenericPanelApi;
+    /**
+     * Disposes of the viewer and its resources.
+     */
+    dispose: () => void;
+    /**
+     * Loads a VIM file via the Ultra server.
+     * Wraps core.load() with connection management, progress UI (loading modal),
+     * and error reporting. For headless loading, use core.load() directly.
+     * @param source The VIM source (url and optional headers)
+     * @returns LoadRequest to track progress and get result
+     */
+    load(source: VimSource): IUltraLoadRequest;
+    /**
+     * Unloads a vim from the viewer and disposes it.
+     * @param vim The vim to unload
+     */
+    unload(vim: IUltraVim): void;
+};
+
+/**
+ * Creates an Ultra viewer with React UI for server-side rendered models.
+ * Returns an {@link UltraViewerApi} for programmatic interaction.
+ *
+ * @param container An optional container or DOM element. If none is provided, one will be created.
+ * @param settings React UI feature toggles (panels, buttons). See {@link UltraSettings}.
+ * @returns A promise resolving to the viewer API.
+ *
+ * @example
+ * const viewer = await React.Ultra.createViewer(document.getElementById('app'))
+ * await viewer.core.connect({ url: 'wss://server:8080' })
+ * viewer.load({ url: 'model.vim' })
+ */
+declare function createUltraViewer(container?: Container | HTMLElement, settings?: PartialUltraSettings): Promise<UltraViewerApi>;
+/**
+ * Represents a React viewer providing UI for the Vim viewer.
+ * @param container The container object containing root, gfx, and UI elements for the Vim viewer.
+ * @param viewer The Vim viewer instance for which UI is provided.
+ * @param onMount A callback function triggered when the viewer is mounted. Receives a reference to the Vim viewer.
+ * @param settings Optional settings for configuring the Vim viewer's behavior.
+ */
+declare function UltraViewerComponent(props: {
+    container: Container;
+    core: IUltraViewer;
+    settings?: PartialUltraSettings;
+    onMount: (viewer: UltraViewerApi) => void;
+}): react_jsx_runtime.JSX.Element;
+
+declare namespace React_Ultra {
+  export { UltraViewerComponent as ViewerComponent, createUltraViewer as createViewer, getDefaultUltraSettings };
+  export type { PartialUltraSettings, UltraSettings, UltraViewerApi as ViewerApi };
+}
+
+declare const controlBarIds: {
+    readonly cameraSpan: "controlBar.cameraSpan";
+    readonly cameraFrameSelection: "controlBar.cameraFrameSelection";
+    readonly cameraFrameScene: "controlBar.cameraFrameScene";
+    readonly cameraAuto: "controlBar.cameraAuto";
+    readonly cursorSpan: "controlBar.cursorSpan";
+    readonly cursorOrbit: "controlBar.cursorOrbit";
+    readonly cursorLook: "controlBar.cursorLook";
+    readonly cursorPan: "controlBar.cursorPan";
+    readonly cursorZoom: "controlBar.cursorZoom";
+    readonly cursorZoomWindow: "controlBar.cursorZoomWindow";
+    readonly visibilitySpan: "controlBar.visibilitySpan";
+    readonly visibilityClearSelection: "controlBar.visibilityClearSelection";
+    readonly visibilityShowAll: "controlBar.visibilityShowAll";
+    readonly visibilityIsolateSelection: "controlBar.visibilityIsolateSelection";
+    readonly visibilityHideSelection: "controlBar.visibilityHideSelection";
+    readonly visibilityShowSelection: "controlBar.visibilityShowSelection";
+    readonly visibilityAutoIsolate: "controlBar.visibilityAutoIsolate";
+    readonly visibilitySettings: "controlBar.visibilitySettings";
+    readonly sectioningSpan: "controlBar.sectioningSpan";
+    readonly sectioningEnable: "controlBar.sectioningEnable";
+    readonly sectioningVisible: "controlBar.sectioningVisible";
+    readonly sectioningFitSelection: "controlBar.sectioningFitSelection";
+    readonly sectioningFitScene: "controlBar.sectioningFitScene";
+    readonly sectioningAuto: "controlBar.sectioningAuto";
+    readonly sectioningSettings: "controlBar.sectioningSettings";
+    readonly measureSpan: "controlBar.measureSpan";
+    readonly measureEnable: "controlBar.measureEnable";
+    readonly miscSpan: "controlBar.miscSpan";
+    readonly miscInspector: "controlBar.miscInspector";
+    readonly miscSettings: "controlBar.miscSettings";
+    readonly miscHelp: "controlBar.miscHelp";
+    readonly miscMaximize: "controlBar.miscMaximize";
+};
+
+declare namespace React_ControlBar {
+  export { controlBarIds as Ids, React_ControlBar_Style as Style };
+  export type { ControlBarApi, ControlBarCustomization, IControlBarButton, IControlBarSection };
+}
+
+declare namespace React_Settings {
+  export { isFalse, isTrue };
+  export type { SettingsBox, SettingsCustomization, SettingsElement, SettingsItem, SettingsSubtitle, SettingsToggle, UserBoolean };
+}
+
+declare const vcColorPrimary = "vc-text-[#212733]";
+declare const vcColorSecondary = "vc-text-[#787C83]";
+declare const vcColorLink = "vc-text-[#0590CC]";
+declare const vcLink = "vc-text-[#0590CC] vc-underline";
+declare const vcLabel = "vc-text-[#3F444F]";
+declare const vcRoboto = "vc-font-['Roboto',sans-serif]";
+declare function footer(): react_jsx_runtime.JSX.Element;
+declare function mainText(text: JSX.Element): react_jsx_runtime.JSX.Element;
+declare function detailText(text: string): react_jsx_runtime.JSX.Element;
+declare function bold(text: string): react_jsx_runtime.JSX.Element;
+declare function subTitle(title: string): react_jsx_runtime.JSX.Element;
+declare function dotList(elements: (JSX.Element | string)[]): react_jsx_runtime.JSX.Element;
+declare function numList(elements: (JSX.Element | string)[]): react_jsx_runtime.JSX.Element;
+declare function bullet(label: string, value: string): react_jsx_runtime.JSX.Element;
+declare function link(url: string, text: string): react_jsx_runtime.JSX.Element;
+
+declare namespace React_Errors_Style {
+  export {
+    bold,
+    bullet,
+    detailText,
+    dotList,
+    footer,
+    link,
+    mainText,
+    numList,
+    subTitle,
+    vcColorLink,
+    vcColorPrimary,
+    vcColorSecondary,
+    vcLabel,
+    vcLink,
+    vcRoboto,
+  };
+}
+
+declare namespace React_Errors {
+  export {
+    React_Errors_Style as Style,
+  };
+}
+
+declare const contextMenuIds: {
+    readonly showControls: "showControls";
+    readonly dividerCamera: "dividerCamera";
+    readonly resetCamera: "resetCamera";
+    readonly zoomToFit: "zoomToFit";
+    readonly dividerSelection: "dividerSelection";
+    readonly isolateSelection: "isolateObject";
+    readonly selectSimilar: "selectSimilar";
+    readonly hideObject: "hideObject";
+    readonly showObject: "showObject";
+    readonly clearSelection: "clearSelection";
+    readonly showAll: "showAll";
+    readonly dividerSection: "dividerSection";
+    readonly ignoreSection: "ignoreSection";
+    readonly resetSection: "resetSection";
+    readonly fitSectionToSelection: "fitSectionToSelection";
+};
+
+declare namespace React_ContextMenu {
+  export { contextMenuIds as Ids };
+  export type { ContextMenuApi, ContextMenuCustomization, ContextMenuElement, IContextMenuButton, IContextMenuDivider };
+}
+
+declare const SectionBoxPanel: {
+    Ids: {
+        topOffset: string;
+        sideOffset: string;
+        bottomOffset: string;
+    };
+};
+declare const IsolationPanel: {
+    Ids: {
+        showGhost: string;
+        ghostOpacity: string;
+        transparency: string;
+    };
+};
+
+type ViewerApi = WebglViewerApi | UltraViewerApi;
+
+declare namespace React {
+  export { React_ContextMenu as ContextMenu, React_ControlBar as ControlBar, React_Errors as Errors, React_Icons as Icons, IsolationPanel, SectionBoxPanel, React_Settings as Settings, React_Ultra as Ultra, React_Webgl as Webgl, createContainer, createState };
+  export type { AugmentedElement, BimInfoPanelApi, Container, Data, DataCustomization, DataRender, Entry, FramingApi, FuncRef, GenericBoolEntry, GenericEntryType, GenericNumberEntry, GenericPanelApi, GenericTextEntry, Group, IsolationApi, LoadingBoxProps, MessageBoxProps, ModalApi, ModalProps, ProgressMode, Section, SectionBoxApi, SettingsApi, StateRef, ViewerApi, VisibilityStatus };
+}
+
+export { Core as Core, React as React };
+export type { ISignal, ISimpleEvent };