@kingsy/viewer 2.25.7

package/dist/modules/extensions/FilteringExtension.d.ts

@@ -0,0 +1,55 @@
+import { Extension } from './Extension.js';
+import { WorldTree } from '../tree/WorldTree.js';
+import { type IViewer } from '../../IViewer.js';
+import type { PropertyInfo } from '../filtering/PropertyManager.js';
+/** TO DO: Should remove selectedObjects entirely*/
+export type FilteringState = {
+    selectedObjects?: string[];
+    hiddenObjects?: string[];
+    isolatedObjects?: string[];
+    colorGroups?: {
+        value: string;
+        color: string;
+        ids: string[];
+    }[];
+    userColorGroups?: {
+        ids: string[];
+        color: string;
+    }[];
+    activePropFilterKey?: string;
+    passMin?: number | null;
+    passMax?: number | null;
+};
+export declare class FilteringExtension extends Extension {
+    WTI: WorldTree;
+    private Renderer;
+    private StateKey;
+    private VisibilityState;
+    private ColorStringFilterState;
+    private ColorNumericFilterState;
+    private UserspaceColorState;
+    private CurrentFilteringState;
+    get filteringState(): FilteringState;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    constructor(viewer: IViewer);
+    hideObjects(objectIds: string[], stateKey?: string | undefined, includeDescendants?: boolean, ghost?: boolean): FilteringState;
+    showObjects(objectIds: string[], stateKey?: string | undefined, includeDescendants?: boolean): FilteringState;
+    isolateObjects(objectIds: string[], stateKey?: string | undefined, includeDescendants?: boolean, ghost?: boolean): FilteringState;
+    unIsolateObjects(objectIds: string[], stateKey?: string | undefined, includeDescendants?: boolean, ghost?: boolean): FilteringState;
+    private setVisibilityState;
+    private visibilityWalk;
+    setColorFilter(prop: PropertyInfo, ghost?: boolean): FilteringState;
+    private setNumericColorFilter;
+    private setStringColorFilter;
+    removeColorFilter(): FilteringState;
+    setUserObjectColors(groups: {
+        objectIds: string[];
+        color: string;
+    }[]): FilteringState;
+    removeUserObjectColors(): FilteringState;
+    resetFilters(): FilteringState | null;
+    private setFilters;
+    private idCache;
+    private getDescendantIds;
+}

package/dist/modules/extensions/HybridCameraController.d.ts

@@ -0,0 +1,14 @@
+import { IViewer } from '../../IViewer.js';
+import { CameraController } from './CameraController.js';
+type MoveType = 'forward' | 'back' | 'left' | 'right' | 'up' | 'down';
+export declare class HybridCameraController extends CameraController {
+    protected keyMap: Record<MoveType, boolean>;
+    protected contextMenuTriggered: boolean;
+    constructor(viewer: IViewer);
+    onEarlyUpdate(_delta?: number): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onKeyUp(event: KeyboardEvent): void;
+    protected onContextMenu(): void;
+    protected cancelMove(): void;
+}
+export {};

package/dist/modules/extensions/SelectionExtension.d.ts

@@ -0,0 +1,53 @@
+import { Extension } from './Extension.js';
+import { NodeRenderView } from '../tree/NodeRenderView.js';
+import { Material, Vector2 } from 'three';
+import { type IViewer, type SelectionEvent } from '../../IViewer.js';
+import { type DisplayStyle, type RenderMaterial } from '../materials/Materials.js';
+import { type MaterialOptions } from '../materials/MaterialOptions.js';
+import { type TreeNode } from '../tree/WorldTree.js';
+import { CameraController } from './CameraController.js';
+export interface SelectionExtensionOptions {
+    selectionMaterialData: RenderMaterial & DisplayStyle & MaterialOptions;
+    hoverMaterialData?: RenderMaterial & DisplayStyle & MaterialOptions;
+}
+export declare const DefaultSelectionExtensionOptions: SelectionExtensionOptions;
+export declare class SelectionExtension extends Extension {
+    protected cameraProvider: CameraController;
+    get inject(): (typeof CameraController)[];
+    protected selectedNodes: Array<TreeNode>;
+    protected selectionRvs: {
+        [id: string]: NodeRenderView;
+    };
+    protected selectionMaterials: {
+        [id: string]: Material;
+    };
+    protected hoverRv: NodeRenderView | null;
+    protected hoverMaterial: Material | null;
+    protected selectionMaterialData: RenderMaterial & DisplayStyle & MaterialOptions;
+    protected hoverMaterialData: RenderMaterial & DisplayStyle & MaterialOptions;
+    protected transparentSelectionMaterialData: RenderMaterial & DisplayStyle & MaterialOptions;
+    protected transparentHoverMaterialData: RenderMaterial & DisplayStyle & MaterialOptions;
+    protected hiddenSelectionMaterialData: RenderMaterial & DisplayStyle & MaterialOptions;
+    protected _enabled: boolean;
+    protected _options: SelectionExtensionOptions;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    get options(): SelectionExtensionOptions;
+    set options(value: SelectionExtensionOptions);
+    constructor(viewer: IViewer, cameraProvider: CameraController);
+    getSelectedObjects(): Array<Record<string, unknown>>;
+    getSelectedNodes(): Array<TreeNode>;
+    selectObjects(ids: Array<string>, multiSelect?: boolean): void;
+    /**TO DO: This is redundant */
+    unselectObjects(ids: Array<string>): void;
+    clearSelection(nodes?: Array<TreeNode>): void;
+    protected onObjectClicked(selection: SelectionEvent | null): void;
+    protected onObjectDoubleClick(selectionInfo: SelectionEvent | null): void;
+    protected onPointerMove(e: Vector2 & {
+        event: Event;
+    }): void;
+    protected applySelection(): void;
+    protected removeSelection(rvs?: Array<NodeRenderView>): void;
+    protected applyHover(renderView: NodeRenderView | null): void;
+    protected removeHover(): void;
+}

package/dist/modules/extensions/TransformControls.d.ts

@@ -0,0 +1,157 @@
+export function intersectObjectWithRay(object: any, raycaster: any, includeInvisible: any): any;
+/**
+ * This class can be used to transform objects in 3D space by adapting a similar interaction model
+ * of DCC tools like Blender. Unlike other controls, it is not intended to transform the scene's camera.
+ *
+ * `TransformControls` expects that its attached 3D object is part of the scene graph.
+ *
+ * @augments Controls
+ */
+export class TransformControls extends Controls {
+    _root: TransformControlsRoot;
+    _gizmo: TransformControlsGizmo;
+    _plane: TransformControlsPlane;
+    _doNotPick: boolean;
+    _offset: Vector3;
+    _startNorm: Vector3;
+    _endNorm: Vector3;
+    _cameraScale: Vector3;
+    _parentPosition: Vector3;
+    _parentQuaternion: Quaternion;
+    _parentQuaternionInv: Quaternion;
+    _parentScale: Vector3;
+    _worldScaleStart: Vector3;
+    _worldQuaternionInv: Quaternion;
+    _worldScale: Vector3;
+    _positionStart: Vector3;
+    _quaternionStart: Quaternion;
+    _scaleStart: Vector3;
+    _getPointer: typeof getPointer;
+    _onPointerDown: typeof onPointerDown;
+    _onPointerHover: typeof onPointerHover;
+    _onPointerMove: typeof onPointerMove;
+    _onPointerUp: typeof onPointerUp;
+    /**
+     * Returns the visual representation of the controls. Add the helper to your scene to
+     * visually transform the attached  3D object.
+     *
+     * @return {TransformControlsRoot} The helper.
+     */
+    getHelper(): TransformControlsRoot;
+    pointerHover(pointer: any): void;
+    axis: any;
+    pointerDown(pointer: any): void;
+    dragging: boolean | undefined;
+    pointerMove(pointer: any): void;
+    rotationAngle: any;
+    pointerUp(pointer: any): void;
+    /**
+     * Sets the 3D object that should be transformed and ensures the controls UI is visible.
+     *
+     * @param {Object3D} object -  The 3D object that should be transformed.
+     * @return {TransformControls} A reference to this controls.
+     */
+    attach(object: Object3D): TransformControls;
+    /**
+     * Removes the current 3D object from the controls and makes the helper UI invisible.
+     *
+     * @return {TransformControls} A reference to this controls.
+     */
+    detach(): TransformControls;
+    /**
+     * Resets the object's position, rotation and scale to when the current transform began.
+     */
+    reset(): void;
+    /**
+     * Returns the raycaster that is used for user interaction. This object is shared between all
+     * instances of `TransformControls`.
+     *
+     * @returns {Raycaster} The internal raycaster.
+     */
+    getRaycaster(): Raycaster;
+    /**
+     * Returns the transformation mode.
+     *
+     * @returns {'translate'|'rotate'|'scale'} The transformation mode.
+     */
+    getMode(): "translate" | "rotate" | "scale";
+    /**
+     * Sets the given transformation mode.
+     *
+     * @param {'translate'|'rotate'|'scale'} mode - The transformation mode to set.
+     */
+    setMode(mode: "translate" | "rotate" | "scale"): void;
+    mode: "translate" | "rotate" | "scale" | undefined;
+    /**
+     * Sets the translation snap.
+     *
+     * @param {?number} translationSnap - The translation snap to set.
+     */
+    setTranslationSnap(translationSnap: number | null): void;
+    translationSnap: number | null | undefined;
+    /**
+     * Sets the rotation snap.
+     *
+     * @param {?number} rotationSnap - The rotation snap to set.
+     */
+    setRotationSnap(rotationSnap: number | null): void;
+    rotationSnap: number | null | undefined;
+    /**
+     * Sets the scale snap.
+     *
+     * @param {?number} scaleSnap - The scale snap to set.
+     */
+    setScaleSnap(scaleSnap: number | null): void;
+    scaleSnap: number | null | undefined;
+    /**
+     * Sets the size of the helper UI.
+     *
+     * @param {number} size - The size to set.
+     */
+    setSize(size: number): void;
+    size: number | undefined;
+    /**
+     * Sets the coordinate space in which transformations are applied.
+     *
+     * @param {'world'|'local'} space - The space to set.
+     */
+    setSpace(space: "world" | "local"): void;
+    space: "world" | "local" | undefined;
+}
+export class TransformControlsGizmo extends Object3D<import("three").Event> {
+    constructor();
+    isTransformControlsGizmo: boolean;
+    gizmo: {};
+    picker: {};
+    helper: {};
+    updateMatrixWorld(force: any): void;
+}
+export class TransformControlsPlane extends Mesh<BufferGeometry, import("three").Material | import("three").Material[]> {
+    constructor();
+    isTransformControlsPlane: boolean;
+    updateMatrixWorld(force: any): void;
+}
+import { Controls } from './Controls.js';
+declare class TransformControlsRoot extends Object3D<import("three").Event> {
+    constructor(controls: any);
+    isTransformControlsRoot: boolean;
+    controls: any;
+    updateMatrixWorld(force: any): void;
+    dispose(): void;
+}
+import { Vector3 } from 'three';
+import { Quaternion } from 'three';
+declare function getPointer(event: any): {
+    x: number;
+    y: number;
+    button: any;
+};
+declare function onPointerDown(event: any): void;
+declare function onPointerHover(event: any): void;
+declare function onPointerMove(event: any): void;
+declare function onPointerUp(event: any): void;
+import { Object3D } from 'three';
+import { Raycaster } from 'three';
+import { BufferGeometry } from 'three';
+import { Mesh } from 'three';
+export {};

package/dist/modules/extensions/ViewModes.d.ts

@@ -0,0 +1,32 @@
+import { IViewer } from '../../IViewer.js';
+import { Extension } from './Extension.js';
+import { FilteringExtension } from './FilteringExtension.js';
+import { PipelineOptions } from '../pipeline/Pipelines/Pipeline.js';
+import { EdgesPipelineOptions } from '../pipeline/Pipelines/EdgesPipeline.js';
+export declare enum ViewMode {
+    DEFAULT = 0,
+    SOLID = 1,
+    PEN = 2,
+    ARCTIC = 3,
+    SHADED = 4
+}
+export declare enum ViewModeEvent {
+    Changed = "view-mode-changed"
+}
+export interface ViewModeEventPayload {
+    [ViewModeEvent.Changed]: ViewMode;
+}
+export type ViewModeOptions = PipelineOptions & EdgesPipelineOptions;
+export declare class ViewModes extends Extension {
+    protected filteringExtension: FilteringExtension;
+    get inject(): (typeof FilteringExtension)[];
+    protected _viewModeOptions: Required<ViewModeOptions>;
+    get viewModeOptions(): ViewModeOptions;
+    protected _viewMode: ViewMode;
+    get viewMode(): ViewMode;
+    constructor(viewer: IViewer, filteringExtension: FilteringExtension);
+    on<T extends ViewModeEvent>(eventType: T, listener: (arg: ViewModeEventPayload[T]) => void): void;
+    setViewMode(viewMode: ViewMode, options?: ViewModeOptions): void;
+    protected updateViewModes(viewMode: ViewMode, options?: ViewModeOptions): void;
+    protected updateViewModeOptions(options?: ViewModeOptions): void;
+}

package/dist/modules/extensions/controls/FlyControls.d.ts

@@ -0,0 +1,82 @@
+import { Euler, OrthographicCamera, PerspectiveCamera, Sphere, Vector2, Vector3 } from 'three';
+import { Damper } from '../../utils/Damper.js';
+import { KingSyControls } from './KingSyControls.js';
+import { World } from '../../World.js';
+import { AngleDamper } from '../../utils/AngleDamper.js';
+type MoveType = 'forward' | 'back' | 'left' | 'right' | 'up' | 'down';
+export interface FlyControlsOptions {
+    [name: string]: unknown;
+    enableLook?: boolean;
+    lookSpeed?: number;
+    moveSpeed?: number;
+    damperDecay?: number;
+    relativeUpDown?: boolean;
+}
+declare class FlyControls extends KingSyControls {
+    protected _options: Required<FlyControlsOptions>;
+    protected _targetCamera: PerspectiveCamera | OrthographicCamera;
+    protected container: HTMLElement;
+    protected velocity: Vector3;
+    protected euler: Euler;
+    protected position: Vector3;
+    protected goalEuler: Euler;
+    protected goalPosition: Vector3;
+    protected keyMap: Record<MoveType, boolean>;
+    protected contextMenuTriggered: boolean;
+    protected eulerXDamper: AngleDamper;
+    protected eulerYDamper: AngleDamper;
+    protected eulerZDamper: AngleDamper;
+    protected positionXDamper: Damper;
+    protected positionYDamper: Damper;
+    protected positionZDamper: Damper;
+    protected _lastTick: number;
+    protected _enabled: boolean;
+    private _basisTransform;
+    private _basisTransformInv;
+    protected _minDist: number;
+    private world;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    get options(): FlyControlsOptions;
+    set options(value: FlyControlsOptions);
+    set targetCamera(target: PerspectiveCamera | OrthographicCamera);
+    get up(): Vector3;
+    set up(value: Vector3);
+    set minDist(value: number);
+    constructor(camera: PerspectiveCamera | OrthographicCamera, container: HTMLElement, world: World, options: Required<FlyControlsOptions>);
+    isStationary(): boolean;
+    update(delta?: number): boolean;
+    protected updatePositionRotation(delta: number): void;
+    jumpToGoal(): void;
+    fitToSphere(sphere: Sphere): void;
+    /** The input position and target will be in a basis with (0,0,1) as up */
+    fromPositionAndTarget(position: Vector3, target: Vector3): void;
+    /** The returned vector needs to be in a basis with (0,0,1) as up */
+    getTarget(): Vector3;
+    /** The returned vector needs to be in a basis with (0,0,1) as up */
+    getPosition(): Vector3;
+    /**
+     * Gets the current goal position
+     */
+    getCurrentPosition(): Vector3;
+    /**
+     * Gets the point in model coordinates the model should orbit/pivot around.
+     */
+    getCurrentTarget(): Vector3;
+    /**
+     * Sets the smoothing decay time.
+     */
+    setDamperDecayTime(decayMilliseconds: number): void;
+    moveBy(amount: Vector3): void;
+    rotateBy(amount: Vector2): void;
+    protected connect(): void;
+    protected disconnect(): void;
+    dispose(): void;
+    protected rotate(euler: Euler): void;
+    protected onMouseMove: (event: PointerEvent) => void;
+    protected onKeyDown: (event: KeyboardEvent) => void;
+    protected onKeyUp: (event: KeyboardEvent) => void;
+    protected onContextMenu: () => void;
+    protected cancelMove(): void;
+}
+export { FlyControls };

package/dist/modules/extensions/controls/KingSyControls.d.ts

@@ -0,0 +1,25 @@
+import { OrthographicCamera, PerspectiveCamera, Sphere, Vector3 } from 'three';
+import EventEmitter from '../../EventEmitter.js';
+export declare abstract class KingSyControls extends EventEmitter {
+    protected _up: Vector3;
+    protected _minDist: number;
+    get up(): Vector3;
+    set up(value: Vector3);
+    get minDist(): number;
+    set minDist(value: number);
+    abstract get options(): Partial<Record<string, unknown>>;
+    abstract set options(value: Partial<Record<string, unknown>>);
+    abstract get enabled(): boolean;
+    abstract set enabled(value: boolean);
+    abstract set targetCamera(target: PerspectiveCamera | OrthographicCamera);
+    abstract isStationary(): boolean;
+    abstract update(delta?: number): boolean;
+    abstract jumpToGoal(): void;
+    abstract fitToSphere(sphere: Sphere): void;
+    abstract dispose(): void;
+    abstract fromPositionAndTarget(position: Vector3, target: Vector3): void;
+    abstract getTarget(): Vector3;
+    abstract getPosition(): Vector3;
+    abstract getCurrentTarget(): Vector3;
+    abstract getCurrentPosition(): Vector3;
+}

package/dist/modules/extensions/controls/SmoothOrbitControls.d.ts

@@ -0,0 +1,222 @@
+import { Matrix3, Spherical, Vector2, Vector3, PerspectiveCamera, Sphere, Matrix4, OrthographicCamera, Quaternion, Mesh } from 'three';
+import { Damper } from '../../utils/Damper.js';
+import { World } from '../../World.js';
+import { KingSyControls } from './KingSyControls.js';
+import KingSyRenderer from '../../KingSyRenderer.js';
+import { ExtendedMeshIntersection } from '../../objects/KingSyRaycaster.js';
+export type TouchMode = null | ((dx: number, dy: number) => void);
+export type TouchAction = 'pan-y' | 'pan-x' | 'none';
+export interface Pointer {
+    clientX: number;
+    clientY: number;
+    id: number;
+}
+export interface SmoothOrbitControlsOptions {
+    enableOrbit?: boolean;
+    enableZoom?: boolean;
+    enablePan?: boolean;
+    orbitSensitivity?: number;
+    zoomSensitivity?: number;
+    panSensitivity?: number;
+    inputSensitivity?: number;
+    minimumRadius?: number;
+    maximumRadius?: number;
+    minimumPolarAngle?: number;
+    maximumPolarAngle?: number;
+    minimumAzimuthalAngle?: number;
+    maximumAzimuthalAngle?: number;
+    minimumFieldOfView?: number;
+    maximumFieldOfView?: number;
+    touchAction?: TouchAction;
+    infiniteZoom?: boolean;
+    zoomToCursor?: boolean;
+    orbitAroundCursor?: boolean;
+    showOrbitPoint?: boolean;
+    damperDecay?: number;
+}
+export declare enum PointerChangeEvent {
+    PointerChangeStart = "pointer-change-start",
+    PointerChangeEnd = "pointer-change-end"
+}
+/**
+ * SmoothControls is a Three.js helper for adding delightful pointer and
+ * keyboard-based input to a staged Three.js scene. Its API is very similar to
+ * OrbitControls, but it offers more opinionated (subjectively more delightful)
+ * defaults, easy extensibility and subjectively better out-of-the-box keyboard
+ * support.
+ *
+ * One important change compared to OrbitControls is that the `update` method
+ * of SmoothControls must be invoked on every frame, otherwise the controls
+ * will not have an effect.
+ *
+ * Another notable difference compared to OrbitControls is that SmoothControls
+ * does not currently support panning (but probably will in a future revision).
+ *
+ * Like OrbitControls, SmoothControls assumes that the orientation of the camera
+ * has been set in terms of position, rotation and scale, so it is important to
+ * ensure that the camera's matrixWorld is in sync before using SmoothControls.
+ */
+export declare class SmoothOrbitControls extends KingSyControls {
+    protected _enabled: boolean;
+    protected _options: Required<SmoothOrbitControlsOptions>;
+    protected isUserPointing: boolean;
+    enablePan: boolean;
+    enableTap: boolean;
+    protected panProjection: Matrix3;
+    protected panPerPixel: number;
+    spherical: Spherical;
+    protected goalSpherical: Spherical;
+    protected origin: Vector3;
+    protected pivotalOrigin: Vector3;
+    protected goalOrigin: Vector3;
+    protected targetDamperX: Damper;
+    protected targetDamperY: Damper;
+    protected targetDamperZ: Damper;
+    protected thetaDamper: Damper;
+    protected phiDamper: Damper;
+    protected radiusDamper: Damper;
+    protected logFov: number;
+    protected goalLogFov: number;
+    protected fovDamper: Damper;
+    protected touchMode: TouchMode;
+    protected pointers: Pointer[];
+    protected startPointerPosition: {
+        clientX: number;
+        clientY: number;
+    };
+    protected lastSeparation: number;
+    protected touchDecided: boolean;
+    protected zoomControlCoord: Vector2;
+    protected _targetCamera: PerspectiveCamera | OrthographicCamera;
+    protected _container: HTMLElement;
+    protected _lastTick: number;
+    protected _basisTransform: Matrix4;
+    protected _basisTransformInv: Matrix4;
+    protected _radiusDelta: number;
+    protected world: World;
+    protected renderer: KingSyRenderer;
+    protected orbitSphere: Mesh;
+    protected pivotPoint: Vector3;
+    protected lastPivotPoint: Vector3;
+    protected usePivotal: boolean;
+    protected _minDist: number;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    get up(): Vector3;
+    set up(value: Vector3);
+    constructor(camera: PerspectiveCamera | OrthographicCamera, container: HTMLElement, world: World, renderer: KingSyRenderer, options: Required<SmoothOrbitControlsOptions>);
+    /**
+     * The options that are currently configured for the controls instance.
+     */
+    get options(): Required<SmoothOrbitControlsOptions>;
+    set options(value: SmoothOrbitControlsOptions);
+    set targetCamera(value: PerspectiveCamera | OrthographicCamera);
+    set minDist(value: number);
+    /** The input position and target will be in a basis with (0,1,0) as up */
+    fromPositionAndTarget(position: Vector3, target: Vector3): void;
+    /**
+     * Move the camera instantly instead of accelerating toward the goal
+     * parameters.
+     */
+    jumpToGoal(): void;
+    fitToSphere(sphere: Sphere): void;
+    /**
+     * Gets the current goal position
+     */
+    getPosition(): Vector3;
+    /**
+     * Gets the point in model coordinates the model should orbit/pivot around.
+     */
+    getTarget(): Vector3;
+    /**
+     * Gets the current goal position
+     */
+    getCurrentPosition(): Vector3;
+    /**
+     * Gets the point in model coordinates the model should orbit/pivot around.
+     */
+    getCurrentTarget(): Vector3;
+    isStationary(): boolean;
+    /**
+     * Configure the _options of the controls. Configured _options will be
+     * merged with whatever _options have already been configured for this
+     * controls instance.
+     */
+    protected applyOptions(_options: SmoothOrbitControlsOptions): void;
+    /** Computes min/max radius values based on the current world size */
+    protected computeMinMaxRadius(): void;
+    /**
+     * Set the absolute orbital goal of the camera. The change will be
+     * applied over a number of frames depending on configured acceleration and
+     * dampening _options.
+     *
+     * Returns true if invoking the method will result in the camera changing
+     * position and/or rotation, otherwise false.
+     */
+    setOrbit(goalTheta?: number, goalPhi?: number, goalRadius?: number): boolean;
+    /**
+     * Subset of setOrbit() above, which only sets the camera's radius.
+     */
+    setRadius(radius: number): void;
+    /**
+     * Sets the goal field of view for the camera
+     */
+    setFieldOfView(fov: number): void;
+    /**
+     * Sets the smoothing decay time.
+     */
+    setDamperDecayTime(decayMilliseconds: number): void;
+    /**
+     * Sets the point in model coordinates the object should orbit/pivot around.
+     */
+    setTarget(x: number, y: number, z: number): void;
+    /**
+     * Adjust the orbital position of the camera relative to its current orbital
+     * position. Does not let the theta goal get more than pi ahead of the current
+     * theta, which ensures interpolation continues in the direction of the delta.
+     * The deltaZoom parameter adjusts both the field of view and the orbit radius
+     * such that they progress across their allowed ranges in sync.
+     */
+    adjustOrbit(deltaTheta: number, deltaPhi: number, deltaZoom: number): void;
+    /**
+     * Update controls. In most cases, this will result in the camera
+     * interpolating its position and rotation until it lines up with the
+     * designated goal orbital position. Returns false if the camera did not move.
+     *
+     * Time and delta are measured in milliseconds.
+     */
+    update(delta?: number): boolean;
+    /** Function expects the position argument to be in a CS where Y is up */
+    protected polarFromPivotal(position: Vector3): void;
+    /** Function expects the origin argument to be in a CS where Y is up */
+    protected positionFromPivotal(origin: Vector3, quaternion: Quaternion): Vector3;
+    /** Function expects the pivotPoint and position arguments to be in a CS where Y is up */
+    protected getPivotalOrigin(pivotPoint: Vector3, position: Vector3, quaternion: Quaternion): Vector3;
+    protected moveCamera(): boolean;
+    /** Three.js Spherical assumes (0, 1, 0) as up... */
+    protected positionFromSpherical(spherical: Spherical, origin?: Vector3): Vector3;
+    /** Three.js Spherical assumes (0, 1, 0) as up... */
+    protected quaternionFromSpherical(spherical: Spherical): Quaternion;
+    protected userAdjustOrbit(deltaTheta: number, deltaPhi: number, deltaZoom: number): void;
+    protected enableInteraction(): void;
+    protected disableInteraction(): void;
+    protected wrapAngle(radians: number): number;
+    protected pixelLengthToSphericalAngle(pixelLength: number): number;
+    protected twoTouchDistance(touchOne: Pointer, touchTwo: Pointer): number;
+    protected touchModeZoom: TouchMode;
+    protected disableScroll: (event: TouchEvent) => void;
+    protected touchModeRotate: TouchMode;
+    protected handleSinglePointerMove(dx: number, dy: number): void;
+    protected initializePan(): void;
+    protected movePan(dx: number, dy: number): void;
+    /** By default hidden objects are ignored when picking for orbit around cursor */
+    protected filterOrbitToCursorHits(hit: ExtendedMeshIntersection): boolean;
+    protected onPointerDown: (event: PointerEvent) => void;
+    protected onPointerMove: (event: PointerEvent) => void;
+    protected onPointerUp: (event: PointerEvent) => void;
+    protected onTouchChange(event: PointerEvent): void;
+    protected onMouseDown(event: MouseEvent): void;
+    protected onWheel: (event: WheelEvent) => void;
+    protected onContext: (event: MouseEvent) => void;
+    dispose(): void;
+}