@cesium/engine 6.2.0 → 8.0.0

package/index.d.ts

@@ -7701,7 +7701,7 @@ export class GroundPolylineGeometry {
 
 /**
  * Defines a heading angle, pitch angle, and range in a local frame.
- * Heading is the rotation from the local north direction where a positive angle is increasing eastward.
+ * Heading is the rotation from the local east direction where a positive angle is increasing southward.
  * Pitch is the rotation from the local xy-plane. Positive pitch angles are above the plane. Negative pitch
  * angles are below the plane. Range is the distance from the center of the frame.
  * @param [heading = 0.0] - The heading angle in radians.
@@ -7711,7 +7711,7 @@ export class GroundPolylineGeometry {
 export class HeadingPitchRange {
     constructor(heading?: number, pitch?: number, range?: number);
     /**
-     * Heading is the rotation from the local north direction where a positive angle is increasing eastward.
+     * Heading is the rotation from the local east direction where a positive angle is increasing southward.
      */
     heading: number;
     /**
@@ -12889,22 +12889,6 @@ export class PolygonGeometry {
      * @returns The result rectangle
      */
     static computeRectangleFromPositions(positions: Cartesian3[], ellipsoid?: Ellipsoid, arcType?: ArcType, result?: Rectangle): Rectangle;
-    /**
-     * Returns the bounding rectangle given the provided options
-     * @param options - Object with the following properties:
-     * @param options.polygonHierarchy - A polygon hierarchy that can include holes.
-     * @param [options.granularity = Math.RADIANS_PER_DEGREE] - The distance, in radians, between each latitude and longitude. Determines the number of positions sampled.
-     * @param [options.arcType = ArcType.GEODESIC] - The type of line the polygon edges must follow. Valid options are {@link ArcType.GEODESIC} and {@link ArcType.RHUMB}.
-     * @param [options.ellipsoid = Ellipsoid.WGS84] - The ellipsoid to be used as a reference.
-     * @param [result] - An object in which to store the result.
-     * @returns The result rectangle
-     */
-    static computeRectangle(options: {
-        polygonHierarchy: PolygonHierarchy;
-        granularity?: number;
-        arcType?: ArcType;
-        ellipsoid?: Ellipsoid;
-    }, result?: Rectangle): Rectangle;
     /**
      * Computes the geometric representation of a polygon, including its vertices, indices, and a bounding sphere.
      * @param polygonGeometry - A description of the polygon.
@@ -17098,7 +17082,7 @@ export namespace Transforms {
     function northWestUpToFixedFrame(origin: Cartesian3, ellipsoid?: Ellipsoid, result?: Matrix4): Matrix4;
     /**
      * Computes a 4x4 transformation matrix from a reference frame with axes computed from the heading-pitch-roll angles
-     * centered at the provided origin to the provided ellipsoid's fixed reference frame. Heading is the rotation from the local north
+     * centered at the provided origin to the provided ellipsoid's fixed reference frame. Heading is the rotation from the local east
      * direction where a positive angle is increasing eastward. Pitch is the rotation from the local east-north plane. Positive pitch angles
      * are above the plane. Negative pitch angles are below the plane. Roll is the first rotation applied about the local east axis.
      * @example
@@ -17120,7 +17104,7 @@ export namespace Transforms {
     function headingPitchRollToFixedFrame(origin: Cartesian3, headingPitchRoll: HeadingPitchRoll, ellipsoid?: Ellipsoid, fixedFrameTransform?: Transforms.LocalFrameToFixedFrame, result?: Matrix4): Matrix4;
     /**
      * Computes a quaternion from a reference frame with axes computed from the heading-pitch-roll angles
-     * centered at the provided origin. Heading is the rotation from the local north
+     * centered at the provided origin. Heading is the rotation from the local east
      * direction where a positive angle is increasing eastward. Pitch is the rotation from the local east-north plane. Positive pitch angles
      * are above the plane. Negative pitch angles are below the plane. Roll is the first rotation applied about the local east axis.
      * @example
@@ -17141,7 +17125,7 @@ export namespace Transforms {
      */
     function headingPitchRollQuaternion(origin: Cartesian3, headingPitchRoll: HeadingPitchRoll, ellipsoid?: Ellipsoid, fixedFrameTransform?: Transforms.LocalFrameToFixedFrame, result?: Quaternion): Quaternion;
     /**
-     * Computes heading-pitch-roll angles from a transform in a particular reference frame. Heading is the rotation from the local north
+     * Computes heading-pitch-roll angles from a transform in a particular reference frame. Heading is the rotation from the local east
      * direction where a positive angle is increasing eastward. Pitch is the rotation from the local east-north plane. Positive pitch angles
      * are above the plane. Negative pitch angles are below the plane. Roll is the first rotation applied about the local east axis.
      * @param transform - The transform
@@ -18114,6 +18098,36 @@ export function combine(object1?: any, object2?: any, deep?: boolean): any;
  */
 export function createGuid(): string;
 
+/**
+ * Creates a {@link CesiumTerrainProvider} instance for the {@link https://cesium.com/content/#cesium-world-bathymetry|Cesium World Bathymetry}.
+ * @example
+ * // Create Cesium World Bathymetry with default settings
+ * try {
+ *   const viewer = new Cesium.Viewer("cesiumContainer", {
+ *     terrainProvider: await Cesium.createWorldBathymetryAsync();
+ *   });
+ * } catch (error) {
+ *   console.log(error);
+ * }
+ * @example
+ * // Create Cesium World Bathymetry with normals.
+ * try {
+ *   const viewer1 = new Cesium.Viewer("cesiumContainer", {
+ *     terrainProvider: await Cesium.createWorldBathymetryAsync({
+ *       requestVertexNormals: true
+ *     });
+ *   });
+ * } catch (error) {
+ *   console.log(error);
+ * }
+ * @param [options] - Object with the following properties:
+ * @param [options.requestVertexNormals = false] - Flag that indicates if the client should request additional lighting information from the server if available.
+ * @returns A promise that resolves to the created CesiumTerrainProvider
+ */
+export function createWorldBathymetryAsync(options?: {
+    requestVertexNormals?: boolean;
+}): Promise<CesiumTerrainProvider>;
+
 /**
  * Creates a {@link CesiumTerrainProvider} instance for the {@link https://cesium.com/content/#cesium-world-terrain|Cesium World Terrain}.
  * @example
@@ -18412,6 +18426,18 @@ export function sampleTerrain(terrainProvider: TerrainProvider, level: number, p
  */
 export function sampleTerrainMostDetailed(terrainProvider: TerrainProvider, positions: Cartographic[], rejectOnTileFail?: boolean): Promise<Cartographic[]>;
 
+/**
+ * Converts the value from sRGB color space to linear color space.
+ * @example
+ * const srgbColor = [0.5, 0.5, 0.5];
+ * const linearColor = srgbColor.map(function (c) {
+ *     return Cesium.srgbToLinear(c);
+ * });
+ * @param value - The color value in sRGB color space.
+ * @returns Returns the color value in linear color space.
+ */
+export function srgbToLinear(value: number): number;
+
 /**
  * Subdivides an array into a number of smaller, equal sized arrays.
  * @param array - The array to divide.
@@ -20604,7 +20630,7 @@ export namespace Entity {
      * @property [show] - A boolean value indicating if the entity and its children are displayed.
      * @property [description] - A string Property specifying an HTML description for this entity.
      * @property [position] - A Property specifying the entity position.
-     * @property [orientation] - A Property specifying the entity orientation.
+     * @property [orientation = Transforms.eastNorthUpToFixedFrame(position)] - A Property specifying the entity orientation in respect to Earth-fixed-Earth-centered (ECEF). If undefined, east-north-up at entity position is used.
      * @property [viewFrom] - A suggested initial offset for viewing this object.
      * @property [parent] - A parent entity to associate with this entity.
      * @property [billboard] - A billboard to associate with this entity.
@@ -20633,8 +20659,8 @@ export namespace Entity {
         show?: boolean;
         description?: Property | string;
         position?: PositionProperty | Cartesian3;
-        orientation?: Property;
-        viewFrom?: Property;
+        orientation?: Property | Quaternion;
+        viewFrom?: Property | Cartesian3;
         parent?: Entity;
         billboard?: BillboardGraphics | BillboardGraphics.ConstructorOptions;
         box?: BoxGraphics | BoxGraphics.ConstructorOptions;
@@ -20751,7 +20777,8 @@ export class Entity {
      */
     tileset: Cesium3DTilesetGraphics | undefined;
     /**
-     * Gets or sets the orientation.
+     * Gets or sets the orientation in respect to Earth-fixed-Earth-centered (ECEF).
+     * Defaults to east-north-up at entity position.
      */
     orientation: Property | undefined;
     /**
@@ -21324,8 +21351,6 @@ export class GeometryUpdater {
     readonly classificationTypeProperty: Property;
     /**
      * Gets a value indicating if the geometry is time-varying.
-     * If true, all visualization is delegated to a DynamicGeometryUpdater
-     * returned by GeometryUpdater#createDynamicUpdater.
      */
     readonly isDynamic: boolean;
     /**
@@ -21373,6 +21398,8 @@ export class GeometryUpdater {
     destroy(): void;
 }
 
+export const geometryUpdaters: GeometryUpdater[];
+
 /**
  * A general purpose visualizer for geometry represented by {@link Primitive} instances.
  * @param scene - The scene the primitives will be rendered in.
@@ -23283,8 +23310,6 @@ export class PolylineGeometryUpdater {
     readonly classificationTypeProperty: Property;
     /**
      * Gets a value indicating if the geometry is time-varying.
-     * If true, all visualization is delegated to the {@link DynamicGeometryUpdater}
-     * returned by GeometryUpdater#createDynamicUpdater.
      */
     readonly isDynamic: boolean;
     /**
@@ -25566,6 +25591,81 @@ export namespace ArcGisMapService {
     function getDefaultTokenCredit(providedKey: string): string | undefined;
 }
 
+/**
+ * Common atmosphere settings used by 3D Tiles and models for rendering sky atmosphere, ground atmosphere, and fog.
+ *
+ * <p>
+ * This class is not to be confused with {@link SkyAtmosphere}, which is responsible for rendering the sky.
+ * </p>
+ * <p>
+ * While the atmosphere settings affect the color of fog, see {@link Fog} to control how fog is rendered.
+ * </p>
+ * @example
+ * // Turn on dynamic atmosphere lighting using the sun direction
+ * scene.atmosphere.dynamicLighting = Cesium.DynamicAtmosphereLightingType.SUNLIGHT;
+ * @example
+ * // Turn on dynamic lighting using whatever light source is in the scene
+ * scene.light = new Cesium.DirectionalLight({
+ *   direction: new Cesium.Cartesian3(1, 0, 0)
+ * });
+ * scene.atmosphere.dynamicLighting = Cesium.DynamicAtmosphereLightingType.SCENE_LIGHT;
+ * @example
+ * // Adjust the color of the atmosphere effects.
+ * scene.atmosphere.hueShift = 0.4; // Cycle 40% around the color wheel
+ * scene.atmosphere.brightnessShift = 0.25; // Increase the brightness
+ * scene.atmosphere.saturationShift = -0.1; // Desaturate the colors
+ */
+export class Atmosphere {
+    constructor();
+    /**
+     * The intensity of the light that is used for computing the ground atmosphere color.
+     */
+    lightIntensity: number;
+    /**
+     * The Rayleigh scattering coefficient used in the atmospheric scattering equations for the ground atmosphere.
+     */
+    rayleighCoefficient: Cartesian3;
+    /**
+     * The Mie scattering coefficient used in the atmospheric scattering equations for the ground atmosphere.
+     */
+    mieCoefficient: Cartesian3;
+    /**
+     * The Rayleigh scale height used in the atmospheric scattering equations for the ground atmosphere, in meters.
+     */
+    rayleighScaleHeight: number;
+    /**
+     * The Mie scale height used in the atmospheric scattering equations for the ground atmosphere, in meters.
+     */
+    mieScaleHeight: number;
+    /**
+     * The anisotropy of the medium to consider for Mie scattering.
+     * <p>
+     * Valid values are between -1.0 and 1.0.
+     * </p>
+     */
+    mieAnisotropy: number;
+    /**
+     * The hue shift to apply to the atmosphere. Defaults to 0.0 (no shift).
+     * A hue shift of 1.0 indicates a complete rotation of the hues available.
+     */
+    hueShift: number;
+    /**
+     * The saturation shift to apply to the atmosphere. Defaults to 0.0 (no shift).
+     * A saturation shift of -1.0 is monochrome.
+     */
+    saturationShift: number;
+    /**
+     * The brightness shift to apply to the atmosphere. Defaults to 0.0 (no shift).
+     * A brightness shift of -1.0 is complete darkness, which will let space show through.
+     */
+    brightnessShift: number;
+    /**
+     * When not DynamicAtmosphereLightingType.NONE, the selected light source will
+     * be used for dynamically lighting all atmosphere-related rendering effects.
+     */
+    dynamicLighting: DynamicAtmosphereLightingType;
+}
+
 /**
  * An enum describing the x, y, and z axes and helper conversion functions.
  */
@@ -26583,7 +26683,7 @@ export class Camera {
     /**
      * If set, the camera will not be able to rotate past this axis in either direction.
      */
-    constrainedAxis: Cartesian3;
+    constrainedAxis: Cartesian3 | undefined;
     /**
      * The factor multiplied by the the map size used to determine where to clamp the camera position
      * when zooming out from the surface. The default is 1.5. Only valid for 2D and the map is rotatable.
@@ -28651,10 +28751,10 @@ export namespace Cesium3DTileset {
      * @property [preloadWhenHidden = false] - Preload tiles when <code>tileset.show</code> is <code>false</code>. Loads tiles as if the tileset is visible but does not render them.
      * @property [preloadFlightDestinations = true] - Optimization option. Preload tiles at the camera's flight destination while the camera is in flight.
      * @property [preferLeaves = false] - Optimization option. Prefer loading of leaves first.
-     * @property [dynamicScreenSpaceError = false] - Optimization option. Reduce the screen space error for tiles that are further away from the camera.
-     * @property [dynamicScreenSpaceErrorDensity = 0.00278] - Density used to adjust the dynamic screen space error, similar to fog density.
-     * @property [dynamicScreenSpaceErrorFactor = 4.0] - A factor used to increase the computed dynamic screen space error.
-     * @property [dynamicScreenSpaceErrorHeightFalloff = 0.25] - A ratio of the tileset's height at which the density starts to falloff.
+     * @property [dynamicScreenSpaceError = true] - Optimization option. For street-level horizon views, use lower resolution tiles far from the camera. This reduces the amount of data loaded and improves tileset loading time with a slight drop in visual quality in the distance.
+     * @property [dynamicScreenSpaceErrorDensity = 2.0e-4] - Similar to {@link Fog#density}, this option controls the camera distance at which the {@link Cesium3DTileset#dynamicScreenSpaceError} optimization applies. Larger values will cause tiles closer to the camera to be affected.
+     * @property [dynamicScreenSpaceErrorFactor = 24.0] - A parameter that controls the intensity of the {@link Cesium3DTileset#dynamicScreenSpaceError} optimization for tiles on the horizon. Larger values cause lower resolution tiles to load, improving runtime performance at a slight reduction of visual quality.
+     * @property [dynamicScreenSpaceErrorHeightFalloff = 0.25] - A ratio of the tileset's height that determines where "street level" camera views occur. When the camera is below this height, the {@link Cesium3DTileset#dynamicScreenSpaceError} optimization will have the maximum effect, and it will roll off above this value.
      * @property [progressiveResolutionHeightFraction = 0.3] - Optimization option. If between (0.0, 0.5], tiles at or above the screen space error for the reduced screen resolution of <code>progressiveResolutionHeightFraction*screenHeight</code> will be prioritized first. This can help get a quick layer of tiles down while full resolution tiles continue to load.
      * @property [foveatedScreenSpaceError = true] - Optimization option. Prioritize loading tiles in the center of the screen by temporarily raising the screen space error for tiles around the edge of the screen. Screen space error returns to normal once all the tiles in the center of the screen as determined by the {@link Cesium3DTileset#foveatedConeSize} are loaded.
      * @property [foveatedConeSize = 0.1] - Optimization option. Used when {@link Cesium3DTileset#foveatedScreenSpaceError} is true to control the cone size that determines which tiles are deferred. Tiles that are inside this cone are loaded immediately. Tiles outside the cone are potentially deferred based on how far outside the cone they are and their screen space error. This is controlled by {@link Cesium3DTileset#foveatedInterpolationCallback} and {@link Cesium3DTileset#foveatedMinimumScreenSpaceErrorRelaxation}. Setting this to 0.0 means the cone will be the line formed by the camera position and its view direction. Setting this to 1.0 means the cone encompasses the entire field of view of the camera, disabling the effect.
@@ -28683,11 +28783,14 @@ export namespace Cesium3DTileset {
      * @property [instanceFeatureIdLabel = "instanceFeatureId_0"] - Label of the instance feature ID set used for picking and styling. If instanceFeatureIdLabel is set to an integer N, it is converted to the string "instanceFeatureId_N" automatically. If both per-primitive and per-instance feature IDs are present, the instance feature IDs take priority.
      * @property [showCreditsOnScreen = false] - Whether to display the credits of this tileset on screen.
      * @property [splitDirection = SplitDirection.NONE] - The {@link SplitDirection} split to apply to this tileset.
-     * @property [projectTo2D = false] - Whether to accurately project the tileset to 2D. If this is true, the tileset will be projected accurately to 2D, but it will use more memory to do so. If this is false, the tileset will use less memory and will still render in 2D / CV mode, but its projected positions may be inaccurate. This cannot be set after the tileset has loaded.
+     * @property [enableCollision = false] - When <code>true</code>, enables collisions for camera or CPU picking. While this is <code>true</code> the camera will be prevented from going below the tileset surface if {@link ScreenSpaceCameraController#enableCollisionDetection} is true.
+     * @property [disableCollision = true] - Whether to turn off collisions for camera collisions or picking. While this is <code>true</code> the camera will be allowed to go in or below the tileset surface if {@link ScreenSpaceCameraController#enableCollisionDetection} is true. Deprecated.
+     * @property [projectTo2D = false] - Whether to accurately project the tileset to 2D. If this is true, the tileset will be projected accurately to 2D, but it will use more memory to do so. If this is false, the tileset will use less memory and will still render in 2D / CV mode, but its projected positions may be inaccurate. This cannot be set after the tileset has been created.
+     * @property [enablePick = false] - Whether to allow collision and CPU picking with <code>pick</code> when using WebGL 1. If using WebGL 2 or above, this option will be ignored. If using WebGL 1 and this is true, the <code>pick</code> operation will work correctly, but it will use more memory to do so. If running with WebGL 1 and this is false, the model will use less memory, but <code>pick</code> will always return <code>undefined</code>. This cannot be set after the tileset has loaded.
      * @property [debugHeatmapTilePropertyName] - The tile variable to colorize as a heatmap. All rendered tiles will be colorized relative to each other's specified variable value.
      * @property [debugFreezeFrame = false] - For debugging only. Determines if only the tiles from last frame should be used for rendering.
      * @property [debugColorizeTiles = false] - For debugging only. When true, assigns a random color to each tile.
-     * @property [enableDebugWireframe] - For debugging only. This must be true for debugWireframe to work in WebGL1. This cannot be set after the tileset has loaded.
+     * @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 [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.
@@ -28744,7 +28847,10 @@ export namespace Cesium3DTileset {
         instanceFeatureIdLabel?: string | number;
         showCreditsOnScreen?: boolean;
         splitDirection?: SplitDirection;
+        enableCollision?: boolean;
+        disableCollision?: boolean;
         projectTo2D?: boolean;
+        enablePick?: boolean;
         debugHeatmapTilePropertyName?: string;
         debugFreezeFrame?: boolean;
         debugColorizeTiles?: boolean;
@@ -28785,6 +28891,17 @@ export namespace Cesium3DTileset {
  *   console.error(`Error creating tileset: ${error}`);
  * }
  * @example
+ * // Turn on camera collisions with the tileset.
+ * try {
+ *   const tileset = await Cesium.Cesium3DTileset.fromUrl(
+ *      "http://localhost:8002/tilesets/Seattle/tileset.json",
+ *      { enableCollision: true }
+ *   );
+ *   scene.primitives.add(tileset);
+ * } catch (error) {
+ *   console.error(`Error creating tileset: ${error}`);
+ * }
+ * @example
  * // Common setting for the skipLevelOfDetail optimization
  * const tileset = await Cesium.Cesium3DTileset.fromUrl(
  *   "http://localhost:8002/tilesets/Seattle/tileset.json", {
@@ -28802,8 +28919,8 @@ export namespace Cesium3DTileset {
  * const tileset = await Cesium.Cesium3DTileset.fromUrl(
  *   "http://localhost:8002/tilesets/Seattle/tileset.json", {
  *      dynamicScreenSpaceError: true,
- *      dynamicScreenSpaceErrorDensity: 0.00278,
- *      dynamicScreenSpaceErrorFactor: 4.0,
+ *      dynamicScreenSpaceErrorDensity: 2.0e-4,
+ *      dynamicScreenSpaceErrorFactor: 24.0,
  *      dynamicScreenSpaceErrorHeightFalloff: 0.25
  * });
  * scene.primitives.add(tileset);
@@ -28836,11 +28953,11 @@ export class Cesium3DTileset {
      */
     preloadFlightDestinations: boolean;
     /**
-     * Optimization option. Whether the tileset should refine based on a dynamic screen space error. Tiles that are further
-     * away will be rendered with lower detail than closer tiles. This improves performance by rendering fewer
-     * tiles and making less requests, but may result in a slight drop in visual quality for tiles in the distance.
-     * The algorithm is biased towards "street views" where the camera is close to the ground plane of the tileset and looking
-     * at the horizon. In addition results are more accurate for tightly fitting bounding volumes like box and region.
+     * Optimization option. For street-level horizon views, use lower resolution tiles far from the camera. This reduces
+     * the amount of data loaded and improves tileset loading time with a slight drop in visual quality in the distance.
+     * <p>
+     * This optimization is strongest when the camera is close to the ground plane of the tileset and looking at the
+     * horizon. Furthermore, the results are more accurate for tightly fitting bounding volumes like box and region.
      */
     dynamicScreenSpaceError: boolean;
     /**
@@ -28862,33 +28979,43 @@ export class Cesium3DTileset {
      */
     foveatedTimeDelay: number;
     /**
-     * A scalar that determines the density used to adjust the dynamic screen space error, similar to {@link Fog}. Increasing this
-     * value has the effect of increasing the maximum screen space error for all tiles, but in a non-linear fashion.
-     * The error starts at 0.0 and increases exponentially until a midpoint is reached, and then approaches 1.0 asymptotically.
-     * This has the effect of keeping high detail in the closer tiles and lower detail in the further tiles, with all tiles
-     * beyond a certain distance all roughly having an error of 1.0.
+     * Similar to {@link Fog#density}, this option controls the camera distance at which the {@link Cesium3DTileset#dynamicScreenSpaceError}
+     * optimization applies. Larger values will cause tiles closer to the camera to be affected. This value must be
+     * non-negative.
      * <p>
-     * The dynamic error is in the range [0.0, 1.0) and is multiplied by <code>dynamicScreenSpaceErrorFactor</code> to produce the
-     * final dynamic error. This dynamic error is then subtracted from the tile's actual screen space error.
+     * This optimization works by rolling off the tile screen space error (SSE) with camera distance like a bell curve.
+     * This has the effect of selecting lower resolution tiles far from the camera. Near the camera, no adjustment is
+     * made. For tiles further away, the SSE is reduced by up to {@link Cesium3DTileset#dynamicScreenSpaceErrorFactor}
+     * (measured in pixels of error).
      * </p>
      * <p>
-     * Increasing <code>dynamicScreenSpaceErrorDensity</code> has the effect of moving the error midpoint closer to the camera.
-     * It is analogous to moving fog closer to the camera.
+     * Increasing the density makes the bell curve narrower so tiles closer to the camera are affected. This is analagous
+     * to moving fog closer to the camera.
+     * </p>
+     * <p>
+     * When the density is 0, the optimization will have no effect on the tileset.
      * </p>
      */
     dynamicScreenSpaceErrorDensity: number;
     /**
-     * A factor used to increase the screen space error of tiles for dynamic screen space error. As this value increases less tiles
-     * are requested for rendering and tiles in the distance will have lower detail. If set to zero, the feature will be disabled.
+     * A parameter that controls the intensity of the {@link Cesium3DTileset#dynamicScreenSpaceError} optimization for
+     * tiles on the horizon. Larger values cause lower resolution tiles to load, improving runtime performance at a slight
+     * reduction of visual quality. The value must be non-negative.
+     * <p>
+     * More specifically, this parameter represents the maximum adjustment to screen space error (SSE) in pixels for tiles
+     * far away from the camera. See {@link Cesium3DTileset#dynamicScreenSpaceErrorDensity} for more details about how
+     * this optimization works.
+     * </p>
+     * <p>
+     * When the SSE factor is set to 0, the optimization will have no effect on the tileset.
+     * </p>
      */
     dynamicScreenSpaceErrorFactor: number;
     /**
-     * A ratio of the tileset's height at which the density starts to falloff. If the camera is below this height the
-     * full computed density is applied, otherwise the density falls off. This has the effect of higher density at
-     * street level views.
+     * A ratio of the tileset's height that determines "street level" for the {@link Cesium3DTileset#dynamicScreenSpaceError}
+     * optimization. When the camera is below this height, the dynamic screen space error optimization will have the maximum
+     * effect, and it will roll off above this value. Valid values are between 0.0 and 1.0.
      * <p>
-     * Valid values are between 0.0 and 1.0.
-     * </p>
      */
     dynamicScreenSpaceErrorHeightFalloff: number;
     /**
@@ -29124,6 +29251,10 @@ export class Cesium3DTileset {
      * The {@link SplitDirection} to apply to this tileset.
      */
     splitDirection: SplitDirection;
+    /**
+     * If <code>true</code>, allows collisions for camera collisions or picking. While this is  <code>true</code> the camera will be prevented from going in or below the tileset surface if {@link ScreenSpaceCameraController#enableCollisionDetection} is true. This can have performance implecations if the tileset contains tile with a larger number of vertices.
+     */
+    enableCollision: boolean;
     /**
      * This property is for debugging only; it is not optimized for production use.
      * <p>
@@ -29205,6 +29336,10 @@ export class Cesium3DTileset {
      * Function for examining vector lines as they are being streamed.
      */
     examineVectorLinesFunction: (...params: any[]) => any;
+    /**
+     * Whether to turn off collisions for camera collisions or picking. While this is <code>true</code> the camera will be allowed to go in or below the tileset surface if {@link ScreenSpaceCameraController#enableCollisionDetection} is true.
+     */
+    disableCollision: boolean;
     /**
      * Gets the tileset's asset object property, which contains metadata about the tileset.
      * <p>
@@ -29392,6 +29527,7 @@ export class Cesium3DTileset {
      *     <li>The glTF cannot contain morph targets, skins, or animations.</li>
      *     <li>The glTF cannot contain the <code>EXT_mesh_gpu_instancing</code> extension.</li>
      *     <li>Only meshes with TRIANGLES can be used to classify other assets.</li>
+     *     <li>The meshes must be watertight.</li>
      *     <li>The <code>POSITION</code> semantic is required.</li>
      *     <li>If <code>_BATCHID</code>s and an index buffer are both present, all indices with the same batch id must occupy contiguous sections of the index buffer.</li>
      *     <li>If <code>_BATCHID</code>s are present with no index buffer, all positions with the same batch id must occupy contiguous sections of the position buffer.</li>
@@ -29401,6 +29537,9 @@ export class Cesium3DTileset {
      * Additionally, classification is not supported for points or instanced 3D
      * models.
      * </p>
+     * <p>
+     * The 3D Tiles or terrain receiving the classification must be opaque.
+     * </p>
      */
     readonly classificationType: ClassificationType;
     /**
@@ -29513,8 +29652,8 @@ export class Cesium3DTileset {
      * const tileset = await Cesium.Cesium3DTileset.fromUrl(
      *   "http://localhost:8002/tilesets/Seattle/tileset.json", {
      *      dynamicScreenSpaceError: true,
-     *      dynamicScreenSpaceErrorDensity: 0.00278,
-     *      dynamicScreenSpaceErrorFactor: 4.0,
+     *      dynamicScreenSpaceErrorDensity: 2.0e-4,
+     *      dynamicScreenSpaceErrorFactor: 24.0,
      *      dynamicScreenSpaceErrorHeightFalloff: 0.25
      * });
      * scene.primitives.add(tileset);
@@ -29569,6 +29708,18 @@ export class Cesium3DTileset {
      * tileset = tileset && tileset.destroy();
      */
     destroy(): void;
+    /**
+     * Get the height of the loaded surface at a given cartographic. This function will only take into account meshes for loaded tiles, not neccisarily the most detailed tiles available for a tileset. This function will always return undefined when sampling a point cloud.
+     * @example
+     * const tileset = await Cesium.Cesium3DTileset.fromIonAssetId(124624234);
+     * scene.primitives.add(tileset);
+     *
+     * const height = tileset.getHeight(scene.camera.positionCartographic, scene);
+     * @param cartographic - The cartographic for which to find the height.
+     * @param scene - The scene where visualization is taking place.
+     * @returns The height of the cartographic or undefined if it could not be found.
+     */
+    getHeight(cartographic: Cartographic, scene: Scene): number | undefined;
 }
 
 /**
@@ -30802,6 +30953,28 @@ export class DiscardMissingTileImagePolicy {
     shouldDiscardImage(image: HTMLImageElement): boolean;
 }
 
+/**
+ * Atmosphere lighting effects (sky atmosphere, ground atmosphere, fog) can be
+ * further modified with dynamic lighting from the sun or other light source
+ * that changes over time. This enum determines which light source to use.
+ */
+export enum DynamicAtmosphereLightingType {
+    /**
+     * Do not use dynamic atmosphere lighting. Atmosphere lighting effects will
+     * be lit from directly above rather than using the scene's light source.
+     */
+    NONE = 0,
+    /**
+     * Use the scene's current light source for dynamic atmosphere lighting.
+     */
+    SCENE_LIGHT = 1,
+    /**
+     * Force the dynamic atmosphere lighting to always use the sunlight direction,
+     * even if the scene uses a different light source.
+     */
+    SUNLIGHT = 2
+}
+
 /**
  * An appearance for geometry on the surface of the ellipsoid like {@link PolygonGeometry}
  * and {@link RectangleGeometry}, which supports all materials like {@link MaterialAppearance}
@@ -32411,13 +32584,29 @@ export enum HeightReference {
      */
     NONE = 0,
     /**
-     * The position is clamped to the terrain.
+     * The position is clamped to the terrain and 3D Tiles.
      */
     CLAMP_TO_GROUND = 1,
     /**
-     * The position height is the height above the terrain.
+     * The position height is the height above the terrain and 3D Tiles.
+     */
+    RELATIVE_TO_GROUND = 2,
+    /**
+     * The position is clamped to terain.
+     */
+    CLAMP_TO_TERRAIN = 3,
+    /**
+     * The position height is the height above terrain.
      */
-    RELATIVE_TO_GROUND = 2
+    RELATIVE_TO_TERRAIN = 4,
+    /**
+     * The position is clamped to 3D Tiles.
+     */
+    CLAMP_TO_3D_TILE = 5,
+    /**
+     * The position height is the height above 3D Tiles.
+     */
+    RELATIVE_TO_3D_TILE = 6
 }
 
 /**
@@ -32448,18 +32637,41 @@ export enum HorizontalOrigin {
 export namespace I3SDataProvider {
     /**
      * Initialization options for the I3SDataProvider constructor
+     * @example
+     * // Increase LOD by reducing SSE
+     * const cesium3dTilesetOptions = {
+     *   maximumScreenSpaceError: 1,
+     * };
+     * const i3sOptions = {
+     *   cesium3dTilesetOptions: cesium3dTilesetOptions,
+     * };
+     * @example
+     * // Set a custom outline color to replace the color defined in I3S symbology
+     * const cesium3dTilesetOptions = {
+     *   outlineColor: Cesium.Color.BLUE,
+     * };
+     * const i3sOptions = {
+     *   cesium3dTilesetOptions: cesium3dTilesetOptions,
+     *   applySymbology: true,
+     * };
      * @property [name] - The name of the I3S dataset.
      * @property [show = true] - Determines if the dataset will be shown.
      * @property [geoidTiledTerrainProvider] - Tiled elevation provider describing an Earth Gravitational Model. If defined, geometry will be shifted based on the offsets given by this provider. Required to position I3S data sets with gravity-related height at the correct location.
-     * @property [traceFetches = false] - Debug option. When true, log a message whenever an I3S tile is fetched.
      * @property [cesium3dTilesetOptions] - Object containing options to pass to an internally created {@link Cesium3DTileset}. See {@link Cesium3DTileset} for list of valid properties. All options can be used with the exception of <code>url</code> and <code>show</code> which are overridden by values from I3SDataProvider.
+     * @property [showFeatures = false] - Determines if the features will be shown.
+     * @property [adjustMaterialAlphaMode = false] - The option to adjust the alpha mode of the material based on the transparency of the vertex color. When <code>true</code>, the alpha mode of the material (if not defined) will be set to BLEND for geometry with any transparency in the color vertex attribute.
+     * @property [applySymbology = false] - Determines if the I3S symbology will be parsed and applied for the layers.
+     * @property [calculateNormals = false] - Determines if the flat normals will be generated for I3S geometry without normals.
      */
     type ConstructorOptions = {
         name?: string;
         show?: boolean;
         geoidTiledTerrainProvider?: ArcGISTiledElevationTerrainProvider | Promise<ArcGISTiledElevationTerrainProvider>;
-        traceFetches?: boolean;
         cesium3dTilesetOptions?: Cesium3DTileset.ConstructorOptions;
+        showFeatures?: boolean;
+        adjustMaterialAlphaMode?: boolean;
+        applySymbology?: boolean;
+        calculateNormals?: boolean;
     };
 }
 
@@ -32506,10 +32718,6 @@ export class I3SDataProvider {
      * Determines if the dataset will be shown.
      */
     show: boolean;
-    /**
-     * Gets or sets debugging and tracing of I3S fetches.
-     */
-    traceFetches: boolean;
     /**
      * The terrain provider referencing the GEOID service to be used for orthometric to ellipsoidal conversion.
      */
@@ -32518,6 +32726,10 @@ export class I3SDataProvider {
      * Gets the collection of layers.
      */
     readonly layers: I3SLayer[];
+    /**
+     * Gets the collection of building sublayers.
+     */
+    readonly sublayers: I3SSublayer[];
     /**
      * Gets the I3S data for this object.
      */
@@ -32530,6 +32742,22 @@ export class I3SDataProvider {
      * The resource used to fetch the I3S dataset.
      */
     readonly resource: Resource;
+    /**
+     * Determines if the features will be shown.
+     */
+    readonly showFeatures: boolean;
+    /**
+     * Determines if the alpha mode of the material will be adjusted depending on the color vertex attribute.
+     */
+    readonly adjustMaterialAlphaMode: boolean;
+    /**
+     * Determines if the I3S symbology will be parsed and applied for the layers.
+     */
+    readonly applySymbology: boolean;
+    /**
+     * Determines if the flat normals will be generated for I3S geometry without normals.
+     */
+    readonly calculateNormals: boolean;
     /**
      * Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
      * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
@@ -32578,6 +32806,23 @@ export class I3SDataProvider {
      * @param options - An object describing initialization options
      */
     static fromUrl(url: string | Resource, options: I3SDataProvider.ConstructorOptions): Promise<I3SDataProvider>;
+    /**
+     * Returns the collection of names for all available attributes
+     * @returns The collection of attribute names
+     */
+    getAttributeNames(): string[];
+    /**
+     * Returns the collection of values for the attribute with the given name
+     * @param name - The attribute name
+     * @returns The collection of attribute values
+     */
+    getAttributeValues(name: string): string[];
+    /**
+     * Filters the drawn elements of a scene to specific attribute names and values
+     * @param [filters = []] - The collection of attribute filters
+     * @returns A promise that is resolved when the filter is applied
+     */
+    filterByAttributes(filters?: I3SNode.AttributeFilter[]): Promise<void>;
 }
 
 /**
@@ -32702,6 +32947,25 @@ export class I3SLayer {
      * When <code>true</code>, when the loaded I3S version is 1.6 or older
      */
     readonly legacyVersion16: boolean;
+    /**
+     * Filters the drawn elements of a layer to specific attribute names and values
+     * @param [filters = []] - The collection of attribute filters
+     * @returns A promise that is resolved when the filter is applied
+     */
+    filterByAttributes(filters?: I3SNode.AttributeFilter[]): Promise<void>;
+}
+
+export namespace I3SNode {
+    /**
+     * A filter given by an attribute name and values.
+     * The 3D feature object should be hidden if its value for the attribute name is not specified in the collection of values.
+     * @property name - The name of the attribute
+     * @property values - The collection of values
+     */
+    type AttributeFilter = {
+        name: string;
+        values: string[] | number[];
+    };
 }
 
 /**
@@ -32753,6 +33017,12 @@ export class I3SNode {
      * @returns A promise that is resolved when the I3S Node fields are loaded
      */
     loadFields(): Promise<void>;
+    /**
+     * Loads the node field.
+     * @param name - The field name
+     * @returns A promise that is resolved when the I3S Node field is loaded
+     */
+    loadField(name: string): Promise<void>;
     /**
      * Returns the fields for a given picked position
      * @param pickedPosition - The picked position
@@ -32767,6 +33037,80 @@ export class I3SNode {
     getFieldsForFeature(featureIndex: number): any;
 }
 
+/**
+ * This class implements an I3S statistics for Building Scene Layer.
+ * <p>
+ * Do not construct this directly, instead access statistics through {@link I3SDataProvider}.
+ * </p>
+ */
+export class I3SStatistics {
+    constructor();
+    /**
+     * Gets the resource for the statistics
+     */
+    readonly resource: Resource;
+    /**
+     * Gets the I3S data for this object.
+     */
+    readonly data: any;
+    /**
+     * Gets the collection of attribute names.
+     */
+    readonly names: string[];
+}
+
+/**
+ * This class implements an I3S sublayer for Building Scene Layer.
+ * <p>
+ * This object is normally not instantiated directly, use {@link I3SSublayer.fromData}.
+ * </p>
+ */
+export class I3SSublayer {
+    constructor();
+    /**
+     * Gets the resource for the sublayer
+     */
+    readonly resource: Resource;
+    /**
+     * Gets the I3S data for this object.
+     */
+    readonly data: any;
+    /**
+     * Gets the name for the sublayer.
+     */
+    readonly name: string;
+    /**
+     * Gets the model name for the sublayer.
+     */
+    readonly modelName: string;
+    /**
+     * Gets the collection of child sublayers.
+     */
+    readonly sublayers: I3SSublayer[];
+    /**
+     * Gets or sets the sublayer visibility.
+     */
+    visibility: boolean;
+    /**
+     * Determines if the sublayer will be shown.
+     */
+    readonly show: boolean;
+}
+
+/**
+ * This class implements an I3S symbology for I3S Layers.
+ * <p>
+ * Do not construct this directly, instead access symbology through {@link I3SLayer}.
+ * </p>
+ */
+export class I3SSymbology {
+    constructor();
+    /**
+     * Gets the default symbology data.
+     */
+    readonly defaultSymbology: any;
+}
+
 /**
  * Properties for managing image-based lighting on tilesets and models.
  * Also manages the necessary resources and textures.
@@ -35914,11 +36258,15 @@ export class Model {
      *     <li>The glTF cannot contain morph targets, skins, or animations.</li>
      *     <li>The glTF cannot contain the <code>EXT_mesh_gpu_instancing</code> extension.</li>
      *     <li>Only meshes with TRIANGLES can be used to classify other assets.</li>
-     *     <li>The position attribute is required.</li>
+     *     <li>The meshes must be watertight.</li>
+     *     <li>The POSITION attribute is required.</li>
      *     <li>If feature IDs and an index buffer are both present, all indices with the same feature id must occupy contiguous sections of the index buffer.</li>
      *     <li>If feature IDs are present without an index buffer, all positions with the same feature id must occupy contiguous sections of the position buffer.</li>
      * </ul>
      * </p>
+     * <p>
+     * The 3D Tiles or terrain receiving the classification must be opaque.
+     * </p>
      */
     readonly classificationType: ClassificationType;
     /**
@@ -36090,6 +36438,7 @@ export class Model {
      * @param [options.showCreditsOnScreen = false] - Whether to display the credits of this model on screen.
      * @param [options.splitDirection = SplitDirection.NONE] - The {@link SplitDirection} split to apply to this model.
      * @param [options.projectTo2D = false] - Whether to accurately project the model's positions in 2D. If this is true, the model will be projected accurately to 2D, but it will use more memory to do so. If this is false, the model will use less memory and will still render in 2D / CV mode, but its positions may be inaccurate. This disables minimumPixelSize and prevents future modification to the model matrix. This also cannot be set after the model has loaded.
+     * @param [options.enablePick = false] - Whether to allow with CPU picking with <code>pick</code> when not using WebGL 2 or above. If using WebGL 2 or above, this option will be ignored. If using WebGL 1 and this is true, the <code>pick</code> operation will work correctly, but it will use more memory to do so. If running with WebGL 1 and this is false, the model will use less memory, but <code>pick</code> will always return <code>undefined</code>. This cannot be set after the model has loaded.
      * @param [options.featureIdLabel = "featureId_0"] - Label of the feature ID set to use for picking and styling. For EXT_mesh_features, this is the feature ID's label property, or "featureId_N" (where N is the index in the featureIds array) when not specified. EXT_feature_metadata did not have a label field, so such feature ID sets are always labeled "featureId_N" where N is the index in the list of all feature Ids, where feature ID attributes are listed before feature ID textures. If featureIdLabel is an integer N, it is converted to the string "featureId_N" automatically. If both per-primitive and per-instance feature IDs are present, the instance feature IDs take priority.
      * @param [options.instanceFeatureIdLabel = "instanceFeatureId_0"] - Label of the instance feature ID set used for picking and styling. If instanceFeatureIdLabel is set to an integer N, it is converted to the string "instanceFeatureId_N" automatically. If both per-primitive and per-instance feature IDs are present, the instance feature IDs take priority.
      * @param [options.pointCloudShading] - Options for constructing a {@link PointCloudShading} object to control point attenuation and lighting.
@@ -36140,6 +36489,7 @@ export class Model {
         showCreditsOnScreen?: boolean;
         splitDirection?: SplitDirection;
         projectTo2D?: boolean;
+        enablePick?: boolean;
         featureIdLabel?: string | number;
         instanceFeatureIdLabel?: string | number;
         pointCloudShading?: any;
@@ -39360,6 +39710,11 @@ export class Scene {
      * }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
      */
     pickTranslucentDepth: boolean;
+    /**
+     * Settings for atmosphere lighting effects affecting 3D Tiles and model rendering. This is not to be confused with
+     * {@link Scene#skyAtmosphere} which is responsible for rendering the sky.
+     */
+    atmosphere: Atmosphere;
     /**
      * Blends the atmosphere to geometry far from the camera for horizon views. Allows for additional
      * performance improvements by rendering less geometry and dispatching less terrain requests.
@@ -39420,6 +39775,11 @@ export class Scene {
      * The light source for shading. Defaults to a directional light from the Sun.
      */
     light: Light;
+    /**
+     * Use this to set the default value for {@link Scene#logarithmicDepthBuffer} in newly constructed Scenes
+     * This property relies on fragmentDepth being supported.
+     */
+    static defaultLogDepthBuffer: any;
     /**
      * Gets the canvas element to which this scene is bound.
      */
@@ -39647,6 +40007,23 @@ export class Scene {
      * @returns Object containing the picked primitive.
      */
     pick(windowPosition: Cartesian2, width?: number, height?: number): any;
+    /**
+     * Returns a {@link VoxelCell} for the voxel sample rendered at a particular window coordinate,
+     * or undefined if no voxel is rendered at that position.
+     * @example
+     * On left click, report the value of the "color" property at that voxel sample.
+     * handler.setInputAction(function(movement) {
+     *   const voxelCell = scene.pickVoxel(movement.position);
+     *   if (defined(voxelCell)) {
+     *     console.log(voxelCell.getProperty("color"));
+     *   }
+     * }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+     * @param windowPosition - Window coordinates to perform picking on.
+     * @param [width = 3] - Width of the pick rectangle.
+     * @param [height = 3] - Height of the pick rectangle.
+     * @returns Information about the voxel cell rendered at the picked position.
+     */
+    pickVoxel(windowPosition: Cartesian2, width?: number, height?: number): VoxelCell | undefined;
     /**
      * Returns the cartesian position reconstructed from the depth buffer and window position.
      * <p>
@@ -40059,6 +40436,24 @@ export class ScreenSpaceCameraController {
     destroy(): void;
 }
 
+/**
+ * Constants used to indicated what part of the sensor volume to display.
+ */
+export enum SensorVolumePortionToDisplay {
+    /**
+     * 0x0000.  Display the complete sensor volume.
+     */
+    COMPLETE = 0,
+    /**
+     * 0x0001.  Display the portion of the sensor volume that lies below the true horizon of the ellipsoid.
+     */
+    BELOW_ELLIPSOID_HORIZON = 1,
+    /**
+     * 0x0002.  Display the portion of the sensor volume that lies above the true horizon of the ellipsoid.
+     */
+    ABOVE_ELLIPSOID_HORIZON = 2
+}
+
 /**
  * <div class="notice">
  * Use {@link Viewer#shadowMap} to get the scene's shadow map. Do not construct this directly.
@@ -40714,6 +41109,44 @@ export class Terrain {
         requestVertexNormals?: boolean;
         requestWaterMask?: boolean;
     }): Terrain;
+    /**
+     * Creates a {@link Terrain} instance for {@link https://cesium.com/content/#cesium-world-bathymetry|Cesium World Bathymetry}.
+     * @example
+     * // Create Cesium World Bathymetry with default settings
+     * const viewer = new Cesium.Viewer("cesiumContainer", {
+     *   terrain: Cesium.Terrain.fromWorldBathymetry)
+     * });
+     * @example
+     * // Create Cesium World Terrain with normals.
+     * const viewer1 = new Cesium.Viewer("cesiumContainer", {
+     *   terrain: Cesium.Terrain.fromWorldBathymetry({
+     *      requestVertexNormals: true
+     *    });
+     * });
+     * @example
+     * // Handle loading events
+     * const bathymetry = Cesium.Terrain.fromWorldBathymetry();
+     *
+     * scene.setTerrain(bathymetry);
+     *
+     * bathymetry.readyEvent.addEventListener(provider => {
+     *   scene.globe.enableLighting = true;
+     *
+     *   bathymetry.provider.errorEvent.addEventListener(error => {
+     *     alert(`Encountered an error while loading bathymetric terrain tiles! ${error}`);
+     *   });
+     * });
+     *
+     * bathymetry.errorEvent.addEventListener(error => {
+     *   alert(`Encountered an error while creating bathymetric terrain! ${error}`);
+     * });
+     * @param [options] - Object with the following properties:
+     * @param [options.requestVertexNormals = false] - Flag that indicates if the client should request additional lighting information from the server if available.
+     * @returns An asynchronous helper object for a CesiumTerrainProvider
+     */
+    static fromWorldBathymetry(options?: {
+        requestVertexNormals?: boolean;
+    }): Terrain;
 }
 
 export namespace TileCoordinatesImageryProvider {
@@ -41512,6 +41945,76 @@ export class ViewportQuad {
     destroy(): void;
 }
 
+/**
+ * A cell from a {@link VoxelPrimitive}.
+ * <p>
+ * Provides access to properties associated with one cell of a voxel primitive.
+ * </p>
+ * <p>
+ * Do not construct this directly.  Access it through picking using {@link Scene#pickVoxel}.
+ * </p>
+ * @example
+ * // On left click, display all the properties for a voxel cell in the console log.
+ * handler.setInputAction(function(movement) {
+ *   const voxelCell = scene.pickVoxel(movement.position);
+ *   if (voxelCell instanceof Cesium.VoxelCell) {
+ *     const propertyIds = voxelCell.getPropertyIds();
+ *     const length = propertyIds.length;
+ *     for (let i = 0; i < length; ++i) {
+ *       const propertyId = propertyIds[i];
+ *       console.log(`{propertyId}: ${voxelCell.getProperty(propertyId)}`);
+ *     }
+ *   }
+ * }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+ * @param primitive - The voxel primitive containing the cell
+ * @param tileIndex - The index of the tile
+ * @param sampleIndex - The index of the sample within the tile, containing metadata for this cell
+ */
+export class VoxelCell {
+    constructor(primitive: VoxelPrimitive, tileIndex: number, sampleIndex: number);
+    /**
+     * All objects returned by {@link Scene#pick} have a <code>primitive</code> property. This returns
+     * the VoxelPrimitive containing the cell.
+     */
+    readonly primitive: VoxelPrimitive;
+    /**
+     * Get the sample index of the cell.
+     */
+    readonly sampleIndex: number;
+    /**
+     * Get the index of the tile containing the cell.
+     */
+    readonly tileIndex: number;
+    /**
+     * Get a copy of the oriented bounding box containing the cell.
+     */
+    readonly orientedBoundingBox: OrientedBoundingBox;
+    /**
+     * Returns <code>true</code> if the feature contains this property.
+     * @param name - The case-sensitive name of the property.
+     * @returns Whether the feature contains this property.
+     */
+    hasProperty(name: string): boolean;
+    /**
+     * Returns an array of metadata property names for the feature.
+     * @returns The IDs of the feature's properties.
+     */
+    getNames(): string[];
+    /**
+     * Returns a copy of the value of the metadata in the cell with the given name.
+     * @example
+     * // Display all the properties for a voxel cell in the console log.
+     * const names = voxelCell.getNames();
+     * for (let i = 0; i < names.length; ++i) {
+     *   const name = names[i];
+     *   console.log(`{name}: ${voxelCell.getProperty(name)}`);
+     * }
+     * @param name - The case-sensitive name of the property.
+     * @returns The value of the property or <code>undefined</code> if the feature does not have this property.
+     */
+    getProperty(name: string): any;
+}
+
 /**
  * A primitive that renders voxel data from a {@link VoxelProvider}.
  * @param [options] - Object with the following properties: