@cesium/engine 25.0.0 → 26.1.0

package/index.d.ts

@@ -3616,8 +3616,6 @@ 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).
@@ -8736,17 +8734,20 @@ export enum IndexDatatype {
     UNSIGNED_INT = WebGLConstants.UNSIGNED_INT
 }
 
-export namespace InterpolationAlgorithm {
+/**
+ * The interface for interpolation algorithms.
+ */
+export interface InterpolationAlgorithm {
     /**
      * Gets the name of this interpolation algorithm.
      */
-    var type: string;
+    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.
      */
-    function getRequiredDataPoints(degree: number): number;
+    getRequiredDataPoints(degree: number): number;
     /**
      * Performs zero order interpolation.
      * @param x - The independent variable for which the dependent variables will be interpolated.
@@ -8759,7 +8760,7 @@ export namespace 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.
      */
-    function interpolateOrderZero(x: number, xTable: number[], yTable: number[], yStride: number, result?: number[]): number[];
+    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.
@@ -8775,13 +8776,7 @@ export namespace 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.
      */
-    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 {
+    interpolate(x: number, xTable: number[], yTable: number[], yStride: number, inputOrder: number, outputOrder: number, result?: number[]): number[];
 }
 
 /**
@@ -9571,7 +9566,7 @@ export interface MapProjection {
     /**
      * Gets the {@link Ellipsoid}.
      */
-    ellipsoid: Ellipsoid;
+    readonly ellipsoid: Ellipsoid;
     /**
      * Projects {@link Cartographic} coordinates, in radians, to projection-specific map coordinates, in meters.
      * @param cartographic - The coordinates to project.
@@ -16122,25 +16117,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 [modifier] - A KeyboardEventModifier key that is held when a <code>type</code>
+     * @param [modifiers] - The KeyboardEventModifier keys that are held when a <code>type</code>
      * event occurs.
      */
-    setInputAction(action: ScreenSpaceEventHandler.PositionedEventCallback | ScreenSpaceEventHandler.MotionEventCallback | ScreenSpaceEventHandler.WheelEventCallback | ScreenSpaceEventHandler.TwoPointEventCallback | ScreenSpaceEventHandler.TwoPointMotionEventCallback, type: ScreenSpaceEventType, modifier?: KeyboardEventModifier): void;
+    setInputAction(action: ScreenSpaceEventHandler.PositionedEventCallback | ScreenSpaceEventHandler.MotionEventCallback | ScreenSpaceEventHandler.WheelEventCallback | ScreenSpaceEventHandler.TwoPointEventCallback | ScreenSpaceEventHandler.TwoPointMotionEventCallback, type: ScreenSpaceEventType, modifiers?: KeyboardEventModifier[] | KeyboardEventModifier): void;
     /**
      * Returns the function to be executed on an input event.
      * @param type - The ScreenSpaceEventType of input event.
-     * @param [modifier] - A KeyboardEventModifier key that is held when a <code>type</code>
+     * @param [modifiers] - The KeyboardEventModifier keys that are held when a <code>type</code>
      * event occurs.
      * @returns The function to be executed on an input event.
      */
-    getInputAction(type: ScreenSpaceEventType, modifier?: KeyboardEventModifier): ScreenSpaceEventHandler.PositionedEventCallback | ScreenSpaceEventHandler.MotionEventCallback | ScreenSpaceEventHandler.WheelEventCallback | ScreenSpaceEventHandler.TwoPointEventCallback | ScreenSpaceEventHandler.TwoPointMotionEventCallback;
+    getInputAction(type: ScreenSpaceEventType, modifiers?: KeyboardEventModifier[] | 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 [modifier] - A KeyboardEventModifier key that is held when a <code>type</code>
+     * @param [modifiers] - The KeyboardEventModifier keys that are held when a <code>type</code>
      * event occurs.
      */
-    removeInputAction(type: ScreenSpaceEventType, modifier?: KeyboardEventModifier): void;
+    removeInputAction(type: ScreenSpaceEventType, modifiers?: KeyboardEventModifier[] | KeyboardEventModifier): void;
     /**
      * Returns true if this object was destroyed; otherwise, false.
      * <br /><br />
@@ -16793,16 +16788,6 @@ 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.
@@ -18940,6 +18925,31 @@ 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
@@ -19109,15 +19119,6 @@ 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.
@@ -22617,11 +22618,39 @@ 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.
      */
@@ -22650,35 +22679,6 @@ 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
@@ -23388,10 +23388,11 @@ 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.
+     * @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 [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;
@@ -23402,6 +23403,7 @@ export namespace PathGraphics {
         material?: MaterialProperty | Color;
         distanceDisplayCondition?: Property | DistanceDisplayCondition;
         relativeTo?: Property | string;
+        materialMode?: Property | PathMode;
     };
 }
 
@@ -23433,6 +23435,7 @@ 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;
     /**
@@ -23461,6 +23464,21 @@ 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.
@@ -26070,8 +26088,6 @@ 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
@@ -27711,13 +27727,24 @@ export type BufferPointOptions = {
  *   collection.get(i, point);
  *   point.setMaterial(material);
  * }
+ * @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;
-        debugShowBoundingVolume?: boolean;
         allowPicking?: boolean;
+        boundingVolume?: BoundingSphere;
+        debugShowBoundingVolume?: boolean;
+        blendOption?: BlendOption;
     });
     /**
      * Adds a new point to the collection, with the specified options. A
@@ -27946,6 +27973,10 @@ 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: {
@@ -27954,9 +27985,12 @@ 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.
@@ -28236,7 +28270,14 @@ 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: {
@@ -28245,16 +28286,22 @@ 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 _boundingVolumeWC: BoundingSphere;
+    protected readonly _boundingVolumeAutoUpdate: boolean;
     /**
      * This property is for debugging only; it is not for production use nor is it optimized.
      * <p>
@@ -28349,15 +28396,20 @@ export class BufferPrimitiveCollection<T extends BufferPrimitive> {
      */
     readonly modelMatrix: Matrix4;
     /**
-     * Local bounding volume for all primitives in the collection, including both
+     * World-space bounding volume for all primitives in the collection, including both
      * shown and hidden primitives.
      */
     readonly boundingVolume: BoundingSphere;
     /**
-     * World bounding volume for all primitives in the collection, including both
-     * shown and hidden primitives.
+     * The component datatype used to store position values.
      */
-    readonly boundingVolumeWC: BoundingSphere;
+    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).
+     */
+    readonly positionNormalized: boolean;
     /**
      * Returns a JSON-serializable array representing the collection. This encoding
      * is not memory-efficient, and should generally be used for debugging and
@@ -29321,8 +29373,7 @@ export enum Cesium3DTileColorBlendMode {
  * This type describes an interface and is not intended to be instantiated directly.
  * </p>
  */
-export class Cesium3DTileContent {
-    constructor();
+export interface Cesium3DTileContent {
     /**
      * Gets the number of features in the tile.
      */
@@ -30683,6 +30734,7 @@ 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.
@@ -30751,6 +30803,7 @@ export namespace Cesium3DTileset {
         debugColorizeTiles?: boolean;
         enableDebugWireframe?: boolean;
         debugWireframe?: boolean;
+        edgeDisplayMode?: EdgeDisplayMode;
         debugShowBoundingVolume?: boolean;
         debugShowContentBoundingVolume?: boolean;
         debugShowViewerRequestVolume?: boolean;
@@ -31175,6 +31228,13 @@ 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>
@@ -32102,33 +32162,6 @@ 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.
@@ -33130,47 +33163,6 @@ 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:
@@ -33404,6 +33396,35 @@ 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}
@@ -33861,14 +33882,16 @@ 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 {
-    constructor();
+export class GaussianSplat3DTileContent implements Cesium3DTileContent {
     /**
      * Performs checks to ensure that the provided tileset has the Gaussian Splatting extensions.
      * @param tileset - The tileset to check for the extensions.
@@ -33933,7 +33956,7 @@ export class GaussianSplat3DTileContent {
      * The resource that this content was loaded from.
      * <p>
      */
-    readonly url: Resource;
+    readonly url: string;
     /**
      * Returns whether the feature has this property.
      * @param batchId - The batchId for the feature.
@@ -33954,6 +33977,75 @@ export class GaussianSplat3DTileContent {
     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;
+}
+
 /**
  * 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
@@ -34354,10 +34446,14 @@ export class GlobeTranslucency {
     rectangle: Rectangle;
 }
 
-/**
- * Loads the gltf object
- */
-export function loadGltfJson(): void;
+export type EXTMeshPolygonExtension = {
+    count: number;
+    indicesOffsets: number;
+    loopIndices?: number;
+    loopIndicesOffsets?: number;
+    triangleIndices?: number;
+    triangleIndicesOffsets?: number;
+};
 
 /**
  * Removes an extension from gltf.extensions, gltf.extensionsUsed, gltf.extensionsRequired, and any other objects in the glTF if it is present.
@@ -37654,6 +37750,32 @@ export class Light {
     intensity: number;
 }
 
+/**
+ * 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>
+ */
+export class MVTDataProvider {
+    /**
+     * 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 = 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] - MVT property name to use as feature ID.
+     */
+    static fromUrl(url: Resource | string, options?: {
+        minZoom?: number;
+        maxZoom?: number;
+        extent?: Rectangle;
+        featureIdProperty?: string;
+    }): void;
+}
+
 /**
  * Describes how the map will operate in 2D.
  */
@@ -38354,14 +38476,6 @@ 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.
@@ -39302,36 +39416,6 @@ 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
@@ -39524,6 +39608,11 @@ export enum LightingModel {
  *  {@link https://github.com/KhronosGroup/glTF/pull/2514|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)
+ *  </li>
+ *  <li>
  *  {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_meshopt_compression|EXT_meshopt_compression}
  *  </li>
  *  <li>
@@ -39551,6 +39640,9 @@ export enum LightingModel {
  *  {@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>
@@ -39696,6 +39788,13 @@ 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.
      */
@@ -39995,6 +40094,7 @@ 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.
@@ -40049,6 +40149,7 @@ export class Model {
         color?: Color;
         colorBlendMode?: ColorBlendMode;
         colorBlendAmount?: number;
+        edgeDisplayMode?: EdgeDisplayMode;
         silhouetteColor?: Color;
         silhouetteSize?: number;
         enableShowOutline?: boolean;
@@ -41337,34 +41438,6 @@ 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
@@ -41379,44 +41452,6 @@ 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.
@@ -44009,18 +44044,6 @@ export class Scene {
     destroy(): void;
 }
 
-/**
- * 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 function obtainTranslucentCommandExecutionFunction(scene: Scene): (...params: any[]) => any;
-
 /**
  * Indicates if the scene is viewed in 3D, 2D, or 2.5D Columbus view.
  */
@@ -46107,7 +46130,8 @@ export class VoxelPrimitive {
      */
     clippingPlanes: ClippingPlaneCollection;
     /**
-     * Gets or sets the custom shader. If undefined, {@link VoxelPrimitive.DefaultCustomShader} is set.
+     * 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}.
      */
     customShader: CustomShader;
     /**
@@ -46140,7 +46164,21 @@ export class VoxelPrimitive {
  * This type describes an interface and is not intended to be instantiated directly.
  */
 export class VoxelProvider {
-    constructor();
+    /**
+     * 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;
     /**
      * A transform from local space to global space.
      */
@@ -46205,21 +46243,6 @@ 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;
 }
 
 /**