@hztxi/cesium-engine 25.0.4 → 25.0.7

package/index.d.ts

@@ -619,9 +619,10 @@ export namespace ArcGISTiledElevationTerrainProvider {
  *   token: "KED1aF_I4UzXOHy3BnhwyBHU4l5oY6rO6walkmHoYqGp4XyIWUd5YZUC1ZrLAzvV40pR6gBXQayh0eFA8m6vPg.."
  * });
  * viewer.terrainProvider = terrainProvider;
+ * @param [options] - A url or an object describing initialization options
  */
 export class ArcGISTiledElevationTerrainProvider {
-    constructor();
+    constructor(options?: CesiumTerrainProvider.ConstructorOptions);
     /**
      * 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
@@ -3615,6 +3616,8 @@ export enum ClockStep {
     SYSTEM_CLOCK = 2
 }
 
+export function hue2rgb(): void;
+
 /**
  * A color, specified using red, green, blue, and alpha values,
  * which range from <code>0</code> (no intensity) to <code>1.0</code> (full intensity).
@@ -8451,10 +8454,6 @@ 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.
@@ -8741,20 +8740,17 @@ export enum IndexDatatype {
     UNSIGNED_INT = WebGLConstants.UNSIGNED_INT
 }
 
-/**
- * The interface for interpolation algorithms.
- */
-export interface InterpolationAlgorithm {
+export namespace InterpolationAlgorithm {
     /**
      * Gets the name of this interpolation algorithm.
      */
-    type: string;
+    var type: string;
     /**
      * Given the desired degree, returns the number of data points required for interpolation.
      * @param degree - The desired degree of interpolation.
      * @returns The number of required data points needed for the desired degree of interpolation.
      */
-    getRequiredDataPoints(degree: number): number;
+    function getRequiredDataPoints(degree: number): number;
     /**
      * Performs zero order interpolation.
      * @param x - The independent variable for which the dependent variables will be interpolated.
@@ -8767,7 +8763,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.
      */
-    interpolateOrderZero(x: number, xTable: number[], yTable: number[], yStride: number, result?: number[]): number[];
+    function interpolateOrderZero(x: number, xTable: number[], yTable: number[], yStride: number, result?: number[]): number[];
     /**
      * Performs higher order interpolation.  Not all interpolators need to support high-order interpolation,
      * if this function remains undefined on implementing objects, interpolateOrderZero will be used instead.
@@ -8783,7 +8779,13 @@ 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[];
+    function interpolate(x: number, xTable: number[], yTable: number[], yStride: number, inputOrder: number, outputOrder: number, result?: number[]): number[];
+}
+
+/**
+ * The interface for interpolation algorithms.
+ */
+export interface InterpolationAlgorithm {
 }
 
 /**
@@ -9436,10 +9438,6 @@ 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.
@@ -9484,10 +9482,6 @@ 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
@@ -9581,7 +9575,7 @@ export interface MapProjection {
     /**
      * Gets the {@link Ellipsoid}.
      */
-    readonly ellipsoid: Ellipsoid;
+    ellipsoid: Ellipsoid;
     /**
      * Projects {@link Cartographic} coordinates, in radians, to projection-specific map coordinates, in meters.
      * @param cartographic - The coordinates to project.
@@ -9803,26 +9797,6 @@ 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
      */
@@ -16152,25 +16126,25 @@ export class ScreenSpaceEventHandler {
      * Set a function to be executed on an input event.
      * @param action - Function to be executed when the input event occurs.
      * @param type - The ScreenSpaceEventType of input event.
-     * @param [modifiers] - The KeyboardEventModifier keys that are held when a <code>type</code>
+     * @param [modifier] - A KeyboardEventModifier key that is held when a <code>type</code>
      * event occurs.
      */
-    setInputAction(action: ScreenSpaceEventHandler.PositionedEventCallback | ScreenSpaceEventHandler.MotionEventCallback | ScreenSpaceEventHandler.WheelEventCallback | ScreenSpaceEventHandler.TwoPointEventCallback | ScreenSpaceEventHandler.TwoPointMotionEventCallback, type: ScreenSpaceEventType, modifiers?: KeyboardEventModifier[] | KeyboardEventModifier): void;
+    setInputAction(action: ScreenSpaceEventHandler.PositionedEventCallback | ScreenSpaceEventHandler.MotionEventCallback | ScreenSpaceEventHandler.WheelEventCallback | ScreenSpaceEventHandler.TwoPointEventCallback | ScreenSpaceEventHandler.TwoPointMotionEventCallback, type: ScreenSpaceEventType, modifier?: KeyboardEventModifier): void;
     /**
      * Returns the function to be executed on an input event.
      * @param type - The ScreenSpaceEventType of input event.
-     * @param [modifiers] - The KeyboardEventModifier keys that are held when a <code>type</code>
+     * @param [modifier] - A KeyboardEventModifier key that is held when a <code>type</code>
      * event occurs.
      * @returns The function to be executed on an input event.
      */
-    getInputAction(type: ScreenSpaceEventType, modifiers?: KeyboardEventModifier[] | KeyboardEventModifier): ScreenSpaceEventHandler.PositionedEventCallback | ScreenSpaceEventHandler.MotionEventCallback | ScreenSpaceEventHandler.WheelEventCallback | ScreenSpaceEventHandler.TwoPointEventCallback | ScreenSpaceEventHandler.TwoPointMotionEventCallback;
+    getInputAction(type: ScreenSpaceEventType, modifier?: KeyboardEventModifier): ScreenSpaceEventHandler.PositionedEventCallback | ScreenSpaceEventHandler.MotionEventCallback | ScreenSpaceEventHandler.WheelEventCallback | ScreenSpaceEventHandler.TwoPointEventCallback | ScreenSpaceEventHandler.TwoPointMotionEventCallback;
     /**
      * Removes the function to be executed on an input event.
      * @param type - The ScreenSpaceEventType of input event.
-     * @param [modifiers] - The KeyboardEventModifier keys that are held when a <code>type</code>
+     * @param [modifier] - A KeyboardEventModifier key that is held when a <code>type</code>
      * event occurs.
      */
-    removeInputAction(type: ScreenSpaceEventType, modifiers?: KeyboardEventModifier[] | KeyboardEventModifier): void;
+    removeInputAction(type: ScreenSpaceEventType, modifier?: KeyboardEventModifier): void;
     /**
      * Returns true if this object was destroyed; otherwise, false.
      * <br /><br />
@@ -16823,6 +16797,16 @@ export class TerrainData {
     wasCreatedByUpsampling(): boolean;
 }
 
+/**
+ * Creates an axis-aligned bounding box for a quadtree node at the given tree-space coordinates and level.
+ * This AABB is in the tree's local space (where the root node of the tree is a unit cube in its own local space).
+ * @param x - The x coordinate of the node.
+ * @param y - The y coordinate of the node.
+ * @param level - The level of the node.
+ * @returns The axis-aligned bounding box for the node.
+ */
+export function createAABBForNode(x: number, y: number, level: number): AxisAlignedBoundingBox;
+
 export namespace TerrainProvider {
     /**
      * A function that is called when an error occurs.
@@ -18117,8 +18101,6 @@ 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,
@@ -18962,31 +18944,6 @@ export type TypedArrayConstructor = Float64ArrayConstructor | Float32ArrayConstr
 
 export type Destroyable = any;
 
-/**
- * A GeoJSON position expressed as [longitude, latitude] or [longitude, latitude, altitude].
- */
-export type GeoJsonPosition = number[];
-
-/**
- * A GeoJSON geometry object.
- */
-export type GeoJsonGeometry = any;
-
-/**
- * A GeoJSON feature object.
- */
-export type GeoJsonFeature = any;
-
-/**
- * A GeoJSON feature collection object.
- */
-export type GeoJsonFeatureCollection = any;
-
-/**
- * A top-level GeoJSON object (Geometry, Feature, or FeatureCollection).
- */
-export type GeoJson = GeoJsonGeometry | GeoJsonFeature | GeoJsonFeatureCollection;
-
 /**
  * Determines if a given date is a leap year.
  * @example
@@ -19156,6 +19113,15 @@ export function srgbToLinear(value: number): number;
  */
 export function subdivideArray(array: any[], numberOfArrays: number): void;
 
+/**
+ * Computes dimensions for text, based on current canvas state.
+ *
+ * Rounds metrics, excluding width, to whole pixels. This is purely to minimize
+ * rendering differences with migration to in-browser measureText(), and may be
+ * revised in the future. See: github.com/CesiumGS/cesium/pull/13081
+ */
+export function measureText(): void;
+
 /**
  * Writes the given text into a new canvas.  The canvas will be sized to fit the text.
  * If text is blank, returns undefined.
@@ -22655,39 +22621,11 @@ export class KmlDataSource {
     update(time: JulianDate): boolean;
 }
 
-export namespace KmlFeatureData {
-    /**
-     * @property name - Gets the name.
-     * @property uri - Gets the URI.
-     * @property age - Gets the email.
-     */
-    type Author = {
-        name: string;
-        uri: string;
-        age: number;
-    };
-    /**
-     * @property href - Gets the href.
-     * @property hreflang - Gets the language of the linked resource.
-     * @property rel - Gets the link relation.
-     * @property type - Gets the link type.
-     * @property title - Gets the link title.
-     * @property length - Gets the link length.
-     */
-    type Link = {
-        href: string;
-        hreflang: string;
-        rel: string;
-        type: string;
-        title: string;
-        length: string;
-    };
-}
-
 /**
  * Contains KML Feature data loaded into the <code>Entity.kml</code> property by {@link KmlDataSource}.
  */
 export class KmlFeatureData {
+    constructor();
     /**
      * Gets the atom syndication format author field.
      */
@@ -22716,6 +22654,35 @@ export class KmlFeatureData {
     extendedData: string;
 }
 
+export namespace KmlFeatureData {
+    /**
+     * @property name - Gets the name.
+     * @property uri - Gets the URI.
+     * @property age - Gets the email.
+     */
+    type Author = {
+        name: string;
+        uri: string;
+        age: number;
+    };
+    /**
+     * @property href - Gets the href.
+     * @property hreflang - Gets the language of the linked resource.
+     * @property rel - Gets the link relation.
+     * @property type - Gets the link type.
+     * @property title - Gets the link title.
+     * @property length - Gets the link length.
+     */
+    type Link = {
+        href: string;
+        hreflang: string;
+        rel: string;
+        type: string;
+        title: string;
+        length: string;
+    };
+}
+
 /**
  * @param position - camera position
  * @param headingPitchRange - camera orientation
@@ -23425,11 +23392,10 @@ export namespace PathGraphics {
      * @property [leadTime] - A Property specifying the number of seconds in front the object to show.
      * @property [trailTime] - A Property specifying the number of seconds behind of the object to show.
      * @property [width = 1.0] - A numeric Property specifying the width in pixels.
-     * @property [resolution = 60] - A numeric Property specifying the maximum number of seconds to step when sampling the position. Fractional positive values are allowed; in PORTIONS materialMode, non-positive values fall back to the default resolution of 60 seconds.
+     * @property [resolution = 60] - A numeric Property specifying the maximum number of seconds to step when sampling the position.
      * @property [material = Color.WHITE] - A Property specifying the material used to draw the path.
      * @property [distanceDisplayCondition] - A Property specifying at what distance from the camera that this path will be displayed.
      * @property [relativeTo] - A Property specifying the frame in which to visualize the path. Use another entity's id to visualize the path relative to that entity, or use the string values "FIXED" or "INERTIAL" to visualize the path in those reference frames.
-     * @property [materialMode] - A Property specifying how material properties are applied along the path.
      */
     type ConstructorOptions = {
         show?: Property | boolean;
@@ -23440,7 +23406,6 @@ export namespace PathGraphics {
         material?: MaterialProperty | Color;
         distanceDisplayCondition?: Property | DistanceDisplayCondition;
         relativeTo?: Property | string;
-        materialMode?: Property | PathMode;
     };
 }
 
@@ -23472,7 +23437,6 @@ export class PathGraphics {
     width: Property | undefined;
     /**
      * Gets or sets the Property specifying the maximum number of seconds to step when sampling the position.
-     * Fractional positive values are allowed; in PORTIONS materialMode, non-positive values fall back to the default resolution of 60 seconds.
      */
     resolution: Property | undefined;
     /**
@@ -23501,21 +23465,6 @@ export class PathGraphics {
     merge(source: PathGraphics): void;
 }
 
-/**
- * Defines how material properties are applied along a path.
- */
-export enum PathMode {
-    /**
-     * The material is applied to the entire path as a whole.
-     */
-    WHOLE = 0,
-    /**
-     * The material is applied in portions based on temporal position information,
-     * using interval-based material properties.
-     */
-    PORTIONS = 1
-}
-
 /**
  * Transforms a path entity's position into the local frame of the reference entity.
  * If the reference entity has an orientation, uses that orientation to define the local frame.
@@ -26125,6 +26074,8 @@ export enum TextureMinificationFilter {
     LINEAR_MIPMAP_LINEAR = WebGLConstants.LINEAR_MIPMAP_LINEAR
 }
 
+export function addAttribute(): void;
+
 /**
  * An appearance defines the full GLSL vertex and fragment shaders and the
  * render state used to draw a {@link Primitive}.  All appearances implement
@@ -26941,9 +26892,8 @@ export class Billboard {
      */
     rotation: number;
     /**
-     * The aligned axis is the direction vector that the billboard up vector points towards.
+     * Gets or sets the aligned axis in world space. The aligned axis is the unit 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
@@ -27767,22 +27717,15 @@ export type BufferPointOptions = {
  * }
  * @param [options.modelMatrix = Matrix4.IDENTITY] - Transforms geometry from model to world coordinates.
  * @param [options.allowPicking = false] - When <code>true</code>, primitives are pickable with {@link Scene#pick}. When <code>false</code>, memory and initialization cost are lower.
- * @param [options.boundingVolume] - Bounding volume, in world space, for the collection. When
- *    unspecified, a bounding volume is computed automatically and updated when primitive positions change. When
- *    specified, users are responsible for updating bounding volume as needed. Pre-computing the bounding volume
- *    manually, and updating it only as needed, will improve performance for larger dynamic collections.
  */
 export class BufferPointCollection extends BufferPrimitiveCollection<BufferPoint> {
     constructor(options: {
         modelMatrix?: Matrix4;
         primitiveCountMax?: number;
-        positionDatatype?: ComponentDatatype;
-        positionNormalized?: boolean;
         show?: boolean;
+        positionDatatype?: ComponentDatatype;
         allowPicking?: boolean;
-        boundingVolume?: BoundingSphere;
         debugShowBoundingVolume?: boolean;
-        blendOption?: BlendOption;
     });
     /**
      * Adds a new point to the collection, with the specified options. A
@@ -28011,10 +27954,6 @@ export type BufferPolygonOptions = {
  *   polygon.setMaterial(material);
  * }
  * @param [options.allowPicking = true] - When <code>true</code>, primitives are pickable with {@link Scene#pick}. When <code>false</code>, memory and initialization cost are lower.
- * @param [options.boundingVolume] - Bounding volume, in world space, for the collection. When
- *    unspecified, a bounding volume is computed automatically and updated when primitive positions change. When
- *    specified, users are responsible for updating bounding volume as needed. Pre-computing the bounding volume
- *    manually, and updating it only as needed, will improve performance for larger dynamic collections.
  */
 export class BufferPolygonCollection extends BufferPrimitiveCollection<BufferPolygon> {
     constructor(options: {
@@ -28023,12 +27962,9 @@ export class BufferPolygonCollection extends BufferPrimitiveCollection<BufferPol
         holeCountMax?: number;
         triangleCountMax?: number;
         positionDatatype?: ComponentDatatype;
-        positionNormalized?: boolean;
         show?: boolean;
         allowPicking?: boolean;
-        boundingVolume?: BoundingSphere;
         debugShowBoundingVolume?: boolean;
-        blendOption?: BlendOption;
     });
     /**
      * Duplicates the contents of this collection into the result collection.
@@ -28308,14 +28244,7 @@ export type BufferPrimitiveOptions = {
  * {@link Color}, {@link Cartesian3}, and other objects can all be reused when working with large collections,
  * using the {@link https://en.wikipedia.org/wiki/Flyweight_pattern|flyweight pattern}.</p>
  * @param [options.modelMatrix = Matrix4.IDENTITY] - Transforms geometry from model to world coordinates.
- * @param [options.positionNormalized = false] - When <code>true</code>, integer position values are treated as normalized,
- *   where the full integer range maps to [-1, 1] (signed) or [0, 1] (unsigned). Only relevant for integer position datatypes
- *   (BYTE, UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT).
  * @param [options.allowPicking = false] - When <code>true</code>, primitives are pickable with {@link Scene#pick}. When <code>false</code>, memory and initialization cost are lower.
- * @param [options.boundingVolume] - Bounding volume, in world space, for the collection. When
- *    unspecified, a bounding volume is computed automatically and updated when primitive positions change. When
- *    specified, users are responsible for updating bounding volume as needed. Pre-computing the bounding volume
- *    manually, and updating it only as needed, will improve performance for larger dynamic collections.
  */
 export class BufferPrimitiveCollection<T extends BufferPrimitive> {
     constructor(options: {
@@ -28324,22 +28253,16 @@ export class BufferPrimitiveCollection<T extends BufferPrimitive> {
         vertexCountMax?: number;
         show?: boolean;
         positionDatatype?: ComponentDatatype;
-        positionNormalized?: boolean;
         allowPicking?: boolean;
-        boundingVolume?: BoundingSphere;
         debugShowBoundingVolume?: boolean;
-        blendOption?: BlendOption;
     });
     /**
      * Determines if primitives in this collection will be shown.
      */
     show: boolean;
-    /**
-     * Transforms geometry from model to world coordinates.
-     */
     protected readonly _modelMatrix: Matrix4;
     protected readonly _boundingVolume: BoundingSphere;
-    protected readonly _boundingVolumeAutoUpdate: boolean;
+    protected readonly _boundingVolumeWC: BoundingSphere;
     /**
      * This property is for debugging only; it is not for production use nor is it optimized.
      * <p>
@@ -28434,20 +28357,15 @@ export class BufferPrimitiveCollection<T extends BufferPrimitive> {
      */
     readonly modelMatrix: Matrix4;
     /**
-     * World-space bounding volume for all primitives in the collection, including both
+     * Local bounding volume for all primitives in the collection, including both
      * shown and hidden primitives.
      */
     readonly boundingVolume: BoundingSphere;
     /**
-     * The component datatype used to store position values.
-     */
-    readonly positionDatatype: ComponentDatatype;
-    /**
-     * When <code>true</code>, integer position values are treated as normalized
-     * values, where the full integer range maps to [-1, 1] (signed) or [0, 1]
-     * (unsigned).
+     * World bounding volume for all primitives in the collection, including both
+     * shown and hidden primitives.
      */
-    readonly positionNormalized: boolean;
+    readonly boundingVolumeWC: BoundingSphere;
     /**
      * Returns a JSON-serializable array representing the collection. This encoding
      * is not memory-efficient, and should generally be used for debugging and
@@ -28977,13 +28895,6 @@ 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.
@@ -29418,7 +29329,8 @@ export enum Cesium3DTileColorBlendMode {
  * This type describes an interface and is not intended to be instantiated directly.
  * </p>
  */
-export interface Cesium3DTileContent {
+export class Cesium3DTileContent {
+    constructor();
     /**
      * Gets the number of features in the tile.
      */
@@ -30750,11 +30662,10 @@ export namespace Cesium3DTileset {
      * @property [skipLevels = 1] - When <code>skipLevelOfDetail</code> is <code>true</code>, a constant defining the minimum number of levels to skip when loading tiles. When it is 0, no levels are skipped. Used in conjunction with <code>skipScreenSpaceErrorFactor</code> to determine which tiles to load.
      * @property [immediatelyLoadDesiredLevelOfDetail = false] - When <code>skipLevelOfDetail</code> is <code>true</code>, only tiles that meet the maximum screen space error will ever be downloaded. Skipping factors are ignored and just the desired tiles are loaded.
      * @property [loadSiblings = false] - When <code>skipLevelOfDetail</code> is <code>true</code>, determines whether siblings of visible tiles are always downloaded during traversal.
-     * @property [maximumSimultaneousTileRequests = Infinity] - Maximum number of this tileset's tile network requests that may be pending at once.
      * @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 features in vector tilesets.
+     * @property [heightReference] - Sets the {@link HeightReference} for point 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.
@@ -30780,7 +30691,6 @@ export namespace Cesium3DTileset {
      * @property [debugColorizeTiles = false] - For debugging only. When true, assigns a random color to each tile.
      * @property [enableDebugWireframe = false] - For debugging only. This must be true for debugWireframe to work in WebGL1. This cannot be set after the tileset has been created.
      * @property [debugWireframe = false] - For debugging only. When true, render's each tile's content as a wireframe.
-     * @property [edgeDisplayMode = EdgeDisplayMode.SURFACES_ONLY] - Controls how edges from the {@link https://github.com/KhronosGroup/glTF/pull/2479|EXT_mesh_primitive_edge_visibility} glTF extension are rendered relative to surface geometry.
      * @property [debugShowBoundingVolume = false] - For debugging only. When true, renders the bounding volume for each tile.
      * @property [debugShowContentBoundingVolume = false] - For debugging only. When true, renders the bounding volume for each tile's content.
      * @property [debugShowViewerRequestVolume = false] - For debugging only. When true, renders the viewer request volume for each tile.
@@ -30820,7 +30730,6 @@ export namespace Cesium3DTileset {
         skipLevels?: number;
         immediatelyLoadDesiredLevelOfDetail?: boolean;
         loadSiblings?: boolean;
-        maximumSimultaneousTileRequests?: number;
         clippingPlanes?: ClippingPlaneCollection;
         clippingPolygons?: ClippingPolygonCollection;
         classificationType?: ClassificationType;
@@ -30850,7 +30759,6 @@ export namespace Cesium3DTileset {
         debugColorizeTiles?: boolean;
         enableDebugWireframe?: boolean;
         debugWireframe?: boolean;
-        edgeDisplayMode?: EdgeDisplayMode;
         debugShowBoundingVolume?: boolean;
         debugShowContentBoundingVolume?: boolean;
         debugShowViewerRequestVolume?: boolean;
@@ -31218,11 +31126,6 @@ export class Cesium3DTileset {
      * </p>
      */
     loadSiblings: boolean;
-    /**
-     * Maximum number of this tileset's tile network requests that may be
-     * pending at once.
-     */
-    maximumSimultaneousTileRequests: number;
     /**
      * The light color when shading models. When <code>undefined</code> the scene's light color is used instead.
      * <p>
@@ -31280,13 +31183,6 @@ export class Cesium3DTileset {
      * </p>
      */
     debugWireframe: boolean;
-    /**
-     * Controls how edges from the
-     * {@link https://github.com/KhronosGroup/glTF/pull/2479|EXT_mesh_primitive_edge_visibility}
-     * glTF extension are rendered relative to surface geometry. Tile content
-     * primitives that do not declare the extension are unaffected.
-     */
-    edgeDisplayMode: EdgeDisplayMode;
     /**
      * This property is for debugging only; it is not optimized for production use.
      * <p>
@@ -31947,6 +31843,23 @@ export class ClassificationPrimitive {
     destroy(): void;
 }
 
+/**
+ * HZ patch: per-material blend modes for ground classification.
+ * The app encodes the mode as a suffix on the composed material type
+ * (e.g. ComposedPolygon_..._blendScreen). Source fragments are
+ * premultiplied (ShadowVolumeAppearanceFS: rgb *= alpha), so:
+ *   screen   = src + dst * (1 - src)                  -> (ONE, ONE_MINUS_SRC_COLOR)
+ *   multiply = dst * mix(1, c, a)  (alpha-gated)      -> (DST_COLOR, ONE_MINUS_SRC_ALPHA)
+ *   additive = src + dst                             -> (ONE, ONE)
+ * Alpha keeps standard premultiplied over except additive.
+ */
+export const classificationBlendOverrides: any;
+
+/**
+ * HZ patch: material type suffix -> blending override (undefined = stock)
+ */
+export function getClassificationBlendOverride(): void;
+
 /**
  * Whether a classification affects terrain, 3D Tiles or both.
  */
@@ -32214,6 +32127,33 @@ export class ClippingPolygon {
     computeRectangle(result?: Rectangle): Rectangle;
 }
 
+/**
+ * Returns a deep copy of the given array.
+ *
+ * If the input is undefined, then <code>undefined</code> is returned.
+ *
+ * Otherwise, the result will be a copy of the given array, where
+ * each element is copied with <code>Cartesian3.clone</code>.
+ * @param input - The input array
+ * @returns The copy
+ */
+export function copyArrayCartesian3(input: Cartesian3[] | undefined): Cartesian3[] | undefined;
+
+/**
+ * Returns whether the given arrays are component-wise equal.
+ *
+ * When both arrays are undefined, then <code>true</code> is returned.
+ * When only one array is defined, or they are both defined but have
+ * different lengths, then <code>false</code> is returned.
+ *
+ * Otherwise, returns whether the corresponding elements of the arrays
+ * are equal, as of <code>Cartesian3.equals</code>.
+ * @param a - The first array
+ * @param b - The second array
+ * @returns Whether the arrays are equal
+ */
+export function equalsArrayCartesian3(a: Cartesian3[] | undefined, b: Cartesian3[] | undefined): boolean;
+
 /**
  * Specifies a set of clipping polygons. Clipping polygons selectively disable rendering in a region
  * inside or outside the specified list of {@link ClippingPolygon} objects for a single glTF model, 3D Tileset, or the globe.
@@ -32570,6 +32510,15 @@ export enum ColorBlendMode {
     MIX = 2
 }
 
+/**
+ * Shared helpers for Columbus View repeat worlds: when
+ * {@link Scene#columbusRepeatWorlds} is enabled, the map surface repeats
+ * horizontally in whole-world copies (each 360° of longitude wide), so
+ * positions and camera destinations must be placed on the copy nearest the
+ * camera instead of the primary [-180°, 180°] world.
+ */
+export namespace ColumbusWorlds { }
+
 /**
  * An expression for a style applied to a {@link Cesium3DTileset}.
  * <p>
@@ -32632,605 +32581,6 @@ 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
@@ -33814,6 +33164,47 @@ export enum DepthFunction {
     ALWAYS = WebGLConstants.ALWAYS
 }
 
+/**
+ * Returns a shader statement that applies the inverse of the
+ * value transform to the given value, based on the given offset
+ * and scale.
+ * @param input - The input value
+ * @param offset - The offset
+ * @param scale - The scale
+ * @returns The statement
+ */
+export function unapplyValueTransform(input: string, offset: string, scale: string): string;
+
+/**
+ * Returns a shader statement that applies the inverse of the
+ * normalization, based on the given component type
+ * @param input - The input value
+ * @param componentType - The component type
+ * @returns The statement
+ */
+export function unnormalize(input: string, componentType: string): string;
+
+/**
+ * Creates a shader statement that returns the value of the specified
+ * property, normalized to the range [0, 1].
+ * @param classProperty - The class property
+ * @param metadataProperty - The metadata property, either
+ * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+ * @returns The string
+ */
+export function getSourceValueStringScalar(classProperty: MetadataClassProperty, metadataProperty: any): string;
+
+/**
+ * Creates a shader statement that returns the value of the specified
+ * component of the given property, normalized to the range [0, 1].
+ * @param classProperty - The class property
+ * @param metadataProperty - The metadata property, either
+ * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+ * @param componentName - The name, in ["x", "y", "z", "w"]
+ * @returns The string
+ */
+export function getSourceValueStringComponent(classProperty: MetadataClassProperty, metadataProperty: any, componentName: string): string;
+
 /**
  * A light that gets emitted in a single direction from infinitely far away.
  * @param options - Object with the following properties:
@@ -34047,35 +33438,6 @@ export class DynamicEnvironmentMapManager {
     static readonly DEFAULT_SPHERICAL_HARMONIC_COEFFICIENTS: Cartesian3[];
 }
 
-/**
- * Defines how edges contributed by the
- * {@link https://github.com/KhronosGroup/glTF/pull/2479|EXT_mesh_primitive_edge_visibility}
- * glTF extension are rendered relative to surface geometry.
- * <p>
- * Primitives that do not include the extension are unaffected by this setting
- * and always render normally.
- * </p>
- */
-export enum EdgeDisplayMode {
-    /**
-     * Render surfaces only. Edges from the
-     * {@link https://github.com/KhronosGroup/glTF/pull/2479|EXT_mesh_primitive_edge_visibility}
-     * extension are hidden.
-     */
-    SURFACES_ONLY = 0,
-    /**
-     * Render both surfaces and edges. Edges from the
-     * {@link https://github.com/KhronosGroup/glTF/pull/2479|EXT_mesh_primitive_edge_visibility}
-     * extension are composited on top of the surface geometry.
-     */
-    SURFACES_AND_EDGES = 1,
-    /**
-     * Render edges only. Surface geometry is hidden for primitives that have edge visibility data,
-     * approximating CAD-style wireframe rendering. Primitives without the extension are unaffected.
-     */
-    EDGES_ONLY = 2
-}
-
 /**
  * An appearance for geometry on the surface of the ellipsoid like {@link PolygonGeometry}
  * and {@link RectangleGeometry}, which supports all materials like {@link MaterialAppearance}
@@ -34533,16 +33895,14 @@ export class FrameRateMonitor {
     destroy(): void;
 }
 
-export interface GaussianSplat3DTileContent extends Cesium3DTileContent {
-}
-
 /**
  * Represents the contents of a glTF or glb using the {@link https://github.com/CesiumGS/glTF/tree/draft-splat-spz/extensions/2.0/Khronos/KHR_gaussian_splatting | KHR_gaussian_splatting} and {@link https://github.com/CesiumGS/glTF/tree/draft-splat-spz/extensions/2.0/Khronos/KHR_gaussian_splatting_compression_spz_2 | KHR_gaussian_splatting_compression_spz_2} extensions.
  * <p>
  * Implements the {@link Cesium3DTileContent} interface.
  * </p>
  */
-export class GaussianSplat3DTileContent implements Cesium3DTileContent {
+export class GaussianSplat3DTileContent {
+    constructor();
     /**
      * Performs checks to ensure that the provided tileset has the Gaussian Splatting extensions.
      * @param tileset - The tileset to check for the extensions.
@@ -34607,7 +33967,7 @@ export class GaussianSplat3DTileContent implements Cesium3DTileContent {
      * The resource that this content was loaded from.
      * <p>
      */
-    readonly url: string;
+    readonly url: Resource;
     /**
      * Returns whether the feature has this property.
      * @param batchId - The batchId for the feature.
@@ -34628,84 +33988,6 @@ export class GaussianSplat3DTileContent implements Cesium3DTileContent {
     getFeature(batchId: number): Cesium3DTileFeature;
 }
 
-export type GeoJsonPrimitiveConstructorOptions = {
-    geoJson?: any;
-    url?: Resource | string;
-    ellipsoid?: Ellipsoid;
-    allowPicking?: boolean;
-    show?: boolean;
-    pickObjectFactory?: (...params: any[]) => any;
-};
-
-/**
- * Lightweight GeoJSON loader that converts features directly into
- * {@link BufferPointCollection}, {@link BufferPolylineCollection}, and
- * {@link BufferPolygonCollection}.
- *
- * Unlike {@link GeoJsonDataSource}, this path does not create entities.
- * Instead, it exposes high-throughput buffer primitive collections that can be
- * added directly to {@link Scene#primitives}.
- * @example
- * const loader = await Cesium.GeoJsonPrimitive.fromUrl("./data.geojson");
- * viewer.scene.primitives.add(loader);
- *
- * loader.points;     // BufferPointCollection | undefined
- * loader.polylines;  // BufferPolylineCollection | undefined
- * loader.polygons;   // BufferPolygonCollection | undefined
- * loader.ids;        // source feature IDs
- * loader.properties; // source feature properties
- */
-export class GeoJsonPrimitive {
-    constructor(options?: GeoJsonPrimitiveConstructorOptions);
-    /**
-     * Loader source URL when created via {@link GeoJsonPrimitive.fromUrl}.
-     */
-    readonly url: string | undefined;
-    /**
-     * Feature count represented by the loaded collections.
-     */
-    readonly featureCount: number;
-    /**
-     * Lookup table from integer ID generated by GeoJsonPrimitive, to integer or string Feature ID from GeoJSON source.
-     */
-    readonly ids: (string | number | undefined)[];
-    /**
-     * Source GeoJSON properties, indexed by generated integer ID.
-     */
-    readonly properties: Record<string, unknown>[];
-    /**
-     * Buffer point collection for point geometries.
-     */
-    readonly points: BufferPointCollection | undefined;
-    /**
-     * Buffer polyline collection for linestring geometries.
-     */
-    readonly polylines: BufferPolylineCollection | undefined;
-    /**
-     * Buffer polygon collection for polygon geometries.
-     */
-    readonly polygons: BufferPolygonCollection | undefined;
-    /**
-     * Loads GeoJSON from a URL or {@link Resource}.
-     */
-    static fromUrl(url: Resource | string, options?: GeoJsonPrimitiveConstructorOptions): Promise<GeoJsonPrimitive>;
-    /**
-     * Creates a loader directly from a parsed GeoJSON object.
-     */
-    static fromGeoJson(geoJson: any, options?: GeoJsonPrimitiveConstructorOptions): GeoJsonPrimitive;
-    getId(featureId: number): void;
-    getProperties(featureId: number): void;
-}
-
-/**
- * Normalized text-symbol rules for GeoVis `vector-label` PBF tiles.
- * They cover every text-bearing source layer and zoom range from the official
- * GeoVis vector-label style, without requiring a Mapbox style runtime.
- */
-export const GeoVisLabelStyles: ReadonlyArray<object>;
-
-export function getDedupeGroup(sourceLayer: string): void;
-
 /**
  * Describes the format in which to request GetFeatureInfo from a Web Map Service (WMS) or Web Map Tile Service (WMTS) server.
  * @param type - The type of response to expect from a GetFeatureInfo request.  Valid
@@ -34738,6 +34020,55 @@ export class Globe {
      * values will provide better performance but lower visual quality.
      */
     maximumScreenSpaceError: number;
+    /**
+     * Gets or sets the uniform level-of-detail mode configuration. When enabled,
+     * tile refinement is evaluated against a single per-frame reference distance
+     * instead of each tile's own distance to the camera, so the tiles in view
+     * converge on one LOD level instead of a distance-dependent mix of levels.
+     * This eliminates visible cross-level seams (e.g. between differently-styled
+     * imagery levels) at the cost of loading more tiles in tilted views.
+     *
+     * The object has the following fields:
+     * <ul>
+     *   <li><code>enabled</code>: set to <code>true</code> to activate the mode.</li>
+     *   <li><code>reference</code>: which distance all tiles are evaluated against.
+     *       <code>"center"</code> (default) uses the distance from the camera to the
+     *       globe along the center of the view; <code>"nearest"</code> uses the
+     *       nearest visible tile distance from the previous frame, which selects
+     *       the highest detail level in view (more tiles).</li>
+     *   <li><code>maxDeviationLevels</code>: caps how many levels above the natural
+     *       LOD far tiles may be forced to refine (default <code>3</code>). Each
+     *       allowed level roughly quadruples the extra tile count toward the
+     *       horizon; lower values are cheaper, higher values are more uniform.</li>
+     *   <li><code>maxCoarsenLevels</code>: caps how many levels below the natural
+     *       LOD near (foreground) tiles may be held back (default <code>1</code>).
+     *       Uncapped, the foreground of a tilted far view lands 2+ levels coarser
+     *       than natural, and <code>verticalExaggeration &gt; 1</code> multiplies
+     *       the interpolation error of coarse terrain (1 level = 4x, 2 levels =
+     *       16x) into visible tearing. <code>1</code> measures +0~4% tile
+     *       requests over uncapped; <code>0</code> makes the foreground fully
+     *       natural (+5~69% requests) but mixes near/far levels again, bringing
+     *       back the dataset's cross-level color bands.</li>
+     *   <li><code>pitchRangeDegrees</code>: a <code>[full, none]</code> pair of pitch
+     *       angles in degrees (e.g. <code>[-50, -25]</code>) between which the effect
+     *       fades out as the view approaches the horizon. Leave undefined or pass
+     *       <code>null</code> to keep it fully engaged regardless of pitch, which is
+     *       appropriate for offline rendering.</li>
+     * </ul>
+     * Applies in {@link SceneMode.SCENE3D} and {@link SceneMode.COLUMBUS_VIEW};
+     * true 2D ({@link SceneMode.SCENE2D}) already uses distance-independent
+     * screen-space error and is unaffected.
+     * @example
+     * // Offline video export: full uniformity, no pitch gating
+     * globe.uniformLevelMode = {
+     *   enabled: true,
+     *   reference: "center",
+     *   maxDeviationLevels: 4,
+     *   maxCoarsenLevels: 1,
+     *   pitchRangeDegrees: null,
+     * };
+     */
+    uniformLevelMode: any | undefined;
     /**
      * The size of the terrain tile cache, expressed as a number of tiles.  Any additional
      * tiles beyond this number will be freed, as long as they aren't needed for rendering
@@ -35106,14 +34437,10 @@ export class GlobeTranslucency {
     rectangle: Rectangle;
 }
 
-export type EXTMeshPolygonExtension = {
-    count: number;
-    indicesOffsets: number;
-    loopIndices?: number;
-    loopIndicesOffsets?: number;
-    triangleIndices?: number;
-    triangleIndicesOffsets?: number;
-};
+/**
+ * Loads the gltf object
+ */
+export function loadGltfJson(): void;
 
 /**
  * Removes an extension from gltf.extensions, gltf.extensionsUsed, gltf.extensionsRequired, and any other objects in the glTF if it is present.
@@ -35998,6 +35325,10 @@ export class GroundPolylinePrimitive {
      * </p>
      */
     debugShowBoundingVolume: boolean;
+    /**
+     * Root {@link GroundPolylineGeometry} ref from the last inner {@link Primitive} build. @private
+     */
+    _lastGroundPolylineRootGeometry: any;
     /**
      * Determines if geometry vertex attributes are interleaved, which can slightly improve rendering performance.
      */
@@ -37119,85 +36450,71 @@ export namespace ImageryLayer {
 export class ImageryLayer {
     constructor(imageryProvider?: ImageryProvider, options?: ImageryLayer.ConstructorOptions);
     /**
-     * The alpha blending value of this layer, with 0.0 representing fully transparent and
-     * 1.0 representing fully opaque.
-     */
-    alpha: number;
-    /**
-     * The alpha blending value of this layer on the night side of the globe, with 0.0 representing fully transparent and
-     * 1.0 representing fully opaque. This only takes effect when {@link Globe#enableLighting} is <code>true</code>.
-     */
-    nightAlpha: number;
-    /**
-     * The alpha blending value of this layer on the day side of the globe, with 0.0 representing fully transparent and
-     * 1.0 representing fully opaque. This only takes effect when {@link Globe#enableLighting} is <code>true</code>.
-     */
-    dayAlpha: number;
-    /**
-     * The brightness of this layer.  1.0 uses the unmodified imagery color.  Less than 1.0
-     * makes the imagery darker while greater than 1.0 makes it brighter.
-     */
-    brightness: number;
-    /**
-     * The contrast of this layer.  1.0 uses the unmodified imagery color.  Less than 1.0 reduces
-     * the contrast while greater than 1.0 increases it.
-     */
-    contrast: number;
-    /**
-     * The hue of this layer in radians. 0.0 uses the unmodified imagery color.
-     */
-    hue: number;
-    /**
-     * The saturation of this layer. 1.0 uses the unmodified imagery color. Less than 1.0 reduces the
-     * saturation while greater than 1.0 increases it.
-     */
-    saturation: number;
-    /**
-     * The gamma correction to apply to this layer.  1.0 uses the unmodified imagery color.
-     */
-    gamma: number;
-    /**
-     * The {@link SplitDirection} to apply to this layer.
+     * Gets the imagery provider for this layer. This should not be called before {@link ImageryLayer#ready} returns true.
      */
-    splitDirection: SplitDirection;
+    readonly imageryProvider: ImageryProvider;
     /**
-     * The {@link TextureMinificationFilter} to apply to this layer.
-     * Possible values are {@link TextureMinificationFilter.LINEAR} (the default)
-     * and {@link TextureMinificationFilter.NEAREST}.
+     * Gets or sets a per-level color correction profile for this layer. Imagery
+     * pyramids from third-party providers are frequently assembled from different
+     * mosaic vintages per level, which shows up as a visible color seam wherever
+     * two levels are rendered next to each other (typically in tilted views).
+     * The profile applies one per-channel affine transform
+     * (<code>scale * color + offset</code>, normalized [0, 1] units) to every
+     * tile of a given level, which makes adjacent levels visually continuous.
+     * Levels not listed in the profile are left uncorrected.
      *
-     * To take effect, this property must be set immediately after adding the imagery layer.
-     * Once a texture is loaded it won't be possible to change the texture filter used.
-     */
-    minificationFilter: TextureMinificationFilter;
-    /**
-     * The {@link TextureMagnificationFilter} to apply to this layer.
-     * Possible values are {@link TextureMagnificationFilter.LINEAR} (the default)
-     * and {@link TextureMagnificationFilter.NEAREST}.
+     * The profile is a plain object, typically generated by the
+     * <code>Apps/LevelColorCalibration.html</code> tool, of the form:
+     * <pre>{
+     *   "strength": 0.8,
+     *   "referenceLevel": 16,
+     *   "levels": {
+     *     "14": { "scale": [1.02, 1.01, 0.98], "offset": [-0.01, 0.0, 0.02] },
+     *     "17": { "scale": [0.99, 1.0, 1.03],  "offset": [0.0, -0.01, 0.03] }
+     *   }
+     * }</pre>
+     * <code>strength</code> (default <code>1.0</code>) blends between the original
+     * and corrected color, <code>(1 - strength) * original + strength * (scale * original + offset)</code>,
+     * so values below 1 keep some of the original per-level character.
      *
-     * To take effect, this property must be set immediately after adding the imagery layer.
-     * Once a texture is loaded it won't be possible to change the texture filter used.
-     */
-    magnificationFilter: TextureMagnificationFilter;
-    /**
-     * Determines if this layer is shown.
-     */
-    show: boolean;
-    /**
-     * Rectangle cutout in this layer of imagery.
-     */
-    cutoutRectangle: Rectangle;
-    /**
-     * Color value that should be set to transparent.
-     */
-    colorToAlpha: Color;
-    /**
-     * Normalized (0-1) threshold for color-to-alpha.
-     */
-    colorToAlphaThreshold: number;
-    /**
-     * Gets the imagery provider for this layer. This should not be called before {@link ImageryLayer#ready} returns true.
-     */
-    readonly imageryProvider: ImageryProvider;
+     * Assigning a profile takes effect immediately, without reloading tiles;
+     * setting it to <code>undefined</code> disables the correction.
+     * @example
+     * const response = await fetch("level-color-profile.json");
+     * layer.levelColorProfile = await response.json();
+     */
+    levelColorProfile: any | undefined;
+    /**
+     * Gets or sets the width, as a fraction of the tile's extent, of an
+     * edge band where this tile's {@link ImageryLayer#levelColorProfile}
+     * correction is smoothly faded into the correction of the adjacent
+     * coarser tile's level. Residual color steps at imagery LOD boundaries
+     * (levels that cannot fully converge, or local deviations from the
+     * calibration statistics) become gradual ramps, which are far less
+     * visible than abrupt steps. The fade is one-sided: only the finer
+     * side of a boundary fades, so both sides apply the same correction
+     * exactly at the shared edge. Requires a levelColorProfile; edges
+     * facing same-level or finer neighbors are not blended.
+     *
+     * The value is clamped to [0.0, 0.45]; 0 disables the fade. Values
+     * between 0.15 and 0.25 are a good starting point. Takes effect
+     * immediately (uniform-only after the first enabling, which compiles
+     * one additional shader variant).
+     */
+    levelColorEdgeBlend: number;
+    /**
+     * Gets or sets whether the {@link ImageryLayer#levelColorEdgeBlend} band
+     * cross-fades the imagery CONTENT with the ancestor imagery at the
+     * adjacent coarser tile's level (the very texture the coarser side
+     * renders), instead of only fading the correction parameters. Content
+     * cross-fading makes both sides of a boundary pixel-identical at the
+     * shared edge, which also removes seams caused by content differences
+     * (mosaic vintage, local deviations from the calibration statistics)
+     * that a correction-parameter fade cannot touch. When the ancestor
+     * texture is unavailable, the parameter fade is used as a fallback.
+     * Requires a levelColorProfile and levelColorEdgeBlend &gt; 0.
+     */
+    levelColorEdgeCrossFade: boolean;
     /**
      * Returns true when the terrain provider has been successfully created. Otherwise, returns false.
      */
@@ -37367,6 +36684,97 @@ export class ImageryLayer {
     getImageryRectangle(): Rectangle;
 }
 
+/**
+ * The alpha blending value of this layer, with 0.0 representing fully transparent and
+ * 1.0 representing fully opaque.
+ */
+export var alpha: number;
+
+/**
+ * The alpha blending value of this layer on the night side of the globe, with 0.0 representing fully transparent and
+ * 1.0 representing fully opaque. This only takes effect when {@link Globe#enableLighting} is <code>true</code>.
+ */
+export var nightAlpha: number;
+
+/**
+ * The alpha blending value of this layer on the day side of the globe, with 0.0 representing fully transparent and
+ * 1.0 representing fully opaque. This only takes effect when {@link Globe#enableLighting} is <code>true</code>.
+ */
+export var dayAlpha: number;
+
+/**
+ * The brightness of this layer.  1.0 uses the unmodified imagery color.  Less than 1.0
+ * makes the imagery darker while greater than 1.0 makes it brighter.
+ */
+export var brightness: number;
+
+/**
+ * The contrast of this layer.  1.0 uses the unmodified imagery color.  Less than 1.0 reduces
+ * the contrast while greater than 1.0 increases it.
+ */
+export var contrast: number;
+
+/**
+ * The hue of this layer in radians. 0.0 uses the unmodified imagery color.
+ */
+export var hue: number;
+
+/**
+ * The saturation of this layer. 1.0 uses the unmodified imagery color. Less than 1.0 reduces the
+ * saturation while greater than 1.0 increases it.
+ */
+export var saturation: number;
+
+/**
+ * The gamma correction to apply to this layer.  1.0 uses the unmodified imagery color.
+ */
+export var gamma: number;
+
+/**
+ * The {@link SplitDirection} to apply to this layer.
+ */
+export var splitDirection: SplitDirection;
+
+/**
+ * The {@link TextureMinificationFilter} to apply to this layer.
+ * Possible values are {@link TextureMinificationFilter.LINEAR} (the default)
+ * and {@link TextureMinificationFilter.NEAREST}.
+ *
+ * To take effect, this property must be set immediately after adding the imagery layer.
+ * Once a texture is loaded it won't be possible to change the texture filter used.
+ */
+export var minificationFilter: TextureMinificationFilter;
+
+/**
+ * The {@link TextureMagnificationFilter} to apply to this layer.
+ * Possible values are {@link TextureMagnificationFilter.LINEAR} (the default)
+ * and {@link TextureMagnificationFilter.NEAREST}.
+ *
+ * To take effect, this property must be set immediately after adding the imagery layer.
+ * Once a texture is loaded it won't be possible to change the texture filter used.
+ */
+export var magnificationFilter: TextureMagnificationFilter;
+
+/**
+ * Determines if this layer is shown.
+ */
+export var show: boolean;
+
+/**
+ * Rectangle cutout in this layer of imagery.
+ */
+export var cutoutRectangle: Rectangle;
+
+/**
+ * Color value that should be set to transparent.
+ */
+export var colorToAlpha: Color;
+
+/**
+ * Normalized (0-1) threshold for color-to-alpha.
+ */
+export var colorToAlphaThreshold: number;
+
 /**
  * An ordered collection of imagery layers for rendering raster imagery on a {@link Globe} or {@link Cesium3DTileset}.
  */
@@ -37696,11 +37104,6 @@ export class ImageryProvider {
     static loadImage(imageryProvider: ImageryProvider, url: Resource | string): Promise<ImageryTypes | CompressedTextureBuffer> | undefined;
 }
 
-/**
- * @param level - @param {number} implicitY
- */
-export function getWebMercatorY(level: number): void;
-
 export namespace IonImageryProvider {
     /**
      * Initialization options for the TileMapServiceImageryProvider constructor
@@ -37722,9 +37125,10 @@ 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();
+    constructor(options?: IonImageryProvider.ConstructorOptions);
     /**
      * Gets the rectangle, in radians, of the imagery provided by the instance.
      */
@@ -38414,123 +37818,6 @@ export class Light {
     intensity: number;
 }
 
-export type MVTProviderOptions = {
-    minZoom?: number;
-    maxZoom?: number;
-    extent?: Rectangle;
-    featureIdProperty?: string;
-    labelStyles?: any[];
-    labelHeightReference?: HeightReference;
-    labelTransitionDuration?: number;
-    labelTransitionSteps?: number;
-    maximumRetiringLabels?: number;
-    maximumLabelsPerTile?: number;
-    maximumCachedGlyphs?: number;
-    renderGeometry?: boolean;
-    format?: "mvt" | "geovis";
-    maximumScreenSpaceError?: number;
-    maximumConcurrentRequests?: number;
-    cacheBytes?: number;
-    maximumCacheOverflowBytes?: number;
-    scene?: Scene;
-};
-
-export type MVTWorkerResult = {
-    glb?: ArrayBuffer;
-    hasFeatures: boolean;
-    decodedTile?: any;
-};
-
-/**
- * A Mapbox Vector Tiles (MVT) data provider. Loads .mvt or .pbf tiles, converting tiles
- * dynamically (at runtime) into 3D Tiles.
- *
- * <div class="notice">
- * This object is normally not instantiated directly, use {@link MVTDataProvider.fromUrl}.
- * </div>
- * @param urlTemplate - @param {MVTProviderOptions} [options]
- */
-export class MVTDataProvider extends UrlTemplate3DTilesDataProvider {
-    constructor(urlTemplate: Resource | string);
-    /**
-     * Creates an MVTDataProvider from the specified URL template and options.
-     * @param url - 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] - Maximum zoom level represented in the generated tileset. GeoVis defaults to 18 and is limited to 18 because its label API returns empty tiles above that level.
-     * @param [options.extent] - Optional geographic extent in radians to constrain the generated tile tree.
-     * @param [options.featureIdProperty] - MVT property name to use as feature ID.
-     * @param [options.labelStyles] - Declarative MVT text-symbol rules.
-     * @param [options.labelHeightReference = HeightReference.CLAMP_TO_GROUND] - Height reference for MVT labels. Ground clamping keeps labels fixed to terrain and 3D Tiles while the camera moves.
-     * @param [options.labelTransitionDuration = 0.2] - Seconds used to cross-fade labels when tile selection changes. Set to 0 to disable transitions.
-     * @param [options.labelTransitionSteps = 4] - Opacity steps in each label transition. A small value keeps rapid zoom and pan updates bounded.
-     * @param [options.maximumRetiringLabels = 512] - Maximum labels retained for fade-out after a tile switch. Excess labels are removed immediately to protect frame time during rapid navigation.
-     * @param [options.maximumLabelsPerTile = 4096] - Maximum label candidates retained from one tile. Higher-priority styles are kept first.
-     * @param [options.maximumCachedGlyphs = 2048] - Maximum distinct glyphs retained by the label atlas before it is rebuilt. Set to 0 to disable atlas recycling.
-     * @param [options.renderGeometry = true] - Render point, line, and polygon geometry in addition to labels.
-     * @param [options.format = "mvt"] - PBF schema used by the tile service. Use `geovis` for GeoVis vector APIs.
-     * @param [options.maximumScreenSpaceError] - Tile screen-space error. When omitted for GeoVis, it adapts from 16 at globe scale to 1 near street scale.
-     * @param [options.maximumConcurrentRequests = 12] - Maximum pending MVT tile network requests. Limits the initial global-tile burst without requiring an extent.
-     * @param [options.cacheBytes = 67108864] - Target tile cache size for labels-only providers. Geometry providers keep the Cesium3DTileset default unless configured.
-     * @param [options.maximumCacheOverflowBytes = 16777216] - Additional cache headroom for labels-only providers. Geometry providers keep the Cesium3DTileset default unless configured.
-     * @param [options.scene] - Scene used for label decluttering and depth behavior.
-     */
-    static fromUrl(url: Resource | string, options?: {
-        minZoom?: number;
-        maxZoom?: number;
-        extent?: Rectangle;
-        featureIdProperty?: string;
-        labelStyles?: object[];
-        labelHeightReference?: HeightReference;
-        labelTransitionDuration?: number;
-        labelTransitionSteps?: number;
-        maximumRetiringLabels?: number;
-        maximumLabelsPerTile?: number;
-        maximumCachedGlyphs?: number;
-        renderGeometry?: boolean;
-        format?: "mvt" | "geovis";
-        maximumScreenSpaceError?: number;
-        maximumConcurrentRequests?: number;
-        cacheBytes?: number;
-        maximumCacheOverflowBytes?: number;
-        scene?: Scene;
-    }): Promise<MVTDataProvider>;
-    protected update(frameState: any): void;
-    /**
-     * 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;
-}
-
-export function getGeoVisScreenSpaceError(height: number | undefined): void;
-
-/**
- * @param options - @returns {MVTProviderOptions}
- */
-export function normalizeMvtOptions(options: MVTProviderOptions | undefined): void;
-
-/**
- * @param parameters - @returns {Promise<MVTWorkerResult>}
- */
-export function scheduleMvtTileTask(parameters: any): void;
-
 /**
  * Describes how the map will operate in 2D.
  */
@@ -39231,6 +38518,14 @@ export class Material {
     static readonly WaterMaskType: string;
 }
 
+/**
+ * Loads the images for a cubemap uniform, if it has changed since the last time this was called.
+ * @param material - The material to load the cubemap images for.
+ * @param uniformId - The ID of the uniform that corresponds to the cubemap images.
+ * @returns A promise that resolves when the images are loaded, or a resolved promise if image loading is not necessary.
+ */
+export function loadCubeMapImagesForUniform(material: Material, uniformId: string): any;
+
 /**
  * An appearance for arbitrary geometry (as opposed to {@link EllipsoidSurfaceAppearance}, for example)
  * that supports shading with materials.
@@ -40171,6 +39466,36 @@ export class CorrelationGroup {
     readonly params: Spdcf[];
 }
 
+/**
+ * Creates a Matrix3 that describes a covariance matrix (which is
+ * symmetric) from the array containing the upper triangle, in
+ * column-major order.
+ * @param array - The input array
+ * @returns The Matrix3
+ */
+export function createCovarianceMatrixFromUpperTriangle(array: number[]): Matrix3;
+
+/**
+ * Creates an `AnchorPointDirect` from the given JSON representation
+ * @param anchorPointDirectJson - The input JSON
+ * @returns The direct anchor point
+ */
+export function createAnchorPointDirect(anchorPointDirectJson: any): AnchorPointDirect;
+
+/**
+ * Creates an `AnchorPointIndirect` from the given JSON representation
+ * @param anchorPointIndirectJson - The input JSON
+ * @returns The indirect anchor point
+ */
+export function createAnchorPointIndirect(anchorPointIndirectJson: any): AnchorPointIndirect;
+
+/**
+ * Creates a `CorrelationGroup` from the given JSON representation
+ * @param correlationGroupJson - The input JSON
+ * @returns The correlation group
+ */
+export function createCorrelationGroup(correlationGroupJson: any): CorrelationGroup;
+
 export namespace GltfGpmLocal {
     /**
      * Initialization options for the GltfGpmLocal constructor
@@ -40360,12 +39685,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/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}
- *  (edges are hidden by default; set {@link EdgeDisplayMode} via
- *  {@link Model#edgeDisplayMode} or {@link Cesium3DTileset#edgeDisplayMode} to display them)
+ *  {@link https://github.com/KhronosGroup/glTF/pull/2514|EXT_mesh_primitive_restart}
  *  </li>
  *  <li>
  *  {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_meshopt_compression|EXT_meshopt_compression}
@@ -40392,16 +39712,9 @@ 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>
- *  {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_meshopt_compression|KHR_meshopt_compression}
- *  </li>
- *  <li>
  *  {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_basisu|KHR_texture_basisu}
  *  </li>
  *  <li>
@@ -40547,13 +39860,6 @@ export class Model {
      * </p>
      */
     debugWireframe: boolean;
-    /**
-     * Controls how edges from the
-     * {@link https://github.com/KhronosGroup/glTF/pull/2479|EXT_mesh_primitive_edge_visibility}
-     * glTF extension are rendered relative to surface geometry. Primitives that
-     * do not declare the extension are unaffected by this setting.
-     */
-    edgeDisplayMode: EdgeDisplayMode;
     /**
      * Whether or not to render the model.
      */
@@ -40853,7 +40159,6 @@ export class Model {
      * @param [options.color] - A color that blends with the model's rendered color.
      * @param [options.colorBlendMode = ColorBlendMode.HIGHLIGHT] - Defines how the color blends with the model.
      * @param [options.colorBlendAmount = 0.5] - Value used to determine the color strength when the <code>colorBlendMode</code> is <code>MIX</code>. A value of 0.0 results in the model's rendered color while a value of 1.0 results in a solid color, with any value in-between resulting in a mix of the two.
-     * @param [options.edgeDisplayMode = EdgeDisplayMode.SURFACES_ONLY] - Controls how edges from the {@link https://github.com/KhronosGroup/glTF/pull/2479|EXT_mesh_primitive_edge_visibility} extension are rendered relative to surface geometry.
      * @param [options.silhouetteColor = Color.RED] - The silhouette color. If more than 256 models have silhouettes enabled, there is a small chance that overlapping models will have minor artifacts.
      * @param [options.silhouetteSize = 0.0] - The size of the silhouette in pixels.
      * @param [options.enableShowOutline = true] - Whether to enable outlines for models using the {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline} extension. This can be set false to avoid post-processing geometry at load time. When false, the showOutlines and outlineColor options are ignored.
@@ -40908,7 +40213,6 @@ export class Model {
         color?: Color;
         colorBlendMode?: ColorBlendMode;
         colorBlendAmount?: number;
-        edgeDisplayMode?: EdgeDisplayMode;
         silhouetteColor?: Color;
         silhouetteSize?: number;
         enableShowOutline?: boolean;
@@ -41630,140 +40934,6 @@ export class Moon {
     destroy(): void;
 }
 
-/**
- * @param left - @param {*} right
- */
-export function compareCandidatePriority(left: any): void;
-
-export function getStringByteLength(value: any): void;
-
-export function normalizeRules(styles: any[]): void;
-
-/**
- * GeoVis changes source layers and omits feature IDs between overview and
- * detailed tiles. A text key in a shared Web Mercator cell identifies the
- * same named feature across those parent and child tiles.
- */
-export function createSemanticDedupeId(group: string, text: string, tileCoordinates: any, anchor: any, extent: number): void;
-
-/**
- * @param filter - @param {Record<string, *>} properties @returns {boolean}
- */
-export function matchesFilter(filter: any): void;
-
-/**
- * @param textField - @param {Record<string, *>} properties @returns {string}
- */
-export function resolveText(textField: any): void;
-
-/**
- * @param expression - @param {Record<string, *>} properties @returns {*}
- */
-export function resolveExpression(expression: any): void;
-
-/**
- * @param feature - @returns {{x:number,y:number}|undefined}
- */
-export function getAnchor(feature: any): void;
-
-export type MvtLabelManagerOptions = {
-    scene: any;
-    styles: any[];
-    heightReference?: HeightReference;
-    transitionDuration?: number;
-    transitionSteps?: number;
-    maximumRetiringLabels?: number;
-    maximumCachedGlyphs?: number;
-};
-
-export function getCachedGlyphCount(labelCollection: any): void;
-
-export function hasPendingGlyphLoads(labelCollection: any): void;
-
-export function resetCandidateLabel(candidate: any): void;
-
-/**
- * @param time - @param {*} startTime
- */
-export function elapsedSeconds(time: any): void;
-
-export function getViewZoom(frameState: any): void;
-
-/**
- * @param textPositions - @param {string} text @param {Cartesian2} position
- */
-export function isDuplicateText(textPositions: Map<string, Cartesian2[]>): void;
-
-export function getVerticalFov(frustum: any): void;
-
-/**
- * @param opacity - @param {number} steps
- */
-export function quantizeOpacity(opacity: number): void;
-
-/**
- * @param color - @param {number} opacity
- */
-export function withAlpha(color: Color): void;
-
-/**
- * @param scene - @param {*} windowPosition
- */
-export function isInsideViewport(scene: any): void;
-
-/**
- * @param target - @param {Array<*>} candidates
- */
-export function removeCandidates(target: any[]): void;
-
-export function getCandidateDedupeKey(candidate: any): void;
-
-/**
- * @param candidates - @param {string} dedupeKey
- */
-export function findCandidateByDedupeKey(candidates: any[]): void;
-
-export function normalizeStyles(styles: any[]): void;
-
-/**
- * @param value - @param {Color} fallback @returns {Color}
- */
-export function toColor(value: any): void;
-
-/**
- * @param left - @param {*} right
- */
-export function compareCandidates(left: any): void;
-
-/**
- * @param candidate - @param {Cartesian3} result @returns {Cartesian3}
- */
-export function getWorldPosition(candidate: any): void;
-
-/**
- * @param candidate - @param {*} style @param {Cartesian2} position
- */
-export function makeCollisionRectangle(candidate: any): void;
-
-/**
- * @param style - @returns {Cartesian2}
- */
-export function getCollisionPadding(style: any): void;
-
-/**
- * @param text - @param {number} fontSize
- */
-export function estimateTextWidth(text: string): void;
-
-export function isWideCharacter(character: string): void;
-
-export function parseFontSize(font: string): void;
-
-/**
- * @param collection - @param {*} candidate @param {*} style @param {Cartesian3} position @param {HeightReference} heightReference
- */
-export function getOrCreateLabel(collection: any): void;
-
 /**
  * A {@link TileDiscardPolicy} specifying that tile images should never be discard.
  */
@@ -42331,6 +41501,34 @@ export class PerInstanceColorAppearance {
     getRenderState(): any;
 }
 
+/**
+ * Compute the rectangle that describes the part of the drawing buffer
+ * that is relevant for picking.
+ * @param drawingBufferHeight - The height of the drawing buffer
+ * @param position - The position inside the drawing buffer
+ * @param width - The width of the rectangle, assumed to
+ * be an odd integer number, default : 3.0
+ * @param height - The height of the rectangle. If unspecified,
+ * height will default to the value of <code>width</code>
+ * @param result - The result rectangle
+ * @returns The result rectangle
+ */
+export function computePickingDrawingBufferRectangle(drawingBufferHeight: number, position: Cartesian2, width: number | undefined, height: number | undefined, result: BoundingRectangle): BoundingRectangle;
+
+/**
+ * Setup needed before picking.
+ * @param windowPosition - Window coordinates to perform picking on.
+ * @param drawingBufferRectangle - The output drawing buffer recangle.
+ * @param [width = 3] - Width of the pick rectangle.
+ * @param [height = 3] - Height of the pick rectangle.
+ */
+export function pickBegin(scene: Scene, windowPosition: Cartesian2, drawingBufferRectangle: BoundingRectangle, width?: number, height?: number): void;
+
+/**
+ * Teardown needed after picking.
+ */
+export function pickEnd(scene: Scene): void;
+
 /**
  * Information about metadata that is supposed to be picked
  * @property schemaId - The optional ID of the metadata schema
@@ -42345,6 +41543,44 @@ export type PickedMetadataInfo = {
     classProperty: MetadataClassProperty;
 };
 
+/**
+ * @param pickedResults - the results from the pickCallback
+ * @param limit - If supplied, stop drilling after collecting this many picks.
+ * @returns whether picking should end
+ */
+export function addDrillPickedResults(pickedResults: object[], limit: number, results: object[], pickedPrimitives: object[], pickedAttributes: object[], pickedFeatures: object[]): boolean;
+
+/**
+ * Drill pick by repeatedly calling a given `pickCallback`, each time stripping away the previously picked objects.
+ * @param pickCallback - Pick callback to execute each iteration
+ * @param [limit = Number.MAX_VALUE] - If supplied, stop drilling after collecting this many picks
+ * @returns List of picked results
+ */
+export function drillPick(pickCallback: (...params: any[]) => any, limit?: number): object[];
+
+/**
+ * Remove all invalid binary body references from the batch table
+ * JSON of the given parsed content.
+ *
+ * This is a workaround for gracefully handling the invalid PNTS
+ * files that may have been created by the point cloud tiler.
+ * See https://github.com/CesiumGS/cesium/issues/12872
+ *
+ * When the batch table JSON is undefined, nothing will be done.
+ * When the batch table binary is defined, nothing will be done
+ * (assuming that any binary body references are valid - this is
+ * not checked here).
+ *
+ * Otherwise, this will remove all binary body references from the
+ * batch table JSON that are not resolved from draco via the
+ * `parsedContent.draco.batchTableProperties`.
+ *
+ * If any (invalid) binary body reference is found (and removed),
+ * a one-time warning will be printed.
+ * @param parsedContent - The parsed content
+ */
+export function removeInvalidBinaryBodyReferences(parsedContent: any): void;
+
 /**
  * Options for performing point attenuation based on geometric error when rendering
  * point clouds using 3D Tiles.
@@ -44196,6 +43432,9 @@ export const TILE_SIZE = 256;
  * @param [options.scene3DOnly = false] - If true, optimizes memory use and performance for 3D mode but disables the ability to use 2D or Columbus View.
  * @param [options.shadows = false] - Determines if shadows are cast by light sources.
  * @param [options.mapMode2D = MapMode2D.INFINITE_SCROLL] - Determines if the 2D map is rotatable or can be scrolled infinitely in the horizontal direction.
+ * @param [options.columbusRepeatWorlds = false] - If true, the Columbus View map repeats horizontally: translated
+ *        copies of the globe surface tiles are rendered beyond the ±180° meridian so the map, entity placement, and
+ *        picking continue seamlessly across the antimeridian.
  * @param [options.requestRenderMode = false] - If true, rendering a frame will only occur when needed as determined by changes within the scene. Enabling improves performance of the application, but requires using {@link Scene#requestRender} to render a new frame explicitly in this mode. This will be necessary in many cases after making changes to the scene in other parts of the API. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
  * @param [options.maximumRenderTimeChange = 0.0] - If requestRenderMode is true, this value defines the maximum change in simulation time allowed before a render is requested. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
  * @param [options.depthPlaneEllipsoidOffset = 0.0] - Adjust the DepthPlane to address rendering artefacts below ellipsoid zero elevation.
@@ -44213,6 +43452,7 @@ export class Scene {
         scene3DOnly?: boolean;
         shadows?: boolean;
         mapMode2D?: MapMode2D;
+        columbusRepeatWorlds?: boolean;
         requestRenderMode?: boolean;
         maximumRenderTimeChange?: number;
         depthPlaneEllipsoidOffset?: number;
@@ -44527,16 +43767,6 @@ 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.
      */
@@ -44630,6 +43860,14 @@ export class Scene {
      * Determines if the 2D map is rotatable or can be scrolled infinitely in the horizontal direction.
      */
     readonly mapMode2D: MapMode2D;
+    /**
+     * Gets or sets whether the Columbus View map repeats horizontally. When true,
+     * translated copies of the globe surface tiles are rendered beyond the ±180°
+     * meridian, and entity placement/picking wrap to the copy nearest the camera,
+     * so editing and animation work seamlessly across the antimeridian.
+     * Only has an effect in {@link SceneMode.COLUMBUS_VIEW}.
+     */
+    columbusRepeatWorlds: boolean;
     /**
      * Gets or sets the position of the splitter within the viewport.  Valid values are between 0.0 and 1.0.
      */
@@ -44708,27 +43946,6 @@ 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.
@@ -44969,18 +44186,16 @@ export class Scene {
 }
 
 /**
- * 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.
+ * Determine how translucent surfaces will be handled.
+ *
+ * When OIT is enabled, then this will delegate to OIT.executeCommands.
+ * Otherwise, it will just be executeTranslucentCommandsBackToFront
+ * for render passes, or executeTranslucentCommandsFrontToBack for
+ * other passes.
+ * @param scene - The scene.
+ * @returns A function to execute translucent commands.
  */
-export type SceneSnapResult = {
-    object: any;
-    position: Cartesian3;
-    screenPosition: Cartesian2;
-    isEdge: boolean;
-};
+export function obtainTranslucentCommandExecutionFunction(scene: Scene): (...params: any[]) => any;
 
 /**
  * Indicates if the scene is viewed in 3D, 2D, or 2.5D Columbus view.
@@ -46378,61 +45593,6 @@ 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;
-    protected update(frameState: any): void;
-}
-
 export namespace UrlTemplateImageryProvider {
     /**
      * Initialization options for the UrlTemplateImageryProvider constructor
@@ -47123,8 +46283,7 @@ export class VoxelPrimitive {
      */
     clippingPlanes: ClippingPlaneCollection;
     /**
-     * Gets or sets the custom shader. If undefined, attempt to build a default custom shader
-     * appropriate to the metadata type. If that fails, use {@link VoxelPrimitive.DefaultCustomShader}.
+     * Gets or sets the custom shader. If undefined, {@link VoxelPrimitive.DefaultCustomShader} is set.
      */
     customShader: CustomShader;
     /**
@@ -47157,21 +46316,7 @@ export class VoxelPrimitive {
  * This type describes an interface and is not intended to be instantiated directly.
  */
 export class VoxelProvider {
-    /**
-     * Requests the data for a given tile.
-     * @param [options] - Object with the following properties:
-     * @param [options.tileLevel = 0] - The tile's level.
-     * @param [options.tileX = 0] - The tile's X coordinate.
-     * @param [options.tileY = 0] - The tile's Y coordinate.
-     * @param [options.tileZ = 0] - The tile's Z coordinate.
-     * @returns A promise resolving to a VoxelContent containing the data for the tile, or undefined if the request could not be scheduled this frame.
-     */
-    requestData(options?: {
-        tileLevel?: number;
-        tileX?: number;
-        tileY?: number;
-        tileZ?: number;
-    }): Promise<VoxelContent> | undefined;
+    constructor();
     /**
      * A transform from local space to global space.
      */
@@ -47236,6 +46381,21 @@ export class VoxelProvider {
      * The number of levels of detail containing available tiles in the tileset.
      */
     readonly availableLevels: number | undefined;
+    /**
+     * Requests the data for a given tile.
+     * @param [options] - Object with the following properties:
+     * @param [options.tileLevel = 0] - The tile's level.
+     * @param [options.tileX = 0] - The tile's X coordinate.
+     * @param [options.tileY = 0] - The tile's Y coordinate.
+     * @param [options.tileZ = 0] - The tile's Z coordinate.
+     * @returns A promise resolving to a VoxelContent containing the data for the tile, or undefined if the request could not be scheduled this frame.
+     */
+    requestData(options?: {
+        tileLevel?: number;
+        tileX?: number;
+        tileY?: number;
+        tileZ?: number;
+    }): Promise<VoxelContent> | undefined;
 }
 
 /**
@@ -48227,24 +47387,6 @@ 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,