@cesium/engine 26.1.0 → 26.2.0

package/index.d.ts

@@ -619,10 +619,9 @@ export namespace ArcGISTiledElevationTerrainProvider {
  *   token: "KED1aF_I4UzXOHy3BnhwyBHU4l5oY6rO6walkmHoYqGp4XyIWUd5YZUC1ZrLAzvV40pR6gBXQayh0eFA8m6vPg.."
  * });
  * viewer.terrainProvider = terrainProvider;
- * @param [options] - A url or an object describing initialization options
  */
 export class ArcGISTiledElevationTerrainProvider {
-    constructor(options?: CesiumTerrainProvider.ConstructorOptions);
+    constructor();
     /**
      * Gets an event that is raised when the terrain provider encounters an asynchronous error.  By subscribing
      * to the event, you will be notified of the error and can potentially recover from it.  Event listeners
@@ -8448,6 +8447,10 @@ export class HeightmapTerrainData {
  * An {@link InterpolationAlgorithm} for performing Hermite interpolation.
  */
 export namespace HermitePolynomialApproximation {
+    /**
+     * Gets the name of this interpolation algorithm.
+     */
+    var type: string;
     /**
      * Given the desired degree, returns the number of data points required for interpolation.
      * @param degree - The desired degree of interpolation.
@@ -8776,7 +8779,7 @@ export interface InterpolationAlgorithm {
      * @param [result] - An existing array into which to store the result.
      * @returns The array of interpolated values, or the result parameter if one was provided.
      */
-    interpolate(x: number, xTable: number[], yTable: number[], yStride: number, inputOrder: number, outputOrder: number, result?: number[]): number[];
+    interpolate?(x: number, xTable: number[], yTable: number[], yStride: number, inputOrder: number, outputOrder: number, result?: number[]): number[];
 }
 
 /**
@@ -9429,6 +9432,10 @@ export enum KeyboardEventModifier {
  * An {@link InterpolationAlgorithm} for performing Lagrange interpolation.
  */
 export namespace LagrangePolynomialApproximation {
+    /**
+     * Gets the name of this interpolation algorithm.
+     */
+    var type: string;
     /**
      * Given the desired degree, returns the number of data points required for interpolation.
      * @param degree - The desired degree of interpolation.
@@ -9473,6 +9480,10 @@ export class LeapSecond {
  * An {@link InterpolationAlgorithm} for performing linear interpolation.
  */
 export namespace LinearApproximation {
+    /**
+     * Gets the name of this interpolation algorithm.
+     */
+    var type: string;
     /**
      * Given the desired degree, returns the number of data points required for interpolation.
      * Since linear interpolation can only generate a first degree polynomial, this function
@@ -9788,6 +9799,26 @@ export namespace Math {
      * @returns The linearly interpolated value.
      */
     function lerp(p: number, q: number, time: number): number;
+    /**
+     * @property value - The new value after applying the smooth damp.
+     * @property velocity - The updated current velocity.
+     */
+    type SmoothDampResult = {
+        value: number;
+        velocity: number;
+    };
+    /**
+     * Gradually changes a value towards a target value over time. The smoothing function uses a spring-damping algorithm based on Game Programming Gems 4 Chapter 1.10.
+     * @param p - The current value.
+     * @param q - The target value.
+     * @param velocity - The current velocity.
+     * @param [deltaTime = 0.0] - The time since the last call to this function. Value must be greater than or equal to 0.0.
+     * @param [maximumSpeed = Number.POSITIVE_INFINITY] - Optionally allows clamping to the specified maximum speed.
+     * @param [smoothTime = 0.0001] - Approximately the time it will take to reach the target. A smaller value will reach the target faster. This value must be greater than or equal to 0.0001.
+     * @param [result] - An object to store the result. If not provided, a new object will be created and returned.
+     * @returns An object containing the new value and the updated current velocity.
+     */
+    function smoothDamp(p: number, q: number, velocity: number, deltaTime?: number, maximumSpeed?: number, smoothTime?: number, result?: SmoothDampResult): SmoothDampResult;
     /**
      * pi
      */
@@ -18082,6 +18113,8 @@ export class VRTheWorldTerrainProvider {
     loadTileDataAvailability(x: number, y: number, level: number): undefined | Promise<void>;
 }
 
+export const GRID_TARGET_SEGMENTS_PER_CELL = 16;
+
 /**
  * A vertex format defines what attributes make up a vertex.  A VertexFormat can be provided
  * to a {@link Geometry} to request that certain properties be computed, e.g., just position,
@@ -26904,8 +26937,9 @@ export class Billboard {
      */
     rotation: number;
     /**
-     * Gets or sets the aligned axis in world space. The aligned axis is the unit vector that the billboard up vector points towards.
+     * The aligned axis is the direction vector that the billboard up vector points towards.
      * The default is the zero vector, which means the billboard is aligned to the screen up vector.
+     * Note that only the zero vector (0,0,0) resets the alignment to screen up.
      * @example
      * // Example 1.
      * // Have the billboard up vector point north
@@ -28939,6 +28973,13 @@ export class Camera {
      * @param [offset] - The offset from the target in a reference frame centered at the target.
      */
     lookAtTransform(transform: Matrix4, offset?: Cartesian3 | HeadingPitchRange): void;
+    /**
+     * Sets the camera orientation to look at a target position in world coordinates. The camera's up vector will be oriented to the world up vector at the target position.
+     * If the camera is at the target position, the camera will be oriented to the world up vector at the target position.
+     * @param target - The target position in world coordinates.
+     * @param [ellipsoid = Ellipsoid.default] - The ellipsoid to use for determining the world up.
+     */
+    lookAtWorldPosition(target: Cartesian3, ellipsoid?: Ellipsoid): void;
     /**
      * Get the camera position needed to view a rectangle on an ellipsoid or map
      * @param rectangle - The rectangle to view.
@@ -30708,7 +30749,7 @@ export namespace Cesium3DTileset {
      * @property [clippingPlanes] - The {@link ClippingPlaneCollection} used to selectively disable rendering the tileset.
      * @property [clippingPolygons] - The {@link ClippingPolygonCollection} used to selectively disable rendering the tileset.
      * @property [classificationType] - Determines whether terrain, 3D Tiles or both will be classified by this tileset. See {@link Cesium3DTileset#classificationType} for details about restrictions and limitations.
-     * @property [heightReference] - Sets the {@link HeightReference} for point features in vector tilesets.
+     * @property [heightReference] - Sets the {@link HeightReference} for features in vector tilesets.
      * @property [scene] - The {@link CesiumWidget#scene} that the tileset will be rendered in, required for tilesets that specify a {@link heightReference} value for clamping 3D Tiles vector data content- like points, lines, and labels- to terrain or 3D tiles.
      * @property [ellipsoid = Ellipsoid.WGS84] - The ellipsoid determining the size and shape of the globe.
      * @property [pointCloudShading] - Options for constructing a {@link PointCloudShading} object to control point attenuation based on geometric error and lighting.
@@ -32580,6 +32621,605 @@ export class ConeEmitter {
     constructor(angle?: number);
 }
 
+/**
+ * An interface for a camera controller that can be registered with the scene to handle input events, camera animations, and other interactions. Implementations of this interface are expected to be registered with the scene via a {@link ControllerHost}.
+ * This type describes an
+ * interface and is not intended to be instantiated directly.
+ */
+export class Controller {
+    /**
+     * Determines if the controller is enabled and should be updated by the host scene.
+     */
+    enabled: boolean;
+    /**
+     * Invoked when the controller is added to the DOM. Implement <code>connectedCallback</code> to set up any DOM event listeners.
+     * @param element - The DOM element containing the Cesium scene.
+     */
+    connectedCallback(element: HTMLElement): void;
+    /**
+     * Invoked when the controller is removed from the DOM. Implement <code>disconnectedCallback</code> to tear down any DOM event listeners.
+     * @param element - The DOM element containing the Cesium scene.
+     */
+    disconnectedCallback(element: HTMLElement): void;
+    /**
+     * Invoked once per frame. Implement <code>update</code> to modify the camera or other parts of the scene.
+     * @param time - The current simulation time.
+     */
+    update(scene: Scene, time: JulianDate): void;
+    /**
+     * Invoked when the controller is being updated the first time, immediately before <code>update</code> is called. Implement <code>firstUpdate</code> to perform one-time work after the relevant scene has begun its render loop. Some examples might include initializing simulation time values or adding a primitive to the scene.
+     * @param time - The current simulation time.
+     */
+    firstUpdate(scene: Scene, time: JulianDate): void;
+}
+
+/**
+ * Creates an instance of a <code>ControllerHost</code>. Typically, a <code>ControllerHost</code> is created by the Scene constructor and accessed via {@link Scene#controllerHost}.
+ */
+export class ControllerHost {
+    /**
+     * The number of controllers registered to this host.
+     */
+    readonly controllerCount: number;
+    /**
+     * Registers a controller implementation with this host.
+     * @param controller - An implementation of the Controller interface to register with this host.
+     * @param element - The DOM element containing the Cesium scene.
+     * @param [priority = 0] - An index, less than or equal to the current count of registed controllers, that defines the precedence of the new controller relative to those previously registered. A priority of <code>0</code> would mean the new controller would apply its updates before any other controller. As subsequent controllers are updated, their effects are applied on top of any previous update effects. If omitted, the new controller becomes the highest priority, i.e., its updates are applied after all other controllers.
+     */
+    registerController(controller: Controller, element: HTMLElement, priority?: number): void;
+    /**
+     * Unregisters a controller implementation from this host.
+     * @param controller - An implementation of the Controller interface to unregister from this host.
+     * @param element - The DOM element containing the Cesium scene.
+     */
+    unregisterController(controller: Controller, element: HTMLElement): void;
+    /**
+     * Invoked once per frame by the host scene. Updates all registered controllers in order of their priority.
+     * @param scene - The host scene.
+     * @param time - The current simulation time.
+     */
+    update(scene: Scene, time: JulianDate): void;
+}
+
+export interface HybridScreenSpacePanCameraController extends Controller {
+}
+
+/**
+ * A contextual camera controller that combines screenspace map panning and screenspace elevator panning. The controller automatically switches between the two based on the camera's angle relative to nadir. If the camera is looking mostly down (within angleThreshold of nadir), <code>ScreenSpaceMapCameraController</code> is used.
+ * If the camera is looking towards the horizon (beyond angleThreshold from nadir), the <code>ScreenSpaceElevatorCameraController</code> is used.
+ * @example
+ * viewer.scene.screenSpaceCameraController.enableInputs = false;
+ * viewer.scene.screenSpaceCameraController.enableCollisionDetection = false;
+ *
+ * const hybridController = new HybridScreenSpacePanCameraController();
+ * viewer.addController(hybridController);
+ */
+export class HybridScreenSpacePanCameraController implements Controller {
+    /**
+     * The angle threshold in radians that determines which controller is used. If the camera is looking within this angle of nadir, the map controller is used. Otherwise, the elevator controller is used.
+     */
+    angleThreshold: number;
+    /**
+     * The controller that is used when the camera is looking more horizontally (beyond angleThreshold from nadir).
+     */
+    readonly elevatorController: ScreenSpaceElevatorCameraController;
+    /**
+     * The controller that is used when the camera is looking mostly down (within angleThreshold of nadir).
+     */
+    readonly mapController: ScreenSpaceMapCameraController;
+    /**
+     * Determines if the controller is enabled and should be updated by the host scene.
+     */
+    enabled: boolean;
+    /**
+     * Invoked when the controller is added to the DOM. Implement <code>connectedCallback</code> to set up any DOM event listeners.
+     * @param element - The DOM element containing the Cesium scene.
+     */
+    connectedCallback(element: HTMLElement): void;
+    /**
+     * Invoked when the controller is removed from the DOM. Implement <code>disconnectedCallback</code> to tear down any DOM event listeners.
+     * @param element - The DOM element containing the Cesium scene.
+     */
+    disconnectedCallback(element: HTMLElement): void;
+    /**
+     * Invoked once per frame. Implement <code>update</code> to modify the camera or other parts of the scene.
+     * @param time - The current simulation time.
+     */
+    update(scene: Scene, time: JulianDate): void;
+    /**
+     * Invoked when the controller is being updated the first time, immediately before <code>update</code> is called. Implement <code>firstUpdate</code> to perform one-time work after the relevant scene has begun its render loop. Some examples might include initializing simulation time values or adding a primitive to the scene.
+     * @param time - The current simulation time.
+     */
+    firstUpdate(scene: Scene, time: JulianDate): void;
+}
+
+/**
+ * This enumerated type is for classifying mouse buttons: left, middle, and right.
+ */
+export enum MouseButton {
+    /**
+     * Represents a mouse left button.
+     */
+    LEFT = 0,
+    /**
+     * Represents a mouse middle button.
+     */
+    MIDDLE = 1,
+    /**
+     * Represents a mouse right button.
+     */
+    RIGHT = 2
+}
+
+export namespace ScreenSpaceElevatorCameraController {
+    /**
+     * @property [dragInputs] - The drag input bindings that control panning.
+     */
+    type ControllerOptions = {
+        dragInputs?: ScreenSpaceInputBindings.InputBinding[];
+    };
+}
+
+export interface ScreenSpaceElevatorCameraController extends Controller {
+}
+
+/**
+ * Creates an instance of a ScreenSpaceElevatorCameraController.
+ * @example
+ * viewer.scene.screenSpaceCameraController.enableInputs = false;
+ * viewer.scene.screenSpaceCameraController.enableCollisionDetection = false;
+ *
+ * const elevatorCameraController = new Cesium.ScreenSpaceElevatorCameraController();
+ * viewer.addController(elevatorCameraController);
+ * @example
+ * // Configure the controller to use the right mouse button for panning instead of the default left mouse button.
+ * const elevatorCameraController = new Cesium.ScreenSpaceElevatorCameraController({
+ *  dragInputs: [{ button: Cesium.MouseButton.RIGHT}]
+ * });
+ * viewer.addController(elevatorCameraController);
+ * @param [options] - The options for configuring the controller.
+ */
+export class ScreenSpaceElevatorCameraController implements Controller {
+    constructor(options?: ScreenSpaceElevatorCameraController.ControllerOptions);
+    /**
+     * The drag input bindings that control vertical panning. Each binding is a combination of the mouse button
+     * and an optional keyboard modifier.
+     */
+    dragInputs: ScreenSpaceInputBindings.InputBinding[];
+    /**
+     * A callback function used to pick the world position from which to pan. The function is called with {@link Scene}, the {@link Cartesian2} screen space position, and a {@link Cartesian3} instance to store the result. The function should return the {@link Cartesian3} world position from which to pan, or <code>undefined</code> if no position could be picked. If <code>undefined</code> is returned, the camera will pan relative to the ellipsoid surface below the camera.
+     * @example
+     * const elevatorCameraController = new Cesium.ScreenSpaceElevatorCameraController();
+     * elevatorCameraController.pickWorldPosition = function (scene, windowPosition, result) {
+     *   // Pick the world position from the depth buffer
+     *   return scene.pickPosition(windowPosition, result);
+     * };
+     * viewer.addController(elevatorCameraController);
+     */
+    pickWorldPosition: (...params: any[]) => any;
+    /**
+     * The speed in meters per pixel at which the camera pans.
+     */
+    panSpeed: number;
+    /**
+     * Enable or disable inertia when panning. When enabled, the camera will continue to move after the user stops dragging, gradually slowing down based on {@link ScreenSpaceMapCameraController#inertialDecay}.
+     */
+    inertiaEnabled: boolean;
+    /**
+     * The rate at which the camera's pan velocity decays over time.
+     */
+    inertialDecay: number;
+    /**
+     * A parameter in the range <code>[0, 1)</code> used to limit the range
+     * of inputs to a percentage of the window width/height per animation frame.
+     * This helps keep the camera under control in low-frame-rate situations.
+     */
+    maximumMovementRatio: number;
+    /**
+     * Determines if the controller is enabled and should be updated by the host scene.
+     */
+    enabled: boolean;
+    /**
+     * Invoked when the controller is added to the DOM. Implement <code>connectedCallback</code> to set up any DOM event listeners.
+     * @param element - The DOM element containing the Cesium scene.
+     */
+    connectedCallback(element: HTMLElement): void;
+    /**
+     * Invoked when the controller is removed from the DOM. Implement <code>disconnectedCallback</code> to tear down any DOM event listeners.
+     * @param element - The DOM element containing the Cesium scene.
+     */
+    disconnectedCallback(element: HTMLElement): void;
+    /**
+     * Invoked once per frame. Implement <code>update</code> to modify the camera or other parts of the scene.
+     * @param time - The current simulation time.
+     */
+    update(scene: Scene, time: JulianDate): void;
+    /**
+     * Invoked when the controller is being updated the first time, immediately before <code>update</code> is called. Implement <code>firstUpdate</code> to perform one-time work after the relevant scene has begun its render loop. Some examples might include initializing simulation time values or adding a primitive to the scene.
+     * @param time - The current simulation time.
+     */
+    firstUpdate(scene: Scene, time: JulianDate): void;
+}
+
+export namespace ScreenSpaceInputBindings {
+    /**
+     * @property button - The mouse button used for drag start/stop.
+     * @property [modifier] - The optional keyboard modifier to register.
+     */
+    type InputBinding = {
+        button: MouseButton;
+        modifier?: number;
+    };
+    /**
+     * @property [start] - Called on drag start.
+     * @property [end] - Called on drag stop.
+     * @property [change] - Called on drag move.
+     */
+    type DragInputActions = {
+        start?: (...params: any[]) => any;
+        end?: (...params: any[]) => any;
+        change?: (...params: any[]) => any;
+    };
+    /**
+     * @property isDragging - True if a drag is in progress, false otherwise.
+     */
+    type DragInputState = {
+        isDragging: boolean;
+    };
+    /**
+     * Registers drag input bindings on a screen space event handler.
+     * @param handler - The screen space event handler.
+     * @param inputBindings - The drag bindings to register.
+     * @param dragInputActions - The callbacks to invoke for drag actions.
+     * @returns The drag input state.
+     */
+    function registerDragInputBindings(handler: ScreenSpaceEventHandler, inputBindings: InputBinding[], dragInputActions: DragInputActions): DragInputState;
+}
+
+export namespace ScreenSpaceMapCameraController {
+    /**
+     * @property [dragInputs] - The drag input bindings that control panning.
+     */
+    type ControllerOptions = {
+        dragInputs?: ScreenSpaceInputBindings.InputBinding[];
+    };
+}
+
+export interface ScreenSpaceMapCameraController extends Controller {
+}
+
+/**
+ * Creates an instance of a ScreenSpaceMapCameraController.
+ * @example
+ * viewer.scene.screenSpaceCameraController.enableInputs = false;
+ *
+ * const mapCameraController = new Cesium.ScreenSpaceMapCameraController();
+ * viewer.addController(mapCameraController);
+ * @example
+ * // Configure the controller to use the right mouse button for panning instead of the default left mouse button.
+ * const mapCameraController = new Cesium.ScreenSpaceMapCameraController({
+ *  dragInputs: [{ button: Cesium.MouseButton.RIGHT}]
+ * });
+ * viewer.addController(mapCameraController);
+ * @param [options] - The options for configuring the controller.
+ */
+export class ScreenSpaceMapCameraController implements Controller {
+    constructor(options?: ScreenSpaceMapCameraController.ControllerOptions);
+    /**
+     * The drag input bindings that map panning. Each binding is a combination of the mouse button
+     * and an optional keyboard modifier.
+     */
+    dragInputs: ScreenSpaceInputBindings.InputBinding[];
+    /**
+     * A callback function used to pick the world position from which to pan. The function is called with {@link Scene}, the {@link Cartesian2} screen space position, and a {@link Cartesian3} instance to store the result. The function should return the {@link Cartesian3} world position from which to pan, or <code>undefined</code> if no position could be picked. If <code>undefined</code> is returned, the camera will pan relative to the ellipsoid surface below the camera.
+     * @example
+     * const mapCameraController = new Cesium.ScreenSpaceMapCameraController();
+     * mapCameraController.pickWorldPosition = function (scene, windowPosition, result) {
+     *   // Pick the world position from the depth buffer
+     *   return scene.pickPosition(windowPosition, result);
+     * };
+     * viewer.addController(mapCameraController);
+     */
+    pickWorldPosition: (...params: any[]) => any;
+    /**
+     * The speed in meters per pixel at which the camera pans.
+     */
+    panSpeed: number;
+    /**
+     * Enable or disable inertia when panning. When enabled, the camera will continue to move after the user stops dragging, gradually slowing down based on {@link ScreenSpaceMapCameraController#inertialDecay}.
+     */
+    inertiaEnabled: boolean;
+    /**
+     * The rate at which the camera's pan velocity decays over time.
+     */
+    inertialDecay: number;
+    /**
+     * A parameter in the range <code>[0, 1)</code> used to limit the range
+     * of inputs to a percentage of the window width/height per animation frame.
+     * This helps keep the camera under control in low-frame-rate situations.
+     */
+    maximumMovementRatio: number;
+    /**
+     * Determines if the controller is enabled and should be updated by the host scene.
+     */
+    enabled: boolean;
+    /**
+     * Invoked when the controller is added to the DOM. Implement <code>connectedCallback</code> to set up any DOM event listeners.
+     * @param element - The DOM element containing the Cesium scene.
+     */
+    connectedCallback(element: HTMLElement): void;
+    /**
+     * Invoked when the controller is removed from the DOM. Implement <code>disconnectedCallback</code> to tear down any DOM event listeners.
+     * @param element - The DOM element containing the Cesium scene.
+     */
+    disconnectedCallback(element: HTMLElement): void;
+    /**
+     * Invoked once per frame. Implement <code>update</code> to modify the camera or other parts of the scene.
+     * @param time - The current simulation time.
+     */
+    update(scene: Scene, time: JulianDate): void;
+    /**
+     * Invoked when the controller is being updated the first time, immediately before <code>update</code> is called. Implement <code>firstUpdate</code> to perform one-time work after the relevant scene has begun its render loop. Some examples might include initializing simulation time values or adding a primitive to the scene.
+     * @param time - The current simulation time.
+     */
+    firstUpdate(scene: Scene, time: JulianDate): void;
+}
+
+export namespace ScreenSpaceTiltOrbitCameraController {
+    /**
+     * @property [dragInputs] - The drag input bindings that control tilting and orbiting.
+     */
+    type ControllerOptions = {
+        dragInputs?: ScreenSpaceInputBindings.InputBinding[];
+    };
+}
+
+export interface ScreenSpaceTiltOrbitCameraController extends Controller {
+}
+
+/**
+ * Creates a new instance of <code>ScreenSpaceTiltOrbitCameraController</code>.
+ * @example
+ * viewer.scene.screenSpaceCameraController.enableInputs = false;
+ * viewer.scene.screenSpaceCameraController.enableCollisionDetection = false;
+ *
+ * const tiltOrbitController = new Cesium.ScreenSpaceTiltOrbitCameraController();
+ * viewer.addController(tiltOrbitController);
+ * @example
+ * // Tilt around the position under the cursor or tap when dragging starts instead of the position at the center of the screen.
+ * viewer.scene.screenSpaceCameraController.enableInputs = false;
+ * viewer.scene.screenSpaceCameraController.enableCollisionDetection = false;
+ *
+ * const tiltOrbitController = new Cesium.ScreenSpaceTiltOrbitCameraController();
+ * tiltOrbitController.useDragPosition = true;
+ * viewer.addController(tiltOrbitController);
+ * @example
+ * // Configure the controller to use the left mouse button for tilting and orbiting instead of the default right mouse button.
+ * const tiltOrbitController = new Cesium.ScreenSpaceTiltOrbitCameraController({
+ *  dragInputs: [{ button: Cesium.MouseButton.LEFT }]
+ * });
+ * viewer.addController(tiltOrbitController);
+ * @param [options] - The options for configuring the controller.
+ */
+export class ScreenSpaceTiltOrbitCameraController implements Controller {
+    constructor(options?: ScreenSpaceTiltOrbitCameraController.ControllerOptions);
+    /**
+     * Enabled dragging to tilt the camera.
+     */
+    tiltEnabled: boolean;
+    /**
+     * Enabled dragging to orbit the camera.
+     */
+    orbitEnabled: boolean;
+    /**
+     * If false, the camera will orbit and tilt around the position at the center of the screen. If true, the camera will orbit and tilt around the position under the cursor or tap when dragging starts.
+     */
+    useDragPosition: boolean;
+    /**
+     * The drag input bindings that control tilting. Each binding is a combination of the mouse button
+     * and an optional keyboard modifier.
+     */
+    dragInputs: ScreenSpaceInputBindings.InputBinding[];
+    /**
+     * A callback function used to pick the world position around which to tilt or orbit. The function is called with {@link Scene}, the {@link Cartesian2} screen space position, and a {@link Cartesian3} instance to store the result. The function should return the {@link Cartesian3} world position from which to tilt or orbit, or <code>undefined</code> if no position could be picked.
+     * @example
+     * const tiltOrbitCameraController = new Cesium.ScreenSpaceTiltOrbitCameraController();
+     * tiltOrbitCameraController.pickWorldPosition = function (scene, windowPosition, result) {
+     *   // Pick the world position from the depth buffer
+     *   return scene.pickPosition(windowPosition, result);
+     * };
+     * viewer.addController(tiltOrbitCameraController);
+     */
+    pickWorldPosition: (...params: any[]) => any;
+    /**
+     * The amount at which the camera tilts per dragged pixel. A value of 1.0 means that dragging the mouse across the entire canvas will tilt the camera by 90 degrees.
+     */
+    tiltMagnitude: number;
+    /**
+     * Enables or disables damping for tilt and orbit animations. Damping smooths out the camera movement and makes it feel more natural or weighty, but it can also introduce a slight delay in the camera response. If damping is disabled, the camera will respond immediately to user input.
+     */
+    dampingEnabled: boolean;
+    /**
+     * Specifies the length of time in seconds in which a single tilt animation is targeted to complete.
+     */
+    tiltAnimationDuration: number;
+    /**
+     * The maximum tilt velocity in radians per second. A value of Number.POSITIVE_INFINITY means that the maximum tilt velocity is unbounded.
+     */
+    maximumTiltVelocity: number;
+    /**
+     * The amount at which the camera orbits per dragged pixel. A value of 1.0 means that dragging the mouse across the entire canvas will orbit the camera by 180 degrees.
+     */
+    orbitMagnitude: number;
+    /**
+     * Specifies the length of time in seconds in which a single orbit animation completes.
+     */
+    orbitAnimationDuration: number;
+    /**
+     * The maximum orbit velocity in radians per second. A value of Number.POSITIVE_INFINITY means that the maximum orbit velocity is unbounded.
+     */
+    maximumOrbitVelocity: number;
+    /**
+     * A parameter in the range <code>[0, 1)</code> used to limit the range
+     * of inputs to a percentage of the window width/height per animation frame.
+     * This helps keep the camera under control in low-frame-rate situations.
+     */
+    maximumMovementRatio: number;
+    /**
+     * Attempts to orbit the camera around the specified origin by the specified amount in radians. Positive values orbit the camera clockwise, negative values orbit the camera counterclockwise. If the drag origin is not on the ellipsoid, no orbit is applied.
+     * @param camera - The camera to orbit.
+     * @param target - The origin position to orbit around in world coordinates.
+     * @param axis - The axis to orbit around, typically the negative of the surface normal at the target position.
+     * @param amount - The amount to orbit the camera in radians. Positive values orbit the camera clockwise, negative values orbit the camera counterclockwise.
+     * @param dt - The time delta in seconds since the last update.
+     * @param [ellipsoid = Ellipsoid.default] - The ellipsoid to pick for the orbit origin. If undefined, the default ellipsoid is used.
+     */
+    orbit(camera: Camera, target: Cartesian3, axis: Cartesian3, amount: number, dt: number, ellipsoid?: Ellipsoid): void;
+    /**
+     * Attempts to tilt the camera by the specified amount in radians. Positive values tilt the camera down, negative values tilt the camera up. If the drag origin is not on the ellipsoid, no tilt is applied.
+     * @param camera - The camera to tilt.
+     * @param target - The origin position to tilt around in world coordinates.
+     * @param axis - The axis to tilt around, typically the negative of the surface normal at the target position.
+     * @param amount - The amount to tilt the camera in radians. Positive values tilt the camera down, negative values tilt the camera up.
+     * @param dt - The time delta in seconds since the last update. Value must be greater than 0.
+     * @param [ellipsoid = Ellipsoid.default] - The ellipsoid to pick for the tilt origin. If undefined, the default ellipsoid is used.
+     */
+    tilt(camera: Camera, target: Cartesian3, axis: Cartesian3, amount: number, dt: number, ellipsoid?: Ellipsoid): void;
+    /**
+     * Determines if the controller is enabled and should be updated by the host scene.
+     */
+    enabled: boolean;
+    /**
+     * Invoked when the controller is added to the DOM. Implement <code>connectedCallback</code> to set up any DOM event listeners.
+     * @param element - The DOM element containing the Cesium scene.
+     */
+    connectedCallback(element: HTMLElement): void;
+    /**
+     * Invoked when the controller is removed from the DOM. Implement <code>disconnectedCallback</code> to tear down any DOM event listeners.
+     * @param element - The DOM element containing the Cesium scene.
+     */
+    disconnectedCallback(element: HTMLElement): void;
+    /**
+     * Invoked once per frame. Implement <code>update</code> to modify the camera or other parts of the scene.
+     * @param time - The current simulation time.
+     */
+    update(scene: Scene, time: JulianDate): void;
+    /**
+     * Invoked when the controller is being updated the first time, immediately before <code>update</code> is called. Implement <code>firstUpdate</code> to perform one-time work after the relevant scene has begun its render loop. Some examples might include initializing simulation time values or adding a primitive to the scene.
+     * @param time - The current simulation time.
+     */
+    firstUpdate(scene: Scene, time: JulianDate): void;
+}
+
+export namespace ScreenSpaceZoomCameraController {
+    /**
+     * @property [dragInputs] - The drag input bindings that control zooming.
+     * @property [scrollInputs] - The scroll input bindings that control zooming.
+     */
+    type ControllerOptions = {
+        dragInputs?: ScreenSpaceInputBindings.InputBinding[];
+        scrollInputs?: ScreenSpaceEventType[];
+    };
+}
+
+export interface ScreenSpaceZoomCameraController extends Controller {
+}
+
+/**
+ * Creates a new instance of <code>ScreenSpaceZoomCameraController</code>.
+ * @example
+ * viewer.scene.screenSpaceCameraController.enableInputs = false;
+ * viewer.scene.screenSpaceCameraController.enableCollisionDetection = false;
+ *
+ * const zoomCameraController = new Cesium.ScreenSpaceZoomCameraController();
+ * viewer.addController(zoomCameraController);
+ * @param [options] - The options for configuring the controller.
+ */
+export class ScreenSpaceZoomCameraController implements Controller {
+    constructor(options?: ScreenSpaceZoomCameraController.ControllerOptions);
+    /**
+     * If false, the camera will zoom to the position at the center of the screen. If true, the camera will zoom to the position under the cursor or tap when dragging starts or when scrolling with the scroll wheel.
+     */
+    usePointerPosition: boolean;
+    /**
+     * The drag input bindings that control zooming. Each binding is a combination of the mouse button
+     * and an optional keyboard modifier.
+     */
+    dragInputs: ScreenSpaceInputBindings.InputBinding[];
+    /**
+     * The scroll input bindings that control zooming.
+     */
+    scrollInputs: ScreenSpaceEventType[];
+    /**
+     * The rate at which the camera zooms in and out based on the mouse wheel delta.
+     */
+    zoomSensitivity: number;
+    /**
+     * A callback function used to pick the world position from which to zoom. The function is called with {@link Scene}, the {@link Cartesian2} screen space position, and a {@link Cartesian3} instance to store the result. The function should return the {@link Cartesian3} world position from which to zoom, or <code>undefined</code> if no position could be picked.
+     * @example
+     * const zoomCameraController = new Cesium.ScreenSpaceZoomCameraController();
+     * zoomCameraController.pickWorldPosition = function (scene, windowPosition, result) {
+     *   // Pick the world position from the depth buffer
+     *   return scene.pickPosition(windowPosition, result);
+     * };
+     * viewer.addController(zoomCameraController);
+     */
+    pickWorldPosition: (...params: any[]) => any;
+    /**
+     * The ratio of the camera's distance to the zoom target that defines how much the camera zooms in and out per second.
+     */
+    zoomDistanceRatio: number;
+    /**
+     * Enable or disable inertia when zooming. When enabled, the camera will continue to move after the user input stops, gradually slowing down based on {@link ScreenSpaceZoomCameraController#inertialDecay}.
+     */
+    inertiaEnabled: boolean;
+    /**
+     * The rate at which the camera's zoom velocity decays over time.
+     */
+    inertialDecay: number;
+    /**
+     * Maximum distance from the zoom target that the camera can move away.
+     */
+    maximumZoomDistance: number;
+    /**
+     * The maximum zoom velocity in meters per second. This limits the speed at which the camera can zoom in and out.
+     */
+    maximumZoomVelocity: number;
+    /**
+     * Enables or disables damping for zooming. Damping smooths out the camera movement and makes it feel more natural or weighty, but it can also introduce a slight delay in the camera response. If damping is disabled, the camera will respond immediately to user input.
+     */
+    dampingEnabled: boolean;
+    /**
+     * Specifies the length of time in seconds in which a single zoom animation is targeted to complete.
+     */
+    zoomAnimationDuration: number;
+    /**
+     * Determines if the controller is enabled and should be updated by the host scene.
+     */
+    enabled: boolean;
+    /**
+     * Invoked when the controller is added to the DOM. Implement <code>connectedCallback</code> to set up any DOM event listeners.
+     * @param element - The DOM element containing the Cesium scene.
+     */
+    connectedCallback(element: HTMLElement): void;
+    /**
+     * Invoked when the controller is removed from the DOM. Implement <code>disconnectedCallback</code> to tear down any DOM event listeners.
+     * @param element - The DOM element containing the Cesium scene.
+     */
+    disconnectedCallback(element: HTMLElement): void;
+    /**
+     * Invoked once per frame. Implement <code>update</code> to modify the camera or other parts of the scene.
+     * @param time - The current simulation time.
+     */
+    update(scene: Scene, time: JulianDate): void;
+    /**
+     * Invoked when the controller is being updated the first time, immediately before <code>update</code> is called. Implement <code>firstUpdate</code> to perform one-time work after the relevant scene has begun its render loop. Some examples might include initializing simulation time values or adding a primitive to the scene.
+     * @param time - The current simulation time.
+     */
+    firstUpdate(scene: Scene, time: JulianDate): void;
+}
+
 /**
  * The credit display is responsible for displaying credits on screen.
  * @example
@@ -37057,10 +37697,9 @@ export namespace IonImageryProvider {
  * @example
  * const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
  * viewer.imageryLayers.add(imageryLayer);
- * @param [options] - Object describing initialization options
  */
 export class IonImageryProvider {
-    constructor(options?: IonImageryProvider.ConstructorOptions);
+    constructor();
     /**
      * Gets the rectangle, in radians, of the imagery provided by the instance.
      */
@@ -37758,7 +38397,7 @@ export class Light {
  * This object is normally not instantiated directly, use {@link MVTDataProvider.fromUrl}.
  * </div>
  */
-export class MVTDataProvider {
+export class MVTDataProvider extends UrlTemplate3DTilesDataProvider {
     /**
      * Creates an MVTDataProvider from the specified URL template and options.
      * @param url - URL template, containing {z}, {x}, and {y} placeholders.
@@ -37773,7 +38412,7 @@ export class MVTDataProvider {
         maxZoom?: number;
         extent?: Rectangle;
         featureIdProperty?: string;
-    }): void;
+    }): Promise<MVTDataProvider>;
 }
 
 /**
@@ -39605,7 +40244,7 @@ export enum LightingModel {
  *  {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_mesh_gpu_instancing|EXT_mesh_gpu_instancing}
  *  </li>
  *  <li>
- *  {@link https://github.com/KhronosGroup/glTF/pull/2514|EXT_mesh_primitive_restart}
+ *  {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_mesh_primitive_restart|EXT_mesh_primitive_restart}
  *  </li>
  *  <li>
  *  {@link https://github.com/KhronosGroup/glTF/pull/2479|EXT_mesh_primitive_edge_visibility}
@@ -39637,6 +40276,10 @@ export enum LightingModel {
  *  {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit/README.md|KHR_materials_unlit}
  *  </li>
  *  <li>
+ *  {@link https://github.com/KhronosGroup/glTF/pull/2569|KHR_mesh_primitive_restart}
+ *  (requires a WebGL 2 context; behavior on WebGL 1 is undefined)
+ *  </li>
+ *  <li>
  *  {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_mesh_quantization|KHR_mesh_quantization}
  *  </li>
  *  <li>
@@ -43634,6 +44277,16 @@ export class Scene {
      * Gets or sets the camera.
      */
     readonly camera: Camera;
+    /**
+     * Collects an array of <code>Controller</code> objects that can be registered with the scene to handle input events, camera animations, and other interactions.
+     * @example
+     * scene.screenSpaceCameraController.enableInputs = false;
+     * scene.screenSpaceCameraController.enableCollisionDetection = false;
+     *
+     * const tiltOrbitController = new Cesium.ScreenSpaceTiltOrbitCameraController();
+     * scene.controllerHost.registerController(tiltOrbitController, scene.canvas.parentNode);
+     */
+    readonly controllerHost: ControllerHost;
     /**
      * Gets the controller for camera input handling.
      */
@@ -43805,6 +44458,27 @@ export class Scene {
      * @returns Object containing the picked primitive or <code>undefined</code> if nothing is at the location.
      */
     pick(windowPosition: Cartesian2, width?: number, height?: number): any | undefined;
+    /**
+     * Returns the best snap target in a screen-space region around <code>windowPosition</code>.
+     * Edges are preferred over surfaces; among hits of the same kind the one
+     * nearest the cursor wins. Returns <code>undefined</code> if the region contains
+     * no snappable geometry.
+     * <p>
+     * Only primitives rendered through the Model pipeline (e.g. 3D Tiles and glTF
+     * models) are snappable. Snapping requires float color attachments
+     * (WebGL2 with <code>EXT_color_buffer_float</code>); if unsupported, this
+     * function returns <code>undefined</code>.
+     * </p>
+     * @param windowPosition - Window coordinates at the center of the search region.
+     * @param [options] - Object with the following properties:
+     * @param [options.width = 25] - Width of the search region in pixels.
+     * @param [options.height = options.width] - Height of the search region in pixels.
+     * @returns The best snap target in the region, or <code>undefined</code> if there is none.
+     */
+    snap(windowPosition: Cartesian2, options?: {
+        width?: number;
+        height?: number;
+    }): SceneSnapResult | undefined;
     /**
      * Performs the same operation as Scene.pick but asynchonosly without blocking the main render thread.
      * Requires WebGL2 else using fallback.
@@ -44044,6 +44718,20 @@ export class Scene {
     destroy(): void;
 }
 
+/**
+ * The result of a snap operation. See {@link Scene#snap}.
+ * @property object - The snapped primitive or feature.
+ * @property position - The world-space position of the snap point, un-projected from the snap framebuffer's eye-space depth.
+ * @property screenPosition - The window coordinates of the snap point.
+ * @property isEdge - <code>true</code> if the snap point lies on an edge; <code>false</code> if it lies on a surface.
+ */
+export type SceneSnapResult = {
+    object: any;
+    position: Cartesian3;
+    screenPosition: Cartesian2;
+    isEdge: boolean;
+};
+
 /**
  * Indicates if the scene is viewed in 3D, 2D, or 2.5D Columbus view.
  */
@@ -45440,6 +46128,60 @@ export enum Tonemapper {
     PBR_NEUTRAL = "PBR_NEUTRAL"
 }
 
+/**
+ * Base provider for URL-template vector sources that are rendered through a
+ * runtime-generated 3D Tiles tileset.
+ * @param urlTemplate - URL template containing {z}, {x}, and {y} placeholders.
+ * @param [options] - Provider options.
+ * @param [options.minZoom = 0] - Minimum zoom level represented in the generated tileset.
+ * @param [options.maxZoom = 14] - Maximum zoom level represented in the generated tileset.
+ * @param [options.extent] - Optional geographic extent in radians to constrain the generated tile tree.
+ * @param [options.featureIdProperty] - Feature property name to use as feature ID when supported by content decoding.
+ */
+export class UrlTemplate3DTilesDataProvider {
+    constructor(urlTemplate: Resource | string, options?: {
+        minZoom?: number;
+        maxZoom?: number;
+        extent?: Rectangle;
+        featureIdProperty?: string;
+    });
+    /**
+     * Creates a provider from a URL template.
+     * @param url - URL template containing {z}, {x}, and {y} placeholders.
+     * @param [options] - Provider options.
+     */
+    static fromUrl(url: Resource | string, options?: any): Promise<UrlTemplate3DTilesDataProvider>;
+    /**
+     * URL template containing {z}/{x}/{y}.
+     */
+    readonly urlTemplate: string;
+    /**
+     * Resource derived from the URL template.
+     */
+    readonly resource: Resource;
+    /**
+     * Optional geographic extent in radians used to generate tile headers.
+     */
+    readonly extent: Rectangle | undefined;
+    /**
+     * Backing 3D Tileset.
+     */
+    readonly tileset: Cesium3DTileset | undefined;
+    /**
+     * Determines if the generated tileset is shown.
+     */
+    show: boolean;
+    protected _createRuntimeTilesetOptions(): void;
+    protected _createTilesetLoadOptions(): any;
+    protected _configureTileset(_tileset: Cesium3DTileset): void;
+    /**
+     * Subclasses must return a runtime content codec describing how to turn
+     * a downloaded tile payload into a {@link Cesium3DTileContent}. See
+     * {@link Cesium3DTileset#_runtimeContentCodec} for the expected shape.
+     */
+    protected _createCodec(): any;
+}
+
 export namespace UrlTemplateImageryProvider {
     /**
      * Initialization options for the UrlTemplateImageryProvider constructor
@@ -47234,6 +47976,24 @@ export class CesiumWidget {
      * unless <code>useDefaultRenderLoop</code> is set to false;
      */
     render(): void;
+    /**
+     * Adds a controller— an implementation of the {@link Controller} interface used to handle input events, camera animations, and other interactions— to the widget's scene.
+     * @example
+     * widget.scene.screenSpaceCameraController.enableInputs = false;
+     * widget.scene.screenSpaceCameraController.enableCollisionDetection = false;
+     *
+     * const tiltOrbitController = new Cesium.ScreenSpaceTiltOrbitCameraController();
+     * widget.addController(tiltOrbitController);
+     * @param controller - An implementation of the <code>Controller</code> interface.
+     */
+    addController(controller: Controller): void;
+    /**
+     * Removes a controller— an implementation of the {@link Controller}  interface used to handle input events, camera animations, and other interactions— from the widget's scene.
+     * @example
+     * widget.removeController(tiltOrbitController);
+     * @param controller - An implementation of the <code>Controller</code> interface.
+     */
+    removeController(controller: Controller): void;
     /**
      * Asynchronously sets the camera to view the provided entity, entities, or data source.
      * If the data source is still in the process of loading or the visualization is otherwise still loading,