mars3d-cesium 1.126.1 → 1.126.2

package/Build/Cesium/Cesium.d.ts

@@ -6429,14 +6429,14 @@ export class EllipsoidRhumbLine {
     interpolateUsingFraction(fraction: number, result?: Cartographic): Cartographic;
     /**
      * Provides the location of a point at the indicated distance along the rhumb line.
-     * @param distance - The distance from the inital point to the point of interest along the rhumbLine.
+     * @param distance - The distance from the initial point to the point of interest along the rhumbLine.
      * @param [result] - The object in which to store the result.
      * @returns The location of the point along the rhumb line.
      */
     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.
@@ -8976,10 +8976,10 @@ export class Interval {
 
 /**
  * Default settings for accessing the Cesium ion API.
- *
- * An ion access token is only required if you are using any ion related APIs.
- * A default access token is provided for evaluation purposes only.
- * Sign up for a free ion account and get your own access token at {@link https://cesium.com}
+
+An ion access token is only required if you are using any ion related APIs.
+A default access token is provided for evaluation purposes only.
+Sign up for a free ion account and get your own access token at {@link https://cesium.com}
  */
 export namespace Ion {
     /**
@@ -12501,19 +12501,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 +12563,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 +12575,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 +12593,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.
@@ -16219,7 +16219,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 +16229,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 +16244,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;
 }
@@ -21880,10 +21880,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 +24099,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;
     /**
@@ -25990,11 +25990,11 @@ export class ArcGisMapServerImageryProvider {
 
 /**
  * Default options for accessing the ArcGIS image tile service.
- *
- * An ArcGIS access token is required to access ArcGIS image tile layers.
- * A default token is provided for evaluation purposes only.
- * To obtain an access token, go to {@link https://developers.arcgis.com} and create a free account.
- * More info can be found in the {@link https://developers.arcgis.com/documentation/mapping-apis-and-services/security/ | ArcGIS developer guide}.
+
+An ArcGIS access token is required to access ArcGIS image tile layers.
+A default token is provided for evaluation purposes only.
+To obtain an access token, go to {@link https://developers.arcgis.com} and create a free account.
+More info can be found in the {@link https://developers.arcgis.com/documentation/mapping-apis-and-services/security/ | ArcGIS developer guide}.
  */
 export namespace ArcGisMapService {
     /**
@@ -27107,23 +27107,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 +27150,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 +27174,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 +27187,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 +27213,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 +27262,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 +27315,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 +27370,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 +27388,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 +27399,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 +27445,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 +27477,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 +27549,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 +27584,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 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 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 +27655,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 +27714,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;
 }
@@ -27854,10 +27854,10 @@ export enum CameraEventType {
 
 /**
  * A tile in a {@link Cesium3DTileset}.  When a tile is first created, its content is not loaded;
- * the content is loaded on-demand when needed based on the view.
- * <p>
- * Do not construct this directly, instead access tiles through {@link Cesium3DTileset#tileVisible}.
- * </p>
+the content is loaded on-demand when needed based on the view.
+<p>
+Do not construct this directly, instead access tiles through {@link Cesium3DTileset#tileVisible}.
+</p>
  * @param tileset - The tileset
  * @param baseResource - The base resource for the tileset
  * @param header - The JSON header for the tile
@@ -27875,7 +27875,7 @@ export class Cesium3DTile {
     readonly computedTransform: Matrix4;
     /**
      * The error, in meters, introduced if this tile is rendered and its children are not.
-     * This is used to compute screen space error, i.e., the error measured in pixels.
+    This is used to compute screen space error, i.e., the error measured in pixels.
      */
     readonly geometricError: number;
     /**
@@ -27884,11 +27884,11 @@ export class Cesium3DTile {
     readonly children: Cesium3DTile[];
     /**
      * This tile's parent or <code>undefined</code> if this tile is the root.
-     * <p>
-     * When a tile's content points to an external tileset JSON file, the external tileset's
-     * root tile's parent is not <code>undefined</code>; instead, the parent references
-     * the tile (with its content pointing to an external tileset JSON file) as if the two tilesets were merged.
-     * </p>
+    <p>
+    When a tile's content points to an external tileset JSON file, the external tileset's
+    root tile's parent is not <code>undefined</code>; instead, the parent references
+    the tile (with its content pointing to an external tileset JSON file) as if the two tilesets were merged.
+    </p>
      */
     readonly parent: Cesium3DTile;
     /**
@@ -27905,7 +27905,7 @@ export class Cesium3DTile {
     readonly tileset: Cesium3DTileset;
     /**
      * The tile's content.  This represents the actual tile's payload,
-     * not the content's metadata in the tileset JSON file.
+    not the content's metadata in the tileset JSON file.
      */
     readonly content: Cesium3DTileContent;
     /**
@@ -27914,7 +27914,7 @@ export class Cesium3DTile {
     readonly boundingSphere: BoundingSphere;
     /**
      * Returns the <code>extras</code> property in the tileset JSON for this tile, which contains application specific metadata.
-     * Returns <code>undefined</code> if <code>extras</code> does not exist.
+    Returns <code>undefined</code> if <code>extras</code> does not exist.
      */
     readonly extras: any;
     /**
@@ -30116,12 +30116,12 @@ export class Cesium3DTileStyle {
 
 /**
  * A {@link VoxelProvider} that fetches voxel data from a 3D Tiles tileset.
- * <p>
- * Implements the {@link VoxelProvider} interface.
- * </p>
- * <div class="notice">
- * This object is normally not instantiated directly, use {@link Cesium3DTilesVoxelProvider.fromUrl}.
- * </div>
+<p>
+Implements the {@link VoxelProvider} interface.
+</p>
+<div class="notice">
+This object is normally not instantiated directly, use {@link Cesium3DTilesVoxelProvider.fromUrl}.
+</div>
  * @param options - Object with the following properties:
  */
 export class Cesium3DTilesVoxelProvider extends VoxelProvider {
@@ -30142,69 +30142,69 @@ export class Cesium3DTilesVoxelProvider extends VoxelProvider {
     readonly shapeTransform: Matrix4 | undefined;
     /**
      * Gets the {@link VoxelShapeType}
-     * This should not be called before {@link VoxelProvider#ready} returns true.
+    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.
+    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.
+    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.
+    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.
+    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly paddingBefore: Cartesian3 | undefined;
     /**
      * 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.
+    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly paddingAfter: Cartesian3 | undefined;
     /**
      * Gets the metadata names.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
+    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.
+    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.
+    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.
+    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.
+    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.
+    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     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.
+    This function should not be called before {@link VoxelProvider#ready} returns true.
      * @param [options] - Object with the following properties:
      * @param [options.tileLevel = 0] - The tile's level.
      * @param [options.tileX = 0] - The tile's X coordinate.
@@ -31132,41 +31132,41 @@ export function createElevationBandMaterial(options: {
 
 /**
  * Creates a {@link Cesium3DTileset} instance for the Google Photorealistic 3D
- * Tiles tileset.
- *
- * Google Photorealistic 3D Tiles can only be used with the Google geocoder.  To
- * confirm that you are aware of this restriction pass
- * `usingOnlyWithGoogleGeocoder: true` to the apiOptions.  Otherwise a one time
- * warning will be displayed when this function is called.
+Tiles tileset.
+
+Google Photorealistic 3D Tiles can only be used with the Google geocoder.  To
+confirm that you are aware of this restriction pass
+`usingOnlyWithGoogleGeocoder: true` to the apiOptions.  Otherwise a one time
+warning will be displayed when this function is called.
  * @example
  * const viewer = new Cesium.Viewer("cesiumContainer", {
- *   geocoder: Cesium.IonGeocodeProviderType.GOOGLE
- * });
- *
- * try {
- *   const tileset = await Cesium.createGooglePhotorealistic3DTileset({
- *      onlyUsingWithGoogleGeocoder: true,
- *   });
- *   viewer.scene.primitives.add(tileset));
- * } catch (error) {
- *   console.log(`Error creating tileset: ${error}`);
- * }
+  geocoder: Cesium.IonGeocodeProviderType.GOOGLE
+});
+
+try {
+  const tileset = await Cesium.createGooglePhotorealistic3DTileset({
+     onlyUsingWithGoogleGeocoder: true,
+  });
+  viewer.scene.primitives.add(tileset));
+} catch (error) {
+  console.log(`Error creating tileset: ${error}`);
+}
  * @example
  * // Use your own Google Maps API key
- * Cesium.GoogleMaps.defaultApiKey = "your-api-key";
- *
- * const viewer = new Cesium.Viewer("cesiumContainer". {
- *   geocoder: Cesium.IonGeocodeProviderType.GOOGLE
- * });
- *
- * try {
- *   const tileset = await Cesium.createGooglePhotorealistic3DTileset({
- *      onlyUsingWithGoogleGeocoder: true,
- *   });
- *   viewer.scene.primitives.add(tileset));
- * } catch (error) {
- *   console.log(`Error creating tileset: ${error}`);
- * }
+Cesium.GoogleMaps.defaultApiKey = "your-api-key";
+
+const viewer = new Cesium.Viewer("cesiumContainer". {
+  geocoder: Cesium.IonGeocodeProviderType.GOOGLE
+});
+
+try {
+  const tileset = await Cesium.createGooglePhotorealistic3DTileset({
+     onlyUsingWithGoogleGeocoder: true,
+  });
+  viewer.scene.primitives.add(tileset));
+} catch (error) {
+  console.log(`Error creating tileset: ${error}`);
+}
  * @param [apiOptions.key = GoogleMaps.defaultApiKey] - Your API key to access Google Photorealistic 3D Tiles. See {@link https://developers.google.com/maps/documentation/javascript/get-api-key} for instructions on how to create your own key.
  * @param [apiOptions.onlyUsingWithGoogleGeocoder] - Confirmation that this tileset will only be used with the Google geocoder.
  * @param [tilesetOptions] - An object describing initialization options.
@@ -31770,9 +31770,9 @@ export enum DepthFunction {
 
 /**
  * Returns the type that the given class property has in a GLSL shader.
-
-It returns the same string as `PropertyTextureProperty.prototype.getGlslType`
-for a property texture property with the given class property
+ *
+ * It returns the same string as `PropertyTextureProperty.prototype.getGlslType`
+ * for a property texture property with the given class property
  * @param classProperty - The class property
  * @returns The GLSL shader type string for the property
  */
@@ -31780,8 +31780,8 @@ export function getGlslType(classProperty: MetadataClassProperty): string;
 
 /**
  * Returns a shader statement that applies the inverse of the
-value transform to the given value, based on the given offset
-and scale.
+ * value transform to the given value, based on the given offset
+ * and scale.
  * @param input - The input value
  * @param offset - The offset
  * @param scale - The scale
@@ -31791,7 +31791,7 @@ export function unapplyValueTransform(input: string, offset: string, scale: stri
 
 /**
  * Returns a shader statement that applies the inverse of the
-normalization, based on the given component type
+ * normalization, based on the given component type
  * @param input - The input value
  * @param componentType - The component type
  * @returns The statement
@@ -31800,20 +31800,20 @@ export function unnormalize(input: string, componentType: string): string;
 
 /**
  * Creates a shader statement that returns the value of the specified
-property, normalized to the range [0, 1].
+ * property, normalized to the range [0, 1].
  * @param classProperty - The class property
  * @param metadataProperty - The metadata property, either
-a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+ * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
  * @returns The string
  */
 export function getSourceValueStringScalar(classProperty: MetadataClassProperty, metadataProperty: any): string;
 
 /**
  * Creates a shader statement that returns the value of the specified
-component of the given property, normalized to the range [0, 1].
+ * component of the given property, normalized to the range [0, 1].
  * @param classProperty - The class property
  * @param metadataProperty - The metadata property, either
-a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+ * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
  * @param componentName - The name, in ["x", "y", "z", "w"]
  * @returns The string
  */
@@ -32179,19 +32179,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 +32203,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 +32217,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 +34644,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 +34672,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 +34701,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 +34749,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();
      */
@@ -35116,15 +35116,15 @@ export enum IonWorldImageryStyle {
 export namespace ITwinData {
     /**
      * Create a {@link Cesium3DTileset} for the given iModel id using iTwin's Mesh Export API.
-     *
-     * If there is not a completed export available for the given iModel id, the returned promise will resolve to <code>undefined</code>.
-     * We recommend waiting 10-20 seconds and trying to load the tileset again.
-     * If all exports are Invalid this will throw an error.
+    
+    If there is not a completed export available for the given iModel id, the returned promise will resolve to <code>undefined</code>.
+    We recommend waiting 10-20 seconds and trying to load the tileset again.
+    If all exports are Invalid this will throw an error.
      * @example
      * const tileset = await Cesium.ITwinData.createTilesetFromIModelId(iModelId);
-     * if (Cesium.defined(tileset)) {
-     *   viewer.scene.primitives.add(tileset);
-     * }
+    if (Cesium.defined(tileset)) {
+      viewer.scene.primitives.add(tileset);
+    }
      * @param iModelId - The id of the iModel to load
      * @param [options] - Object containing options to pass to the internally created {@link Cesium3DTileset}.
      * @returns A promise that will resolve to the created 3D tileset or <code>undefined</code> if there is no completed export for the given iModel id
@@ -35132,10 +35132,10 @@ export namespace ITwinData {
     function createTilesetFromIModelId(iModelId: string, options?: Cesium3DTileset.ConstructorOptions): Promise<Cesium3DTileset | undefined>;
     /**
      * Create a tileset for the specified reality data id. This function only works
-     * with 3D Tiles meshes and point clouds.
-     *
-     * If the <code>type</code> or <code>rootDocument</code> are not provided this function
-     * will first request the full metadata for the specified reality data to fill these values.
+    with 3D Tiles meshes and point clouds.
+    
+    If the <code>type</code> or <code>rootDocument</code> are not provided this function
+    will first request the full metadata for the specified reality data to fill these values.
      * @param iTwinId - The id of the iTwin to load data from
      * @param realityDataId - The id of the reality data to load
      * @param [type] - The type of this reality data
@@ -35144,10 +35144,10 @@ export namespace ITwinData {
     function createTilesetForRealityDataId(iTwinId: string, realityDataId: string, type?: ITwinPlatform.RealityDataType, rootDocument?: string): Promise<Cesium3DTileset>;
     /**
      * Create a data source of the correct type for the specified reality data id.
-     * This function only works for KML and GeoJSON type data.
-     *
-     * If the <code>type</code> or <code>rootDocument</code> are not provided this function
-     * will first request the full metadata for the specified reality data to fill these values.
+    This function only works for KML and GeoJSON type data.
+    
+    If the <code>type</code> or <code>rootDocument</code> are not provided this function
+    will first request the full metadata for the specified reality data to fill these values.
      * @param iTwinId - The id of the iTwin to load data from
      * @param realityDataId - The id of the reality data to load
      * @param [type] - The type of this reality data
@@ -35995,216 +35995,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 +36235,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 +36258,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 +37022,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 +37096,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 +37112,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 +37127,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;
     /**
@@ -37138,6 +37138,25 @@ export class CustomShader {
      * @param value - The new value of the uniform.
      */
     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.
+     * @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.
+     * @example
+     * customShader = customShader && customShader.destroy();
+     */
+    destroy(): void;
 }
 
 /**
@@ -40695,88 +40714,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.
@@ -40812,67 +40831,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;
     /**
@@ -40905,60 +40924,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();
      */
@@ -41121,15 +41140,15 @@ export class PrimitiveCollection {
 
 /**
  * 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.
@@ -41165,14 +41184,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;
     /**
@@ -41209,106 +41228,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;
     /**
@@ -41317,33 +41336,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;
     /**
@@ -41352,13 +41371,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;
     /**
@@ -41375,18 +41394,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;
     /**
@@ -41403,7 +41422,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;
     /**
@@ -41488,48 +41507,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;
     /**
@@ -41538,8 +41557,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;
     /**
@@ -41552,7 +41571,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;
     /**
@@ -41565,14 +41584,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;
     /**
@@ -41607,30 +41626,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.
@@ -41639,15 +41658,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.
@@ -41658,34 +41677,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.
@@ -41693,9 +41712,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.
@@ -41707,16 +41726,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.
@@ -41725,16 +41744,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.
@@ -41744,20 +41763,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.
@@ -41766,19 +41785,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.
@@ -41787,15 +41806,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.
@@ -41824,34 +41843,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();
      */
@@ -41860,11 +41879,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.
  */
@@ -41899,14 +41918,14 @@ export enum SceneMode {
 export namespace SceneTransforms {
     /**
      * Transforms a position in world (WGS84 or alternative ellipsoid) coordinates to window 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 window position of longitude/latitude (0, 0) every time the mouse moves.
-     * const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
-     * const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
-     * handler.setInputAction(function(movement) {
-     *     console.log(Cesium.SceneTransforms.worldToWindowCoordinates(scene, position));
-     * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+    const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
+    const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
+    handler.setInputAction(function(movement) {
+        console.log(Cesium.SceneTransforms.worldToWindowCoordinates(scene, position));
+    }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
      * @param scene - The scene.
      * @param position - The position in world (WGS84 or alternative ellipsoid) coordinates.
      * @param [result] - An optional object to return the input position transformed to window coordinates.
@@ -41915,14 +41934,14 @@ export namespace SceneTransforms {
     function worldToWindowCoordinates(scene: Scene, position: Cartesian3, result?: Cartesian2): Cartesian2 | undefined;
     /**
      * Transforms a position in world coordinates to drawing buffer coordinates.  This may produce different
-     * results from SceneTransforms.worldToWindowCoordinates when the browser zoom is not 100%, or on high-DPI displays.
+    results from SceneTransforms.worldToWindowCoordinates when the browser zoom is not 100%, or on high-DPI displays.
      * @example
      * // Output the window position of longitude/latitude (0, 0) every time the mouse moves.
-     * const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
-     * const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
-     * handler.setInputAction(function(movement) {
-     *     console.log(Cesium.SceneTransforms.worldToDrawingBufferCoordinates(scene, position));
-     * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+    const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
+    const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
+    handler.setInputAction(function(movement) {
+        console.log(Cesium.SceneTransforms.worldToDrawingBufferCoordinates(scene, position));
+    }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
      * @param scene - The scene.
      * @param position - The position in world (WGS84 or alternative ellipsoid) coordinates.
      * @param [result] - An optional object to return the input position transformed to window coordinates.
@@ -41939,18 +41958,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;
     /**
@@ -41959,41 +41978,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;
     /**
@@ -42014,47 +42033,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;
     /**
@@ -42071,7 +42090,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;
     /**
@@ -42082,23 +42101,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();
      */
@@ -42125,13 +42144,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();
@@ -43746,87 +43765,87 @@ export class VoxelPrimitive {
     readonly availableLevels: number | undefined;
     /**
      * The event fired to indicate that a tile's content was loaded.
-     * <p>
-     * This event is fired during the tileset traversal while the frame is being rendered
-     * so that updates to the tile take effect in the same frame.  Do not create or modify
-     * Cesium entities or primitives during the event listener.
-     * </p>
+    <p>
+    This event is fired during the tileset traversal while the frame is being rendered
+    so that updates to the tile take effect in the same frame.  Do not create or modify
+    Cesium entities or primitives during the event listener.
+    </p>
      * @example
      * voxelPrimitive.tileLoad.addEventListener(function() {
-     *     console.log('A tile was loaded.');
-     * });
+        console.log('A tile was loaded.');
+    });
      */
     tileLoad: Event;
     /**
      * This event fires once for each visible tile in a frame.
-     * <p>
-     * This event is fired during the traversal while the frame is being rendered.
+    <p>
+    This event is fired during the traversal while the frame is being rendered.
      * @example
      * voxelPrimitive.tileVisible.addEventListener(function() {
-     *     console.log('A tile is visible.');
-     * });
+        console.log('A tile is visible.');
+    });
      */
     tileVisible: Event;
     /**
      * The event fired to indicate that a tile's content failed to load.
      * @example
      * voxelPrimitive.tileFailed.addEventListener(function() {
-     *     console.log('An error occurred loading tile.');
-     * });
+        console.log('An error occurred loading tile.');
+    });
      */
     tileFailed: Event;
     /**
      * The event fired to indicate that a tile's content was unloaded.
      * @example
      * voxelPrimitive.tileUnload.addEventListener(function() {
-     *     console.log('A tile was unloaded from the cache.');
-     * });
+        console.log('A tile was unloaded from the cache.');
+    });
      */
     tileUnload: Event;
     /**
      * The event fired to indicate progress of loading new tiles. This event is fired when a new tile
-     * is requested, when a requested tile is finished downloading, and when a downloaded tile has been
-     * processed and is ready to render.
-     * <p>
-     * The number of pending tile requests, <code>numberOfPendingRequests</code>, and number of tiles
-     * processing, <code>numberOfTilesProcessing</code> are passed to the event listener.
-     * </p>
-     * <p>
-     * This event is fired at the end of the frame after the scene is rendered.
-     * </p>
+    is requested, when a requested tile is finished downloading, and when a downloaded tile has been
+    processed and is ready to render.
+    <p>
+    The number of pending tile requests, <code>numberOfPendingRequests</code>, and number of tiles
+    processing, <code>numberOfTilesProcessing</code> are passed to the event listener.
+    </p>
+    <p>
+    This event is fired at the end of the frame after the scene is rendered.
+    </p>
      * @example
      * voxelPrimitive.loadProgress.addEventListener(function(numberOfPendingRequests, numberOfTilesProcessing) {
-     *     if ((numberOfPendingRequests === 0) && (numberOfTilesProcessing === 0)) {
-     *         console.log('Finished loading');
-     *         return;
-     *     }
-     *
-     *     console.log(`Loading: requests: ${numberOfPendingRequests}, processing: ${numberOfTilesProcessing}`);
-     * });
+        if ((numberOfPendingRequests === 0) && (numberOfTilesProcessing === 0)) {
+            console.log('Finished loading');
+            return;
+        }
+    
+        console.log(`Loading: requests: ${numberOfPendingRequests}, processing: ${numberOfTilesProcessing}`);
+    });
      */
     loadProgress: Event;
     /**
      * The event fired to indicate that all tiles that meet the screen space error this frame are loaded. The voxel
-     * primitive is completely loaded for this view.
-     * <p>
-     * This event is fired at the end of the frame after the scene is rendered.
-     * </p>
+    primitive is completely loaded for this view.
+    <p>
+    This event is fired at the end of the frame after the scene is rendered.
+    </p>
      * @example
      * voxelPrimitive.allTilesLoaded.addEventListener(function() {
-     *     console.log('All tiles are loaded');
-     * });
+        console.log('All tiles are loaded');
+    });
      */
     allTilesLoaded: Event;
     /**
      * The event fired to indicate that all tiles that meet the screen space error this frame are loaded. This event
-     * is fired once when all tiles in the initial view are loaded.
-     * <p>
-     * This event is fired at the end of the frame after the scene is rendered.
-     * </p>
+    is fired once when all tiles in the initial view are loaded.
+    <p>
+    This event is fired at the end of the frame after the scene is rendered.
+    </p>
      * @example
      * voxelPrimitive.initialTilesLoaded.addEventListener(function() {
-     *     console.log('Initial tiles are loaded');
-     * });
+        console.log('Initial tiles are loaded');
+    });
      */
     initialTilesLoaded: Event;
     /**
@@ -43887,35 +43906,35 @@ export class VoxelPrimitive {
     nearestSampling: boolean;
     /**
      * Gets or sets the screen space error in pixels. If the screen space size
-     * of a voxel is greater than the screen space error, the tile is subdivided.
-     * Lower screen space error corresponds with higher detail rendering, but could
-     * result in worse performance and higher memory consumption.
+    of a voxel is greater than the screen space error, the tile is subdivided.
+    Lower screen space error corresponds with higher detail rendering, but could
+    result in worse performance and higher memory consumption.
      */
     screenSpaceError: number;
     /**
      * Gets or sets the step size multiplier used during raymarching.
-     * The lower the value, the higher the rendering quality, but
-     * also the worse the performance.
+    The lower the value, the higher the rendering quality, but
+    also the worse the performance.
      */
     stepSize: number;
     /**
      * Gets or sets the minimum bounds in the shape's local coordinate system.
-     * Voxel data is stretched or squashed to fit the bounds.
+    Voxel data is stretched or squashed to fit the bounds.
      */
     minBounds: Cartesian3;
     /**
      * Gets or sets the maximum bounds in the shape's local coordinate system.
-     * Voxel data is stretched or squashed to fit the bounds.
+    Voxel data is stretched or squashed to fit the bounds.
      */
     maxBounds: Cartesian3;
     /**
      * Gets or sets the minimum clipping location in the shape's local coordinate system.
-     * Any voxel content outside the range is clipped.
+    Any voxel content outside the range is clipped.
      */
     minClippingBounds: Cartesian3;
     /**
      * Gets or sets the maximum clipping location in the shape's local coordinate system.
-     * Any voxel content outside the range is clipped.
+    Any voxel content outside the range is clipped.
      */
     maxClippingBounds: Cartesian3;
     /**
@@ -43932,19 +43951,19 @@ export class VoxelPrimitive {
     readonly customShaderCompilationEvent: Event;
     /**
      * 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
      * voxelPrimitive = voxelPrimitive && voxelPrimitive.destroy();
      */
@@ -43953,7 +43972,7 @@ export class VoxelPrimitive {
 
 /**
  * Provides voxel data. Intended to be used with {@link VoxelPrimitive}.
- * This type describes an interface and is not intended to be instantiated directly.
+This type describes an interface and is not intended to be instantiated directly.
  */
 export class VoxelProvider {
     constructor();
@@ -43967,69 +43986,69 @@ export class VoxelProvider {
     readonly shapeTransform: Matrix4 | undefined;
     /**
      * Gets the {@link VoxelShapeType}
-     * This should not be called before {@link VoxelProvider#ready} returns true.
+    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.
+    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.
+    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.
+    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.
+    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly paddingBefore: Cartesian3 | undefined;
     /**
      * 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.
+    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly paddingAfter: Cartesian3 | undefined;
     /**
      * Gets the metadata names.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
+    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.
+    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.
+    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.
+    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.
+    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.
+    This should not be called before {@link VoxelProvider#ready} returns true.
      */
     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.
+    This function should not be called before {@link VoxelProvider#ready} returns true.
      * @param [options] - Object with the following properties:
      * @param [options.tileLevel = 0] - The tile's level.
      * @param [options.tileX = 0] - The tile's X coordinate.
@@ -44099,31 +44118,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.
@@ -44156,12 +44175,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 {
@@ -44202,234 +44221,6 @@ export class WebMapServiceImageryProvider {
      * Gets the rectangle, in radians, of the imagery provided by this instance.
      */
     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.
-     */
-    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}.
-     */
-    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.
-     */
-    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.
-     */
-    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.
-     */
-    enablePickFeatures: boolean;
-    /**
-     * Gets or sets a clock that is used to get keep the time used for time dynamic parameters.
-     */
-    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.
-     */
-    times: TimeIntervalCollection;
-    /**
-     * Gets the getFeatureInfo URL of the WMS server.
-     */
-    readonly getFeatureInfoUrl: Resource | string;
-    /**
-     * Gets the credits to be displayed when a given tile is displayed.
-     * @param x - The tile X coordinate.
-     * @param y - The tile Y coordinate.
-     * @param level - The tile level;
-     * @returns The credits to be displayed when the tile is displayed.
-     */
-    getTileCredits(x: number, y: number, level: number): Credit[];
-    /**
-     * Requests the image for a given tile.
-     * @param x - The tile X coordinate.
-     * @param y - The tile Y coordinate.
-     * @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.
-     */
-    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.
-     * @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.
-     */
-    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
-     */
-    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
-     */
-    static readonly GetFeatureInfoDefaultParameters: any;
-}
-
-export namespace WebMapTileServiceImageryProvider {
-    /**
-     * Initialization options for the WebMapTileServiceImageryProvider constructor
-     * @property url - The base URL for the WMTS GetTile operation (for KVP-encoded requests) or the tile-URL template (for RESTful requests). The tile-URL template should contain the following variables: &#123;style&#125;, &#123;TileMatrixSet&#125;, &#123;TileMatrix&#125;, &#123;TileRow&#125;, &#123;TileCol&#125;. The first two are optional if actual values are hardcoded or not required by the server. The &#123;s&#125; keyword may be used to specify subdomains.
-     * @property [format = 'image/jpeg'] - The MIME type for images to retrieve from the server.
-     * @property layer - The layer name for WMTS requests.
-     * @property style - The style name for WMTS requests.
-     * @property tileMatrixSetID - The identifier of the TileMatrixSet to use for WMTS requests.
-     * @property [tileMatrixLabels] - A list of identifiers in the TileMatrix to use for WMTS requests, one per TileMatrix level.
-     * @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 <code>data</code> property being an object containing time dynamic dimension and their values.
-     * @property [dimensions] - A object containing static dimensions and their values.
-     * @property [tileWidth = 256] - The tile width in pixels.
-     * @property [tileHeight = 256] - The tile height in pixels.
-     * @property [tilingScheme] - The tiling scheme corresponding to the organization of the tiles in the TileMatrixSet.
-     * @property [rectangle = Rectangle.MAX_VALUE] - The rectangle covered by the layer.
-     * @property [minimumLevel = 0] - The minimum level-of-detail supported by the imagery provider.
-     * @property [maximumLevel] - The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit.
-     * @property [ellipsoid] - The ellipsoid.  If not specified, the WGS84 ellipsoid is used.
-     * @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.
-     */
-    type ConstructorOptions = {
-        url: Resource | string;
-        format?: string;
-        layer: string;
-        style: string;
-        tileMatrixSetID: string;
-        tileMatrixLabels?: any[];
-        clock?: Clock;
-        times?: TimeIntervalCollection;
-        dimensions?: any;
-        tileWidth?: number;
-        tileHeight?: number;
-        tilingScheme?: TilingScheme;
-        rectangle?: Rectangle;
-        minimumLevel?: number;
-        maximumLevel?: number;
-        ellipsoid?: Ellipsoid;
-        credit?: Credit | string;
-        subdomains?: string | string[];
-    };
-}
-
-/**
- * Provides tiled imagery served by {@link http://www.opengeospatial.org/standards/wmts|WMTS 1.0.0} compliant servers.
- * This provider supports HTTP KVP-encoded and RESTful GetTile requests, but does not yet support the SOAP encoding.
- * @example
- * // Example 1. USGS shaded relief tiles (KVP)
- * const shadedRelief1 = new Cesium.WebMapTileServiceImageryProvider({
- *     url : 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS',
- *     layer : 'USGSShadedReliefOnly',
- *     style : 'default',
- *     format : 'image/jpeg',
- *     tileMatrixSetID : 'default028mm',
- *     // tileMatrixLabels : ['default028mm:0', 'default028mm:1', 'default028mm:2' ...],
- *     maximumLevel: 19,
- *     credit : new Cesium.Credit('U. S. Geological Survey')
- * });
- * viewer.imageryLayers.addImageryProvider(shadedRelief1);
- * @example
- * // Example 2. USGS shaded relief tiles (RESTful)
- * const shadedRelief2 = new Cesium.WebMapTileServiceImageryProvider({
- *     url : 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS/tile/1.0.0/USGSShadedReliefOnly/{Style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.jpg',
- *     layer : 'USGSShadedReliefOnly',
- *     style : 'default',
- *     format : 'image/jpeg',
- *     tileMatrixSetID : 'default028mm',
- *     maximumLevel: 19,
- *     credit : new Cesium.Credit('U. S. Geological Survey')
- * });
- * viewer.imageryLayers.addImageryProvider(shadedRelief2);
- * @example
- * // Example 3. NASA time dynamic weather data (RESTful)
- * const times = Cesium.TimeIntervalCollection.fromIso8601({
- *     iso8601: '2015-07-30/2017-06-16/P1D',
- *     dataCallback: function dataCallback(interval, index) {
- *         return {
- *             Time: Cesium.JulianDate.toIso8601(interval.start)
- *         };
- *     }
- * });
- * const weather = new Cesium.WebMapTileServiceImageryProvider({
- *     url : 'https://gibs.earthdata.nasa.gov/wmts/epsg4326/best/AMSR2_Snow_Water_Equivalent/default/{Time}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.png',
- *     layer : 'AMSR2_Snow_Water_Equivalent',
- *     style : 'default',
- *     tileMatrixSetID : '2km',
- *     maximumLevel : 5,
- *     format : 'image/png',
- *     clock: clock,
- *     times: times,
- *     credit : new Cesium.Credit('NASA Global Imagery Browse Services for EOSDIS')
- * });
- * viewer.imageryLayers.addImageryProvider(weather);
- * @param options - Object describing initialization options
- */
-export class WebMapTileServiceImageryProvider {
-    constructor(options: WebMapTileServiceImageryProvider.ConstructorOptions);
-    /**
-     * Gets the URL of the service hosting the imagery.
-     */
-    readonly url: string;
-    /**
-     * Gets the proxy used by this provider.
-     */
-    readonly proxy: Proxy;
-    /**
-     * Gets the width of each tile, in pixels.
-     */
-    readonly tileWidth: number;
-    /**
-     * Gets the height of each tile, in pixels.
-     */
-    readonly tileHeight: number;
-    /**
-     * Gets the maximum level-of-detail that can be requested.
-     */
-    readonly maximumLevel: number | undefined;
-    /**
-     * Gets the minimum level-of-detail that can be requested.
-     */
-    readonly minimumLevel: number;
-    /**
-     * Gets the tiling scheme used by this provider.
-     */
-    readonly tilingScheme: TilingScheme;
-    /**
-     * Gets the rectangle, in radians, of the imagery provided by this instance.
-     */
-    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
@@ -44442,10 +44233,6 @@ export class WebMapTileServiceImageryProvider {
      * are passed an instance of {@link TileProviderError}.
      */
     readonly errorEvent: Event;
-    /**
-     * Gets the mime type of images returned by this imagery provider.
-     */
-    readonly format: string;
     /**
      * Gets the credit to display when this imagery provider is active.  Typically this is used to credit
      * the source of the imagery.
@@ -44459,6 +44246,14 @@ export class WebMapTileServiceImageryProvider {
      * 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.
+     */
+    enablePickFeatures: boolean;
     /**
      * Gets or sets a clock that is used to get keep the time used for time dynamic parameters.
      */
@@ -44469,6 +44264,230 @@ export class WebMapTileServiceImageryProvider {
      * tile requests.
      */
     times: TimeIntervalCollection;
+    /**
+     * Gets the getFeatureInfo URL of the WMS server.
+     */
+    readonly getFeatureInfoUrl: Resource | string;
+    /**
+     * Gets the credits to be displayed when a given tile is displayed.
+     * @param x - The tile X coordinate.
+     * @param y - The tile Y coordinate.
+     * @param level - The tile level;
+     * @returns The credits to be displayed when the tile is displayed.
+     */
+    getTileCredits(x: number, y: number, level: number): Credit[];
+    /**
+     * Requests the image for a given tile.
+     * @param x - The tile X coordinate.
+     * @param y - The tile Y coordinate.
+     * @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.
+     */
+    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.
+     * @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.
+     */
+    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
+     */
+    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
+     */
+    static readonly GetFeatureInfoDefaultParameters: any;
+}
+
+export namespace WebMapTileServiceImageryProvider {
+    /**
+     * Initialization options for the WebMapTileServiceImageryProvider constructor
+     * @property url - The base URL for the WMTS GetTile operation (for KVP-encoded requests) or the tile-URL template (for RESTful requests). The tile-URL template should contain the following variables: &#123;style&#125;, &#123;TileMatrixSet&#125;, &#123;TileMatrix&#125;, &#123;TileRow&#125;, &#123;TileCol&#125;. The first two are optional if actual values are hardcoded or not required by the server. The &#123;s&#125; keyword may be used to specify subdomains.
+     * @property [format = 'image/jpeg'] - The MIME type for images to retrieve from the server.
+     * @property layer - The layer name for WMTS requests.
+     * @property style - The style name for WMTS requests.
+     * @property tileMatrixSetID - The identifier of the TileMatrixSet to use for WMTS requests.
+     * @property [tileMatrixLabels] - A list of identifiers in the TileMatrix to use for WMTS requests, one per TileMatrix level.
+     * @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 <code>data</code> property being an object containing time dynamic dimension and their values.
+     * @property [dimensions] - A object containing static dimensions and their values.
+     * @property [tileWidth = 256] - The tile width in pixels.
+     * @property [tileHeight = 256] - The tile height in pixels.
+     * @property [tilingScheme] - The tiling scheme corresponding to the organization of the tiles in the TileMatrixSet.
+     * @property [rectangle = Rectangle.MAX_VALUE] - The rectangle covered by the layer.
+     * @property [minimumLevel = 0] - The minimum level-of-detail supported by the imagery provider.
+     * @property [maximumLevel] - The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit.
+     * @property [ellipsoid] - The ellipsoid.  If not specified, the WGS84 ellipsoid is used.
+     * @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.
+     */
+    type ConstructorOptions = {
+        url: Resource | string;
+        format?: string;
+        layer: string;
+        style: string;
+        tileMatrixSetID: string;
+        tileMatrixLabels?: any[];
+        clock?: Clock;
+        times?: TimeIntervalCollection;
+        dimensions?: any;
+        tileWidth?: number;
+        tileHeight?: number;
+        tilingScheme?: TilingScheme;
+        rectangle?: Rectangle;
+        minimumLevel?: number;
+        maximumLevel?: number;
+        ellipsoid?: Ellipsoid;
+        credit?: Credit | string;
+        subdomains?: string | string[];
+    };
+}
+
+/**
+ * Provides tiled imagery served by {@link http://www.opengeospatial.org/standards/wmts|WMTS 1.0.0} compliant servers.
+This provider supports HTTP KVP-encoded and RESTful GetTile requests, but does not yet support the SOAP encoding.
+ * @example
+ * // Example 1. USGS shaded relief tiles (KVP)
+const shadedRelief1 = new Cesium.WebMapTileServiceImageryProvider({
+    url : 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS',
+    layer : 'USGSShadedReliefOnly',
+    style : 'default',
+    format : 'image/jpeg',
+    tileMatrixSetID : 'default028mm',
+    // tileMatrixLabels : ['default028mm:0', 'default028mm:1', 'default028mm:2' ...],
+    maximumLevel: 19,
+    credit : new Cesium.Credit('U. S. Geological Survey')
+});
+viewer.imageryLayers.addImageryProvider(shadedRelief1);
+ * @example
+ * // Example 2. USGS shaded relief tiles (RESTful)
+const shadedRelief2 = new Cesium.WebMapTileServiceImageryProvider({
+    url : 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS/tile/1.0.0/USGSShadedReliefOnly/{Style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.jpg',
+    layer : 'USGSShadedReliefOnly',
+    style : 'default',
+    format : 'image/jpeg',
+    tileMatrixSetID : 'default028mm',
+    maximumLevel: 19,
+    credit : new Cesium.Credit('U. S. Geological Survey')
+});
+viewer.imageryLayers.addImageryProvider(shadedRelief2);
+ * @example
+ * // Example 3. NASA time dynamic weather data (RESTful)
+const times = Cesium.TimeIntervalCollection.fromIso8601({
+    iso8601: '2015-07-30/2017-06-16/P1D',
+    dataCallback: function dataCallback(interval, index) {
+        return {
+            Time: Cesium.JulianDate.toIso8601(interval.start)
+        };
+    }
+});
+const weather = new Cesium.WebMapTileServiceImageryProvider({
+    url : 'https://gibs.earthdata.nasa.gov/wmts/epsg4326/best/AMSR2_Snow_Water_Equivalent/default/{Time}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.png',
+    layer : 'AMSR2_Snow_Water_Equivalent',
+    style : 'default',
+    tileMatrixSetID : '2km',
+    maximumLevel : 5,
+    format : 'image/png',
+    clock: clock,
+    times: times,
+    credit : new Cesium.Credit('NASA Global Imagery Browse Services for EOSDIS')
+});
+viewer.imageryLayers.addImageryProvider(weather);
+ * @param options - Object describing initialization options
+ */
+export class WebMapTileServiceImageryProvider {
+    constructor(options: WebMapTileServiceImageryProvider.ConstructorOptions);
+    /**
+     * Gets the URL of the service hosting the imagery.
+     */
+    readonly url: string;
+    /**
+     * Gets the proxy used by this provider.
+     */
+    readonly proxy: Proxy;
+    /**
+     * Gets the width of each tile, in pixels.
+     */
+    readonly tileWidth: number;
+    /**
+     * Gets the height of each tile, in pixels.
+     */
+    readonly tileHeight: number;
+    /**
+     * Gets the maximum level-of-detail that can be requested.
+     */
+    readonly maximumLevel: number | undefined;
+    /**
+     * Gets the minimum level-of-detail that can be requested.
+     */
+    readonly minimumLevel: number;
+    /**
+     * Gets the tiling scheme used by this provider.
+     */
+    readonly tilingScheme: TilingScheme;
+    /**
+     * Gets the rectangle, in radians, of the imagery provided by this instance.
+     */
+    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.
+     */
+    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}.
+     */
+    readonly errorEvent: Event;
+    /**
+     * Gets the mime type of images returned by this imagery provider.
+     */
+    readonly format: string;
+    /**
+     * Gets the credit to display when this imagery provider is active.  Typically this is used to credit
+    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.
+     */
+    readonly hasAlphaChannel: boolean;
+    /**
+     * Gets or sets a clock that is used to get keep the time used for time dynamic parameters.
+     */
+    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.
+     */
+    times: TimeIntervalCollection;
     /**
      * Gets or sets an object that contains static dimensions and their values.
      */
@@ -44488,12 +44507,12 @@ export class WebMapTileServiceImageryProvider {
      * @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;
     /**
      * Picking features is not currently supported by this imagery provider, so this function simply returns
-     * undefined.
+    undefined.
      * @param x - The tile X coordinate.
      * @param y - The tile Y coordinate.
      * @param level - The tile level.
@@ -44508,29 +44527,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.
@@ -44553,10 +44572,10 @@ const widget2 = new Cesium.CesiumWidget("cesiumContainer", {
  * @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.
@@ -44635,7 +44654,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;
     /**
@@ -44660,46 +44679,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;
     /**
@@ -44716,9 +44735,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.
@@ -44730,34 +44749,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.
@@ -44765,18 +44784,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.
@@ -45093,12 +45112,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[];
     /**
@@ -45139,7 +45158,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: {
@@ -45163,7 +45182,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;
     /**