mars3d-cesium 1.126.2 → 1.128.0

package/Build/Cesium/Cesium.d.ts

@@ -653,7 +653,7 @@ export class ArcGISTiledElevationTerrainProvider {
     at points and in rectangles. This property may be undefined if availability
     information is not available.
      */
-    readonly availability: TileAvailability;
+    readonly availability: TileAvailability | undefined;
     /**
      * Creates a {@link TerrainProvider} that produces terrain geometry by tessellating height maps
     retrieved from Elevation Tiles of an an ArcGIS ImageService.
@@ -2976,7 +2976,7 @@ export class CesiumTerrainProvider {
     exists deeper in the tree rather than it all being discoverable at the root. However, a tile that
     is available now will not become unavailable in the future.
      */
-    readonly availability: TileAvailability;
+    readonly availability: TileAvailability | undefined;
     /**
      * Gets the maximum geometric error allowed in a tile at a given level.
      * @param level - The tile level for which to get the maximum geometric error.
@@ -6436,7 +6436,7 @@ export class EllipsoidRhumbLine {
     interpolateUsingSurfaceDistance(distance: number, result?: Cartographic): Cartographic;
     /**
      * Provides the location of a point at the indicated longitude along the rhumb line.
-     * If the longitude is outside the range of start and end points, the first intersection with the longitude from the start point in the direction of the heading is returned. This follows the spiral property of a rhumb line.
+    If the longitude is outside the range of start and end points, the first intersection with the longitude from the start point in the direction of the heading is returned. This follows the spiral property of a rhumb line.
      * @param intersectionLongitude - The longitude, in radians, at which to find the intersection point from the starting point using the heading.
      * @param [result] - The object in which to store the result.
      * @returns The location of the intersection point along the rhumb line, undefined if there is no intersection or infinite intersections.
@@ -6444,7 +6444,7 @@ export class EllipsoidRhumbLine {
     findIntersectionWithLongitude(intersectionLongitude: number, result?: Cartographic): Cartographic;
     /**
      * Provides the location of a point at the indicated latitude along the rhumb line.
-     * If the latitude is outside the range of start and end points, the first intersection with the latitude from that start point in the direction of the heading is returned. This follows the spiral property of a rhumb line.
+    If the latitude is outside the range of start and end points, the first intersection with the latitude from that start point in the direction of the heading is returned. This follows the spiral property of a rhumb line.
      * @param intersectionLatitude - The latitude, in radians, at which to find the intersection point from the starting point using the heading.
      * @param [result] - The object in which to store the result.
      * @returns The location of the intersection point along the rhumb line, undefined if there is no intersection or infinite intersections.
@@ -6584,7 +6584,7 @@ export class EllipsoidTerrainProvider {
     at points and in rectangles. This property may be undefined if availability
     information is not available.
      */
-    readonly availability: TileAvailability;
+    readonly availability: TileAvailability | undefined;
     /**
      * Requests the geometry for a given tile. The result includes terrain
     data and indicates that all child tiles are available.
@@ -6796,6 +6796,22 @@ properties, otherwise, falls back on toString().
  */
 export function formatError(object: any): string;
 
+/**
+ * Utilities helpful for setting a default value for a parameter.
+ */
+export namespace Frozen {
+    /**
+     * A frozen empty object that can be used as the default value for options passed as
+    an object literal.
+     */
+    var EMPTY_OBJECT: any;
+    /**
+     * A frozen empty array that can be used as the default value for options passed as
+    an array literal.
+     */
+    var EMPTY_ARRAY: any[];
+}
+
 /**
  * Describes a frustum at the given the origin and orientation.
  * @param options - Object with the following properties:
@@ -7857,7 +7873,7 @@ export class GoogleEarthEnterpriseTerrainData {
     Uint8Array or image where a value of 255 indicates water and a value of 0 indicates land.
     Values in between 0 and 255 are allowed as well to smoothly blend between land and water.
      */
-    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement;
+    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | undefined;
     /**
      * Computes the terrain height at a specified longitude and latitude.
      * @param rectangle - The rectangle covered by this terrain data.
@@ -7968,7 +7984,7 @@ export class GoogleEarthEnterpriseTerrainProvider {
     at points and in rectangles. This property may be undefined if availability
     information is not available.
      */
-    readonly availability: TileAvailability;
+    readonly availability: TileAvailability | undefined;
     /**
      * Creates a GoogleEarthTerrainProvider from GoogleEarthEnterpriseMetadata
      * @example
@@ -8398,7 +8414,7 @@ export class HeightmapTerrainData {
     Uint8Array or image where a value of 255 indicates water and a value of 0 indicates land.
     Values in between 0 and 255 are allowed as well to smoothly blend between land and water.
      */
-    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement;
+    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | undefined;
     /**
      * Computes the terrain height at a specified longitude and latitude.
      * @param rectangle - The rectangle covered by this terrain data.
@@ -9171,8 +9187,17 @@ export namespace ITwinPlatform {
     }
     /**
      * Gets or sets the default iTwin access token. This token should have the <code>itwin-platform</code> scope.
+    
+    This value will be ignored if {@link ITwinPlatform.defaultShareKey} is defined.
      */
     var defaultAccessToken: string | undefined;
+    /**
+     * Gets or sets the default iTwin share key. If this value is provided it will override {@link ITwinPlatform.defaultAccessToken} in all requests.
+    
+    Share keys can be generated using the iTwin Shares api
+    https://developer.bentley.com/apis/access-control-v2/operations/create-itwin-share/
+     */
+    var defaultShareKey: string | undefined;
     /**
      * Gets or sets the default iTwin API endpoint.
      */
@@ -12501,19 +12526,19 @@ export class OrthographicFrustum {
 
 /**
  * The viewing frustum is defined by 6 planes.
- * Each plane is represented by a {@link Cartesian4} object, where the x, y, and z components
- * define the unit vector normal to the plane, and the w component is the distance of the
- * plane from the origin/camera position.
+Each plane is represented by a {@link Cartesian4} object, where the x, y, and z components
+define the unit vector normal to the plane, and the w component is the distance of the
+plane from the origin/camera position.
  * @example
  * const maxRadii = ellipsoid.maximumRadius;
- *
- * const frustum = new Cesium.OrthographicOffCenterFrustum();
- * frustum.right = maxRadii * Cesium.Math.PI;
- * frustum.left = -c.frustum.right;
- * frustum.top = c.frustum.right * (canvas.clientHeight / canvas.clientWidth);
- * frustum.bottom = -c.frustum.top;
- * frustum.near = 0.01 * maxRadii;
- * frustum.far = 50.0 * maxRadii;
+
+const frustum = new Cesium.OrthographicOffCenterFrustum();
+frustum.right = maxRadii * Cesium.Math.PI;
+frustum.left = -c.frustum.right;
+frustum.top = c.frustum.right * (canvas.clientHeight / canvas.clientWidth);
+frustum.bottom = -c.frustum.top;
+frustum.near = 0.01 * maxRadii;
+frustum.far = 50.0 * maxRadii;
  * @param [options] - An object with the following properties:
  * @param [options.left] - The left clipping plane distance.
  * @param [options.right] - The right clipping plane distance.
@@ -12563,8 +12588,8 @@ export class OrthographicOffCenterFrustum {
      * Creates a culling volume for this frustum.
      * @example
      * // Check if a bounding volume intersects the frustum.
-     * const cullingVolume = frustum.computeCullingVolume(cameraPosition, cameraDirection, cameraUp);
-     * const intersect = cullingVolume.computeVisibility(boundingVolume);
+    const cullingVolume = frustum.computeCullingVolume(cameraPosition, cameraDirection, cameraUp);
+    const intersect = cullingVolume.computeVisibility(boundingVolume);
      * @param position - The eye position.
      * @param direction - The view direction.
      * @param up - The up direction.
@@ -12575,8 +12600,8 @@ export class OrthographicOffCenterFrustum {
      * Returns the pixel's width and height in meters.
      * @example
      * // Example 1
-     * // Get the width and height of a pixel.
-     * const pixelSize = camera.frustum.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, 0.0, scene.pixelRatio, new Cesium.Cartesian2());
+    // Get the width and height of a pixel.
+    const pixelSize = camera.frustum.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, 0.0, scene.pixelRatio, new Cesium.Cartesian2());
      * @param drawingBufferWidth - The width of the drawing buffer.
      * @param drawingBufferHeight - The height of the drawing buffer.
      * @param distance - The distance to the near plane in meters.
@@ -12593,15 +12618,15 @@ export class OrthographicOffCenterFrustum {
     clone(result?: OrthographicOffCenterFrustum): OrthographicOffCenterFrustum;
     /**
      * Compares the provided OrthographicOffCenterFrustum componentwise and returns
-     * <code>true</code> if they are equal, <code>false</code> otherwise.
+    <code>true</code> if they are equal, <code>false</code> otherwise.
      * @param [other] - The right hand side OrthographicOffCenterFrustum.
      * @returns <code>true</code> if they are equal, <code>false</code> otherwise.
      */
     equals(other?: OrthographicOffCenterFrustum): boolean;
     /**
      * Compares the provided OrthographicOffCenterFrustum componentwise and returns
-     * <code>true</code> if they pass an absolute or relative tolerance test,
-     * <code>false</code> otherwise.
+    <code>true</code> if they pass an absolute or relative tolerance test,
+    <code>false</code> otherwise.
      * @param other - The right hand side OrthographicOffCenterFrustum.
      * @param relativeEpsilon - The relative epsilon tolerance to use for equality testing.
      * @param [absoluteEpsilon = relativeEpsilon] - The absolute epsilon tolerance to use for equality testing.
@@ -14016,7 +14041,7 @@ export class QuantizedMeshTerrainData {
     Uint8Array or image where a value of 255 indicates water and a value of 0 indicates land.
     Values in between 0 and 255 are allowed as well to smoothly blend between land and water.
      */
-    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement;
+    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | undefined;
     /**
      * Upsamples this terrain data for use by a descendant tile.  The resulting instance will contain a subset of the
     vertices in this instance, interpolated if necessary.
@@ -14043,7 +14068,7 @@ export class QuantizedMeshTerrainData {
     interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number;
     /**
      * Determines if a given child tile is available, based on the
-    {@link HeightmapTerrainData.childTileMask}.  The given child tile coordinates are assumed
+    {@link QuantizedMeshTerrainData.childTileMask}.  The given child tile coordinates are assumed
     to be one of the four children of this tile.  If non-child tile coordinates are
     given, the availability of the southeast child tile is returned.
      * @param thisX - The tile X coordinate of this (the parent) tile.
@@ -16219,7 +16244,7 @@ export namespace ScreenSpaceEventHandler {
 
 /**
  * Handles user input events. Custom functions can be added to be executed on
- * when the user enters input.
+when the user enters input.
  * @param [element = document] - The element to add events to.
  */
 export class ScreenSpaceEventHandler {
@@ -16229,14 +16254,14 @@ export class ScreenSpaceEventHandler {
      * @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>
-     * event occurs.
+    event occurs.
      */
     setInputAction(action: ScreenSpaceEventHandler.PositionedEventCallback | ScreenSpaceEventHandler.MotionEventCallback | ScreenSpaceEventHandler.WheelEventCallback | ScreenSpaceEventHandler.TwoPointEventCallback | ScreenSpaceEventHandler.TwoPointMotionEventCallback, type: ScreenSpaceEventType, modifier?: KeyboardEventModifier): void;
     /**
      * Returns the function to be executed on an input event.
      * @param type - The ScreenSpaceEventType of input event.
      * @param [modifier] - A KeyboardEventModifier key that is held when a <code>type</code>
-     * event occurs.
+    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;
@@ -16244,35 +16269,35 @@ export class ScreenSpaceEventHandler {
      * 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>
-     * event occurs.
+    event occurs.
      */
     removeInputAction(type: ScreenSpaceEventType, modifier?: KeyboardEventModifier): void;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-     * <br /><br />
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+    <br /><br />
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
      * @returns <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
      */
     isDestroyed(): boolean;
     /**
      * Removes listeners held by this object.
-     * <br /><br />
-     * Once an object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
+    <br /><br />
+    Once an object is destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+    assign the return value (<code>undefined</code>) to the object as done in the example.
      * @example
      * handler = handler && handler.destroy();
      */
     destroy(): void;
     /**
      * The amount of time, in milliseconds, that mouse events will be disabled after
-     * receiving any touch events, such that any emulated mouse events will be ignored.
+    receiving any touch events, such that any emulated mouse events will be ignored.
      */
     static mouseEmulationIgnoreMilliseconds: number;
     /**
      * The amount of time, in milliseconds, before a touch on the screen becomes a
-     * touch and hold.
+    touch and hold.
      */
     static touchHoldDelayMilliseconds: number;
 }
@@ -16871,7 +16896,7 @@ export class TerrainData {
     Uint8Array or image where a value of 255 indicates water and a value of 0 indicates land.
     Values in between 0 and 255 are allowed as well to smoothly blend between land and water.
      */
-    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement;
+    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | undefined;
     /**
      * Computes the terrain height at a specified longitude and latitude.
      * @param rectangle - The rectangle covered by this terrain data.
@@ -16963,7 +16988,7 @@ export class TerrainProvider {
     at points and in rectangles. This property may be undefined if availability
     information is not available.
      */
-    readonly availability: TileAvailability;
+    readonly availability: TileAvailability | undefined;
     /**
      * Gets a list of indices for a triangle mesh representing a regular grid.  Calling
     this function multiple times with the same grid width and height returns the
@@ -18351,7 +18376,7 @@ export class VRTheWorldTerrainProvider {
     at points and in rectangles. This property may be undefined if availability
     information is not available.
      */
-    readonly availability: TileAvailability;
+    readonly availability: TileAvailability | undefined;
     /**
      * Creates a {@link TerrainProvider} that produces terrain geometry by tessellating height maps
     retrieved from a {@link http://vr-theworld.com/|VT MÄK VR-TheWorld server}.
@@ -21880,10 +21905,10 @@ export class GeometryVisualizer {
     constructor(scene: Scene, entityCollection: EntityCollection, primitives?: PrimitiveCollection, groundPrimitives?: PrimitiveCollection);
     /**
      * Updates all of the primitives created by this visualizer to match their
-     * Entity counterpart at the given time.
+    Entity counterpart at the given time.
      * @param time - The time to update to.
      * @returns True if the visualizer successfully updated to the provided time,
-     * false if the visualizer is waiting for asynchronous primitives to be created.
+    false if the visualizer is waiting for asynchronous primitives to be created.
      */
     update(time: JulianDate): boolean;
     /**
@@ -24099,10 +24124,10 @@ export class PolylineVisualizer {
     constructor(scene: Scene, entityCollection: EntityCollection, primitives?: PrimitiveCollection, groundPrimitives?: PrimitiveCollection);
     /**
      * Updates all of the primitives created by this visualizer to match their
-     * Entity counterpart at the given time.
+    Entity counterpart at the given time.
      * @param time - The time to update to.
      * @returns True if the visualizer successfully updated to the provided time,
-     * false if the visualizer is waiting for asynchronous primitives to be created.
+    false if the visualizer is waiting for asynchronous primitives to be created.
      */
     update(time: JulianDate): boolean;
     /**
@@ -26386,11 +26411,11 @@ export class Billboard {
     /**
      * Gets or sets a width for the billboard. If undefined, the image width will be used.
      */
-    width: number;
+    width: number | undefined;
     /**
      * Gets or sets a height for the billboard. If undefined, the image height will be used.
      */
-    height: number;
+    height: number | undefined;
     /**
      * Gets or sets if the billboard size is in meters or pixels. <code>true</code> to size the billboard in meters;
     otherwise, the size is in pixels.
@@ -26593,7 +26618,7 @@ export class BillboardCollection {
     {@link BillboardCollection#get} to iterate over all the billboards
     in the collection.
      */
-    length: number;
+    readonly length: number;
     /**
      * Creates and adds a billboard with the specified initial properties to the collection.
     The added billboard is returned so it can be modified or removed from the collection later.
@@ -27107,23 +27132,23 @@ export type HeadingPitchRollValues = {
 
 /**
  * The camera is defined by a position, orientation, and view frustum.
- * <br /><br />
- * The orientation forms an orthonormal basis with a view, up and right = view x up unit vectors.
- * <br /><br />
- * The viewing frustum is defined by 6 planes.
- * Each plane is represented by a {@link Cartesian4} object, where the x, y, and z components
- * define the unit vector normal to the plane, and the w component is the distance of the
- * plane from the origin/camera position.
+<br /><br />
+The orientation forms an orthonormal basis with a view, up and right = view x up unit vectors.
+<br /><br />
+The viewing frustum is defined by 6 planes.
+Each plane is represented by a {@link Cartesian4} object, where the x, y, and z components
+define the unit vector normal to the plane, and the w component is the distance of the
+plane from the origin/camera position.
  * @example
  * // Create a camera looking down the negative z-axis, positioned at the origin,
- * // with a field of view of 60 degrees, and 1:1 aspect ratio.
- * const camera = new Cesium.Camera(scene);
- * camera.position = new Cesium.Cartesian3();
- * camera.direction = Cesium.Cartesian3.negate(Cesium.Cartesian3.UNIT_Z, new Cesium.Cartesian3());
- * camera.up = Cesium.Cartesian3.clone(Cesium.Cartesian3.UNIT_Y);
- * camera.frustum.fov = Cesium.Math.PI_OVER_THREE;
- * camera.frustum.near = 1.0;
- * camera.frustum.far = 2.0;
+// with a field of view of 60 degrees, and 1:1 aspect ratio.
+const camera = new Cesium.Camera(scene);
+camera.position = new Cesium.Cartesian3();
+camera.direction = Cesium.Cartesian3.negate(Cesium.Cartesian3.UNIT_Z, new Cesium.Cartesian3());
+camera.up = Cesium.Cartesian3.clone(Cesium.Cartesian3.UNIT_Y);
+camera.frustum.fov = Cesium.Math.PI_OVER_THREE;
+camera.frustum.near = 1.0;
+camera.frustum.far = 2.0;
  * @param scene - The scene.
  */
 export class Camera {
@@ -27150,22 +27175,22 @@ export class Camera {
     frustum: PerspectiveFrustum | PerspectiveOffCenterFrustum | OrthographicFrustum;
     /**
      * The default amount to move the camera when an argument is not
-     * provided to the move methods.
+    provided to the move methods.
      */
     defaultMoveAmount: number;
     /**
      * The default amount to rotate the camera when an argument is not
-     * provided to the look methods.
+    provided to the look methods.
      */
     defaultLookAmount: number;
     /**
      * The default amount to rotate the camera when an argument is not
-     * provided to the rotate methods.
+    provided to the rotate methods.
      */
     defaultRotateAmount: number;
     /**
      * The default amount to move the camera when an argument is not
-     * provided to the zoom methods.
+    provided to the zoom methods.
      */
     defaultZoomAmount: number;
     /**
@@ -27174,7 +27199,7 @@ export class Camera {
     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.
+    when zooming out from the surface. The default is 1.5. Only valid for 2D and the map is rotatable.
      */
     maximumZoomFactor: number;
     /**
@@ -27187,8 +27212,8 @@ export class Camera {
     static DEFAULT_VIEW_RECTANGLE: Rectangle;
     /**
      * A scalar to multiply to the camera position and add it back after setting the camera to view the rectangle.
-     * A value of zero means the camera will view the entire {@link Camera#DEFAULT_VIEW_RECTANGLE}, a value greater than zero
-     * will move it further away from the extent, and a value less than zero will move it close to the extent.
+    A value of zero means the camera will view the entire {@link Camera#DEFAULT_VIEW_RECTANGLE}, a value greater than zero
+    will move it further away from the extent, and a value less than zero will move it close to the extent.
      */
     static DEFAULT_VIEW_FACTOR: number;
     /**
@@ -27213,9 +27238,9 @@ export class Camera {
     readonly inverseViewMatrix: Matrix4;
     /**
      * Gets the {@link Cartographic} position of the camera, with longitude and latitude
-     * expressed in radians and height in meters.  In 2D and Columbus View, it is possible
-     * for the returned longitude and latitude to be outside the range of valid longitudes
-     * and latitudes when the camera is outside the map.
+    expressed in radians and height in meters.  In 2D and Columbus View, it is possible
+    for the returned longitude and latitude to be outside the range of valid longitudes
+    and latitudes when the camera is outside the map.
      */
     readonly positionCartographic: Cartographic;
     /**
@@ -27262,48 +27287,48 @@ export class Camera {
      * Sets the camera position, orientation and transform.
      * @example
      * // 1. Set position with a top-down view
-     * viewer.camera.setView({
-     *     destination : Cesium.Cartesian3.fromDegrees(-117.16, 32.71, 15000.0)
-     * });
-     *
-     * // 2 Set view with heading, pitch and roll
-     * viewer.camera.setView({
-     *     destination : cartesianPosition,
-     *     orientation: {
-     *         heading : Cesium.Math.toRadians(90.0), // east, default value is 0.0 (north)
-     *         pitch : Cesium.Math.toRadians(-90),    // default value (looking down)
-     *         roll : 0.0                             // default value
-     *     }
-     * });
-     *
-     * // 3. Change heading, pitch and roll with the camera position remaining the same.
-     * viewer.camera.setView({
-     *     orientation: {
-     *         heading : Cesium.Math.toRadians(90.0), // east, default value is 0.0 (north)
-     *         pitch : Cesium.Math.toRadians(-90),    // default value (looking down)
-     *         roll : 0.0                             // default value
-     *     }
-     * });
-     *
-     *
-     * // 4. View rectangle with a top-down view
-     * viewer.camera.setView({
-     *     destination : Cesium.Rectangle.fromDegrees(west, south, east, north)
-     * });
-     *
-     * // 5. Set position with an orientation using unit vectors.
-     * viewer.camera.setView({
-     *     destination : Cesium.Cartesian3.fromDegrees(-122.19, 46.25, 5000.0),
-     *     orientation : {
-     *         direction : new Cesium.Cartesian3(-0.04231243104240401, -0.20123236049443421, -0.97862924300734),
-     *         up : new Cesium.Cartesian3(-0.47934589305293746, -0.8553216253114552, 0.1966022179118339)
-     *     }
-     * });
+    viewer.camera.setView({
+        destination : Cesium.Cartesian3.fromDegrees(-117.16, 32.71, 15000.0)
+    });
+    
+    // 2 Set view with heading, pitch and roll
+    viewer.camera.setView({
+        destination : cartesianPosition,
+        orientation: {
+            heading : Cesium.Math.toRadians(90.0), // east, default value is 0.0 (north)
+            pitch : Cesium.Math.toRadians(-90),    // default value (looking down)
+            roll : 0.0                             // default value
+        }
+    });
+    
+    // 3. Change heading, pitch and roll with the camera position remaining the same.
+    viewer.camera.setView({
+        orientation: {
+            heading : Cesium.Math.toRadians(90.0), // east, default value is 0.0 (north)
+            pitch : Cesium.Math.toRadians(-90),    // default value (looking down)
+            roll : 0.0                             // default value
+        }
+    });
+    
+    
+    // 4. View rectangle with a top-down view
+    viewer.camera.setView({
+        destination : Cesium.Rectangle.fromDegrees(west, south, east, north)
+    });
+    
+    // 5. Set position with an orientation using unit vectors.
+    viewer.camera.setView({
+        destination : Cesium.Cartesian3.fromDegrees(-122.19, 46.25, 5000.0),
+        orientation : {
+            direction : new Cesium.Cartesian3(-0.04231243104240401, -0.20123236049443421, -0.97862924300734),
+            up : new Cesium.Cartesian3(-0.47934589305293746, -0.8553216253114552, 0.1966022179118339)
+        }
+    });
      * @param options - Object with the following properties:
      * @param [options.destination] - The final position of the camera in world coordinates or a rectangle that would be visible from a top-down view.
      * @param [options.orientation] - An object that contains either direction and up properties or heading, pitch and roll properties. By default, the direction will point
-     * towards the center of the frame in 3D and in the negative z direction in Columbus view. The up direction will point towards local north in 3D and in the positive
-     * y direction in Columbus view. Orientation is not used in 2D when in infinite scrolling mode.
+    towards the center of the frame in 3D and in the negative z direction in Columbus view. The up direction will point towards local north in 3D and in the positive
+    y direction in Columbus view. Orientation is not used in 2D when in infinite scrolling mode.
      * @param [options.endTransform] - Transform matrix representing the reference frame of the camera.
      * @param [options.convert] - Whether to convert the destination from world coordinates to scene coordinates (only relevant when not using 3D). Defaults to <code>true</code>.
      */
@@ -27315,8 +27340,8 @@ export class Camera {
     }): void;
     /**
      * Fly the camera to the home view.  Use {@link Camera#.DEFAULT_VIEW_RECTANGLE} to set
-     * the default view for the 3D scene.  The home view for 2D and columbus view shows the
-     * entire map.
+    the default view for the 3D scene.  The home view for 2D and columbus view shows the
+    entire map.
      * @param [duration] - The duration of the flight in seconds. If omitted, Cesium attempts to calculate an ideal duration based on the distance to be traveled by the flight. See {@link Camera#flyTo}
      */
     flyHome(duration?: number): void;
@@ -27370,14 +27395,14 @@ export class Camera {
     move(direction: Cartesian3, amount?: number): void;
     /**
      * Translates the camera's position by <code>amount</code> along the camera's view vector.
-     * When in 2D mode, this will zoom in the camera instead of translating the camera's position.
+    When in 2D mode, this will zoom in the camera instead of translating the camera's position.
      * @param [amount] - The amount, in meters, to move. Defaults to <code>defaultMoveAmount</code>.
      */
     moveForward(amount?: number): void;
     /**
      * Translates the camera's position by <code>amount</code> along the opposite direction
-     * of the camera's view vector.
-     * When in 2D mode, this will zoom out the camera instead of translating the camera's position.
+    of the camera's view vector.
+    When in 2D mode, this will zoom out the camera instead of translating the camera's position.
      * @param [amount] - The amount, in meters, to move. Defaults to <code>defaultMoveAmount</code>.
      */
     moveBackward(amount?: number): void;
@@ -27388,7 +27413,7 @@ export class Camera {
     moveUp(amount?: number): void;
     /**
      * Translates the camera's position by <code>amount</code> along the opposite direction
-     * of the camera's up vector.
+    of the camera's up vector.
      * @param [amount] - The amount, in meters, to move. Defaults to <code>defaultMoveAmount</code>.
      */
     moveDown(amount?: number): void;
@@ -27399,31 +27424,31 @@ export class Camera {
     moveRight(amount?: number): void;
     /**
      * Translates the camera's position by <code>amount</code> along the opposite direction
-     * of the camera's right vector.
+    of the camera's right vector.
      * @param [amount] - The amount, in meters, to move. Defaults to <code>defaultMoveAmount</code>.
      */
     moveLeft(amount?: number): void;
     /**
      * Rotates the camera around its up vector by amount, in radians, in the opposite direction
-     * of its right vector if not in 2D mode.
+    of its right vector if not in 2D mode.
      * @param [amount] - The amount, in radians, to rotate by. Defaults to <code>defaultLookAmount</code>.
      */
     lookLeft(amount?: number): void;
     /**
      * Rotates the camera around its up vector by amount, in radians, in the direction
-     * of its right vector if not in 2D mode.
+    of its right vector if not in 2D mode.
      * @param [amount] - The amount, in radians, to rotate by. Defaults to <code>defaultLookAmount</code>.
      */
     lookRight(amount?: number): void;
     /**
      * Rotates the camera around its right vector by amount, in radians, in the direction
-     * of its up vector if not in 2D mode.
+    of its up vector if not in 2D mode.
      * @param [amount] - The amount, in radians, to rotate by. Defaults to <code>defaultLookAmount</code>.
      */
     lookUp(amount?: number): void;
     /**
      * Rotates the camera around its right vector by amount, in radians, in the opposite direction
-     * of its up vector if not in 2D mode.
+    of its up vector if not in 2D mode.
      * @param [amount] - The amount, in radians, to rotate by. Defaults to <code>defaultLookAmount</code>.
      */
     lookDown(amount?: number): void;
@@ -27445,7 +27470,7 @@ export class Camera {
     twistRight(amount?: number): void;
     /**
      * Rotates the camera around <code>axis</code> by <code>angle</code>. The distance
-     * of the camera's position to the center of the camera's reference frame remains the same.
+    of the camera's position to the center of the camera's reference frame remains the same.
      * @param axis - The axis to rotate around given in world coordinates.
      * @param [angle] - The angle, in radians, to rotate by. Defaults to <code>defaultRotateAmount</code>.
      */
@@ -27477,63 +27502,63 @@ export class Camera {
     zoomIn(amount?: number): void;
     /**
      * Zooms <code>amount</code> along the opposite direction of
-     * the camera's view vector.
+    the camera's view vector.
      * @param [amount] - The amount to move. Defaults to <code>defaultZoomAmount</code>.
      */
     zoomOut(amount?: number): void;
     /**
      * Gets the magnitude of the camera position. In 3D, this is the vector magnitude. In 2D and
-     * Columbus view, this is the distance to the map.
+    Columbus view, this is the distance to the map.
      * @returns The magnitude of the position.
      */
     getMagnitude(): number;
     /**
      * Sets the camera position and orientation using a target and offset. The target must be given in
-     * world coordinates. The offset can be either a cartesian or heading/pitch/range in the local east-north-up reference frame centered at the target.
-     * If the offset is a cartesian, then it is an offset from the center of the reference frame defined by the transformation matrix. If the offset
-     * is heading/pitch/range, then the heading and the pitch angles are defined in the reference frame defined by the transformation matrix.
-     * The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
-     * angles are below the plane. Negative pitch angles are above the plane. The range is the distance from the center.
-     *
-     * In 2D, there must be a top down view. The camera will be placed above the target looking down. The height above the
-     * target will be the magnitude of the offset. The heading will be determined from the offset. If the heading cannot be
-     * determined from the offset, the heading will be north.
+    world coordinates. The offset can be either a cartesian or heading/pitch/range in the local east-north-up reference frame centered at the target.
+    If the offset is a cartesian, then it is an offset from the center of the reference frame defined by the transformation matrix. If the offset
+    is heading/pitch/range, then the heading and the pitch angles are defined in the reference frame defined by the transformation matrix.
+    The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
+    angles are below the plane. Negative pitch angles are above the plane. The range is the distance from the center.
+    
+    In 2D, there must be a top down view. The camera will be placed above the target looking down. The height above the
+    target will be the magnitude of the offset. The heading will be determined from the offset. If the heading cannot be
+    determined from the offset, the heading will be north.
      * @example
      * // 1. Using a cartesian offset
-     * const center = Cesium.Cartesian3.fromDegrees(-98.0, 40.0);
-     * viewer.camera.lookAt(center, new Cesium.Cartesian3(0.0, -4790000.0, 3930000.0));
-     *
-     * // 2. Using a HeadingPitchRange offset
-     * const center = Cesium.Cartesian3.fromDegrees(-72.0, 40.0);
-     * const heading = Cesium.Math.toRadians(50.0);
-     * const pitch = Cesium.Math.toRadians(-20.0);
-     * const range = 5000.0;
-     * viewer.camera.lookAt(center, new Cesium.HeadingPitchRange(heading, pitch, range));
+    const center = Cesium.Cartesian3.fromDegrees(-98.0, 40.0);
+    viewer.camera.lookAt(center, new Cesium.Cartesian3(0.0, -4790000.0, 3930000.0));
+    
+    // 2. Using a HeadingPitchRange offset
+    const center = Cesium.Cartesian3.fromDegrees(-72.0, 40.0);
+    const heading = Cesium.Math.toRadians(50.0);
+    const pitch = Cesium.Math.toRadians(-20.0);
+    const range = 5000.0;
+    viewer.camera.lookAt(center, new Cesium.HeadingPitchRange(heading, pitch, range));
      * @param target - The target position in world coordinates.
      * @param offset - The offset from the target in the local east-north-up reference frame centered at the target.
      */
     lookAt(target: Cartesian3, offset: Cartesian3 | HeadingPitchRange): void;
     /**
      * Sets the camera position and orientation using a target and transformation matrix. The offset can be either a cartesian or heading/pitch/range.
-     * If the offset is a cartesian, then it is an offset from the center of the reference frame defined by the transformation matrix. If the offset
-     * is heading/pitch/range, then the heading and the pitch angles are defined in the reference frame defined by the transformation matrix.
-     * The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
-     * angles are below the plane. Negative pitch angles are above the plane. The range is the distance from the center.
-     *
-     * In 2D, there must be a top down view. The camera will be placed above the center of the reference frame. The height above the
-     * target will be the magnitude of the offset. The heading will be determined from the offset. If the heading cannot be
-     * determined from the offset, the heading will be north.
+    If the offset is a cartesian, then it is an offset from the center of the reference frame defined by the transformation matrix. If the offset
+    is heading/pitch/range, then the heading and the pitch angles are defined in the reference frame defined by the transformation matrix.
+    The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
+    angles are below the plane. Negative pitch angles are above the plane. The range is the distance from the center.
+    
+    In 2D, there must be a top down view. The camera will be placed above the center of the reference frame. The height above the
+    target will be the magnitude of the offset. The heading will be determined from the offset. If the heading cannot be
+    determined from the offset, the heading will be north.
      * @example
      * // 1. Using a cartesian offset
-     * const transform = Cesium.Transforms.eastNorthUpToFixedFrame(Cesium.Cartesian3.fromDegrees(-98.0, 40.0));
-     * viewer.camera.lookAtTransform(transform, new Cesium.Cartesian3(0.0, -4790000.0, 3930000.0));
-     *
-     * // 2. Using a HeadingPitchRange offset
-     * const transform = Cesium.Transforms.eastNorthUpToFixedFrame(Cesium.Cartesian3.fromDegrees(-72.0, 40.0));
-     * const heading = Cesium.Math.toRadians(50.0);
-     * const pitch = Cesium.Math.toRadians(-20.0);
-     * const range = 5000.0;
-     * viewer.camera.lookAtTransform(transform, new Cesium.HeadingPitchRange(heading, pitch, range));
+    const transform = Cesium.Transforms.eastNorthUpToFixedFrame(Cesium.Cartesian3.fromDegrees(-98.0, 40.0));
+    viewer.camera.lookAtTransform(transform, new Cesium.Cartesian3(0.0, -4790000.0, 3930000.0));
+    
+    // 2. Using a HeadingPitchRange offset
+    const transform = Cesium.Transforms.eastNorthUpToFixedFrame(Cesium.Cartesian3.fromDegrees(-72.0, 40.0));
+    const heading = Cesium.Math.toRadians(50.0);
+    const pitch = Cesium.Math.toRadians(-20.0);
+    const range = 5000.0;
+    viewer.camera.lookAtTransform(transform, new Cesium.HeadingPitchRange(heading, pitch, range));
      * @param transform - The transformation matrix defining the reference frame.
      * @param [offset] - The offset from the target in a reference frame centered at the target.
      */
@@ -27549,20 +27574,20 @@ export class Camera {
      * Pick an ellipsoid or map.
      * @example
      * const canvas = viewer.scene.canvas;
-     * const center = new Cesium.Cartesian2(canvas.clientWidth / 2.0, canvas.clientHeight / 2.0);
-     * const ellipsoid = viewer.scene.ellipsoid;
-     * const result = viewer.camera.pickEllipsoid(center, ellipsoid);
+    const center = new Cesium.Cartesian2(canvas.clientWidth / 2.0, canvas.clientHeight / 2.0);
+    const ellipsoid = viewer.scene.ellipsoid;
+    const result = viewer.camera.pickEllipsoid(center, ellipsoid);
      * @param windowPosition - The x and y coordinates of a pixel.
      * @param [ellipsoid = Ellipsoid.default] - The ellipsoid to pick.
      * @param [result] - The object onto which to store the result.
      * @returns If the ellipsoid or map was picked,
-     * returns the point on the surface of the ellipsoid or map in world
-     * coordinates. If the ellipsoid or map was not picked, returns undefined.
+    returns the point on the surface of the ellipsoid or map in world
+    coordinates. If the ellipsoid or map was not picked, returns undefined.
      */
     pickEllipsoid(windowPosition: Cartesian2, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3 | undefined;
     /**
      * Create a ray from the camera position through the pixel at <code>windowPosition</code>
-     * in world coordinates.
+    in world coordinates.
      * @param windowPosition - The x and y coordinates of a pixel.
      * @param [result] - The object onto which to store the result.
      * @returns Returns the {@link Cartesian3} position and direction of the ray, or undefined if the pick ray cannot be determined.
@@ -27584,50 +27609,50 @@ export class Camera {
     getPixelSize(boundingSphere: BoundingSphere, drawingBufferWidth: number, drawingBufferHeight: number): number;
     /**
      * Cancels the current camera flight and leaves the camera at its current location.
-     * If no flight is in progress, this function does nothing.
+    If no flight is in progress, this function does nothing.
      */
     cancelFlight(): void;
     /**
      * Completes the current camera flight and moves the camera immediately to its final destination.
-     * If no flight is in progress, this function does nothing.
+    If no flight is in progress, this function does nothing.
      */
     completeFlight(): void;
     /**
      * Flies the camera from its current position to a new position.
      * @example
      * // 1. Fly to a position with a top-down view
-     * viewer.camera.flyTo({
-     *     destination : Cesium.Cartesian3.fromDegrees(-117.16, 32.71, 15000.0)
-     * });
-     *
-     * // 2. Fly to a Rectangle with a top-down view
-     * viewer.camera.flyTo({
-     *     destination : Cesium.Rectangle.fromDegrees(west, south, east, north)
-     * });
-     *
-     * // 3. Fly to a position with an orientation using unit vectors.
-     * viewer.camera.flyTo({
-     *     destination : Cesium.Cartesian3.fromDegrees(-122.19, 46.25, 5000.0),
-     *     orientation : {
-     *         direction : new Cesium.Cartesian3(-0.04231243104240401, -0.20123236049443421, -0.97862924300734),
-     *         up : new Cesium.Cartesian3(-0.47934589305293746, -0.8553216253114552, 0.1966022179118339)
-     *     }
-     * });
-     *
-     * // 4. Fly to a position with an orientation using heading, pitch and roll.
-     * viewer.camera.flyTo({
-     *     destination : Cesium.Cartesian3.fromDegrees(-122.19, 46.25, 5000.0),
-     *     orientation : {
-     *         heading : Cesium.Math.toRadians(175.0),
-     *         pitch : Cesium.Math.toRadians(-35.0),
-     *         roll : 0.0
-     *     }
-     * });
+    viewer.camera.flyTo({
+        destination : Cesium.Cartesian3.fromDegrees(-117.16, 32.71, 15000.0)
+    });
+    
+    // 2. Fly to a Rectangle with a top-down view
+    viewer.camera.flyTo({
+        destination : Cesium.Rectangle.fromDegrees(west, south, east, north)
+    });
+    
+    // 3. Fly to a position with an orientation using unit vectors.
+    viewer.camera.flyTo({
+        destination : Cesium.Cartesian3.fromDegrees(-122.19, 46.25, 5000.0),
+        orientation : {
+            direction : new Cesium.Cartesian3(-0.04231243104240401, -0.20123236049443421, -0.97862924300734),
+            up : new Cesium.Cartesian3(-0.47934589305293746, -0.8553216253114552, 0.1966022179118339)
+        }
+    });
+    
+    // 4. Fly to a position with an orientation using heading, pitch and roll.
+    viewer.camera.flyTo({
+        destination : Cesium.Cartesian3.fromDegrees(-122.19, 46.25, 5000.0),
+        orientation : {
+            heading : Cesium.Math.toRadians(175.0),
+            pitch : Cesium.Math.toRadians(-35.0),
+            roll : 0.0
+        }
+    });
      * @param options - Object with the following properties:
      * @param options.destination - The final position of the camera in world coordinates or a rectangle that would be visible from a top-down view.
      * @param [options.orientation] - An object that contains either direction and up properties or heading, pitch and roll properties. By default, the direction will point
-     * towards the center of the frame in 3D and in the negative z direction in Columbus view. The up direction will point towards local north in 3D and in the positive
-     * y direction in Columbus view.  Orientation is not used in 2D when in infinite scrolling mode.
+    towards the center of the frame in 3D and in the negative z direction in Columbus view. The up direction will point towards local north in 3D and in the positive
+    y direction in Columbus view.  Orientation is not used in 2D when in infinite scrolling mode.
      * @param [options.duration] - The duration of the flight in seconds. If omitted, Cesium attempts to calculate an ideal duration based on the distance to be traveled by the flight.
      * @param [options.complete] - The function to execute when the flight is complete.
      * @param [options.cancel] - The function to execute if the flight is cancelled.
@@ -27655,31 +27680,31 @@ export class Camera {
     }): void;
     /**
      * Sets the camera so that the current view contains the provided bounding sphere.
-     *
-     * <p>The offset is heading/pitch/range in the local east-north-up reference frame centered at the center of the bounding sphere.
-     * The heading and the pitch angles are defined in the local east-north-up reference frame.
-     * The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
-     * angles are below the plane. Negative pitch angles are above the plane. The range is the distance from the center. If the range is
-     * zero, a range will be computed such that the whole bounding sphere is visible.</p>
-     *
-     * <p>In 2D, there must be a top down view. The camera will be placed above the target looking down. The height above the
-     * target will be the range. The heading will be determined from the offset. If the heading cannot be
-     * determined from the offset, the heading will be north.</p>
+    
+    <p>The offset is heading/pitch/range in the local east-north-up reference frame centered at the center of the bounding sphere.
+    The heading and the pitch angles are defined in the local east-north-up reference frame.
+    The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
+    angles are below the plane. Negative pitch angles are above the plane. The range is the distance from the center. If the range is
+    zero, a range will be computed such that the whole bounding sphere is visible.</p>
+    
+    <p>In 2D, there must be a top down view. The camera will be placed above the target looking down. The height above the
+    target will be the range. The heading will be determined from the offset. If the heading cannot be
+    determined from the offset, the heading will be north.</p>
      * @param boundingSphere - The bounding sphere to view, in world coordinates.
      * @param [offset] - The offset from the target in the local east-north-up reference frame centered at the target.
      */
     viewBoundingSphere(boundingSphere: BoundingSphere, offset?: HeadingPitchRange): void;
     /**
      * Flies the camera to a location where the current view contains the provided bounding sphere.
-     *
-     * <p> The offset is heading/pitch/range in the local east-north-up reference frame centered at the center of the bounding sphere.
-     * The heading and the pitch angles are defined in the local east-north-up reference frame.
-     * The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
-     * angles are below the plane. Negative pitch angles are above the plane. The range is the distance from the center. If the range is
-     * zero, a range will be computed such that the whole bounding sphere is visible.</p>
-     *
-     * <p>In 2D and Columbus View, there must be a top down view. The camera will be placed above the target looking down. The height above the
-     * target will be the range. The heading will be aligned to local north.</p>
+    
+    <p> The offset is heading/pitch/range in the local east-north-up reference frame centered at the center of the bounding sphere.
+    The heading and the pitch angles are defined in the local east-north-up reference frame.
+    The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
+    angles are below the plane. Negative pitch angles are above the plane. The range is the distance from the center. If the range is
+    zero, a range will be computed such that the whole bounding sphere is visible.</p>
+    
+    <p>In 2D and Columbus View, there must be a top down view. The camera will be placed above the target looking down. The height above the
+    target will be the range. The heading will be aligned to local north.</p>
      * @param boundingSphere - The bounding sphere to view, in world coordinates.
      * @param [options] - Object with the following properties:
      * @param [options.duration] - The duration of the flight in seconds. If omitted, Cesium attempts to calculate an ideal duration based on the distance to be traveled by the flight.
@@ -27714,14 +27739,14 @@ export class Camera {
     computeViewRectangle(ellipsoid?: Ellipsoid, result?: Rectangle): Rectangle | undefined;
     /**
      * Switches the frustum/projection to perspective.
-     *
-     * This function is a no-op in 2D which must always be orthographic.
+    
+    This function is a no-op in 2D which must always be orthographic.
      */
     switchToPerspectiveFrustum(): void;
     /**
      * Switches the frustum/projection to orthographic.
-     *
-     * This function is a no-op in 2D which will always be orthographic.
+    
+    This function is a no-op in 2D which will always be orthographic.
      */
     switchToOrthographicFrustum(): void;
 }
@@ -30114,6 +30139,44 @@ export class Cesium3DTileStyle {
     meta: StyleExpression;
 }
 
+export namespace Cesium3DTilesVoxelProvider {
+    /**
+     * Initialization options for the Cesium3DTilesVoxelProvider constructor
+     * @property className - The class in the tileset schema describing voxel metadata.
+     * @property names - The metadata names.
+     * @property types - The metadata types.
+     * @property componentTypes - The metadata component types.
+     * @property shape - The {@link VoxelShapeType}.
+     * @property dimensions - The number of voxels per dimension of a tile. This is the same for all tiles in the dataset.
+     * @property [paddingBefore = Cartesian3.ZERO] - The number of padding voxels before the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
+     * @property [paddingAfter = Cartesian3.ZERO] - The number of padding voxels after the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
+     * @property [globalTransform = Matrix4.IDENTITY] - A transform from local space to global space.
+     * @property [shapeTransform = Matrix4.IDENTITY] - A transform from shape space to local space.
+     * @property [minBounds] - The minimum bounds.
+     * @property [maxBounds] - The maximum bounds.
+     * @property [minimumValues] - The metadata minimum values.
+     * @property [maximumValues] - The metadata maximum values.
+     * @property [maximumTileCount] - The maximum number of tiles that exist for this provider. This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory. If this value is not known it can be undefined.
+     */
+    type ConstructorOptions = {
+        className: string;
+        names: string[];
+        types: MetadataType[];
+        componentTypes: MetadataComponentType[];
+        shape: VoxelShapeType;
+        dimensions: Cartesian3;
+        paddingBefore?: Cartesian3;
+        paddingAfter?: Cartesian3;
+        globalTransform?: Matrix4;
+        shapeTransform?: Matrix4;
+        minBounds?: Cartesian3;
+        maxBounds?: Cartesian3;
+        minimumValues?: number[][];
+        maximumValues?: number[][];
+        maximumTileCount?: number;
+    };
+}
+
 /**
  * A {@link VoxelProvider} that fetches voxel data from a 3D Tiles tileset.
 <p>
@@ -30122,102 +30185,112 @@ Implements the {@link VoxelProvider} interface.
 <div class="notice">
 This object is normally not instantiated directly, use {@link Cesium3DTilesVoxelProvider.fromUrl}.
 </div>
- * @param options - Object with the following properties:
+ * @param options - An object describing initialization options
  */
 export class Cesium3DTilesVoxelProvider extends VoxelProvider {
-    constructor(options: any);
-    /**
-     * Creates a {@link VoxelProvider} that fetches voxel data from a 3D Tiles tileset.
-     * @param url - The URL to a tileset JSON file
-     * @returns The created provider
-     */
-    static fromUrl(url: Resource | string): Promise<Cesium3DTilesVoxelProvider>;
+    constructor(options: Cesium3DTilesVoxelProvider.ConstructorOptions);
     /**
-     * A transform from local space to global space. If undefined, the identity matrix will be used instead.
+     * A transform from local space to global space.
      */
-    readonly globalTransform: Matrix4 | undefined;
+    readonly globalTransform: Matrix4;
     /**
-     * A transform from shape space to local space. If undefined, the identity matrix will be used instead.
+     * A transform from shape space to local space.
      */
-    readonly shapeTransform: Matrix4 | undefined;
+    readonly shapeTransform: Matrix4;
     /**
      * Gets the {@link VoxelShapeType}
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly shape: VoxelShapeType;
     /**
      * Gets the minimum bounds.
     If undefined, the shape's default minimum bounds will be used instead.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly minBounds: Cartesian3 | undefined;
     /**
      * Gets the maximum bounds.
     If undefined, the shape's default maximum bounds will be used instead.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maxBounds: Cartesian3 | undefined;
     /**
      * Gets the number of voxels per dimension of a tile. This is the same for all tiles in the dataset.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly dimensions: Cartesian3;
     /**
      * Gets the number of padding voxels before the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
-    readonly paddingBefore: Cartesian3 | undefined;
+    readonly paddingBefore: Cartesian3;
     /**
      * Gets the number of padding voxels after the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
-    readonly paddingAfter: Cartesian3 | undefined;
+    readonly paddingAfter: Cartesian3;
+    /**
+     * The metadata class for this tileset.
+     */
+    readonly className: string;
     /**
      * Gets the metadata names.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly names: string[];
     /**
      * Gets the metadata types.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly types: MetadataType[];
     /**
      * Gets the metadata component types.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly componentTypes: MetadataComponentType[];
     /**
      * Gets the metadata minimum values.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly minimumValues: number[][] | undefined;
     /**
      * Gets the metadata maximum values.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maximumValues: number[][] | undefined;
     /**
-     * The maximum number of tiles that exist for this provider. This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory. If this value is not known it can be undefined.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * The maximum number of tiles that exist for this provider.
+    This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory.
+    If this value is not known it can be undefined.
      */
     readonly maximumTileCount: number | undefined;
     /**
-     * Requests the data for a given tile. The data is a flattened 3D array ordered by X, then Y, then Z.
-    This function should not be called before {@link VoxelProvider#ready} returns true.
+     * The number of levels of detail containing available tiles in the tileset.
+     */
+    readonly availableLevels: number | undefined;
+    /**
+     * Creates a {@link Cesium3DTilesVoxelProvider} that fetches voxel data from a 3D Tiles tileset.
+     * @example
+     * try {
+      const voxelProvider = await Cesium3DTilesVoxelProvider.fromUrl(
+        "http://localhost:8002/tilesets/voxel/tileset.json"
+      );
+      const voxelPrimitive = new VoxelPrimitive({
+        provider: voxelProvider,
+        customShader: customShader,
+      });
+      scene.primitives.add(voxelPrimitive);
+    } catch (error) {
+      console.error(`Error creating voxel primitive: ${error}`);
+    }
+     * @param url - The URL to a tileset JSON file
+     * @returns The created provider
+     */
+    static fromUrl(url: Resource | string): Promise<Cesium3DTilesVoxelProvider>;
+    /**
+     * 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 to an array of typed arrays containing the requested voxel data or undefined if there was a problem loading the data.
+     * @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<any[][]> | undefined;
+    }): Promise<VoxelContent> | undefined;
 }
 
 /**
@@ -32179,19 +32252,19 @@ export class EllipsoidSurfaceAppearance {
 
 /**
  * An expression for a style applied to a {@link Cesium3DTileset}.
- * <p>
- * Evaluates an expression defined using the
- * {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification/Styling|3D Tiles Styling language}.
- * </p>
- * <p>
- * Implements the {@link StyleExpression} interface.
- * </p>
+<p>
+Evaluates an expression defined using the
+{@link https://github.com/CesiumGS/3d-tiles/tree/main/specification/Styling|3D Tiles Styling language}.
+</p>
+<p>
+Implements the {@link StyleExpression} interface.
+</p>
  * @example
  * const expression = new Cesium.Expression('(regExp("^Chest").test(${County})) && (${YearBuilt} >= 1970)');
- * expression.evaluate(feature); // returns true or false depending on the feature's properties
+expression.evaluate(feature); // returns true or false depending on the feature's properties
  * @example
  * const expression = new Cesium.Expression('(${Temperature} > 90) ? color("red") : color("white")');
- * expression.evaluateColor(feature, result); // returns a Cesium.Color object
+expression.evaluateColor(feature, result); // returns a Cesium.Color object
  * @param [expression] - The expression defined using the 3D Tiles Styling language.
  * @param [defines] - Defines in the style.
  */
@@ -32203,13 +32276,13 @@ export class Expression {
     readonly expression: string;
     /**
      * Evaluates the result of an expression, optionally using the provided feature's properties. If the result of
-     * the expression in the
-     * {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification/Styling|3D Tiles Styling language}
-     * is of type <code>Boolean</code>, <code>Number</code>, or <code>String</code>, the corresponding JavaScript
-     * primitive type will be returned. If the result is a <code>RegExp</code>, a Javascript <code>RegExp</code>
-     * object will be returned. If the result is a <code>Cartesian2</code>, <code>Cartesian3</code>, or <code>Cartesian4</code>,
-     * a {@link Cartesian2}, {@link Cartesian3}, or {@link Cartesian4} object will be returned. If the <code>result</code> argument is
-     * a {@link Color}, the {@link Cartesian4} value is converted to a {@link Color} and then returned.
+    the expression in the
+    {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification/Styling|3D Tiles Styling language}
+    is of type <code>Boolean</code>, <code>Number</code>, or <code>String</code>, the corresponding JavaScript
+    primitive type will be returned. If the result is a <code>RegExp</code>, a Javascript <code>RegExp</code>
+    object will be returned. If the result is a <code>Cartesian2</code>, <code>Cartesian3</code>, or <code>Cartesian4</code>,
+    a {@link Cartesian2}, {@link Cartesian3}, or {@link Cartesian4} object will be returned. If the <code>result</code> argument is
+    a {@link Color}, the {@link Cartesian4} value is converted to a {@link Color} and then returned.
      * @param feature - The feature whose properties may be used as variables in the expression.
      * @param [result] - The object onto which to store the result.
      * @returns The result of evaluating the expression.
@@ -32217,9 +32290,9 @@ export class Expression {
     evaluate(feature: Cesium3DTileFeature, result?: any): boolean | number | string | RegExp | Cartesian2 | Cartesian3 | Cartesian4 | Color;
     /**
      * Evaluates the result of a Color expression, optionally using the provided feature's properties.
-     * <p>
-     * This is equivalent to {@link Expression#evaluate} but always returns a {@link Color} object.
-     * </p>
+    <p>
+    This is equivalent to {@link Expression#evaluate} but always returns a {@link Color} object.
+    </p>
      * @param feature - The feature whose properties may be used as variables in the expression.
      * @param [result] - The object in which to store the result
      * @returns The modified result parameter or a new Color instance if one was not provided.
@@ -34644,24 +34717,24 @@ export class ImageryLayerCollection {
     constructor();
     /**
      * An event that is raised when a layer is added to the collection.  Event handlers are passed the layer that
-     * was added and the index at which it was added.
+    was added and the index at which it was added.
      */
     layerAdded: Event;
     /**
      * An event that is raised when a layer is removed from the collection.  Event handlers are passed the layer that
-     * was removed and the index from which it was removed.
+    was removed and the index from which it was removed.
      */
     layerRemoved: Event;
     /**
      * An event that is raised when a layer changes position in the collection.  Event handlers are passed the layer that
-     * was moved, its new index after the move, and its old index prior to the move.
+    was moved, its new index after the move, and its old index prior to the move.
      */
     layerMoved: Event;
     /**
      * An event that is raised when a layer is shown or hidden by setting the
-     * {@link ImageryLayer#show} property.  Event handlers are passed a reference to this layer,
-     * the index of the layer in the collection, and a flag that is true if the layer is now
-     * shown or false if it is now hidden.
+    {@link ImageryLayer#show} property.  Event handlers are passed a reference to this layer,
+    the index of the layer in the collection, and a flag that is true if the layer is now
+    shown or false if it is now hidden.
      */
     layerShownOrHidden: Event;
     /**
@@ -34672,27 +34745,27 @@ export class ImageryLayerCollection {
      * Adds a layer to the collection.
      * @example
      * const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
-     * scene.imageryLayers.add(imageryLayer);
+    scene.imageryLayers.add(imageryLayer);
      * @example
      * const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
-     * scene.imageryLayers.add(imageryLayer);
+    scene.imageryLayers.add(imageryLayer);
      * @param layer - the layer to add.
      * @param [index] - the index to add the layer at.  If omitted, the layer will
-     *                         be added on top of all existing layers.
+                            be added on top of all existing layers.
      */
     add(layer: ImageryLayer, index?: number): void;
     /**
      * Creates a new layer using the given ImageryProvider and adds it to the collection.
      * @example
      * try {
-     *    const provider = await Cesium.IonImageryProvider.fromAssetId(3812);
-     *    scene.imageryLayers.addImageryProvider(provider);
-     * } catch (error) {
-     *   console.log(`There was an error creating the imagery layer. ${error}`)
-     * }
+       const provider = await Cesium.IonImageryProvider.fromAssetId(3812);
+       scene.imageryLayers.addImageryProvider(provider);
+    } catch (error) {
+      console.log(`There was an error creating the imagery layer. ${error}`)
+    }
      * @param imageryProvider - the imagery provider to create a new layer for.
      * @param [index] - the index to add the layer at.  If omitted, the layer will
-     *                         added on top of all existing layers.
+                            added on top of all existing layers.
      * @returns The newly created layer.
      */
     addImageryProvider(imageryProvider: ImageryProvider, index?: number): ImageryLayer;
@@ -34701,7 +34774,7 @@ export class ImageryLayerCollection {
      * @param layer - The layer to remove.
      * @param [destroy = true] - whether to destroy the layers in addition to removing them.
      * @returns true if the layer was in the collection and was removed,
-     *                    false if the layer was not in the collection.
+                       false if the layer was not in the collection.
      */
     remove(layer: ImageryLayer, destroy?: boolean): boolean;
     /**
@@ -34749,57 +34822,57 @@ export class ImageryLayerCollection {
     lowerToBottom(layer: ImageryLayer): void;
     /**
      * Determines the imagery layers that are intersected by a pick ray. To compute a pick ray from a
-     * location on the screen, use {@link Camera.getPickRay}.
+    location on the screen, use {@link Camera.getPickRay}.
      * @param ray - The ray to test for intersection.
      * @param scene - The scene.
      * @returns An array that includes all of
-     *                                 the layers that are intersected by a given pick ray. Undefined if
-     *                                 no layers are selected.
+                                    the layers that are intersected by a given pick ray. Undefined if
+                                    no layers are selected.
      */
     pickImageryLayers(ray: Ray, scene: Scene): ImageryLayer[] | undefined;
     /**
      * Asynchronously determines the imagery layer features that are intersected by a pick ray.  The intersected imagery
-     * layer features are found by invoking {@link ImageryProvider#pickFeatures} for each imagery layer tile intersected
-     * by the pick ray.  To compute a pick ray from a location on the screen, use {@link Camera.getPickRay}.
+    layer features are found by invoking {@link ImageryProvider#pickFeatures} for each imagery layer tile intersected
+    by the pick ray.  To compute a pick ray from a location on the screen, use {@link Camera.getPickRay}.
      * @example
      * const pickRay = viewer.camera.getPickRay(windowPosition);
-     * const featuresPromise = viewer.imageryLayers.pickImageryLayerFeatures(pickRay, viewer.scene);
-     * if (!Cesium.defined(featuresPromise)) {
-     *     console.log('No features picked.');
-     * } else {
-     *     Promise.resolve(featuresPromise).then(function(features) {
-     *         // This function is called asynchronously when the list if picked features is available.
-     *         console.log(`Number of features: ${features.length}`);
-     *         if (features.length > 0) {
-     *             console.log(`First feature name: ${features[0].name}`);
-     *         }
-     *     });
-     * }
+    const featuresPromise = viewer.imageryLayers.pickImageryLayerFeatures(pickRay, viewer.scene);
+    if (!Cesium.defined(featuresPromise)) {
+        console.log('No features picked.');
+    } else {
+        Promise.resolve(featuresPromise).then(function(features) {
+            // This function is called asynchronously when the list if picked features is available.
+            console.log(`Number of features: ${features.length}`);
+            if (features.length > 0) {
+                console.log(`First feature name: ${features[0].name}`);
+            }
+        });
+    }
      * @param ray - The ray to test for intersection.
      * @param scene - The scene.
      * @returns A promise that resolves to an array of features intersected by the pick ray.
-     *                                             If it can be quickly determined that no features are intersected (for example,
-     *                                             because no active imagery providers support {@link ImageryProvider#pickFeatures}
-     *                                             or because the pick ray does not intersect the surface), this function will
-     *                                             return undefined.
+                                                If it can be quickly determined that no features are intersected (for example,
+                                                because no active imagery providers support {@link ImageryProvider#pickFeatures}
+                                                or because the pick ray does not intersect the surface), this function will
+                                                return undefined.
      */
     pickImageryLayerFeatures(ray: Ray, scene: Scene): Promise<ImageryLayerFeatureInfo[]> | undefined;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-     * <br /><br />
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+    <br /><br />
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
      * @returns true if this object was destroyed; otherwise, false.
      */
     isDestroyed(): boolean;
     /**
      * Destroys the WebGL resources held by all layers in this collection.  Explicitly destroying this
-     * object allows for deterministic release of WebGL resources, instead of relying on the garbage
-     * collector.
-     * <br /><br />
-     * Once this object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
+    object allows for deterministic release of WebGL resources, instead of relying on the garbage
+    collector.
+    <br /><br />
+    Once this object is destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+    assign the return value (<code>undefined</code>) to the object as done in the example.
      * @example
      * layerCollection = layerCollection && layerCollection.destroy();
      */
@@ -35571,7 +35644,7 @@ export class LabelCollection {
     {@link LabelCollection#get} to iterate over all the labels
     in the collection.
      */
-    length: number;
+    readonly length: number;
     /**
      * Creates and adds a label with the specified initial properties to the collection.
     The added label is returned so it can be modified or removed from the collection later.
@@ -35995,216 +36068,216 @@ export enum MapMode2D {
 
 /**
  * A Material defines surface appearance through a combination of diffuse, specular,
- * normal, emission, and alpha components. These values are specified using a
- * JSON schema called Fabric which gets parsed and assembled into glsl shader code
- * behind-the-scenes. Check out the {@link https://github.com/CesiumGS/cesium/wiki/Fabric|wiki page}
- * for more details on Fabric.
- * <br /><br />
- * <style type="text/css">
- *  #materialDescriptions code {
- *      font-weight: normal;
- *      font-family: Consolas, 'Lucida Console', Monaco, monospace;
- *      color: #A35A00;
- *  }
- *  #materialDescriptions ul, #materialDescriptions ul ul {
- *      list-style-type: none;
- *  }
- *  #materialDescriptions ul ul {
- *      margin-bottom: 10px;
- *  }
- *  #materialDescriptions ul ul li {
- *      font-weight: normal;
- *      color: #000000;
- *      text-indent: -2em;
- *      margin-left: 2em;
- *  }
- *  #materialDescriptions ul li {
- *      font-weight: bold;
- *      color: #0053CF;
- *  }
- * </style>
- *
- * Base material types and their uniforms:
- * <div id='materialDescriptions'>
- * <ul>
- *  <li>Color</li>
- *  <ul>
- *      <li><code>color</code>:  rgba color object.</li>
- *  </ul>
- *  <li>Image</li>
- *  <ul>
- *      <li><code>image</code>:  path to image.</li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
- *  </ul>
- *  <li>DiffuseMap</li>
- *  <ul>
- *      <li><code>image</code>:  path to image.</li>
- *      <li><code>channels</code>:  Three character string containing any combination of r, g, b, and a for selecting the desired image channels.</li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
- *  </ul>
- *  <li>AlphaMap</li>
- *  <ul>
- *      <li><code>image</code>:  path to image.</li>
- *      <li><code>channel</code>:  One character string containing r, g, b, or a for selecting the desired image channel. </li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
- *  </ul>
- *  <li>SpecularMap</li>
- *  <ul>
- *      <li><code>image</code>: path to image.</li>
- *      <li><code>channel</code>: One character string containing r, g, b, or a for selecting the desired image channel. </li>
- *      <li><code>repeat</code>: Object with x and y values specifying the number of times to repeat the image.</li>
- *  </ul>
- *  <li>EmissionMap</li>
- *  <ul>
- *      <li><code>image</code>:  path to image.</li>
- *      <li><code>channels</code>:  Three character string containing any combination of r, g, b, and a for selecting the desired image channels. </li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
- *  </ul>
- *  <li>BumpMap</li>
- *  <ul>
- *      <li><code>image</code>:  path to image.</li>
- *      <li><code>channel</code>:  One character string containing r, g, b, or a for selecting the desired image channel. </li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
- *      <li><code>strength</code>:  Bump strength value between 0.0 and 1.0 where 0.0 is small bumps and 1.0 is large bumps.</li>
- *  </ul>
- *  <li>NormalMap</li>
- *  <ul>
- *      <li><code>image</code>:  path to image.</li>
- *      <li><code>channels</code>:  Three character string containing any combination of r, g, b, and a for selecting the desired image channels. </li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
- *      <li><code>strength</code>:  Bump strength value between 0.0 and 1.0 where 0.0 is small bumps and 1.0 is large bumps.</li>
- *  </ul>
- *  <li>Grid</li>
- *  <ul>
- *      <li><code>color</code>:  rgba color object for the whole material.</li>
- *      <li><code>cellAlpha</code>: Alpha value for the cells between grid lines.  This will be combined with color.alpha.</li>
- *      <li><code>lineCount</code>:  Object with x and y values specifying the number of columns and rows respectively.</li>
- *      <li><code>lineThickness</code>:  Object with x and y values specifying the thickness of grid lines (in pixels where available).</li>
- *      <li><code>lineOffset</code>:  Object with x and y values specifying the offset of grid lines (range is 0 to 1).</li>
- *  </ul>
- *  <li>Stripe</li>
- *  <ul>
- *      <li><code>horizontal</code>:  Boolean that determines if the stripes are horizontal or vertical.</li>
- *      <li><code>evenColor</code>:  rgba color object for the stripe's first color.</li>
- *      <li><code>oddColor</code>:  rgba color object for the stripe's second color.</li>
- *      <li><code>offset</code>:  Number that controls at which point into the pattern to begin drawing; with 0.0 being the beginning of the even color, 1.0 the beginning of the odd color, 2.0 being the even color again, and any multiple or fractional values being in between.</li>
- *      <li><code>repeat</code>:  Number that controls the total number of stripes, half light and half dark.</li>
- *  </ul>
- *  <li>Checkerboard</li>
- *  <ul>
- *      <li><code>lightColor</code>:  rgba color object for the checkerboard's light alternating color.</li>
- *      <li><code>darkColor</code>: rgba color object for the checkerboard's dark alternating color.</li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of columns and rows respectively.</li>
- *  </ul>
- *  <li>Dot</li>
- *  <ul>
- *      <li><code>lightColor</code>:  rgba color object for the dot color.</li>
- *      <li><code>darkColor</code>:  rgba color object for the background color.</li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of columns and rows of dots respectively.</li>
- *  </ul>
- *  <li>Water</li>
- *  <ul>
- *      <li><code>baseWaterColor</code>:  rgba color object base color of the water.</li>
- *      <li><code>blendColor</code>:  rgba color object used when blending from water to non-water areas.</li>
- *      <li><code>specularMap</code>:  Single channel texture used to indicate areas of water.</li>
- *      <li><code>normalMap</code>:  Normal map for water normal perturbation.</li>
- *      <li><code>frequency</code>:  Number that controls the number of waves.</li>
- *      <li><code>animationSpeed</code>:  Number that controls the animations speed of the water.</li>
- *      <li><code>amplitude</code>:  Number that controls the amplitude of water waves.</li>
- *      <li><code>specularIntensity</code>:  Number that controls the intensity of specular reflections.</li>
- *  </ul>
- *  <li>RimLighting</li>
- *  <ul>
- *      <li><code>color</code>:  diffuse color and alpha.</li>
- *      <li><code>rimColor</code>:  diffuse color and alpha of the rim.</li>
- *      <li><code>width</code>:  Number that determines the rim's width.</li>
- *  </ul>
- *  <li>Fade</li>
- *  <ul>
- *      <li><code>fadeInColor</code>: diffuse color and alpha at <code>time</code></li>
- *      <li><code>fadeOutColor</code>: diffuse color and alpha at <code>maximumDistance</code> from <code>time</code></li>
- *      <li><code>maximumDistance</code>: Number between 0.0 and 1.0 where the <code>fadeInColor</code> becomes the <code>fadeOutColor</code>. A value of 0.0 gives the entire material a color of <code>fadeOutColor</code> and a value of 1.0 gives the the entire material a color of <code>fadeInColor</code></li>
- *      <li><code>repeat</code>: true if the fade should wrap around the texture coodinates.</li>
- *      <li><code>fadeDirection</code>: Object with x and y values specifying if the fade should be in the x and y directions.</li>
- *      <li><code>time</code>: Object with x and y values between 0.0 and 1.0 of the <code>fadeInColor</code> position</li>
- *  </ul>
- *  <li>PolylineArrow</li>
- *  <ul>
- *      <li><code>color</code>: diffuse color and alpha.</li>
- *  </ul>
- *  <li>PolylineDash</li>
- *  <ul>
- *      <li><code>color</code>: color for the line.</li>
- *      <li><code>gapColor</code>: color for the gaps in the line.</li>
- *      <li><code>dashLength</code>: Dash length in pixels.</li>
- *      <li><code>dashPattern</code>: The 16 bit stipple pattern for the line..</li>
- *  </ul>
- *  <li>PolylineGlow</li>
- *  <ul>
- *      <li><code>color</code>: color and maximum alpha for the glow on the line.</li>
- *      <li><code>glowPower</code>: strength of the glow, as a percentage of the total line width (less than 1.0).</li>
- *      <li><code>taperPower</code>: strength of the tapering effect, as a percentage of the total line length.  If 1.0 or higher, no taper effect is used.</li>
- *  </ul>
- *  <li>PolylineOutline</li>
- *  <ul>
- *      <li><code>color</code>: diffuse color and alpha for the interior of the line.</li>
- *      <li><code>outlineColor</code>: diffuse color and alpha for the outline.</li>
- *      <li><code>outlineWidth</code>: width of the outline in pixels.</li>
- *  </ul>
- *  <li>ElevationContour</li>
- *  <ul>
- *      <li><code>color</code>: color and alpha for the contour line.</li>
- *      <li><code>spacing</code>: spacing for contour lines in meters.</li>
- *      <li><code>width</code>: Number specifying the width of the grid lines in pixels.</li>
- *  </ul>
- *  <li>ElevationRamp</li>
- *  <ul>
- *      <li><code>image</code>: color ramp image to use for coloring the terrain.</li>
- *      <li><code>minimumHeight</code>: minimum height for the ramp.</li>
- *      <li><code>maximumHeight</code>: maximum height for the ramp.</li>
- *  </ul>
- *  <li>SlopeRamp</li>
- *  <ul>
- *      <li><code>image</code>: color ramp image to use for coloring the terrain by slope.</li>
- *  </ul>
- *  <li>AspectRamp</li>
- *  <ul>
- *      <li><code>image</code>: color ramp image to use for color the terrain by aspect.</li>
- *  </ul>
- *  <li>ElevationBand</li>
- *  <ul>
- *      <li><code>heights</code>: image of heights sorted from lowest to highest.</li>
- *      <li><code>colors</code>: image of colors at the corresponding heights.</li>
- * </ul>
- * <li>WaterMask</li>
- * <ul>
- *      <li><code>waterColor</code>: diffuse color and alpha for the areas covered by water.</li>
- *      <li><code>landColor</code>: diffuse color and alpha for the areas covered by land.</li>
- * </ul>
- * </ul>
- * </ul>
- * </div>
+normal, emission, and alpha components. These values are specified using a
+JSON schema called Fabric which gets parsed and assembled into glsl shader code
+behind-the-scenes. Check out the {@link https://github.com/CesiumGS/cesium/wiki/Fabric|wiki page}
+for more details on Fabric.
+<br /><br />
+<style type="text/css">
+ #materialDescriptions code {
+     font-weight: normal;
+     font-family: Consolas, 'Lucida Console', Monaco, monospace;
+     color: #A35A00;
+ }
+ #materialDescriptions ul, #materialDescriptions ul ul {
+     list-style-type: none;
+ }
+ #materialDescriptions ul ul {
+     margin-bottom: 10px;
+ }
+ #materialDescriptions ul ul li {
+     font-weight: normal;
+     color: #000000;
+     text-indent: -2em;
+     margin-left: 2em;
+ }
+ #materialDescriptions ul li {
+     font-weight: bold;
+     color: #0053CF;
+ }
+</style>
+
+Base material types and their uniforms:
+<div id='materialDescriptions'>
+<ul>
+ <li>Color</li>
+ <ul>
+     <li><code>color</code>:  rgba color object.</li>
+ </ul>
+ <li>Image</li>
+ <ul>
+     <li><code>image</code>:  path to image.</li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
+ </ul>
+ <li>DiffuseMap</li>
+ <ul>
+     <li><code>image</code>:  path to image.</li>
+     <li><code>channels</code>:  Three character string containing any combination of r, g, b, and a for selecting the desired image channels.</li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
+ </ul>
+ <li>AlphaMap</li>
+ <ul>
+     <li><code>image</code>:  path to image.</li>
+     <li><code>channel</code>:  One character string containing r, g, b, or a for selecting the desired image channel. </li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
+ </ul>
+ <li>SpecularMap</li>
+ <ul>
+     <li><code>image</code>: path to image.</li>
+     <li><code>channel</code>: One character string containing r, g, b, or a for selecting the desired image channel. </li>
+     <li><code>repeat</code>: Object with x and y values specifying the number of times to repeat the image.</li>
+ </ul>
+ <li>EmissionMap</li>
+ <ul>
+     <li><code>image</code>:  path to image.</li>
+     <li><code>channels</code>:  Three character string containing any combination of r, g, b, and a for selecting the desired image channels. </li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
+ </ul>
+ <li>BumpMap</li>
+ <ul>
+     <li><code>image</code>:  path to image.</li>
+     <li><code>channel</code>:  One character string containing r, g, b, or a for selecting the desired image channel. </li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
+     <li><code>strength</code>:  Bump strength value between 0.0 and 1.0 where 0.0 is small bumps and 1.0 is large bumps.</li>
+ </ul>
+ <li>NormalMap</li>
+ <ul>
+     <li><code>image</code>:  path to image.</li>
+     <li><code>channels</code>:  Three character string containing any combination of r, g, b, and a for selecting the desired image channels. </li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
+     <li><code>strength</code>:  Bump strength value between 0.0 and 1.0 where 0.0 is small bumps and 1.0 is large bumps.</li>
+ </ul>
+ <li>Grid</li>
+ <ul>
+     <li><code>color</code>:  rgba color object for the whole material.</li>
+     <li><code>cellAlpha</code>: Alpha value for the cells between grid lines.  This will be combined with color.alpha.</li>
+     <li><code>lineCount</code>:  Object with x and y values specifying the number of columns and rows respectively.</li>
+     <li><code>lineThickness</code>:  Object with x and y values specifying the thickness of grid lines (in pixels where available).</li>
+     <li><code>lineOffset</code>:  Object with x and y values specifying the offset of grid lines (range is 0 to 1).</li>
+ </ul>
+ <li>Stripe</li>
+ <ul>
+     <li><code>horizontal</code>:  Boolean that determines if the stripes are horizontal or vertical.</li>
+     <li><code>evenColor</code>:  rgba color object for the stripe's first color.</li>
+     <li><code>oddColor</code>:  rgba color object for the stripe's second color.</li>
+     <li><code>offset</code>:  Number that controls at which point into the pattern to begin drawing; with 0.0 being the beginning of the even color, 1.0 the beginning of the odd color, 2.0 being the even color again, and any multiple or fractional values being in between.</li>
+     <li><code>repeat</code>:  Number that controls the total number of stripes, half light and half dark.</li>
+ </ul>
+ <li>Checkerboard</li>
+ <ul>
+     <li><code>lightColor</code>:  rgba color object for the checkerboard's light alternating color.</li>
+     <li><code>darkColor</code>: rgba color object for the checkerboard's dark alternating color.</li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of columns and rows respectively.</li>
+ </ul>
+ <li>Dot</li>
+ <ul>
+     <li><code>lightColor</code>:  rgba color object for the dot color.</li>
+     <li><code>darkColor</code>:  rgba color object for the background color.</li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of columns and rows of dots respectively.</li>
+ </ul>
+ <li>Water</li>
+ <ul>
+     <li><code>baseWaterColor</code>:  rgba color object base color of the water.</li>
+     <li><code>blendColor</code>:  rgba color object used when blending from water to non-water areas.</li>
+     <li><code>specularMap</code>:  Single channel texture used to indicate areas of water.</li>
+     <li><code>normalMap</code>:  Normal map for water normal perturbation.</li>
+     <li><code>frequency</code>:  Number that controls the number of waves.</li>
+     <li><code>animationSpeed</code>:  Number that controls the animations speed of the water.</li>
+     <li><code>amplitude</code>:  Number that controls the amplitude of water waves.</li>
+     <li><code>specularIntensity</code>:  Number that controls the intensity of specular reflections.</li>
+ </ul>
+ <li>RimLighting</li>
+ <ul>
+     <li><code>color</code>:  diffuse color and alpha.</li>
+     <li><code>rimColor</code>:  diffuse color and alpha of the rim.</li>
+     <li><code>width</code>:  Number that determines the rim's width.</li>
+ </ul>
+ <li>Fade</li>
+ <ul>
+     <li><code>fadeInColor</code>: diffuse color and alpha at <code>time</code></li>
+     <li><code>fadeOutColor</code>: diffuse color and alpha at <code>maximumDistance</code> from <code>time</code></li>
+     <li><code>maximumDistance</code>: Number between 0.0 and 1.0 where the <code>fadeInColor</code> becomes the <code>fadeOutColor</code>. A value of 0.0 gives the entire material a color of <code>fadeOutColor</code> and a value of 1.0 gives the the entire material a color of <code>fadeInColor</code></li>
+     <li><code>repeat</code>: true if the fade should wrap around the texture coodinates.</li>
+     <li><code>fadeDirection</code>: Object with x and y values specifying if the fade should be in the x and y directions.</li>
+     <li><code>time</code>: Object with x and y values between 0.0 and 1.0 of the <code>fadeInColor</code> position</li>
+ </ul>
+ <li>PolylineArrow</li>
+ <ul>
+     <li><code>color</code>: diffuse color and alpha.</li>
+ </ul>
+ <li>PolylineDash</li>
+ <ul>
+     <li><code>color</code>: color for the line.</li>
+     <li><code>gapColor</code>: color for the gaps in the line.</li>
+     <li><code>dashLength</code>: Dash length in pixels.</li>
+     <li><code>dashPattern</code>: The 16 bit stipple pattern for the line..</li>
+ </ul>
+ <li>PolylineGlow</li>
+ <ul>
+     <li><code>color</code>: color and maximum alpha for the glow on the line.</li>
+     <li><code>glowPower</code>: strength of the glow, as a percentage of the total line width (less than 1.0).</li>
+     <li><code>taperPower</code>: strength of the tapering effect, as a percentage of the total line length.  If 1.0 or higher, no taper effect is used.</li>
+ </ul>
+ <li>PolylineOutline</li>
+ <ul>
+     <li><code>color</code>: diffuse color and alpha for the interior of the line.</li>
+     <li><code>outlineColor</code>: diffuse color and alpha for the outline.</li>
+     <li><code>outlineWidth</code>: width of the outline in pixels.</li>
+ </ul>
+ <li>ElevationContour</li>
+ <ul>
+     <li><code>color</code>: color and alpha for the contour line.</li>
+     <li><code>spacing</code>: spacing for contour lines in meters.</li>
+     <li><code>width</code>: Number specifying the width of the grid lines in pixels.</li>
+ </ul>
+ <li>ElevationRamp</li>
+ <ul>
+     <li><code>image</code>: color ramp image to use for coloring the terrain.</li>
+     <li><code>minimumHeight</code>: minimum height for the ramp.</li>
+     <li><code>maximumHeight</code>: maximum height for the ramp.</li>
+ </ul>
+ <li>SlopeRamp</li>
+ <ul>
+     <li><code>image</code>: color ramp image to use for coloring the terrain by slope.</li>
+ </ul>
+ <li>AspectRamp</li>
+ <ul>
+     <li><code>image</code>: color ramp image to use for color the terrain by aspect.</li>
+ </ul>
+ <li>ElevationBand</li>
+ <ul>
+     <li><code>heights</code>: image of heights sorted from lowest to highest.</li>
+     <li><code>colors</code>: image of colors at the corresponding heights.</li>
+</ul>
+<li>WaterMask</li>
+<ul>
+     <li><code>waterColor</code>: diffuse color and alpha for the areas covered by water.</li>
+     <li><code>landColor</code>: diffuse color and alpha for the areas covered by land.</li>
+</ul>
+</ul>
+</ul>
+</div>
  * @example
  * // Create a color material with fromType:
- * polygon.material = Cesium.Material.fromType('Color');
- * polygon.material.uniforms.color = new Cesium.Color(1.0, 1.0, 0.0, 1.0);
- *
- * // Create the default material:
- * polygon.material = new Cesium.Material();
- *
- * // Create a color material with full Fabric notation:
- * polygon.material = new Cesium.Material({
- *   fabric: {
- *     type: 'Color',
- *     uniforms: {
- *       color: new Cesium.Color(1.0, 1.0, 0.0, 1.0)
- *     }
- *   }
- * });
+polygon.material = Cesium.Material.fromType('Color');
+polygon.material.uniforms.color = new Cesium.Color(1.0, 1.0, 0.0, 1.0);
+
+// Create the default material:
+polygon.material = new Cesium.Material();
+
+// Create a color material with full Fabric notation:
+polygon.material = new Cesium.Material({
+  fabric: {
+    type: 'Color',
+    uniforms: {
+      color: new Cesium.Color(1.0, 1.0, 0.0, 1.0)
+    }
+  }
+});
  * @param [options] - Object with the following properties:
  * @param [options.strict = false] - Throws errors for issues that would normally be ignored, including unused uniforms or materials.
  * @param [options.translucent = true] - When <code>true</code> or a function that returns <code>true</code>, the geometry
- *                           with this material is expected to appear translucent.
+                          with this material is expected to appear translucent.
  * @param [options.minificationFilter = TextureMinificationFilter.LINEAR] - The {@link TextureMinificationFilter} to apply to this material's textures.
  * @param [options.magnificationFilter = TextureMagnificationFilter.LINEAR] - The {@link TextureMagnificationFilter} to apply to this material's textures.
  * @param options.fabric - The fabric JSON used to generate the material.
@@ -36235,17 +36308,17 @@ export class Material {
     uniforms: any;
     /**
      * When <code>true</code> or a function that returns <code>true</code>,
-     * the geometry is expected to appear translucent.
+    the geometry is expected to appear translucent.
      */
     translucent: boolean | ((...params: any[]) => any);
     /**
      * Creates a new material using an existing material type.
-     * <br /><br />
-     * Shorthand for: new Material({fabric : {type : type}});
+    <br /><br />
+    Shorthand for: new Material({fabric : {type : type}});
      * @example
      * const material = Cesium.Material.fromType('Color', {
-     *   color: new Cesium.Color(1.0, 0.0, 0.0, 1.0)
-     * });
+      color: new Cesium.Color(1.0, 0.0, 0.0, 1.0)
+    });
      * @param type - The base material type.
      * @param [uniforms] - Overrides for the default uniforms.
      * @returns New material object.
@@ -36258,19 +36331,19 @@ export class Material {
     isTranslucent(): boolean;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-     * <br /><br />
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+    <br /><br />
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
      * @returns True if this object was destroyed; otherwise, false.
      */
     isDestroyed(): 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.
-     * <br /><br />
-     * Once an object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
+    release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+    <br /><br />
+    Once an object is destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+    assign the return value (<code>undefined</code>) to the object as done in the example.
      * @example
      * material = material && material.destroy();
      */
@@ -37022,55 +37095,55 @@ export type UniformSpecifier = {
 
 /**
  * A user defined GLSL shader used with {@link Model} as well
- * as {@link Cesium3DTileset}.
- * <p>
- * If texture uniforms are used, additional resource management must be done:
- * </p>
- * <ul>
- *   <li>
- *      The <code>update</code> function must be called each frame. When a
- *      custom shader is passed to a {@link Model} or a
- *      {@link Cesium3DTileset}, this step is handled automaticaly
- *   </li>
- *   <li>
- *      {@link CustomShader#destroy} must be called when the custom shader is
- *      no longer needed to clean up GPU resources properly. The application
- *      is responsible for calling this method.
- *   </li>
- * </ul>
- * <p>
- * See the {@link https://github.com/CesiumGS/cesium/tree/main/Documentation/CustomShaderGuide|Custom Shader Guide} for more detailed documentation.
- * </p>
+as {@link Cesium3DTileset}.
+<p>
+If texture uniforms are used, additional resource management must be done:
+</p>
+<ul>
+  <li>
+     The <code>update</code> function must be called each frame. When a
+     custom shader is passed to a {@link Model} or a
+     {@link Cesium3DTileset}, this step is handled automaticaly
+  </li>
+  <li>
+     {@link CustomShader#destroy} must be called when the custom shader is
+     no longer needed to clean up GPU resources properly. The application
+     is responsible for calling this method.
+  </li>
+</ul>
+<p>
+See the {@link https://github.com/CesiumGS/cesium/tree/main/Documentation/CustomShaderGuide|Custom Shader Guide} for more detailed documentation.
+</p>
  * @example
  * const customShader = new CustomShader({
- *   uniforms: {
- *     u_colorIndex: {
- *       type: Cesium.UniformType.FLOAT,
- *       value: 1.0
- *     },
- *     u_normalMap: {
- *       type: Cesium.UniformType.SAMPLER_2D,
- *       value: new Cesium.TextureUniform({
- *         url: "http://example.com/normal.png"
- *       })
- *     }
- *   },
- *   varyings: {
- *     v_selectedColor: Cesium.VaryingType.VEC3
- *   },
- *   vertexShaderText: `
- *   void vertexMain(VertexInput vsInput, inout czm_modelVertexOutput vsOutput) {
- *     v_selectedColor = mix(vsInput.attributes.color_0, vsInput.attributes.color_1, u_colorIndex);
- *     vsOutput.positionMC += 0.1 * vsInput.attributes.normal;
- *   }
- *   `,
- *   fragmentShaderText: `
- *   void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material) {
- *     material.normal = texture(u_normalMap, fsInput.attributes.texCoord_0);
- *     material.diffuse = v_selectedColor;
- *   }
- *   `
- * });
+  uniforms: {
+    u_colorIndex: {
+      type: Cesium.UniformType.FLOAT,
+      value: 1.0
+    },
+    u_normalMap: {
+      type: Cesium.UniformType.SAMPLER_2D,
+      value: new Cesium.TextureUniform({
+        url: "http://example.com/normal.png"
+      })
+    }
+  },
+  varyings: {
+    v_selectedColor: Cesium.VaryingType.VEC3
+  },
+  vertexShaderText: `
+  void vertexMain(VertexInput vsInput, inout czm_modelVertexOutput vsOutput) {
+    v_selectedColor = mix(vsInput.attributes.color_0, vsInput.attributes.color_1, u_colorIndex);
+    vsOutput.positionMC += 0.1 * vsInput.attributes.normal;
+  }
+  `,
+  fragmentShaderText: `
+  void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material) {
+    material.normal = texture(u_normalMap, fsInput.attributes.texCoord_0);
+    material.diffuse = v_selectedColor;
+  }
+  `
+});
  * @param options - An object with the following options
  * @param [options.mode = CustomShaderMode.MODIFY_MATERIAL] - The custom shader mode, which determines how the custom shader code is inserted into the fragment shader.
  * @param [options.lightingModel] - The lighting model (e.g. PBR or unlit). If present, this overrides the default lighting for the model.
@@ -37096,12 +37169,12 @@ export class CustomShader {
     });
     /**
      * A value determining how the custom shader interacts with the overall
-     * fragment shader. This is used by {@link CustomShaderPipelineStage}
+    fragment shader. This is used by {@link CustomShaderPipelineStage}
      */
     readonly mode: CustomShaderMode;
     /**
      * The lighting model to use when using the custom shader.
-     * This is used by {@link CustomShaderPipelineStage}
+    This is used by {@link CustomShaderPipelineStage}
      */
     readonly lightingModel: LightingModel;
     /**
@@ -37112,7 +37185,7 @@ export class CustomShader {
     };
     /**
      * Additional varyings as declared by the user.
-     * This is used by {@link CustomShaderPipelineStage}
+    This is used by {@link CustomShaderPipelineStage}
      */
     readonly varyings: {
         [key: string]: VaryingType;
@@ -37127,9 +37200,9 @@ export class CustomShader {
     readonly fragmentShaderText: string;
     /**
      * The translucency mode, which determines how the custom shader will be applied. If the value is
-     * CustomShaderTransulcencyMode.OPAQUE or CustomShaderTransulcencyMode.TRANSLUCENT, the custom shader
-     * will override settings from the model's material. If the value isCustomShaderTransulcencyMode.INHERIT,
-     * the custom shader will render as either opaque or translucent depending on the primitive's material settings.
+    CustomShaderTransulcencyMode.OPAQUE or CustomShaderTransulcencyMode.TRANSLUCENT, the custom shader
+    will override settings from the model's material. If the value isCustomShaderTransulcencyMode.INHERIT,
+    the custom shader will render as either opaque or translucent depending on the primitive's material settings.
      */
     readonly translucencyMode: CustomShaderTranslucencyMode;
     /**
@@ -37140,19 +37213,19 @@ export class CustomShader {
     setUniform(uniformName: string, value: boolean | number | Cartesian2 | Cartesian3 | Cartesian4 | Matrix2 | Matrix3 | Matrix4 | string | Resource | TextureUniform): void;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-     * <br /><br />
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+    <br /><br />
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
      * @returns True if this object was destroyed; otherwise, false.
      */
     isDestroyed(): 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.
-     * <br /><br />
-     * Once an object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
+    release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+    <br /><br />
+    Once an object is destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+    assign the return value (<code>undefined</code>) to the object as done in the example.
      * @example
      * customShader = customShader && customShader.destroy();
      */
@@ -38675,9 +38748,9 @@ export enum VaryingType {
     /**
      * A 3x3 matrix of floating point values.
      */
-    MAT3 = "mat2",
+    MAT3 = "mat3",
     /**
-     * A 3x3 matrix of floating point values.
+     * A 4x4 matrix of floating point values.
      */
     MAT4 = "mat4"
 }
@@ -40714,88 +40787,88 @@ export enum PostProcessStageSampleMode {
 
 /**
  * A primitive represents geometry in the {@link Scene}.  The geometry can be from a single {@link GeometryInstance}
- * as shown in example 1 below, or from an array of instances, even if the geometry is from different
- * geometry types, e.g., an {@link RectangleGeometry} and an {@link EllipsoidGeometry} as shown in Code Example 2.
- * <p>
- * A primitive combines geometry instances with an {@link Appearance} that describes the full shading, including
- * {@link Material} and {@link RenderState}.  Roughly, the geometry instance defines the structure and placement,
- * and the appearance defines the visual characteristics.  Decoupling geometry and appearance allows us to mix
- * and match most of them and add a new geometry or appearance independently of each other.
- * </p>
- * <p>
- * Combining multiple instances into one primitive is called batching, and significantly improves performance for static data.
- * Instances can be individually picked; {@link Scene#pick} returns their {@link GeometryInstance#id}.  Using
- * per-instance appearances like {@link PerInstanceColorAppearance}, each instance can also have a unique color.
- * </p>
- * <p>
- * {@link Geometry} can either be created and batched on a web worker or the main thread. The first two examples
- * show geometry that will be created on a web worker by using the descriptions of the geometry. The third example
- * shows how to create the geometry on the main thread by explicitly calling the <code>createGeometry</code> method.
- * </p>
+as shown in example 1 below, or from an array of instances, even if the geometry is from different
+geometry types, e.g., an {@link RectangleGeometry} and an {@link EllipsoidGeometry} as shown in Code Example 2.
+<p>
+A primitive combines geometry instances with an {@link Appearance} that describes the full shading, including
+{@link Material} and {@link RenderState}.  Roughly, the geometry instance defines the structure and placement,
+and the appearance defines the visual characteristics.  Decoupling geometry and appearance allows us to mix
+and match most of them and add a new geometry or appearance independently of each other.
+</p>
+<p>
+Combining multiple instances into one primitive is called batching, and significantly improves performance for static data.
+Instances can be individually picked; {@link Scene#pick} returns their {@link GeometryInstance#id}.  Using
+per-instance appearances like {@link PerInstanceColorAppearance}, each instance can also have a unique color.
+</p>
+<p>
+{@link Geometry} can either be created and batched on a web worker or the main thread. The first two examples
+show geometry that will be created on a web worker by using the descriptions of the geometry. The third example
+shows how to create the geometry on the main thread by explicitly calling the <code>createGeometry</code> method.
+</p>
  * @example
  * // 1. Draw a translucent ellipse on the surface with a checkerboard pattern
- * const instance = new Cesium.GeometryInstance({
- *   geometry : new Cesium.EllipseGeometry({
- *       center : Cesium.Cartesian3.fromDegrees(-100.0, 20.0),
- *       semiMinorAxis : 500000.0,
- *       semiMajorAxis : 1000000.0,
- *       rotation : Cesium.Math.PI_OVER_FOUR,
- *       vertexFormat : Cesium.VertexFormat.POSITION_AND_ST
- *   }),
- *   id : 'object returned when this instance is picked and to get/set per-instance attributes'
- * });
- * scene.primitives.add(new Cesium.Primitive({
- *   geometryInstances : instance,
- *   appearance : new Cesium.EllipsoidSurfaceAppearance({
- *     material : Cesium.Material.fromType('Checkerboard')
- *   })
- * }));
+const instance = new Cesium.GeometryInstance({
+  geometry : new Cesium.EllipseGeometry({
+      center : Cesium.Cartesian3.fromDegrees(-100.0, 20.0),
+      semiMinorAxis : 500000.0,
+      semiMajorAxis : 1000000.0,
+      rotation : Cesium.Math.PI_OVER_FOUR,
+      vertexFormat : Cesium.VertexFormat.POSITION_AND_ST
+  }),
+  id : 'object returned when this instance is picked and to get/set per-instance attributes'
+});
+scene.primitives.add(new Cesium.Primitive({
+  geometryInstances : instance,
+  appearance : new Cesium.EllipsoidSurfaceAppearance({
+    material : Cesium.Material.fromType('Checkerboard')
+  })
+}));
  * @example
  * // 2. Draw different instances each with a unique color
- * const rectangleInstance = new Cesium.GeometryInstance({
- *   geometry : new Cesium.RectangleGeometry({
- *     rectangle : Cesium.Rectangle.fromDegrees(-140.0, 30.0, -100.0, 40.0),
- *     vertexFormat : Cesium.PerInstanceColorAppearance.VERTEX_FORMAT
- *   }),
- *   id : 'rectangle',
- *   attributes : {
- *     color : new Cesium.ColorGeometryInstanceAttribute(0.0, 1.0, 1.0, 0.5)
- *   }
- * });
- * const ellipsoidInstance = new Cesium.GeometryInstance({
- *   geometry : new Cesium.EllipsoidGeometry({
- *     radii : new Cesium.Cartesian3(500000.0, 500000.0, 1000000.0),
- *     vertexFormat : Cesium.VertexFormat.POSITION_AND_NORMAL
- *   }),
- *   modelMatrix : Cesium.Matrix4.multiplyByTranslation(Cesium.Transforms.eastNorthUpToFixedFrame(
- *     Cesium.Cartesian3.fromDegrees(-95.59777, 40.03883)), new Cesium.Cartesian3(0.0, 0.0, 500000.0), new Cesium.Matrix4()),
- *   id : 'ellipsoid',
- *   attributes : {
- *     color : Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.AQUA)
- *   }
- * });
- * scene.primitives.add(new Cesium.Primitive({
- *   geometryInstances : [rectangleInstance, ellipsoidInstance],
- *   appearance : new Cesium.PerInstanceColorAppearance()
- * }));
+const rectangleInstance = new Cesium.GeometryInstance({
+  geometry : new Cesium.RectangleGeometry({
+    rectangle : Cesium.Rectangle.fromDegrees(-140.0, 30.0, -100.0, 40.0),
+    vertexFormat : Cesium.PerInstanceColorAppearance.VERTEX_FORMAT
+  }),
+  id : 'rectangle',
+  attributes : {
+    color : new Cesium.ColorGeometryInstanceAttribute(0.0, 1.0, 1.0, 0.5)
+  }
+});
+const ellipsoidInstance = new Cesium.GeometryInstance({
+  geometry : new Cesium.EllipsoidGeometry({
+    radii : new Cesium.Cartesian3(500000.0, 500000.0, 1000000.0),
+    vertexFormat : Cesium.VertexFormat.POSITION_AND_NORMAL
+  }),
+  modelMatrix : Cesium.Matrix4.multiplyByTranslation(Cesium.Transforms.eastNorthUpToFixedFrame(
+    Cesium.Cartesian3.fromDegrees(-95.59777, 40.03883)), new Cesium.Cartesian3(0.0, 0.0, 500000.0), new Cesium.Matrix4()),
+  id : 'ellipsoid',
+  attributes : {
+    color : Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.AQUA)
+  }
+});
+scene.primitives.add(new Cesium.Primitive({
+  geometryInstances : [rectangleInstance, ellipsoidInstance],
+  appearance : new Cesium.PerInstanceColorAppearance()
+}));
  * @example
  * // 3. Create the geometry on the main thread.
- * scene.primitives.add(new Cesium.Primitive({
- *   geometryInstances : new Cesium.GeometryInstance({
- *     geometry : Cesium.EllipsoidGeometry.createGeometry(new Cesium.EllipsoidGeometry({
- *       radii : new Cesium.Cartesian3(500000.0, 500000.0, 1000000.0),
- *       vertexFormat : Cesium.VertexFormat.POSITION_AND_NORMAL
- *     })),
- *     modelMatrix : Cesium.Matrix4.multiplyByTranslation(Cesium.Transforms.eastNorthUpToFixedFrame(
- *       Cesium.Cartesian3.fromDegrees(-95.59777, 40.03883)), new Cesium.Cartesian3(0.0, 0.0, 500000.0), new Cesium.Matrix4()),
- *     id : 'ellipsoid',
- *     attributes : {
- *       color : Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.AQUA)
- *     }
- *   }),
- *   appearance : new Cesium.PerInstanceColorAppearance(),
- *   asynchronous : false
- * }));
+scene.primitives.add(new Cesium.Primitive({
+  geometryInstances : new Cesium.GeometryInstance({
+    geometry : Cesium.EllipsoidGeometry.createGeometry(new Cesium.EllipsoidGeometry({
+      radii : new Cesium.Cartesian3(500000.0, 500000.0, 1000000.0),
+      vertexFormat : Cesium.VertexFormat.POSITION_AND_NORMAL
+    })),
+    modelMatrix : Cesium.Matrix4.multiplyByTranslation(Cesium.Transforms.eastNorthUpToFixedFrame(
+      Cesium.Cartesian3.fromDegrees(-95.59777, 40.03883)), new Cesium.Cartesian3(0.0, 0.0, 500000.0), new Cesium.Matrix4()),
+    id : 'ellipsoid',
+    attributes : {
+      color : Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.AQUA)
+    }
+  }),
+  appearance : new Cesium.PerInstanceColorAppearance(),
+  asynchronous : false
+}));
  * @param [options] - Object with the following properties:
  * @param [options.geometryInstances] - The geometry instances - or a single geometry instance - to render.
  * @param [options.appearance] - The appearance used to render the primitive.
@@ -40831,67 +40904,67 @@ export class Primitive {
     });
     /**
      * The geometry instances rendered with this primitive.  This may
-     * be <code>undefined</code> if <code>options.releaseGeometryInstances</code>
-     * is <code>true</code> when the primitive is constructed.
-     * <p>
-     * Changing this property after the primitive is rendered has no effect.
-     * </p>
+    be <code>undefined</code> if <code>options.releaseGeometryInstances</code>
+    is <code>true</code> when the primitive is constructed.
+    <p>
+    Changing this property after the primitive is rendered has no effect.
+    </p>
      */
     readonly geometryInstances: GeometryInstance[] | GeometryInstance;
     /**
      * The {@link Appearance} used to shade this primitive. Each geometry
-     * instance is shaded with the same appearance.  Some appearances, like
-     * {@link PerInstanceColorAppearance} allow giving each instance unique
-     * properties.
+    instance is shaded with the same appearance.  Some appearances, like
+    {@link PerInstanceColorAppearance} allow giving each instance unique
+    properties.
      */
     appearance: Appearance;
     /**
      * The {@link Appearance} used to shade this primitive when it fails the depth test. Each geometry
-     * instance is shaded with the same appearance.  Some appearances, like
-     * {@link PerInstanceColorAppearance} allow giving each instance unique
-     * properties.
-     *
-     * <p>
-     * When using an appearance that requires a color attribute, like PerInstanceColorAppearance,
-     * add a depthFailColor per-instance attribute instead.
-     * </p>
-     *
-     * <p>
-     * Requires the EXT_frag_depth WebGL extension to render properly. If the extension is not supported,
-     * there may be artifacts.
-     * </p>
+    instance is shaded with the same appearance.  Some appearances, like
+    {@link PerInstanceColorAppearance} allow giving each instance unique
+    properties.
+    
+    <p>
+    When using an appearance that requires a color attribute, like PerInstanceColorAppearance,
+    add a depthFailColor per-instance attribute instead.
+    </p>
+    
+    <p>
+    Requires the EXT_frag_depth WebGL extension to render properly. If the extension is not supported,
+    there may be artifacts.
+    </p>
      */
     depthFailAppearance: Appearance;
     /**
      * The 4x4 transformation matrix that transforms the primitive (all geometry instances) from model to world coordinates.
-     * When this is the identity matrix, the primitive is drawn in world coordinates, i.e., Earth's WGS84 coordinates.
-     * Local reference frames can be used by providing a different transformation matrix, like that returned
-     * by {@link Transforms.eastNorthUpToFixedFrame}.
-     *
-     * <p>
-     * This property is only supported in 3D mode.
-     * </p>
+    When this is the identity matrix, the primitive is drawn in world coordinates, i.e., Earth's WGS84 coordinates.
+    Local reference frames can be used by providing a different transformation matrix, like that returned
+    by {@link Transforms.eastNorthUpToFixedFrame}.
+    
+    <p>
+    This property is only supported in 3D mode.
+    </p>
      * @example
      * const origin = Cesium.Cartesian3.fromDegrees(-95.0, 40.0, 200000.0);
-     * p.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(origin);
+    p.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(origin);
      */
     modelMatrix: Matrix4;
     /**
      * Determines if the primitive will be shown.  This affects all geometry
-     * instances in the primitive.
+    instances in the primitive.
      */
     show: boolean;
     /**
      * When <code>true</code>, the renderer frustum culls and horizon culls the primitive's commands
-     * based on their bounding volume.  Set this to <code>false</code> for a small performance gain
-     * if you are manually culling the primitive.
+    based on their bounding volume.  Set this to <code>false</code> for a small performance gain
+    if you are manually culling the primitive.
      */
     cull: boolean;
     /**
      * This property is for debugging only; it is not for production use nor is it optimized.
-     * <p>
-     * Draws the bounding sphere for each draw command in the primitive.
-     * </p>
+    <p>
+    Draws the bounding sphere for each draw command in the primitive.
+    </p>
      */
     debugShowBoundingVolume: boolean;
     /**
@@ -40924,60 +40997,60 @@ export class Primitive {
     readonly compressVertices: boolean;
     /**
      * Determines if the primitive is complete and ready to render.  If this property is
-     * true, the primitive will be rendered the next time that {@link Primitive#update}
-     * is called.
+    true, the primitive will be rendered the next time that {@link Primitive#update}
+    is called.
      * @example
      * // Wait for a primitive to become ready before accessing attributes
-     * const removeListener = scene.postRender.addEventListener(() => {
-     *   if (!frustumPrimitive.ready) {
-     *     return;
-     *   }
-     *
-     *   const attributes = primitive.getGeometryInstanceAttributes('an id');
-     *   attributes.color = Cesium.ColorGeometryInstanceAttribute.toValue(Cesium.Color.AQUA);
-     *
-     *   removeListener();
-     * });
+    const removeListener = scene.postRender.addEventListener(() => {
+      if (!frustumPrimitive.ready) {
+        return;
+      }
+    
+      const attributes = primitive.getGeometryInstanceAttributes('an id');
+      attributes.color = Cesium.ColorGeometryInstanceAttribute.toValue(Cesium.Color.AQUA);
+    
+      removeListener();
+    });
      */
     readonly ready: boolean;
     /**
      * Called when {@link Viewer} or {@link CesiumWidget} render the scene to
-     * get the draw commands needed to render this primitive.
-     * <p>
-     * Do not call this function directly.  This is documented just to
-     * list the exceptions that may be propagated when the scene is rendered:
-     * </p>
+    get the draw commands needed to render this primitive.
+    <p>
+    Do not call this function directly.  This is documented just to
+    list the exceptions that may be propagated when the scene is rendered:
+    </p>
      */
     update(): void;
     /**
      * Returns the modifiable per-instance attributes for a {@link GeometryInstance}.
      * @example
      * const attributes = primitive.getGeometryInstanceAttributes('an id');
-     * attributes.color = Cesium.ColorGeometryInstanceAttribute.toValue(Cesium.Color.AQUA);
-     * attributes.show = Cesium.ShowGeometryInstanceAttribute.toValue(true);
-     * attributes.distanceDisplayCondition = Cesium.DistanceDisplayConditionGeometryInstanceAttribute.toValue(100.0, 10000.0);
-     * attributes.offset = Cesium.OffsetGeometryInstanceAttribute.toValue(Cartesian3.IDENTITY);
+    attributes.color = Cesium.ColorGeometryInstanceAttribute.toValue(Cesium.Color.AQUA);
+    attributes.show = Cesium.ShowGeometryInstanceAttribute.toValue(true);
+    attributes.distanceDisplayCondition = Cesium.DistanceDisplayConditionGeometryInstanceAttribute.toValue(100.0, 10000.0);
+    attributes.offset = Cesium.OffsetGeometryInstanceAttribute.toValue(Cartesian3.IDENTITY);
      * @param id - The id of the {@link GeometryInstance}.
      * @returns The typed array in the attribute's format or undefined if the is no instance with id.
      */
     getGeometryInstanceAttributes(id: any): any;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-     * <p>
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
-     * </p>
+    <p>
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+    </p>
      * @returns <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
      */
     isDestroyed(): 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.
-     * <p>
-     * Once an object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
-     * </p>
+    release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+    <p>
+    Once an object is destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+    assign the return value (<code>undefined</code>) to the object as done in the example.
+    </p>
      * @example
      * e = e && e.destroy();
      */
@@ -41138,17 +41211,53 @@ export class PrimitiveCollection {
     destroy(): void;
 }
 
+/**
+ * A simple Least Recently Used (LRU) cache implementation.
+ */
+export class LRUCache {
+}
+
+/**
+ * Creates a spatial hash key for the given longitude, latitude, and tile level.
+The precision is adjusted based on the tile level and extent to achieve finer precision at higher levels.
+
+This function calculates the spatial hash key by first determining the precision at the given tile for the current maximum screenspace error (MAX_ERROR_PX),
+and then rounding the longitude and latitude to that precision for consistency.
+
+The steps for computing the level precision are as follows:
+
+1. Compute the resolution (meters per pixel) at the given level:
+     level_resolution_m = (2 * PI * RADIUS) / (2^level * TILE_SIZE)
+
+2. Compute the target precision in meters:
+     level_precision_m = level_resolution_m * MAX_ERROR_PX
+
+3. Compute the target precision to radians:
+     level_precision_rad = level_precision_m / BODY_RADIUS
+
+This simplifies to:
+     level_precision_rad = (2 * PI * MAX_ERROR_PX) / (2^level * TILE_SIZE)
+which can also be written as:
+     level_precision_rad = (PI * MAX_ERROR_PX) / (2^(level-1) * TILE_SIZE)
+
+The computed level_precision_rad is then used to round the input longitude and latitude,
+ensuring that positions that fall within the same spatial bin produce the same hash key.
+
+The constants below are computed once since they are fixed for the given configuration.
+ */
+export const TILE_SIZE = 256;
+
 /**
  * The container for all 3D graphical objects and state in a Cesium virtual scene.  Generally,
- * a scene is not created directly; instead, it is implicitly created by {@link CesiumWidget}.
+a scene is not created directly; instead, it is implicitly created by {@link CesiumWidget}.
  * @example
  * // Create scene without anisotropic texture filtering
- * const scene = new Cesium.Scene({
- *   canvas : canvas,
- *   contextOptions : {
- *     allowTextureFilterAnisotropic : false
- *   }
- * });
+const scene = new Cesium.Scene({
+  canvas : canvas,
+  contextOptions : {
+    allowTextureFilterAnisotropic : false
+  }
+});
  * @param options - Object with the following properties:
  * @param options.canvas - The HTML canvas element to create the scene for.
  * @param [options.contextOptions] - Context and WebGL creation properties.
@@ -41184,14 +41293,14 @@ export class Scene {
     });
     /**
      * Exceptions occurring in <code>render</code> are always caught in order to raise the
-     * <code>renderError</code> event.  If this property is true, the error is rethrown
-     * after the event is raised.  If this property is false, the <code>render</code> function
-     * returns normally after raising the event.
+    <code>renderError</code> event.  If this property is true, the error is rethrown
+    after the event is raised.  If this property is false, the <code>render</code> function
+    returns normally after raising the event.
      */
     rethrowRenderErrors: boolean;
     /**
      * Determines whether or not to instantly complete the
-     * scene transition animation on user input.
+    scene transition animation on user input.
      */
     completeMorphOnUserInput: boolean;
     /**
@@ -41228,106 +41337,106 @@ export class Scene {
     backgroundColor: Color;
     /**
      * The current morph transition time between 2D/Columbus View and 3D,
-     * with 0.0 being 2D or Columbus View and 1.0 being 3D.
+    with 0.0 being 2D or Columbus View and 1.0 being 3D.
      */
     morphTime: number;
     /**
      * The far-to-near ratio of the multi-frustum when using a normal depth buffer.
-     * <p>
-     * This value is used to create the near and far values for each frustum of the multi-frustum. It is only used
-     * when {@link Scene#logarithmicDepthBuffer} is <code>false</code>. When <code>logarithmicDepthBuffer</code> is
-     * <code>true</code>, use {@link Scene#logarithmicDepthFarToNearRatio}.
-     * </p>
+    <p>
+    This value is used to create the near and far values for each frustum of the multi-frustum. It is only used
+    when {@link Scene#logarithmicDepthBuffer} is <code>false</code>. When <code>logarithmicDepthBuffer</code> is
+    <code>true</code>, use {@link Scene#logarithmicDepthFarToNearRatio}.
+    </p>
      */
     farToNearRatio: number;
     /**
      * The far-to-near ratio of the multi-frustum when using a logarithmic depth buffer.
-     * <p>
-     * This value is used to create the near and far values for each frustum of the multi-frustum. It is only used
-     * when {@link Scene#logarithmicDepthBuffer} is <code>true</code>. When <code>logarithmicDepthBuffer</code> is
-     * <code>false</code>, use {@link Scene#farToNearRatio}.
-     * </p>
+    <p>
+    This value is used to create the near and far values for each frustum of the multi-frustum. It is only used
+    when {@link Scene#logarithmicDepthBuffer} is <code>true</code>. When <code>logarithmicDepthBuffer</code> is
+    <code>false</code>, use {@link Scene#farToNearRatio}.
+    </p>
      */
     logarithmicDepthFarToNearRatio: number;
     /**
      * Determines the uniform depth size in meters of each frustum of the multifrustum in 2D. If a primitive or model close
-     * to the surface shows z-fighting, decreasing this will eliminate the artifact, but decrease performance. On the
-     * other hand, increasing this will increase performance but may cause z-fighting among primitives close to the surface.
+    to the surface shows z-fighting, decreasing this will eliminate the artifact, but decrease performance. On the
+    other hand, increasing this will increase performance but may cause z-fighting among primitives close to the surface.
      */
     nearToFarDistance2D: number;
     /**
      * The vertical exaggeration of the scene.
-     * When set to 1.0, no exaggeration is applied.
+    When set to 1.0, no exaggeration is applied.
      */
     verticalExaggeration: number;
     /**
      * The reference height for vertical exaggeration of the scene.
-     * When set to 0.0, the exaggeration is applied relative to the ellipsoid surface.
+    When set to 0.0, the exaggeration is applied relative to the ellipsoid surface.
      */
     verticalExaggerationRelativeHeight: number;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * A function that determines what commands are executed.  As shown in the examples below,
-     * the function receives the command's <code>owner</code> as an argument, and returns a boolean indicating if the
-     * command should be executed.
-     * </p>
-     * <p>
-     * The default is <code>undefined</code>, indicating that all commands are executed.
-     * </p>
+    <p>
+    A function that determines what commands are executed.  As shown in the examples below,
+    the function receives the command's <code>owner</code> as an argument, and returns a boolean indicating if the
+    command should be executed.
+    </p>
+    <p>
+    The default is <code>undefined</code>, indicating that all commands are executed.
+    </p>
      * @example
      * // Do not execute any commands.
-     * scene.debugCommandFilter = function(command) {
-     *     return false;
-     * };
-     *
-     * // Execute only the billboard's commands.  That is, only draw the billboard.
-     * const billboards = new Cesium.BillboardCollection();
-     * scene.debugCommandFilter = function(command) {
-     *     return command.owner === billboards;
-     * };
+    scene.debugCommandFilter = function(command) {
+        return false;
+    };
+    
+    // Execute only the billboard's commands.  That is, only draw the billboard.
+    const billboards = new Cesium.BillboardCollection();
+    scene.debugCommandFilter = function(command) {
+        return command.owner === billboards;
+    };
      */
     debugCommandFilter: (...params: any[]) => any;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * When <code>true</code>, commands are randomly shaded.  This is useful
-     * for performance analysis to see what parts of a scene or model are
-     * command-dense and could benefit from batching.
-     * </p>
+    <p>
+    When <code>true</code>, commands are randomly shaded.  This is useful
+    for performance analysis to see what parts of a scene or model are
+    command-dense and could benefit from batching.
+    </p>
      */
     debugShowCommands: boolean;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * When <code>true</code>, commands are shaded based on the frustums they
-     * overlap.  Commands in the closest frustum are tinted red, commands in
-     * the next closest are green, and commands in the farthest frustum are
-     * blue.  If a command overlaps more than one frustum, the color components
-     * are combined, e.g., a command overlapping the first two frustums is tinted
-     * yellow.
-     * </p>
+    <p>
+    When <code>true</code>, commands are shaded based on the frustums they
+    overlap.  Commands in the closest frustum are tinted red, commands in
+    the next closest are green, and commands in the farthest frustum are
+    blue.  If a command overlaps more than one frustum, the color components
+    are combined, e.g., a command overlapping the first two frustums is tinted
+    yellow.
+    </p>
      */
     debugShowFrustums: boolean;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * Displays frames per second and time between frames.
-     * </p>
+    <p>
+    Displays frames per second and time between frames.
+    </p>
      */
     debugShowFramesPerSecond: boolean;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * Indicates which frustum will have depth information displayed.
-     * </p>
+    <p>
+    Indicates which frustum will have depth information displayed.
+    </p>
      */
     debugShowDepthFrustum: number;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * When <code>true</code>, draws outlines to show the boundaries of the camera frustums
-     * </p>
+    <p>
+    When <code>true</code>, draws outlines to show the boundaries of the camera frustums
+    </p>
      */
     debugShowFrustumPlanes: boolean;
     /**
@@ -41336,33 +41445,33 @@ export class Scene {
     useDepthPicking: boolean;
     /**
      * When <code>true</code>, enables picking translucent geometry using the depth buffer. Note that {@link Scene#useDepthPicking} must also be true for enabling this to work.
-     *
-     * <p>
-     * There is a decrease in performance when enabled. There are extra draw calls to write depth for
-     * translucent geometry.
-     * </p>
+    
+    <p>
+    There is a decrease in performance when enabled. There are extra draw calls to write depth for
+    translucent geometry.
+    </p>
      * @example
      * // picking the position of a translucent primitive
-     * viewer.screenSpaceEventHandler.setInputAction(function onLeftClick(movement) {
-     *      const pickedFeature = viewer.scene.pick(movement.position);
-     *      if (!Cesium.defined(pickedFeature)) {
-     *          // nothing picked
-     *          return;
-     *      }
-     *      const worldPosition = viewer.scene.pickPosition(movement.position);
-     * }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+    viewer.screenSpaceEventHandler.setInputAction(function onLeftClick(movement) {
+         const pickedFeature = viewer.scene.pick(movement.position);
+         if (!Cesium.defined(pickedFeature)) {
+             // nothing picked
+             return;
+         }
+         const worldPosition = viewer.scene.pickPosition(movement.position);
+    }, 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.
+    {@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.
-     *
-     * Disbaled by default if an ellipsoid other than WGS84 is used.
+    performance improvements by rendering less geometry and dispatching less terrain requests.
+    
+    Disbaled by default if an ellipsoid other than WGS84 is used.
      */
     fog: Fog;
     /**
@@ -41371,13 +41480,13 @@ export class Scene {
     shadowMap: ShadowMap;
     /**
      * When <code>false</code>, 3D Tiles will render normally. When <code>true</code>, classified 3D Tile geometry will render normally and
-     * unclassified 3D Tile geometry will render with the color multiplied by {@link Scene#invertClassificationColor}.
+    unclassified 3D Tile geometry will render with the color multiplied by {@link Scene#invertClassificationColor}.
      */
     invertClassification: boolean;
     /**
      * The highlight color of unclassified 3D Tile geometry when {@link Scene#invertClassification} is <code>true</code>.
-     * <p>When the color's alpha is less than 1.0, the unclassified portions of the 3D Tiles will not blend correctly with the classified positions of the 3D Tiles.</p>
-     * <p>Also, when the color's alpha is less than 1.0, the WEBGL_depth_texture and EXT_frag_depth WebGL extensions must be supported.</p>
+    <p>When the color's alpha is less than 1.0, the unclassified portions of the 3D Tiles will not blend correctly with the classified positions of the 3D Tiles.</p>
+    <p>Also, when the color's alpha is less than 1.0, the WEBGL_depth_texture and EXT_frag_depth WebGL extensions must be supported.</p>
      */
     invertClassificationColor: Color;
     /**
@@ -41394,18 +41503,18 @@ export class Scene {
     postProcessStages: PostProcessStageCollection;
     /**
      * When <code>true</code>, rendering a frame will only occur when needed as determined by changes within the scene.
-     * Enabling improves performance of the application, but requires using {@link Scene#requestRender}
-     * to render a new frame explicitly in this mode. This will be necessary in many cases after making changes
-     * to the scene in other parts of the API.
+    Enabling improves performance of the application, but requires using {@link Scene#requestRender}
+    to render a new frame explicitly in this mode. This will be necessary in many cases after making changes
+    to the scene in other parts of the API.
      */
     requestRenderMode: boolean;
     /**
      * If {@link Scene#requestRenderMode} is <code>true</code>, this value defines the maximum change in
-     * simulation time allowed before a render is requested. Lower values increase the number of frames rendered
-     * and higher values decrease the number of frames rendered. If <code>undefined</code>, changes to
-     * the simulation time will never request a render.
-     * This value impacts the rate of rendering for changes in the scene like lighting, entity property updates,
-     * and animations.
+    simulation time allowed before a render is requested. Lower values increase the number of frames rendered
+    and higher values decrease the number of frames rendered. If <code>undefined</code>, changes to
+    the simulation time will never request a render.
+    This value impacts the rate of rendering for changes in the scene like lighting, entity property updates,
+    and animations.
      */
     maximumRenderTimeChange: number;
     /**
@@ -41422,7 +41531,7 @@ export class Scene {
     light: Light;
     /**
      * Use this to set the default value for {@link Scene#logarithmicDepthBuffer} in newly constructed Scenes
-     * This property relies on fragmentDepth being supported.
+    This property relies on fragmentDepth being supported.
      */
     static defaultLogDepthBuffer: any;
     /**
@@ -41507,48 +41616,48 @@ export class Scene {
     readonly terrainProviderChanged: Event;
     /**
      * Gets the event that will be raised before the scene is updated or rendered.  Subscribers to the event
-     * receive the Scene instance as the first parameter and the current time as the second parameter.
+    receive the Scene instance as the first parameter and the current time as the second parameter.
      */
     readonly preUpdate: Event;
     /**
      * Gets the event that will be raised immediately after the scene is updated and before the scene is rendered.
-     * Subscribers to the event receive the Scene instance as the first parameter and the current time as the second
-     * parameter.
+    Subscribers to the event receive the Scene instance as the first parameter and the current time as the second
+    parameter.
      */
     readonly postUpdate: Event;
     /**
      * Gets the event that will be raised when an error is thrown inside the <code>render</code> function.
-     * The Scene instance and the thrown error are the only two parameters passed to the event handler.
-     * By default, errors are not rethrown after this event is raised, but that can be changed by setting
-     * the <code>rethrowRenderErrors</code> property.
+    The Scene instance and the thrown error are the only two parameters passed to the event handler.
+    By default, errors are not rethrown after this event is raised, but that can be changed by setting
+    the <code>rethrowRenderErrors</code> property.
      */
     readonly renderError: Event;
     /**
      * Gets the event that will be raised after the scene is updated and immediately before the scene is rendered.
-     * Subscribers to the event receive the Scene instance as the first parameter and the current time as the second
-     * parameter.
+    Subscribers to the event receive the Scene instance as the first parameter and the current time as the second
+    parameter.
      */
     readonly preRender: Event;
     /**
      * Gets the event that will be raised immediately after the scene is rendered.  Subscribers to the event
-     * receive the Scene instance as the first parameter and the current time as the second parameter.
+    receive the Scene instance as the first parameter and the current time as the second parameter.
      */
     readonly postRender: Event;
     /**
      * Gets the simulation time when the scene was last rendered. Returns undefined if the scene has not yet been
-     * rendered.
+    rendered.
      */
     readonly lastRenderTime: JulianDate;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * When {@link Scene.debugShowFrustums} is <code>true</code>, this contains
-     * properties with statistics about the number of command execute per frustum.
-     * <code>totalCommands</code> is the total number of commands executed, ignoring
-     * overlap. <code>commandsInFrustums</code> is an array with the number of times
-     * commands are executed redundantly, e.g., how many commands overlap two or
-     * three frustums.
-     * </p>
+    <p>
+    When {@link Scene.debugShowFrustums} is <code>true</code>, this contains
+    properties with statistics about the number of command execute per frustum.
+    <code>totalCommands</code> is the total number of commands executed, ignoring
+    overlap. <code>commandsInFrustums</code> is an array with the number of times
+    commands are executed redundantly, e.g., how many commands overlap two or
+    three frustums.
+    </p>
      */
     readonly debugFrustumStatistics: any;
     /**
@@ -41557,8 +41666,8 @@ export class Scene {
     readonly scene3DOnly: boolean;
     /**
      * Gets whether or not the scene has order independent translucency enabled.
-     * Note that this only reflects the original construction option, and there are
-     * other factors that could prevent OIT from functioning on a given system configuration.
+    Note that this only reflects the original construction option, and there are
+    other factors that could prevent OIT from functioning on a given system configuration.
      */
     readonly orderIndependentTranslucency: boolean;
     /**
@@ -41571,7 +41680,7 @@ export class Scene {
     mode: SceneMode;
     /**
      * When <code>true</code>, splits the scene into two viewports with steroscopic views for the left and right eyes.
-     * Used for cardboard and WebVR.
+    Used for cardboard and WebVR.
      */
     useWebVR: boolean;
     /**
@@ -41584,14 +41693,14 @@ export class Scene {
     splitPosition: number;
     /**
      * The distance from the camera at which to disable the depth test of billboards, labels and points
-     * to, for example, prevent clipping against terrain. When set to zero, the depth test should always
-     * be applied. When less than zero, the depth test should never be applied. Setting the disableDepthTestDistance
-     * property of a billboard, label or point will override this value.
+    to, for example, prevent clipping against terrain. When set to zero, the depth test should always
+    be applied. When less than zero, the depth test should never be applied. Setting the disableDepthTestDistance
+    property of a billboard, label or point will override this value.
      */
     minimumDisableDepthTestDistance: number;
     /**
      * Whether or not to use a logarithmic depth buffer. Enabling this option will allow for less frustums in the multi-frustum,
-     * increasing performance. This property relies on fragmentDepth being supported.
+    increasing performance. This property relies on fragmentDepth being supported.
      */
     logarithmicDepthBuffer: boolean;
     /**
@@ -41626,30 +41735,30 @@ export class Scene {
     getCompressedTextureFormatSupported(format: string): boolean;
     /**
      * Update and render the scene. It is usually not necessary to call this function
-     * directly because {@link CesiumWidget} will do it automatically.
+    directly because {@link CesiumWidget} will do it automatically.
      * @param [time] - The simulation time at which to render.
      */
     render(time?: JulianDate): void;
     /**
      * Requests a new rendered frame when {@link Scene#requestRenderMode} is set to <code>true</code>.
-     * The render rate will not exceed the {@link CesiumWidget#targetFrameRate}.
+    The render rate will not exceed the {@link CesiumWidget#targetFrameRate}.
      */
     requestRender(): void;
     /**
      * Returns an object with a `primitive` property that contains the first (top) primitive in the scene
-     * at a particular window coordinate or undefined if nothing is at the location. Other properties may
-     * potentially be set depending on the type of primitive and may be used to further identify the picked object.
-     * <p>
-     * When a feature of a 3D Tiles tileset is picked, <code>pick</code> returns a {@link Cesium3DTileFeature} object.
-     * </p>
+    at a particular window coordinate or undefined if nothing is at the location. Other properties may
+    potentially be set depending on the type of primitive and may be used to further identify the picked object.
+    <p>
+    When a feature of a 3D Tiles tileset is picked, <code>pick</code> returns a {@link Cesium3DTileFeature} object.
+    </p>
      * @example
      * // On mouse over, color the feature yellow.
-     * handler.setInputAction(function(movement) {
-     *     const feature = scene.pick(movement.endPosition);
-     *     if (feature instanceof Cesium.Cesium3DTileFeature) {
-     *         feature.color = Cesium.Color.YELLOW;
-     *     }
-     * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+    handler.setInputAction(function(movement) {
+        const feature = scene.pick(movement.endPosition);
+        if (feature instanceof Cesium.Cesium3DTileFeature) {
+            feature.color = Cesium.Color.YELLOW;
+        }
+    }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
      * @param windowPosition - Window coordinates to perform picking on.
      * @param [width = 3] - Width of the pick rectangle.
      * @param [height = 3] - Height of the pick rectangle.
@@ -41658,15 +41767,15 @@ export class Scene {
     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.
+    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);
+    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.
@@ -41677,34 +41786,34 @@ export class Scene {
      * Pick a metadata value at the given window position.
      * @param windowPosition - Window coordinates to perform picking on.
      * @param schemaId - The ID of the metadata schema to pick values
-     * from. If this is `undefined`, then it will pick the values from the object
-     * that match the given class- and property name, regardless of the schema ID.
+    from. If this is `undefined`, then it will pick the values from the object
+    that match the given class- and property name, regardless of the schema ID.
      * @param className - The name of the metadata class to pick
-     * values from
+    values from
      * @param propertyName - The name of the metadata property to pick
-     * values from
+    values from
      * @returns The metadata value, or `undefined` when
-     * no matching metadata was found at the given position
+    no matching metadata was found at the given position
      */
     pickMetadata(windowPosition: Cartesian2, schemaId: string | undefined, className: string, propertyName: string): MetadataValue | undefined;
     /**
      * Pick the schema of the metadata of the object at the given position
      * @param windowPosition - Window coordinates to perform picking on.
      * @returns The metadata schema, or `undefined` if there is no object with
-     * associated metadata at the given position.
+    associated metadata at the given position.
      */
     pickMetadataSchema(windowPosition: Cartesian2): MetadataSchema;
     /**
      * Returns the cartesian position reconstructed from the depth buffer and window position.
-     * <p>
-     * The position reconstructed from the depth buffer in 2D may be slightly different from those
-     * reconstructed in 3D and Columbus view. This is caused by the difference in the distribution
-     * of depth values of perspective and orthographic projection.
-     * </p>
-     * <p>
-     * Set {@link Scene#pickTranslucentDepth} to <code>true</code> to include the depth of
-     * translucent primitives; otherwise, this essentially picks through translucent primitives.
-     * </p>
+    <p>
+    The position reconstructed from the depth buffer in 2D may be slightly different from those
+    reconstructed in 3D and Columbus view. This is caused by the difference in the distribution
+    of depth values of perspective and orthographic projection.
+    </p>
+    <p>
+    Set {@link Scene#pickTranslucentDepth} to <code>true</code> to include the depth of
+    translucent primitives; otherwise, this essentially picks through translucent primitives.
+    </p>
      * @param windowPosition - Window coordinates to perform picking on.
      * @param [result] - The object on which to restore the result.
      * @returns The cartesian position.
@@ -41712,9 +41821,9 @@ export class Scene {
     pickPosition(windowPosition: Cartesian2, result?: Cartesian3): Cartesian3;
     /**
      * Returns a list of objects, each containing a `primitive` property, for all primitives at
-     * a particular window coordinate position. Other properties may also be set depending on the
-     * type of primitive and may be used to further identify the picked object. The primitives in
-     * the list are ordered by their visual order in the scene (front to back).
+    a particular window coordinate position. Other properties may also be set depending on the
+    type of primitive and may be used to further identify the picked object. The primitives in
+    the list are ordered by their visual order in the scene (front to back).
      * @example
      * const pickedObjects = scene.drillPick(new Cesium.Cartesian2(100.0, 200.0));
      * @param windowPosition - Window coordinates to perform picking on.
@@ -41726,16 +41835,16 @@ export class Scene {
     drillPick(windowPosition: Cartesian2, limit?: number, width?: number, height?: number): any[];
     /**
      * Returns the height of scene geometry at the given cartographic position or <code>undefined</code> if there was no
-     * scene geometry to sample height from. The height of the input position is ignored. May be used to clamp objects to
-     * the globe, 3D Tiles, or primitives in the scene.
-     * <p>
-     * This function only samples height from globe tiles and 3D Tiles that are rendered in the current view. Samples height
-     * from all other primitives regardless of their visibility.
-     * </p>
+    scene geometry to sample height from. The height of the input position is ignored. May be used to clamp objects to
+    the globe, 3D Tiles, or primitives in the scene.
+    <p>
+    This function only samples height from globe tiles and 3D Tiles that are rendered in the current view. Samples height
+    from all other primitives regardless of their visibility.
+    </p>
      * @example
      * const position = new Cesium.Cartographic(-1.31968, 0.698874);
-     * const height = viewer.scene.sampleHeight(position);
-     * console.log(height);
+    const height = viewer.scene.sampleHeight(position);
+    console.log(height);
      * @param position - The cartographic position to sample height from.
      * @param [objectsToExclude] - A list of primitives, entities, or 3D Tiles features to not sample height from.
      * @param [width = 0.1] - Width of the intersection volume in meters.
@@ -41744,16 +41853,16 @@ export class Scene {
     sampleHeight(position: Cartographic, objectsToExclude?: object[], width?: number): number;
     /**
      * Clamps the given cartesian position to the scene geometry along the geodetic surface normal. Returns the
-     * clamped position or <code>undefined</code> if there was no scene geometry to clamp to. May be used to clamp
-     * objects to the globe, 3D Tiles, or primitives in the scene.
-     * <p>
-     * This function only clamps to globe tiles and 3D Tiles that are rendered in the current view. Clamps to
-     * all other primitives regardless of their visibility.
-     * </p>
+    clamped position or <code>undefined</code> if there was no scene geometry to clamp to. May be used to clamp
+    objects to the globe, 3D Tiles, or primitives in the scene.
+    <p>
+    This function only clamps to globe tiles and 3D Tiles that are rendered in the current view. Clamps to
+    all other primitives regardless of their visibility.
+    </p>
      * @example
      * // Clamp an entity to the underlying scene geometry
-     * const position = entity.position.getValue(Cesium.JulianDate.now());
-     * entity.position = viewer.scene.clampToHeight(position);
+    const position = entity.position.getValue(Cesium.JulianDate.now());
+    entity.position = viewer.scene.clampToHeight(position);
      * @param cartesian - The cartesian position.
      * @param [objectsToExclude] - A list of primitives, entities, or 3D Tiles features to not clamp to.
      * @param [width = 0.1] - Width of the intersection volume in meters.
@@ -41763,20 +41872,20 @@ export class Scene {
     clampToHeight(cartesian: Cartesian3, objectsToExclude?: object[], width?: number, result?: Cartesian3): Cartesian3;
     /**
      * Initiates an asynchronous {@link Scene#sampleHeight} query for an array of {@link Cartographic} positions
-     * using the maximum level of detail for 3D Tilesets in the scene. The height of the input positions is ignored.
-     * Returns a promise that is resolved when the query completes. Each point height is modified in place.
-     * If a height cannot be determined because no geometry can be sampled at that location, or another error occurs,
-     * the height is set to undefined.
+    using the maximum level of detail for 3D Tilesets in the scene. The height of the input positions is ignored.
+    Returns a promise that is resolved when the query completes. Each point height is modified in place.
+    If a height cannot be determined because no geometry can be sampled at that location, or another error occurs,
+    the height is set to undefined.
      * @example
      * const positions = [
-     *     new Cesium.Cartographic(-1.31968, 0.69887),
-     *     new Cesium.Cartographic(-1.10489, 0.83923)
-     * ];
-     * const promise = viewer.scene.sampleHeightMostDetailed(positions);
-     * promise.then(function(updatedPosition) {
-     *     // positions[0].height and positions[1].height have been updated.
-     *     // updatedPositions is just a reference to positions.
-     * }
+        new Cesium.Cartographic(-1.31968, 0.69887),
+        new Cesium.Cartographic(-1.10489, 0.83923)
+    ];
+    const promise = viewer.scene.sampleHeightMostDetailed(positions);
+    promise.then(function(updatedPosition) {
+        // positions[0].height and positions[1].height have been updated.
+        // updatedPositions is just a reference to positions.
+    }
      * @param positions - The cartographic positions to update with sampled heights.
      * @param [objectsToExclude] - A list of primitives, entities, or 3D Tiles features to not sample height from.
      * @param [width = 0.1] - Width of the intersection volume in meters.
@@ -41785,19 +41894,19 @@ export class Scene {
     sampleHeightMostDetailed(positions: Cartographic[], objectsToExclude?: object[], width?: number): Promise<Cartographic[]>;
     /**
      * Initiates an asynchronous {@link Scene#clampToHeight} query for an array of {@link Cartesian3} positions
-     * using the maximum level of detail for 3D Tilesets in the scene. Returns a promise that is resolved when
-     * the query completes. Each position is modified in place. If a position cannot be clamped because no geometry
-     * can be sampled at that location, or another error occurs, the element in the array is set to undefined.
+    using the maximum level of detail for 3D Tilesets in the scene. Returns a promise that is resolved when
+    the query completes. Each position is modified in place. If a position cannot be clamped because no geometry
+    can be sampled at that location, or another error occurs, the element in the array is set to undefined.
      * @example
      * const cartesians = [
-     *     entities[0].position.getValue(Cesium.JulianDate.now()),
-     *     entities[1].position.getValue(Cesium.JulianDate.now())
-     * ];
-     * const promise = viewer.scene.clampToHeightMostDetailed(cartesians);
-     * promise.then(function(updatedCartesians) {
-     *     entities[0].position = updatedCartesians[0];
-     *     entities[1].position = updatedCartesians[1];
-     * }
+        entities[0].position.getValue(Cesium.JulianDate.now()),
+        entities[1].position.getValue(Cesium.JulianDate.now())
+    ];
+    const promise = viewer.scene.clampToHeightMostDetailed(cartesians);
+    promise.then(function(updatedCartesians) {
+        entities[0].position = updatedCartesians[0];
+        entities[1].position = updatedCartesians[1];
+    }
      * @param cartesians - The cartesian positions to update with clamped positions.
      * @param [objectsToExclude] - A list of primitives, entities, or 3D Tiles features to not clamp to.
      * @param [width = 0.1] - Width of the intersection volume in meters.
@@ -41806,15 +41915,15 @@ export class Scene {
     clampToHeightMostDetailed(cartesians: Cartesian3[], objectsToExclude?: object[], width?: number): Promise<Cartesian3[]>;
     /**
      * Transforms a position in cartesian coordinates to canvas coordinates.  This is commonly used to place an
-     * HTML element at the same screen position as an object in the scene.
+    HTML element at the same screen position as an object in the scene.
      * @example
      * // Output the canvas position of longitude/latitude (0, 0) every time the mouse moves.
-     * const scene = widget.scene;
-     * const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
-     * const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
-     * handler.setInputAction(function(movement) {
-     *     console.log(scene.cartesianToCanvasCoordinates(position));
-     * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+    const scene = widget.scene;
+    const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
+    const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
+    handler.setInputAction(function(movement) {
+        console.log(scene.cartesianToCanvasCoordinates(position));
+    }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
      * @param position - The position in cartesian coordinates.
      * @param [result] - An optional object to return the input position transformed to canvas coordinates.
      * @returns The modified result parameter or a new Cartesian2 instance if one was not provided.  This may be <code>undefined</code> if the input position is near the center of the ellipsoid.
@@ -41843,34 +41952,34 @@ export class Scene {
      * Update the terrain providing surface geometry for the globe.
      * @example
      * // Use Cesium World Terrain
-     * scene.setTerrain(Cesium.Terrain.fromWorldTerrain());
+    scene.setTerrain(Cesium.Terrain.fromWorldTerrain());
      * @example
      * // Use a custom terrain provider
-     * const terrain = new Cesium.Terrain(Cesium.CesiumTerrainProvider.fromUrl("https://myTestTerrain.com"));
-     * scene.setTerrain(terrain);
-     *
-     * terrain.errorEvent.addEventListener(error => {
-     *   alert(`Encountered an error while creating terrain! ${error}`);
-     * });
+    const terrain = new Cesium.Terrain(Cesium.CesiumTerrainProvider.fromUrl("https://myTestTerrain.com"));
+    scene.setTerrain(terrain);
+    
+    terrain.errorEvent.addEventListener(error => {
+      alert(`Encountered an error while creating terrain! ${error}`);
+    });
      * @param terrain - The terrain provider async helper
      * @returns terrain The terrain provider async helper
      */
     setTerrain(terrain: Terrain): Terrain;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-     * <br /><br />
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+    <br /><br />
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
      * @returns <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
      */
     isDestroyed(): 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.
-     * <br /><br />
-     * Once an object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
+    release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+    <br /><br />
+    Once an object is destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+    assign the return value (<code>undefined</code>) to the object as done in the example.
      * @example
      * scene = scene && scene.destroy();
      */
@@ -41879,11 +41988,11 @@ export class Scene {
 
 /**
  * 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.
+
+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.
  */
@@ -41958,18 +42067,18 @@ export class ScreenSpaceCameraController {
     constructor(scene: Scene);
     /**
      * If true, inputs are allowed conditionally with the flags enableTranslate, enableZoom,
-     * enableRotate, enableTilt, and enableLook.  If false, all inputs are disabled.
-     *
-     * NOTE: This setting is for temporary use cases, such as camera flights and
-     * drag-selection of regions (see Picking demo).  It is typically set to false at the
-     * start of such events, and set true on completion.  To keep inputs disabled
-     * past the end of camera flights, you must use the other booleans (enableTranslate,
-     * enableZoom, enableRotate, enableTilt, and enableLook).
+    enableRotate, enableTilt, and enableLook.  If false, all inputs are disabled.
+    
+    NOTE: This setting is for temporary use cases, such as camera flights and
+    drag-selection of regions (see Picking demo).  It is typically set to false at the
+    start of such events, and set true on completion.  To keep inputs disabled
+    past the end of camera flights, you must use the other booleans (enableTranslate,
+    enableZoom, enableRotate, enableTilt, and enableLook).
      */
     enableInputs: boolean;
     /**
      * If true, allows the user to pan around the map.  If false, the camera stays locked at the current position.
-     * This flag only applies in 2D and Columbus view modes.
+    This flag only applies in 2D and Columbus view modes.
      */
     enableTranslate: boolean;
     /**
@@ -41978,41 +42087,41 @@ export class ScreenSpaceCameraController {
     enableZoom: boolean;
     /**
      * If true, allows the user to rotate the world which translates the user's position.
-     * This flag only applies in 2D and 3D.
+    This flag only applies in 2D and 3D.
      */
     enableRotate: boolean;
     /**
      * If true, allows the user to tilt the camera.  If false, the camera is locked to the current heading.
-     * This flag only applies in 3D and Columbus view.
+    This flag only applies in 3D and Columbus view.
      */
     enableTilt: boolean;
     /**
      * If true, allows the user to use free-look. If false, the camera view direction can only be changed through translating
-     * or rotating. This flag only applies in 3D and Columbus view modes.
+    or rotating. This flag only applies in 3D and Columbus view modes.
      */
     enableLook: boolean;
     /**
      * A parameter in the range <code>[0, 1)</code> used to determine how long
-     * the camera will continue to spin because of inertia.
-     * With value of zero, the camera will have no inertia.
+    the camera will continue to spin because of inertia.
+    With value of zero, the camera will have no inertia.
      */
     inertiaSpin: number;
     /**
      * A parameter in the range <code>[0, 1)</code> used to determine how long
-     * the camera will continue to translate because of inertia.
-     * With value of zero, the camera will have no inertia.
+    the camera will continue to translate because of inertia.
+    With value of zero, the camera will have no inertia.
      */
     inertiaTranslate: number;
     /**
      * A parameter in the range <code>[0, 1)</code> used to determine how long
-     * the camera will continue to zoom because of inertia.
-     * With value of zero, the camera will have no inertia.
+    the camera will continue to zoom because of inertia.
+    With value of zero, the camera will have no inertia.
      */
     inertiaZoom: number;
     /**
      * A parameter in the range <code>[0, 1)</code> used to limit the range
-     * of various user inputs to a percentage of the window width/height per animation frame.
-     * This helps keep the camera under control in low-frame-rate situations.
+    of various user inputs to a percentage of the window width/height per animation frame.
+    This helps keep the camera under control in low-frame-rate situations.
      */
     maximumMovementRatio: number;
     /**
@@ -42033,47 +42142,47 @@ export class ScreenSpaceCameraController {
     zoomFactor: number;
     /**
      * The input that allows the user to pan around the map. This only applies in 2D and Columbus view modes.
-     * <p>
-     * The type can be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
-     * and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
-     * or an array of any of the preceding.
-     * </p>
+    <p>
+    The type can be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
+    and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
+    or an array of any of the preceding.
+    </p>
      */
     translateEventTypes: CameraEventType | any[] | undefined;
     /**
      * The input that allows the user to zoom in/out.
-     * <p>
-     * The type can be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
-     * and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
-     * or an array of any of the preceding.
-     * </p>
+    <p>
+    The type can be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
+    and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
+    or an array of any of the preceding.
+    </p>
      */
     zoomEventTypes: CameraEventType | any[] | undefined;
     /**
      * The input that allows the user to rotate around the globe or another object. This only applies in 3D and Columbus view modes.
-     * <p>
-     * The type can be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
-     * and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
-     * or an array of any of the preceding.
-     * </p>
+    <p>
+    The type can be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
+    and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
+    or an array of any of the preceding.
+    </p>
      */
     rotateEventTypes: CameraEventType | any[] | undefined;
     /**
      * The input that allows the user to tilt in 3D and Columbus view or twist in 2D.
-     * <p>
-     * The type can be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
-     * and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
-     * or an array of any of the preceding.
-     * </p>
+    <p>
+    The type can be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
+    and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
+    or an array of any of the preceding.
+    </p>
      */
     tiltEventTypes: CameraEventType | any[] | undefined;
     /**
      * The input that allows the user to change the direction the camera is viewing. This only applies in 3D and Columbus view modes.
-     * <p>
-     * The type can be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
-     * and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
-     * or an array of any of the preceding.
-     * </p>
+    <p>
+    The type can be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
+    and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
+    or an array of any of the preceding.
+    </p>
      */
     lookEventTypes: CameraEventType | any[] | undefined;
     /**
@@ -42090,7 +42199,7 @@ export class ScreenSpaceCameraController {
     minimumCollisionTerrainHeight: number;
     /**
      * The minimum height the camera must be before switching from rotating a track ball to
-     * free look when clicks originate on the sky or in space. Defaults to ellipsoid.minimumRadius * 1.175 when another ellipsoid than WGS84 is used.
+    free look when clicks originate on the sky or in space. Defaults to ellipsoid.minimumRadius * 1.175 when another ellipsoid than WGS84 is used.
      */
     minimumTrackBallHeight: number;
     /**
@@ -42101,23 +42210,23 @@ export class ScreenSpaceCameraController {
      * The angle, relative to the ellipsoid normal, restricting the maximum amount that the user can tilt the camera. If <code>undefined</code>, the angle of the camera tilt is unrestricted.
      * @example
      * // Prevent the camera from tilting below the ellipsoid surface
-     * viewer.scene.screenSpaceCameraController.maximumTiltAngle = Math.PI / 2.0;
+    viewer.scene.screenSpaceCameraController.maximumTiltAngle = Math.PI / 2.0;
      */
     maximumTiltAngle: number | undefined;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-     * <br /><br />
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+    <br /><br />
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
      * @returns <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
      */
     isDestroyed(): boolean;
     /**
      * Removes mouse listeners held by this object.
-     * <br /><br />
-     * Once an object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
+    <br /><br />
+    Once an object is destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+    assign the return value (<code>undefined</code>) to the object as done in the example.
      * @example
      * controller = controller && controller.destroy();
      */
@@ -42144,13 +42253,13 @@ export enum SensorVolumePortionToDisplay {
 
 /**
  * <div class="notice">
- * Use {@link Viewer#shadowMap} to get the scene's shadow map. Do not construct this directly.
- * </div>
- *
- * <p>
- * The normalOffset bias pushes the shadows forward slightly, and may be disabled
- * for applications that require ultra precise shadows.
- * </p>
+Use {@link Viewer#shadowMap} to get the scene's shadow map. Do not construct this directly.
+</div>
+
+<p>
+The normalOffset bias pushes the shadows forward slightly, and may be disabled
+for applications that require ultra precise shadows.
+</p>
  */
 export class ShadowMap {
     constructor();
@@ -43744,6 +43853,29 @@ export class VoxelCell {
     getProperty(name: string): any;
 }
 
+/**
+ * <div class="notice">
+To construct a VoxelContent, call {@link VoxelContent.fromMetadataArray} or {@link VoxelContent.fromGltf}. Do not call the constructor directly.
+</div>
+An object representing voxel content for a {@link Cesium3DTilesVoxelProvider}.
+ */
+export class VoxelContent {
+    constructor();
+    /**
+     * Constructs a VoxelContent from an array of metadata.
+     * @param metadata - The metadata to use for this voxel content.
+     * @returns A VoxelContent containing the specified metadata.
+     */
+    static fromMetadataArray(metadata: Int8Array[] | Uint8Array[] | Int16Array[] | Uint16Array[] | Int32Array[] | Uint32Array[] | Float32Array[] | Float64Array[]): VoxelContent;
+}
+
+/**
+ * The metadata for this voxel content.
+The metadata is an array of typed arrays, one for each field.
+The data for one field is a flattened 3D array ordered by X, then Y, then Z.
+ */
+export const metadata: Int8Array[] | Uint8Array[] | Int16Array[] | Uint16Array[] | Int32Array[] | Uint32Array[] | Float32Array[] | Float64Array[];
+
 /**
  * A primitive that renders voxel data from a {@link VoxelProvider}.
  * @param [options] - Object with the following properties:
@@ -43751,6 +43883,7 @@ export class VoxelCell {
  * @param [options.modelMatrix = Matrix4.IDENTITY] - The model matrix used to transform the primitive.
  * @param [options.customShader] - The custom shader used to style the primitive.
  * @param [options.clock] - The clock used to control time dynamic behavior.
+ * @param [options.calculateStatistics] - Generate statistics for performance profile.
  */
 export class VoxelPrimitive {
     constructor(options?: {
@@ -43758,11 +43891,8 @@ export class VoxelPrimitive {
         modelMatrix?: Matrix4;
         customShader?: CustomShader;
         clock?: Clock;
+        calculateStatistics?: boolean;
     });
-    /**
-     * The number of levels of detail containing available tiles in the tileset.
-     */
-    readonly availableLevels: number | undefined;
     /**
      * The event fired to indicate that a tile's content was loaded.
     <p>
@@ -43873,9 +44003,23 @@ export class VoxelPrimitive {
      */
     readonly shape: VoxelShapeType;
     /**
-     * Gets the voxel dimensions.
+     * Gets the dimensions of each voxel tile, in z-up orientation.
+    Does not include padding.
      */
     readonly dimensions: Cartesian3;
+    /**
+     * Gets the dimensions of one tile of the input voxel data, in the input orientation.
+    Includes padding.
+     */
+    readonly inputDimensions: Cartesian3;
+    /**
+     * Gets the padding before the voxel data.
+     */
+    readonly paddingBefore: Cartesian3;
+    /**
+     * Gets the padding after the voxel data.
+     */
+    readonly paddingAfter: Cartesian3;
     /**
      * Gets the minimum value per channel of the voxel data.
      */
@@ -43977,91 +44121,80 @@ This type describes an interface and is not intended to be instantiated directly
 export class VoxelProvider {
     constructor();
     /**
-     * A transform from local space to global space. If undefined, the identity matrix will be used instead.
+     * A transform from local space to global space.
      */
-    readonly globalTransform: Matrix4 | undefined;
+    readonly globalTransform: Matrix4;
     /**
-     * A transform from shape space to local space. If undefined, the identity matrix will be used instead.
+     * A transform from shape space to local space.
      */
-    readonly shapeTransform: Matrix4 | undefined;
+    readonly shapeTransform: Matrix4;
     /**
      * Gets the {@link VoxelShapeType}
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly shape: VoxelShapeType;
     /**
      * Gets the minimum bounds.
     If undefined, the shape's default minimum bounds will be used instead.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly minBounds: Cartesian3 | undefined;
     /**
      * Gets the maximum bounds.
     If undefined, the shape's default maximum bounds will be used instead.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maxBounds: Cartesian3 | undefined;
     /**
      * Gets the number of voxels per dimension of a tile. This is the same for all tiles in the dataset.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly dimensions: Cartesian3;
     /**
      * Gets the number of padding voxels before the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
-    readonly paddingBefore: Cartesian3 | undefined;
+    readonly paddingBefore: Cartesian3;
     /**
      * Gets the number of padding voxels after the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
-    readonly paddingAfter: Cartesian3 | undefined;
+    readonly paddingAfter: Cartesian3;
     /**
      * Gets the metadata names.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly names: string[];
     /**
      * Gets the metadata types.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly types: MetadataType[];
     /**
      * Gets the metadata component types.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly componentTypes: MetadataComponentType[];
     /**
      * Gets the metadata minimum values.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly minimumValues: number[][] | undefined;
     /**
      * Gets the metadata maximum values.
-    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maximumValues: number[][] | undefined;
     /**
-     * The maximum number of tiles that exist for this provider. This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory. If this value is not known it can be undefined.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * The maximum number of tiles that exist for this provider.
+    This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory.
+    If this value is not known it can be undefined.
      */
     readonly maximumTileCount: number | undefined;
     /**
-     * Requests the data for a given tile. The data is a flattened 3D array ordered by X, then Y, then Z.
-    This function should not be called before {@link VoxelProvider#ready} returns true.
+     * 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 to an array of typed arrays containing the requested voxel data or undefined if there was a problem loading the data.
+     * @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<any[][]> | undefined;
+    }): Promise<VoxelContent> | undefined;
 }
 
 /**
@@ -44069,19 +44202,6 @@ export class VoxelProvider {
  */
 export const availableLevels: number | undefined;
 
-export const shaderUniforms: {
-    [key: string]: any;
-};
-
-export const shaderDefines: {
-    [key: string]: any;
-};
-
-/**
- * The maximum number of intersections against the shape for any ray direction.
- */
-export const shaderMaximumIntersectionsLength: number;
-
 /**
  * An enum of voxel shapes. The shape controls how the voxel grid is mapped to 3D space.
  */
@@ -44118,31 +44238,31 @@ export namespace WebMapServiceImageryProvider {
      * @property [parameters = WebMapServiceImageryProvider.DefaultParameters] - Additional parameters to pass to the WMS server in the GetMap URL.
      * @property [getFeatureInfoParameters = WebMapServiceImageryProvider.GetFeatureInfoDefaultParameters] - Additional parameters to pass to the WMS server in the GetFeatureInfo URL.
      * @property [enablePickFeatures = true] - If true, {@link WebMapServiceImageryProvider#pickFeatures} will invoke
-     *        the GetFeatureInfo operation on the WMS server and return the features included in the response.  If false,
-     *        {@link WebMapServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable features)
-     *        without communicating with the server.  Set this property to false if you know your WMS server does not support
-     *        GetFeatureInfo or if you don't want this provider's features to be pickable. Note that this can be dynamically
-     *        overridden by modifying the WebMapServiceImageryProvider#enablePickFeatures property.
+           the GetFeatureInfo operation on the WMS server and return the features included in the response.  If false,
+           {@link WebMapServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable features)
+           without communicating with the server.  Set this property to false if you know your WMS server does not support
+           GetFeatureInfo or if you don't want this provider's features to be pickable. Note that this can be dynamically
+           overridden by modifying the WebMapServiceImageryProvider#enablePickFeatures property.
      * @property [getFeatureInfoFormats = WebMapServiceImageryProvider.DefaultGetFeatureInfoFormats] - The formats
-     *        in which to try WMS GetFeatureInfo requests.
+           in which to try WMS GetFeatureInfo requests.
      * @property [rectangle = Rectangle.MAX_VALUE] - The rectangle of the layer.
      * @property [tilingScheme = new GeographicTilingScheme()] - The tiling scheme to use to divide the world into tiles.
      * @property [ellipsoid] - The ellipsoid.  If the tilingScheme is specified,
-     *        this parameter is ignored and the tiling scheme's ellipsoid is used instead. If neither
-     *        parameter is specified, the WGS84 ellipsoid is used.
+           this parameter is ignored and the tiling scheme's ellipsoid is used instead. If neither
+           parameter is specified, the WGS84 ellipsoid is used.
      * @property [tileWidth = 256] - The width of each tile in pixels.
      * @property [tileHeight = 256] - The height of each tile in pixels.
      * @property [minimumLevel = 0] - The minimum level-of-detail supported by the imagery provider.  Take care when
-     *        specifying this that the number of tiles at the minimum level is small, such as four or less.  A larger number is
-     *        likely to result in rendering problems.
+           specifying this that the number of tiles at the minimum level is small, such as four or less.  A larger number is
+           likely to result in rendering problems.
      * @property [maximumLevel] - The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit.
-     *        If not specified, there is no limit.
+           If not specified, there is no limit.
      * @property [crs] - CRS specification, for use with WMS specification >= 1.3.0.
      * @property [srs] - SRS specification, for use with WMS specification 1.1.0 or 1.1.1
      * @property [credit] - A credit for the data source, which is displayed on the canvas.
      * @property [subdomains = 'abc'] - The subdomains to use for the <code>{s}</code> placeholder in the URL template.
-     *                          If this parameter is a single string, each character in the string is a subdomain.  If it is
-     *                          an array, each element in the array is a subdomain.
+                             If this parameter is a single string, each character in the string is a subdomain.  If it is
+                             an array, each element in the array is a subdomain.
      * @property [clock] - A Clock instance that is used when determining the value for the time dimension. Required when `times` is specified.
      * @property [times] - TimeIntervalCollection with its data property being an object containing time dynamic dimension and their values.
      * @property [getFeatureInfoUrl] - The getFeatureInfo URL of the WMS service. If the property is not defined then we use the property value of url.
@@ -44175,12 +44295,12 @@ export namespace WebMapServiceImageryProvider {
  * Provides tiled imagery hosted by a Web Map Service (WMS) server.
  * @example
  * const provider = new Cesium.WebMapServiceImageryProvider({
- *     url : 'https://sampleserver1.arcgisonline.com/ArcGIS/services/Specialty/ESRI_StatesCitiesRivers_USA/MapServer/WMSServer',
- *     layers : '0',
- *     proxy: new Cesium.DefaultProxy('/proxy/')
- * });
- * const imageryLayer = new Cesium.ImageryLayer(provider);
- * viewer.imageryLayers.add(imageryLayer);
+    url : 'https://sampleserver1.arcgisonline.com/ArcGIS/services/Specialty/ESRI_StatesCitiesRivers_USA/MapServer/WMSServer',
+    layers : '0',
+    proxy: new Cesium.DefaultProxy('/proxy/')
+});
+const imageryLayer = new Cesium.ImageryLayer(provider);
+viewer.imageryLayers.add(imageryLayer);
  * @param options - Object describing initialization options
  */
 export class WebMapServiceImageryProvider {
@@ -44223,35 +44343,35 @@ export class WebMapServiceImageryProvider {
     readonly rectangle: Rectangle;
     /**
      * Gets the tile discard policy.  If not undefined, the discard policy is responsible
-     * for filtering out "missing" tiles via its shouldDiscardImage function.  If this function
-     * returns undefined, no tiles are filtered.
+    for filtering out "missing" tiles via its shouldDiscardImage function.  If this function
+    returns undefined, no tiles are filtered.
      */
     readonly tileDiscardPolicy: TileDiscardPolicy;
     /**
      * Gets an event that is raised when the imagery provider encounters an asynchronous error.  By subscribing
-     * to the event, you will be notified of the error and can potentially recover from it.  Event listeners
-     * are passed an instance of {@link TileProviderError}.
+    to the event, you will be notified of the error and can potentially recover from it.  Event listeners
+    are passed an instance of {@link TileProviderError}.
      */
     readonly errorEvent: Event;
     /**
      * Gets the credit to display when this imagery provider is active.  Typically this is used to credit
-     * the source of the imagery.
+    the source of the imagery.
      */
     readonly credit: Credit;
     /**
      * Gets a value indicating whether or not the images provided by this imagery provider
-     * include an alpha channel.  If this property is false, an alpha channel, if present, will
-     * be ignored.  If this property is true, any images without an alpha channel will be treated
-     * as if their alpha is 1.0 everywhere.  When this property is false, memory usage
-     * and texture upload time are reduced.
+    include an alpha channel.  If this property is false, an alpha channel, if present, will
+    be ignored.  If this property is true, any images without an alpha channel will be treated
+    as if their alpha is 1.0 everywhere.  When this property is false, memory usage
+    and texture upload time are reduced.
      */
     readonly hasAlphaChannel: boolean;
     /**
      * Gets or sets a value indicating whether feature picking is enabled.  If true, {@link WebMapServiceImageryProvider#pickFeatures} will
-     * invoke the <code>GetFeatureInfo</code> service on the WMS server and attempt to interpret the features included in the response.  If false,
-     * {@link WebMapServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable
-     * features) without communicating with the server.  Set this property to false if you know your data
-     * source does not support picking features or if you don't want this provider's features to be pickable.
+    invoke the <code>GetFeatureInfo</code> service on the WMS server and attempt to interpret the features included in the response.  If false,
+    {@link WebMapServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable
+    features) without communicating with the server.  Set this property to false if you know your data
+    source does not support picking features or if you don't want this provider's features to be pickable.
      */
     enablePickFeatures: boolean;
     /**
@@ -44260,8 +44380,8 @@ export class WebMapServiceImageryProvider {
     clock: Clock;
     /**
      * Gets or sets a time interval collection that is used to get time dynamic parameters. The data of each
-     * TimeInterval is an object containing the keys and values of the properties that are used during
-     * tile requests.
+    TimeInterval is an object containing the keys and values of the properties that are used during
+    tile requests.
      */
     times: TimeIntervalCollection;
     /**
@@ -44283,36 +44403,36 @@ export class WebMapServiceImageryProvider {
      * @param level - The tile level.
      * @param [request] - The request object. Intended for internal use only.
      * @returns A promise for the image that will resolve when the image is available, or
-     *          undefined if there are too many active requests to the server, and the request should be retried later.
+             undefined if there are too many active requests to the server, and the request should be retried later.
      */
     requestImage(x: number, y: number, level: number, request?: Request): Promise<ImageryTypes> | undefined;
     /**
      * Asynchronously determines what features, if any, are located at a given longitude and latitude within
-     * a tile.
+    a tile.
      * @param x - The tile X coordinate.
      * @param y - The tile Y coordinate.
      * @param level - The tile level.
      * @param longitude - The longitude at which to pick features.
      * @param latitude - The latitude at which to pick features.
      * @returns A promise for the picked features that will resolve when the asynchronous
-     *                   picking completes.  The resolved value is an array of {@link ImageryLayerFeatureInfo}
-     *                   instances.  The array may be empty if no features are found at the given location.
+                      picking completes.  The resolved value is an array of {@link ImageryLayerFeatureInfo}
+                      instances.  The array may be empty if no features are found at the given location.
      */
     pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
     /**
      * The default parameters to include in the WMS URL to obtain images.  The values are as follows:
-     *    service=WMS
-     *    version=1.1.1
-     *    request=GetMap
-     *    styles=
-     *    format=image/jpeg
+       service=WMS
+       version=1.1.1
+       request=GetMap
+       styles=
+       format=image/jpeg
      */
     static readonly DefaultParameters: any;
     /**
      * The default parameters to include in the WMS URL to get feature information.  The values are as follows:
-     *     service=WMS
-     *     version=1.1.1
-     *     request=GetFeatureInfo
+        service=WMS
+        version=1.1.1
+        request=GetFeatureInfo
      */
     static readonly GetFeatureInfoDefaultParameters: any;
 }
@@ -44527,29 +44647,29 @@ export class WebMapTileServiceImageryProvider {
  * A widget containing a Cesium scene.
  * @example
  * // For each example, include a link to CesiumWidget.css stylesheet in HTML head,
- * // and in the body, include: <div id="cesiumContainer"></div>
- *
- * // Widget with no terrain and default Bing Maps imagery provider.
- * const widget = new Cesium.CesiumWidget("cesiumContainer");
- *
- * // Widget with ion imagery and Cesium World Terrain.
- * const widget2 = new Cesium.CesiumWidget("cesiumContainer", {
- *     baseLayer: Cesium.ImageryLayer.fromWorldTerrain(),
- *     terrain: Cesium.Terrain.fromWorldTerrain()
- *     skyBox: new Cesium.SkyBox({
- *       sources: {
- *         positiveX: "stars/TychoSkymapII.t3_08192x04096_80_px.jpg",
- *         negativeX: "stars/TychoSkymapII.t3_08192x04096_80_mx.jpg",
- *         positiveY: "stars/TychoSkymapII.t3_08192x04096_80_py.jpg",
- *         negativeY: "stars/TychoSkymapII.t3_08192x04096_80_my.jpg",
- *         positiveZ: "stars/TychoSkymapII.t3_08192x04096_80_pz.jpg",
- *         negativeZ: "stars/TychoSkymapII.t3_08192x04096_80_mz.jpg"
- *       }
- *     }),
- *     // Show Columbus View map with Web Mercator projection
- *     sceneMode: Cesium.SceneMode.COLUMBUS_VIEW,
- *     mapProjection: new Cesium.WebMercatorProjection()
- * });
+// and in the body, include: <div id="cesiumContainer"></div>
+
+// Widget with no terrain and default Bing Maps imagery provider.
+const widget = new Cesium.CesiumWidget("cesiumContainer");
+
+// Widget with ion imagery and Cesium World Terrain.
+const widget2 = new Cesium.CesiumWidget("cesiumContainer", {
+    baseLayer: Cesium.ImageryLayer.fromWorldTerrain(),
+    terrain: Cesium.Terrain.fromWorldTerrain()
+    skyBox: new Cesium.SkyBox({
+      sources: {
+        positiveX: "stars/TychoSkymapII.t3_08192x04096_80_px.jpg",
+        negativeX: "stars/TychoSkymapII.t3_08192x04096_80_mx.jpg",
+        positiveY: "stars/TychoSkymapII.t3_08192x04096_80_py.jpg",
+        negativeY: "stars/TychoSkymapII.t3_08192x04096_80_my.jpg",
+        positiveZ: "stars/TychoSkymapII.t3_08192x04096_80_pz.jpg",
+        negativeZ: "stars/TychoSkymapII.t3_08192x04096_80_mz.jpg"
+      }
+    }),
+    // Show Columbus View map with Web Mercator projection
+    sceneMode: Cesium.SceneMode.COLUMBUS_VIEW,
+    mapProjection: new Cesium.WebMercatorProjection()
+});
  * @param container - The DOM element or ID that will contain the widget.
  * @param [options] - Object with the following properties:
  * @param [options.clock = new Clock()] - The clock to use to control current time.
@@ -44572,10 +44692,10 @@ export class WebMapTileServiceImageryProvider {
  * @param [options.automaticallyTrackDataSourceClocks = true] - If true, this widget will automatically track the clock settings of newly added DataSources, updating if the DataSource's clock changes.  Set this to false if you want to configure the clock independently.
  * @param [options.contextOptions] - Context and WebGL creation properties passed to {@link Scene}.
  * @param [options.creditContainer] - The DOM element or ID that will contain the {@link CreditDisplay}.  If not specified, the credits are added
- *        to the bottom of the widget itself.
+       to the bottom of the widget itself.
  * @param [options.creditViewport] - The DOM element or ID that will contain the credit pop up created by the {@link CreditDisplay}.  If not specified, it will appear over the widget itself.
  * @param [options.dataSources = new DataSourceCollection()] - The collection of data sources visualized by the widget.  If this parameter is provided,
- *                               the instance is assumed to be owned by the caller and will not be destroyed when the widget is destroyed.
+                              the instance is assumed to be owned by the caller and will not be destroyed when the widget is destroyed.
  * @param [options.shadows = false] - Determines if shadows are cast by light sources.
  * @param [options.terrainShadows = ShadowMode.RECEIVE_ONLY] - Determines if the terrain casts or receives shadows from light sources.
  * @param [options.mapMode2D = MapMode2D.INFINITE_SCROLL] - Determines if the 2D map is rotatable or can be scrolled infinitely in the horizontal direction.
@@ -44654,7 +44774,7 @@ export class CesiumWidget {
     readonly dataSourceDisplay: DataSourceDisplay;
     /**
      * Gets the collection of entities not tied to a particular data source.
-     * This is a shortcut to [dataSourceDisplay.defaultDataSource.entities]{@link CesiumWidget#dataSourceDisplay}.
+    This is a shortcut to [dataSourceDisplay.defaultDataSource.entities]{@link CesiumWidget#dataSourceDisplay}.
      */
     readonly entities: EntityCollection;
     /**
@@ -44679,46 +44799,46 @@ export class CesiumWidget {
     readonly screenSpaceEventHandler: ScreenSpaceEventHandler;
     /**
      * Gets or sets the target frame rate of the widget when <code>useDefaultRenderLoop</code>
-     * is true. If undefined, the browser's requestAnimationFrame implementation
-     * determines the frame rate.  If defined, this value must be greater than 0.  A value higher
-     * than the underlying requestAnimationFrame implementation will have no effect.
+    is true. If undefined, the browser's requestAnimationFrame implementation
+    determines the frame rate.  If defined, this value must be greater than 0.  A value higher
+    than the underlying requestAnimationFrame implementation will have no effect.
      */
     targetFrameRate: number;
     /**
      * Gets or sets whether or not this widget should control the render loop.
-     * If true the widget will use requestAnimationFrame to
-     * perform rendering and resizing of the widget, as well as drive the
-     * simulation clock. If set to false, you must manually call the
-     * <code>resize</code>, <code>render</code> methods as part of a custom
-     * render loop.  If an error occurs during rendering, {@link Scene}'s
-     * <code>renderError</code> event will be raised and this property
-     * will be set to false.  It must be set back to true to continue rendering
-     * after the error.
+    If true the widget will use requestAnimationFrame to
+    perform rendering and resizing of the widget, as well as drive the
+    simulation clock. If set to false, you must manually call the
+    <code>resize</code>, <code>render</code> methods as part of a custom
+    render loop.  If an error occurs during rendering, {@link Scene}'s
+    <code>renderError</code> event will be raised and this property
+    will be set to false.  It must be set back to true to continue rendering
+    after the error.
      */
     useDefaultRenderLoop: boolean;
     /**
      * Gets or sets a scaling factor for rendering resolution.  Values less than 1.0 can improve
-     * performance on less powerful devices while values greater than 1.0 will render at a higher
-     * resolution and then scale down, resulting in improved visual fidelity.
-     * For example, if the widget is laid out at a size of 640x480, setting this value to 0.5
-     * will cause the scene to be rendered at 320x240 and then scaled up while setting
-     * it to 2.0 will cause the scene to be rendered at 1280x960 and then scaled down.
+    performance on less powerful devices while values greater than 1.0 will render at a higher
+    resolution and then scale down, resulting in improved visual fidelity.
+    For example, if the widget is laid out at a size of 640x480, setting this value to 0.5
+    will cause the scene to be rendered at 320x240 and then scaled up while setting
+    it to 2.0 will cause the scene to be rendered at 1280x960 and then scaled down.
      */
     resolutionScale: number;
     /**
      * Boolean flag indicating if the browser's recommended resolution is used.
-     * If true, the browser's device pixel ratio is ignored and 1.0 is used instead,
-     * effectively rendering based on CSS pixels instead of device pixels. This can improve
-     * performance on less powerful devices that have high pixel density. When false, rendering
-     * will be in device pixels. {@link CesiumWidget#resolutionScale} will still take effect whether
-     * this flag is true or false.
+    If true, the browser's device pixel ratio is ignored and 1.0 is used instead,
+    effectively rendering based on CSS pixels instead of device pixels. This can improve
+    performance on less powerful devices that have high pixel density. When false, rendering
+    will be in device pixels. {@link CesiumWidget#resolutionScale} will still take effect whether
+    this flag is true or false.
      */
     useBrowserRecommendedResolution: boolean;
     /**
      * Gets or sets whether or not data sources can temporarily pause
-     * animation in order to avoid showing an incomplete picture to the user.
-     * For example, if asynchronous primitives are being processed in the
-     * background, the clock will not advance until the geometry is ready.
+    animation in order to avoid showing an incomplete picture to the user.
+    For example, if asynchronous primitives are being processed in the
+    background, the clock will not advance until the geometry is ready.
      */
     allowDataSourcesToSuspendAnimation: boolean;
     /**
@@ -44735,9 +44855,9 @@ export class CesiumWidget {
     clockTrackedDataSource: DataSource;
     /**
      * Show an error panel to the user containing a title and a longer error message,
-     * which can be dismissed using an OK button.  This panel is displayed automatically
-     * when a render loop error occurs, if showRenderLoopErrors was not false when the
-     * widget was constructed.
+    which can be dismissed using an OK button.  This panel is displayed automatically
+    when a render loop error occurs, if showRenderLoopErrors was not false when the
+    widget was constructed.
      * @param title - The title to be displayed on the error panel.  This string is interpreted as text.
      * @param [message] - A helpful, user-facing message to display prior to the detailed error information.  This string is interpreted as HTML.
      * @param [error] - The error to be displayed on the error panel.  This string is formatted using {@link formatError} and then displayed as text.
@@ -44749,34 +44869,34 @@ export class CesiumWidget {
     isDestroyed(): boolean;
     /**
      * Destroys the widget.  Should be called if permanently
-     * removing the widget from layout.
+    removing the widget from layout.
      */
     destroy(): void;
     /**
      * Updates the canvas size, camera aspect ratio, and viewport size.
-     * This function is called automatically as needed unless
-     * <code>useDefaultRenderLoop</code> is set to false.
+    This function is called automatically as needed unless
+    <code>useDefaultRenderLoop</code> is set to false.
      */
     resize(): void;
     /**
      * Renders the scene.  This function is called automatically
-     * unless <code>useDefaultRenderLoop</code> is set to false;
+    unless <code>useDefaultRenderLoop</code> is set to false;
      */
     render(): void;
     /**
      * Asynchronously sets the camera to view the provided entity, entities, or data source.
-     * If the data source is still in the process of loading or the visualization is otherwise still loading,
-     * this method waits for the data to be ready before performing the zoom.
-     *
-     * <p>The offset is heading/pitch/range in the local east-north-up reference frame centered at the center of the bounding sphere.
-     * The heading and the pitch angles are defined in the local east-north-up reference frame.
-     * The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
-     * angles are above the plane. Negative pitch angles are below the plane. The range is the distance from the center. If the range is
-     * zero, a range will be computed such that the whole bounding sphere is visible.</p>
-     *
-     * <p>In 2D, there must be a top down view. The camera will be placed above the target looking down. The height above the
-     * target will be the range. The heading will be determined from the offset. If the heading cannot be
-     * determined from the offset, the heading will be north.</p>
+    If the data source is still in the process of loading or the visualization is otherwise still loading,
+    this method waits for the data to be ready before performing the zoom.
+    
+    <p>The offset is heading/pitch/range in the local east-north-up reference frame centered at the center of the bounding sphere.
+    The heading and the pitch angles are defined in the local east-north-up reference frame.
+    The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
+    angles are above the plane. Negative pitch angles are below the plane. The range is the distance from the center. If the range is
+    zero, a range will be computed such that the whole bounding sphere is visible.</p>
+    
+    <p>In 2D, there must be a top down view. The camera will be placed above the target looking down. The height above the
+    target will be the range. The heading will be determined from the offset. If the heading cannot be
+    determined from the offset, the heading will be north.</p>
      * @param target - The entity, array of entities, entity collection, data source, Cesium3DTileset, point cloud, or imagery layer to view. You can also pass a promise that resolves to one of the previously mentioned types.
      * @param [offset] - The offset from the center of the entity in the local east-north-up reference frame.
      * @returns A Promise that resolves to true if the zoom was successful or false if the target is not currently visualized in the scene or the zoom was cancelled.
@@ -44784,18 +44904,18 @@ export class CesiumWidget {
     zoomTo(target: Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud | Promise<Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud | VoxelPrimitive>, offset?: HeadingPitchRange): Promise<boolean>;
     /**
      * Flies the camera to the provided entity, entities, or data source.
-     * If the data source is still in the process of loading or the visualization is otherwise still loading,
-     * this method waits for the data to be ready before performing the flight.
-     *
-     * <p>The offset is heading/pitch/range in the local east-north-up reference frame centered at the center of the bounding sphere.
-     * The heading and the pitch angles are defined in the local east-north-up reference frame.
-     * The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
-     * angles are above the plane. Negative pitch angles are below the plane. The range is the distance from the center. If the range is
-     * zero, a range will be computed such that the whole bounding sphere is visible.</p>
-     *
-     * <p>In 2D, there must be a top down view. The camera will be placed above the target looking down. The height above the
-     * target will be the range. The heading will be determined from the offset. If the heading cannot be
-     * determined from the offset, the heading will be north.</p>
+    If the data source is still in the process of loading or the visualization is otherwise still loading,
+    this method waits for the data to be ready before performing the flight.
+    
+    <p>The offset is heading/pitch/range in the local east-north-up reference frame centered at the center of the bounding sphere.
+    The heading and the pitch angles are defined in the local east-north-up reference frame.
+    The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
+    angles are above the plane. Negative pitch angles are below the plane. The range is the distance from the center. If the range is
+    zero, a range will be computed such that the whole bounding sphere is visible.</p>
+    
+    <p>In 2D, there must be a top down view. The camera will be placed above the target looking down. The height above the
+    target will be the range. The heading will be determined from the offset. If the heading cannot be
+    determined from the offset, the heading will be north.</p>
      * @param target - The entity, array of entities, entity collection, data source, Cesium3DTileset, point cloud, or imagery layer to view. You can also pass a promise that resolves to one of the previously mentioned types.
      * @param [options] - Object with the following properties:
      * @param [options.duration = 3.0] - The duration of the flight in seconds.
@@ -45112,12 +45232,12 @@ export class BaseLayerPickerViewModel {
     });
     /**
      * Gets or sets an array of ProviderViewModel instances available for imagery selection.
-     * This property is observable.
+    This property is observable.
      */
     imageryProviderViewModels: ProviderViewModel[];
     /**
      * Gets or sets an array of ProviderViewModel instances available for terrain selection.
-     * This property is observable.
+    This property is observable.
      */
     terrainProviderViewModels: ProviderViewModel[];
     /**
@@ -45158,7 +45278,7 @@ export class BaseLayerPickerViewModel {
  * @param options.iconUrl - An icon representing the layer.
  * @param [options.category] - A category for the layer.
  * @param options.creationFunction - A function or Command
- *        that creates one or more providers which will be added to the globe when this item is selected.
+       that creates one or more providers which will be added to the globe when this item is selected.
  */
 export class ProviderViewModel {
     constructor(options: {
@@ -45182,7 +45302,7 @@ export class ProviderViewModel {
     iconUrl: string;
     /**
      * Gets the Command that creates one or more providers which will be added to
-     * the globe when this item is selected.
+    the globe when this item is selected.
      */
     readonly creationCommand: Command;
     /**