mars3d-cesium 1.123.0 → 1.124.0

package/Build/Cesium/Cesium.d.ts

@@ -8010,6 +8010,27 @@ export class GoogleEarthEnterpriseTerrainProvider {
     loadTileDataAvailability(x: number, y: number, level: number): undefined;
 }
 
+/**
+ * Provides geocoding through Google.
+ * @param options - Object with the following properties:
+ * @param options.key - An API key to use with the Google geocoding service
+ */
+export class GoogleGeocoderService {
+    constructor(options: {
+        key: string;
+    });
+    /**
+     * Gets the credit to display after a geocode is performed. Typically this is used to credit
+    the geocoder service.
+     */
+    readonly credit: Credit | undefined;
+    /**
+     * Get a list of possible locations that match a search string.
+     * @param query - The query to be sent to the geocoder service
+     */
+    geocode(query: string): Promise<GeocoderService.Result[]>;
+}
+
 /**
  * Default settings for accessing the Google Maps API.
 <br/>
@@ -8968,24 +8989,49 @@ export namespace Ion {
     var defaultServer: string | Resource;
 }
 
+/**
+ * Underlying geocoding services that can be used via Cesium ion.
+ */
+export enum IonGeocodeProviderType {
+    /**
+     * Google geocoder, for use with Google data.
+     */
+    GOOGLE = "GOOGLE",
+    /**
+     * Bing geocoder, for use with Bing data.
+     */
+    BING = "BING",
+    /**
+     * Use the default geocoder as set on the server.  Used when neither Bing or
+    Google data is used.
+     */
+    DEFAULT = "DEFAULT"
+}
+
 /**
  * Provides geocoding through Cesium ion.
  * @param options - Object with the following properties:
  * @param options.scene - The scene
  * @param [options.accessToken = Ion.defaultAccessToken] - The access token to use.
  * @param [options.server = Ion.defaultServer] - The resource to the Cesium ion API server.
+ * @param [options.geocodeProviderType = IonGeocodeProviderType.DEFAULT] - The geocoder the Cesium ion API server should use to fulfill this request.
  */
 export class IonGeocoderService {
     constructor(options: {
         scene: Scene;
         accessToken?: string;
         server?: string | Resource;
+        geocodeProviderType?: IonGeocodeProviderType;
     });
     /**
      * Gets the credit to display after a geocode is performed. Typically this is used to credit
     the geocoder service.
      */
     readonly credit: Credit | undefined;
+    /**
+     * The geocoding service that Cesium ion API server should use to fulfill geocding requests.
+     */
+    geocodeProviderType: IonGeocodeProviderType;
     /**
      * @param query - The query to be sent to the geocoder service
      * @param [type = GeocodeType.SEARCH] - The type of geocode to perform.
@@ -9099,6 +9145,37 @@ export namespace Iso8601 {
     const MAXIMUM_INTERVAL: TimeInterval;
 }
 
+/**
+ * Default settings for accessing the iTwin platform.
+ */
+export namespace ITwinPlatform {
+    /**
+     * Status states for a mesh-export export.
+    Valid values are: <code>NotStarted</code>, <code>InProgress</code>, <code>Complete</code>, <code>Invalid</code>
+     */
+    enum ExportStatus {
+    }
+    /**
+     * Types of mesh-export exports. CesiumJS only supports loading <code>3DTILES</code> type exports.
+    Valid values are: <code>IMODEL</code>, <code>CESIUM</code>, <code>3DTILES</code>
+     */
+    enum ExportType {
+    }
+    /**
+     * Types of Reality data
+     */
+    enum RealityDataType {
+    }
+    /**
+     * Gets or sets the default iTwin access token. This token should have the <code>itwin-platform</code> scope.
+     */
+    var defaultAccessToken: string | undefined;
+    /**
+     * Gets or sets the default iTwin API endpoint.
+     */
+    var apiEndpoint: string | Resource;
+}
+
 /**
  * Represents an astronomical Julian date, which is the number of days since noon on January 1, -4712 (4713 BC).
 For increased precision, this class stores the whole number part of the date and the seconds
@@ -12421,19 +12498,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.
@@ -12483,8 +12560,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.
@@ -12495,8 +12572,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.
@@ -12513,15 +12590,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.
@@ -14661,11 +14738,6 @@ export class Rectangle {
      * @returns <code>true</code> if the Rectangles are within the provided epsilon, <code>false</code> otherwise.
      */
     equalsEpsilon(other?: Rectangle, epsilon?: number): boolean;
-    /**
-     * Checks a Rectangle's properties and throws if they are not in valid ranges.
-     * @param rectangle - The rectangle to validate
-     */
-    static validate(rectangle: Rectangle): void;
     /**
      * Computes the southwest corner of a rectangle.
      * @param rectangle - The rectangle for which to find the corner
@@ -16144,7 +16216,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 {
@@ -16154,14 +16226,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;
@@ -16169,35 +16241,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;
 }
@@ -17599,6 +17671,34 @@ export enum TimeStandard {
     TAI = 1
 }
 
+/**
+ * Constants for identifying well-known tracking reference frames.
+ */
+export enum TrackingReferenceFrame {
+    /**
+     * Auto-detect algorithm. The reference frame used to track the Entity will
+    be automatically selected based on its trajectory: near-surface slow moving
+    objects will be tracked in the entity's local east-north-up reference
+    frame, while faster objects like satellites will use VVLH (Vehicle Velocity,
+    Local Horizontal).
+     */
+    AUTODETECT = 0,
+    /**
+     * The entity's local East-North-Up reference frame.
+     */
+    ENU = 1,
+    /**
+     * The entity's inertial reference frame. If entity has no defined orientation
+    property, it falls back to auto-detect algorithm.
+     */
+    INERTIAL = 2,
+    /**
+     * The entity's inertial reference frame with orientation fixed to its
+    {@link VelocityOrientationProperty}, ignoring its own orientation.
+     */
+    VELOCITY = 3
+}
+
 /**
  * Contains functions for transforming positions to various reference frames.
  */
@@ -20905,6 +21005,7 @@ export namespace Entity {
      * @property [name] - A human readable name to display to users. It does not have to be unique.
      * @property [availability] - The availability, if any, associated with this object.
      * @property [show] - A boolean value indicating if the entity and its children are displayed.
+     * @property [trackingReferenceFrame = TrackingReferenceFrame.AUTODETECT] - The reference frame used when this entity is being tracked. <br/> If <code>undefined</code>, reference frame is determined based on entity velocity: near-surface slow moving entities are tracked using the local east-north-up reference frame, whereas fast moving entities such as satellites are tracked using VVLH (Vehicle Velocity, Local Horizontal).
      * @property [description] - A string Property specifying an HTML description for this entity.
      * @property [position] - A Property specifying the entity position.
      * @property [orientation = Transforms.eastNorthUpToFixedFrame(position)] - A Property specifying the entity orientation in respect to Earth-fixed-Earth-centered (ECEF). If undefined, east-north-up at entity position is used.
@@ -20934,8 +21035,9 @@ export namespace Entity {
         name?: string;
         availability?: TimeIntervalCollection;
         show?: boolean;
+        trackingReferenceFrame?: TrackingReferenceFrame;
         description?: Property | string;
-        position?: PositionProperty | Cartesian3 | CallbackProperty;
+        position?: PositionProperty | Cartesian3 | CallbackPositionProperty;
         orientation?: Property | Quaternion;
         viewFrom?: Property | Cartesian3;
         parent?: Entity;
@@ -21000,6 +21102,10 @@ export class Entity {
     the entity is only displayed if the parent entity's show property is also true.
      */
     show: boolean;
+    /**
+     * Gets or sets the entity's tracking reference frame.
+     */
+    trackingReferenceFrame: TrackingReferenceFrame;
     /**
      * Gets whether this entity is being displayed, taking into account
     the visibility of any ancestor entities.
@@ -21758,10 +21864,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;
     /**
@@ -22893,7 +22999,7 @@ export class ModelVisualizer {
     constructor(scene: Scene, entityCollection: EntityCollection);
     /**
      * Updates models created 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 This function always returns true.
      */
@@ -23969,10 +24075,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;
     /**
@@ -24933,6 +25039,12 @@ export class SampledProperty {
      * @param [derivativeValues] - An array where each item is the array of derivatives at the equivalent time index.
      */
     addSamples(times: JulianDate[], values: Packable[], derivativeValues?: any[][]): void;
+    /**
+     * Retrieves the time of the provided sample associated with the index. A negative index accesses the list of samples in reverse order.
+     * @param index - The index of samples list.
+     * @returns The JulianDate time of the sample, or undefined if failed.
+     */
+    getSample(index: number): JulianDate | undefined;
     /**
      * Adds samples as a single packed array where each new sample is represented as a date,
     followed by the packed representation of the corresponding value and derivatives.
@@ -30994,12 +31106,22 @@ export function createElevationBandMaterial(options: {
 }): Material;
 
 /**
- * Creates a {@link Cesium3DTileset} instance for the Google Photorealistic 3D Tiles tileset.
+ * 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.
  * @example
- * const viewer = new Cesium.Viewer("cesiumContainer");
+ * const viewer = new Cesium.Viewer("cesiumContainer", {
+  geocoder: Cesium.IonGeocodeProviderType.GOOGLE
+});
 
 try {
-  const tileset = await Cesium.createGooglePhotorealistic3DTileset();
+  const tileset = await Cesium.createGooglePhotorealistic3DTileset({
+     onlyUsingWithGoogleGeocoder: true,
+  });
   viewer.scene.primitives.add(tileset));
 } catch (error) {
   console.log(`Error creating tileset: ${error}`);
@@ -31008,18 +31130,26 @@ try {
  * // Use your own Google Maps API key
 Cesium.GoogleMaps.defaultApiKey = "your-api-key";
 
-const viewer = new Cesium.Viewer("cesiumContainer");
+const viewer = new Cesium.Viewer("cesiumContainer". {
+  geocoder: Cesium.IonGeocodeProviderType.GOOGLE
+});
 
 try {
-  const tileset = await Cesium.createGooglePhotorealistic3DTileset();
+  const tileset = await Cesium.createGooglePhotorealistic3DTileset({
+     onlyUsingWithGoogleGeocoder: true,
+  });
   viewer.scene.primitives.add(tileset));
 } catch (error) {
   console.log(`Error creating tileset: ${error}`);
 }
- * @param [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 [options] - An object describing initialization options.
+ * @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.
  */
-export function createGooglePhotorealistic3DTileset(key?: string, options?: Cesium3DTileset.ConstructorOptions): Promise<Cesium3DTileset>;
+export function createGooglePhotorealistic3DTileset(apiOptions?: {
+    key?: string;
+    onlyUsingWithGoogleGeocoder?: true;
+}, tilesetOptions?: Cesium3DTileset.ConstructorOptions): Promise<Cesium3DTileset>;
 
 /**
  * Creates a {@link Cesium3DTileset} instance for the
@@ -31615,14 +31745,55 @@ 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
  */
 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.
+ * @param input - The input value
+ * @param offset - The offset
+ * @param scale - The scale
+ * @returns The statement
+ */
+export function unapplyValueTransform(input: string, offset: string, scale: string): string;
+
+/**
+ * Returns a shader statement that applies the inverse of the
+ * normalization, based on the given component type
+ * @param input - The input value
+ * @param componentType - The component type
+ * @returns The statement
+ */
+export function unnormalize(input: string, componentType: string): string;
+
+/**
+ * Creates a shader statement that returns the value of the specified
+ * property, normalized to the range [0, 1].
+ * @param classProperty - The class property
+ * @param metadataProperty - The metadata property, either
+ * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+ * @returns The string
+ */
+export function getSourceValueStringScalar(classProperty: MetadataClassProperty, metadataProperty: any): string;
+
+/**
+ * Creates a shader statement that returns the value of the specified
+ * component of the given property, normalized to the range [0, 1].
+ * @param classProperty - The class property
+ * @param metadataProperty - The metadata property, either
+ * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+ * @param componentName - The name, in ["x", "y", "z", "w"]
+ * @returns The string
+ */
+export function getSourceValueStringComponent(classProperty: MetadataClassProperty, metadataProperty: any, componentName: string): string;
+
 /**
  * A light that gets emitted in a single direction from infinitely far away.
  * @param options - Object with the following properties:
@@ -31835,10 +32006,25 @@ export class DynamicEnvironmentMapManager {
      * mapManager = mapManager && mapManager.destroy();
      */
     destroy(): void;
+    /**
+     * Returns <code>true</code> if dynamic updates are supported in the current WebGL rendering context.
+    Dynamic updates requires the EXT_color_buffer_float or EXT_color_buffer_half_float extension.
+     * @param scene - The object containing the rendering context
+     * @returns true if supported
+     */
+    static isDynamicUpdateSupported(scene: Scene): boolean;
     /**
      * Average hue of ground color on earth, a warm green-gray.
      */
-    static AVERAGE_EARTH_GROUND_COLOR: Color;
+    static readonly AVERAGE_EARTH_GROUND_COLOR: Color;
+    /**
+     * The default third order spherical harmonic coefficients used for the diffuse color of image-based lighting, a white ambient light with low intensity.
+    <p>
+    There are nine <code>Cartesian3</code> coefficients.
+    The order of the coefficients is: L<sub>0,0</sub>, L<sub>1,-1</sub>, L<sub>1,0</sub>, L<sub>1,1</sub>, L<sub>2,-2</sub>, L<sub>2,-1</sub>, L<sub>2,0</sub>, L<sub>2,1</sub>, L<sub>2,2</sub>
+    </p>
+     */
+    static readonly DEFAULT_SPHERICAL_HARMONIC_COEFFICIENTS: Cartesian3[];
 }
 
 /**
@@ -34053,81 +34239,81 @@ export namespace ImageryLayer {
     /**
      * Initialization options for the ImageryLayer constructor.
      * @property [rectangle = imageryProvider.rectangle] - The rectangle of the layer.  This rectangle
-           can limit the visible portion of the imagery provider.
+     *        can limit the visible portion of the imagery provider.
      * @property [alpha = 1.0] - The alpha blending value of this layer, from 0.0 to 1.0.
-                             This can either be a simple number or a function with the signature
-                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-                             current frame state, this layer, and the x, y, and level coordinates of the
-                             imagery tile for which the alpha is required, and it is expected to return
-                             the alpha value to use for the tile.
+     *                          This can either be a simple number or a function with the signature
+     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+     *                          current frame state, this layer, and the x, y, and level coordinates of the
+     *                          imagery tile for which the alpha is required, and it is expected to return
+     *                          the alpha value to use for the tile.
      * @property [nightAlpha = 1.0] - The alpha blending value of this layer on the night side of the globe, from 0.0 to 1.0.
-                             This can either be a simple number or a function with the signature
-                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-                             current frame state, this layer, and the x, y, and level coordinates of the
-                             imagery tile for which the alpha is required, and it is expected to return
-                             the alpha value to use for the tile. This only takes effect when <code>enableLighting</code> is <code>true</code>.
+     *                          This can either be a simple number or a function with the signature
+     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+     *                          current frame state, this layer, and the x, y, and level coordinates of the
+     *                          imagery tile for which the alpha is required, and it is expected to return
+     *                          the alpha value to use for the tile. This only takes effect when <code>enableLighting</code> is <code>true</code>.
      * @property [dayAlpha = 1.0] - The alpha blending value of this layer on the day side of the globe, from 0.0 to 1.0.
-                             This can either be a simple number or a function with the signature
-                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-                             current frame state, this layer, and the x, y, and level coordinates of the
-                             imagery tile for which the alpha is required, and it is expected to return
-                             the alpha value to use for the tile. This only takes effect when <code>enableLighting</code> is <code>true</code>.
+     *                          This can either be a simple number or a function with the signature
+     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+     *                          current frame state, this layer, and the x, y, and level coordinates of the
+     *                          imagery tile for which the alpha is required, and it is expected to return
+     *                          the alpha value to use for the tile. This only takes effect when <code>enableLighting</code> is <code>true</code>.
      * @property [brightness = 1.0] - The brightness of this layer.  1.0 uses the unmodified imagery
-                             color.  Less than 1.0 makes the imagery darker while greater than 1.0 makes it brighter.
-                             This can either be a simple number or a function with the signature
-                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-                             current frame state, this layer, and the x, y, and level coordinates of the
-                             imagery tile for which the brightness is required, and it is expected to return
-                             the brightness value to use for the tile.  The function is executed for every
-                             frame and for every tile, so it must be fast.
+     *                          color.  Less than 1.0 makes the imagery darker while greater than 1.0 makes it brighter.
+     *                          This can either be a simple number or a function with the signature
+     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+     *                          current frame state, this layer, and the x, y, and level coordinates of the
+     *                          imagery tile for which the brightness is required, and it is expected to return
+     *                          the brightness value to use for the tile.  The function is executed for every
+     *                          frame and for every tile, so it must be fast.
      * @property [contrast = 1.0] - The contrast of this layer.  1.0 uses the unmodified imagery color.
-                             Less than 1.0 reduces the contrast while greater than 1.0 increases it.
-                             This can either be a simple number or a function with the signature
-                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-                             current frame state, this layer, and the x, y, and level coordinates of the
-                             imagery tile for which the contrast is required, and it is expected to return
-                             the contrast value to use for the tile.  The function is executed for every
-                             frame and for every tile, so it must be fast.
+     *                          Less than 1.0 reduces the contrast while greater than 1.0 increases it.
+     *                          This can either be a simple number or a function with the signature
+     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+     *                          current frame state, this layer, and the x, y, and level coordinates of the
+     *                          imagery tile for which the contrast is required, and it is expected to return
+     *                          the contrast value to use for the tile.  The function is executed for every
+     *                          frame and for every tile, so it must be fast.
      * @property [hue = 0.0] - The hue of this layer.  0.0 uses the unmodified imagery color.
-                             This can either be a simple number or a function with the signature
-                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-                             current frame state, this layer, and the x, y, and level coordinates
-                             of the imagery tile for which the hue is required, and it is expected to return
-                             the contrast value to use for the tile.  The function is executed for every
-                             frame and for every tile, so it must be fast.
+     *                          This can either be a simple number or a function with the signature
+     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+     *                          current frame state, this layer, and the x, y, and level coordinates
+     *                          of the imagery tile for which the hue is required, and it is expected to return
+     *                          the contrast value to use for the tile.  The function is executed for every
+     *                          frame and for every tile, so it must be fast.
      * @property [saturation = 1.0] - The saturation of this layer.  1.0 uses the unmodified imagery color.
-                             Less than 1.0 reduces the saturation while greater than 1.0 increases it.
-                             This can either be a simple number or a function with the signature
-                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-                             current frame state, this layer, and the x, y, and level coordinates
-                             of the imagery tile for which the saturation is required, and it is expected to return
-                             the contrast value to use for the tile.  The function is executed for every
-                             frame and for every tile, so it must be fast.
+     *                          Less than 1.0 reduces the saturation while greater than 1.0 increases it.
+     *                          This can either be a simple number or a function with the signature
+     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+     *                          current frame state, this layer, and the x, y, and level coordinates
+     *                          of the imagery tile for which the saturation is required, and it is expected to return
+     *                          the contrast value to use for the tile.  The function is executed for every
+     *                          frame and for every tile, so it must be fast.
      * @property [gamma = 1.0] - The gamma correction to apply to this layer.  1.0 uses the unmodified imagery color.
-                             This can either be a simple number or a function with the signature
-                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-                             current frame state, this layer, and the x, y, and level coordinates of the
-                             imagery tile for which the gamma is required, and it is expected to return
-                             the gamma value to use for the tile.  The function is executed for every
-                             frame and for every tile, so it must be fast.
+     *                          This can either be a simple number or a function with the signature
+     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+     *                          current frame state, this layer, and the x, y, and level coordinates of the
+     *                          imagery tile for which the gamma is required, and it is expected to return
+     *                          the gamma value to use for the tile.  The function is executed for every
+     *                          frame and for every tile, so it must be fast.
      * @property [splitDirection = SplitDirection.NONE] - The {@link SplitDirection} split to apply to this layer.
      * @property [minificationFilter = TextureMinificationFilter.LINEAR] - The
-                                       texture minification filter to apply to this layer. Possible values
-                                       are <code>TextureMinificationFilter.LINEAR</code> and
-                                       <code>TextureMinificationFilter.NEAREST</code>.
+     *                                    texture minification filter to apply to this layer. Possible values
+     *                                    are <code>TextureMinificationFilter.LINEAR</code> and
+     *                                    <code>TextureMinificationFilter.NEAREST</code>.
      * @property [magnificationFilter = TextureMagnificationFilter.LINEAR] - The
-                                        texture minification filter to apply to this layer. Possible values
-                                        are <code>TextureMagnificationFilter.LINEAR</code> and
-                                        <code>TextureMagnificationFilter.NEAREST</code>.
+     *                                     texture minification filter to apply to this layer. Possible values
+     *                                     are <code>TextureMagnificationFilter.LINEAR</code> and
+     *                                     <code>TextureMagnificationFilter.NEAREST</code>.
      * @property [show = true] - True if the layer is shown; otherwise, false.
      * @property [maximumAnisotropy = maximum supported] - The maximum anisotropy level to use
-           for texture filtering.  If this parameter is not specified, the maximum anisotropy supported
-           by the WebGL stack will be used.  Larger values make the imagery look better in horizon
-           views.
+     *        for texture filtering.  If this parameter is not specified, the maximum anisotropy supported
+     *        by the WebGL stack will be used.  Larger values make the imagery look better in horizon
+     *        views.
      * @property [minimumTerrainLevel] - The minimum terrain level-of-detail at which to show this imagery layer,
-                    or undefined to show it at all levels.  Level zero is the least-detailed level.
+     *                 or undefined to show it at all levels.  Level zero is the least-detailed level.
      * @property [maximumTerrainLevel] - The maximum terrain level-of-detail at which to show this imagery layer,
-                    or undefined to show it at all levels.  Level zero is the least-detailed level.
+     *                 or undefined to show it at all levels.  Level zero is the least-detailed level.
      * @property [cutoutRectangle] - Cartographic rectangle for cutting out a portion of this ImageryLayer.
      * @property [colorToAlpha] - Color to be used as alpha.
      * @property [colorToAlphaThreshold = 0.004] - Threshold for color-to-alpha.
@@ -34162,22 +34348,22 @@ export namespace ImageryLayer {
 
 /**
  * An imagery layer that displays tiled image data from a single imagery provider
-on a {@link Globe}.
+ * on a {@link Globe}.
  * @example
  * // Add an OpenStreetMaps layer
-const imageryLayer = new Cesium.ImageryLayer(new Cesium.OpenStreetMapImageryProvider({
-  url: "https://tile.openstreetmap.org/"
-}));
-scene.imageryLayers.add(imageryLayer);
+ * const imageryLayer = new Cesium.ImageryLayer(new Cesium.OpenStreetMapImageryProvider({
+ *   url: "https://tile.openstreetmap.org/"
+ * }));
+ * scene.imageryLayers.add(imageryLayer);
  * @example
  * // Add Cesium ion's default world imagery layer
-const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
-scene.imageryLayers.add(imageryLayer);
+ * const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
+ * scene.imageryLayers.add(imageryLayer);
  * @example
  * // Add a new transparent layer from Cesium ion
-const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
-imageryLayer.alpha = 0.5;
-scene.imageryLayers.add(imageryLayer);
+ * const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
+ * imageryLayer.alpha = 0.5;
+ * scene.imageryLayers.add(imageryLayer);
  * @param [imageryProvider] - The imagery provider to use.
  * @param [options] - An object describing initialization options
  */
@@ -34185,27 +34371,27 @@ export class ImageryLayer {
     constructor(imageryProvider?: ImageryProvider, options?: ImageryLayer.ConstructorOptions);
     /**
      * The alpha blending value of this layer, with 0.0 representing fully transparent and
-    1.0 representing fully opaque.
+     * 1.0 representing fully opaque.
      */
     alpha: number;
     /**
      * The alpha blending value of this layer on the night side of the globe, with 0.0 representing fully transparent and
-    1.0 representing fully opaque. This only takes effect when {@link Globe#enableLighting} is <code>true</code>.
+     * 1.0 representing fully opaque. This only takes effect when {@link Globe#enableLighting} is <code>true</code>.
      */
     nightAlpha: number;
     /**
      * The alpha blending value of this layer on the day side of the globe, with 0.0 representing fully transparent and
-    1.0 representing fully opaque. This only takes effect when {@link Globe#enableLighting} is <code>true</code>.
+     * 1.0 representing fully opaque. This only takes effect when {@link Globe#enableLighting} is <code>true</code>.
      */
     dayAlpha: number;
     /**
      * The brightness of this layer.  1.0 uses the unmodified imagery color.  Less than 1.0
-    makes the imagery darker while greater than 1.0 makes it brighter.
+     * makes the imagery darker while greater than 1.0 makes it brighter.
      */
     brightness: number;
     /**
      * The contrast of this layer.  1.0 uses the unmodified imagery color.  Less than 1.0 reduces
-    the contrast while greater than 1.0 increases it.
+     * the contrast while greater than 1.0 increases it.
      */
     contrast: number;
     /**
@@ -34214,7 +34400,7 @@ export class ImageryLayer {
     hue: number;
     /**
      * The saturation of this layer. 1.0 uses the unmodified imagery color. Less than 1.0 reduces the
-    saturation while greater than 1.0 increases it.
+     * saturation while greater than 1.0 increases it.
      */
     saturation: number;
     /**
@@ -34227,20 +34413,20 @@ export class ImageryLayer {
     splitDirection: SplitDirection;
     /**
      * The {@link TextureMinificationFilter} to apply to this layer.
-    Possible values are {@link TextureMinificationFilter.LINEAR} (the default)
-    and {@link TextureMinificationFilter.NEAREST}.
-    
-    To take effect, this property must be set immediately after adding the imagery layer.
-    Once a texture is loaded it won't be possible to change the texture filter used.
+     * Possible values are {@link TextureMinificationFilter.LINEAR} (the default)
+     * and {@link TextureMinificationFilter.NEAREST}.
+     *
+     * To take effect, this property must be set immediately after adding the imagery layer.
+     * Once a texture is loaded it won't be possible to change the texture filter used.
      */
     minificationFilter: TextureMinificationFilter;
     /**
      * The {@link TextureMagnificationFilter} to apply to this layer.
-    Possible values are {@link TextureMagnificationFilter.LINEAR} (the default)
-    and {@link TextureMagnificationFilter.NEAREST}.
-    
-    To take effect, this property must be set immediately after adding the imagery layer.
-    Once a texture is loaded it won't be possible to change the texture filter used.
+     * Possible values are {@link TextureMagnificationFilter.LINEAR} (the default)
+     * and {@link TextureMagnificationFilter.NEAREST}.
+     *
+     * To take effect, this property must be set immediately after adding the imagery layer.
+     * Once a texture is loaded it won't be possible to change the texture filter used.
      */
     magnificationFilter: TextureMagnificationFilter;
     /**
@@ -34269,85 +34455,85 @@ export class ImageryLayer {
     readonly ready: boolean;
     /**
      * Gets an event that is raised when the imagery provider has been successfully created. Event listeners
-    are passed the created instance of {@link ImageryProvider}.
+     * are passed the created instance of {@link ImageryProvider}.
      */
     readonly readyEvent: Event<ImageryLayer.ReadyEventCallback>;
     /**
      * Gets the rectangle of this layer.  If this rectangle is smaller than the rectangle of the
-    {@link ImageryProvider}, only a portion of the imagery provider is shown.
+     * {@link ImageryProvider}, only a portion of the imagery provider is shown.
      */
     readonly rectangle: Rectangle;
     /**
      * This value is used as the default brightness for the imagery layer if one is not provided during construction
-    or by the imagery provider. This value does not modify the brightness of the imagery.
+     * or by the imagery provider. This value does not modify the brightness of the imagery.
      */
     static DEFAULT_BRIGHTNESS: number;
     /**
      * This value is used as the default contrast for the imagery layer if one is not provided during construction
-    or by the imagery provider. This value does not modify the contrast of the imagery.
+     * or by the imagery provider. This value does not modify the contrast of the imagery.
      */
     static DEFAULT_CONTRAST: number;
     /**
      * This value is used as the default hue for the imagery layer if one is not provided during construction
-    or by the imagery provider. This value does not modify the hue of the imagery.
+     * or by the imagery provider. This value does not modify the hue of the imagery.
      */
     static DEFAULT_HUE: number;
     /**
      * This value is used as the default saturation for the imagery layer if one is not provided during construction
-    or by the imagery provider. This value does not modify the saturation of the imagery.
+     * or by the imagery provider. This value does not modify the saturation of the imagery.
      */
     static DEFAULT_SATURATION: number;
     /**
      * This value is used as the default gamma for the imagery layer if one is not provided during construction
-    or by the imagery provider. This value does not modify the gamma of the imagery.
+     * or by the imagery provider. This value does not modify the gamma of the imagery.
      */
     static DEFAULT_GAMMA: number;
     /**
      * This value is used as the default split for the imagery layer if one is not provided during construction
-    or by the imagery provider.
+     * or by the imagery provider.
      */
     static DEFAULT_SPLIT: SplitDirection;
     /**
      * This value is used as the default texture minification filter for the imagery layer if one is not provided
-    during construction or by the imagery provider.
+     * during construction or by the imagery provider.
      */
     static DEFAULT_MINIFICATION_FILTER: TextureMinificationFilter;
     /**
      * This value is used as the default texture magnification filter for the imagery layer if one is not provided
-    during construction or by the imagery provider.
+     * during construction or by the imagery provider.
      */
     static DEFAULT_MAGNIFICATION_FILTER: TextureMagnificationFilter;
     /**
      * This value is used as the default threshold for color-to-alpha if one is not provided
-    during construction or by the imagery provider.
+     * during construction or by the imagery provider.
      */
     static DEFAULT_APPLY_COLOR_TO_ALPHA_THRESHOLD: number;
     /**
      * Create a new imagery layer from an asynchronous imagery provider. The layer will handle any asynchronous loads or errors, and begin rendering the imagery layer once ready.
      * @example
      * // Create a new base layer
-    const viewer = new Cesium.Viewer("cesiumContainer", {
-      baseLayer: Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
-    });
+     * const viewer = new Cesium.Viewer("cesiumContainer", {
+     *   baseLayer: Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
+     * });
      * @example
      * // Add a new transparent layer
-    const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
-    imageryLayer.alpha = 0.5;
-    viewer.imageryLayers.add(imageryLayer);
+     * const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
+     * imageryLayer.alpha = 0.5;
+     * viewer.imageryLayers.add(imageryLayer);
      * @example
      * // Handle loading events
-    const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
-    viewer.imageryLayers.add(imageryLayer);
-    
-    imageryLayer.readyEvent.addEventListener(provider => {
-      imageryLayer.provider.errorEvent.addEventListener(error => {
-        alert(`Encountered an error while loading imagery tiles! ${error}`);
-      });
-    });
-    
-    imageryLayer.errorEvent.addEventListener(error => {
-      alert(`Encountered an error while creating an imagery layer! ${error}`);
-    });
+     * const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
+     * viewer.imageryLayers.add(imageryLayer);
+     *
+     * imageryLayer.readyEvent.addEventListener(provider => {
+     *   imageryLayer.provider.errorEvent.addEventListener(error => {
+     *     alert(`Encountered an error while loading imagery tiles! ${error}`);
+     *   });
+     * });
+     *
+     * imageryLayer.errorEvent.addEventListener(error => {
+     *   alert(`Encountered an error while creating an imagery layer! ${error}`);
+     * });
      * @param imageryProviderPromise - A promise which resolves to a imagery provider
      * @param options - An object describing initialization options
      * @returns The created imagery layer.
@@ -34357,70 +34543,70 @@ export class ImageryLayer {
      * Create a new imagery layer for ion's default global base imagery layer, currently Bing Maps. The layer will handle any asynchronous loads or errors, and begin rendering the imagery layer once ready.
      * @example
      * // Add a new transparent layer
-    const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
-    imageryLayer.alpha = 0.5;
-    viewer.imageryLayers.add(imageryLayer);
+     * const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
+     * imageryLayer.alpha = 0.5;
+     * viewer.imageryLayers.add(imageryLayer);
      * @example
      * // Handle loading events
-    const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
-    viewer.imageryLayers.add(imageryLayer);
-    
-    imageryLayer.readyEvent.addEventListener(provider => {
-      imageryLayer.provider.errorEvent.addEventListener(error => {
-        alert(`Encountered an error while loading imagery tiles! ${error}`);
-      });
-    });
-    
-    imageryLayer.errorEvent.addEventListener(error => {
-      alert(`Encountered an error while creating an imagery layer! ${error}`);
-    });
+     * const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
+     * viewer.imageryLayers.add(imageryLayer);
+     *
+     * imageryLayer.readyEvent.addEventListener(provider => {
+     *   imageryLayer.provider.errorEvent.addEventListener(error => {
+     *     alert(`Encountered an error while loading imagery tiles! ${error}`);
+     *   });
+     * });
+     *
+     * imageryLayer.errorEvent.addEventListener(error => {
+     *   alert(`Encountered an error while creating an imagery layer! ${error}`);
+     * });
      * @param options - An object describing initialization options
      * @returns The created imagery layer.
-    
-    * @example
-    // Create a new base layer
-    const viewer = new Cesium.Viewer("cesiumContainer", {
-      baseLayer: Cesium.ImageryLayer.fromWorldImagery();
-    });
+     *
+     * * @example
+     * // Create a new base layer
+     * const viewer = new Cesium.Viewer("cesiumContainer", {
+     *   baseLayer: Cesium.ImageryLayer.fromWorldImagery();
+     * });
      */
     static fromWorldImagery(options: ImageryLayer.WorldImageryConstructorOptions): ImageryLayer;
     /**
      * Gets a value indicating whether this layer is the base layer in the
-    {@link ImageryLayerCollection}.  The base layer is the one that underlies all
-    others.  It is special in that it is treated as if it has global rectangle, even if
-    it actually does not, by stretching the texels at the edges over the entire
-    globe.
+     * {@link ImageryLayerCollection}.  The base layer is the one that underlies all
+     * others.  It is special in that it is treated as if it has global rectangle, even if
+     * it actually does not, by stretching the texels at the edges over the entire
+     * globe.
      * @returns true if this is the base layer; otherwise, false.
      */
     isBaseLayer(): 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
      * imageryLayer = imageryLayer && imageryLayer.destroy();
      */
     destroy(): void;
     /**
      * Computes the intersection of this layer's rectangle with the imagery provider's availability rectangle,
-    producing the overall bounds of imagery that can be produced by this layer.
+     * producing the overall bounds of imagery that can be produced by this layer.
      * @example
      * // Zoom to an imagery layer.
-    const imageryRectangle = imageryLayer.getImageryRectangle();
-    scene.camera.flyTo({
-        destination: rectangle
-    });
+     * const imageryRectangle = imageryLayer.getImageryRectangle();
+     * scene.camera.flyTo({
+     *     destination: rectangle
+     * });
      * @returns A rectangle which defines the overall bounds of imagery that can be produced by this layer.
      */
     getImageryRectangle(): Rectangle;
@@ -34433,24 +34619,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;
     /**
@@ -34461,27 +34647,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;
@@ -34490,7 +34676,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;
     /**
@@ -34538,57 +34724,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();
      */
@@ -34899,6 +35085,40 @@ export enum IonWorldImageryStyle {
     ROAD = 4
 }
 
+/**
+ * Methods for loading iTwin platform data into CesiumJS
+ */
+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.
+     * @example
+     * const tileset = await Cesium.ITwinData.createTilesetFromIModelId(iModelId);
+    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
+     */
+    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.
+     * @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
+     * @param [rootDocument] - The path of the root document for this reality data
+     */
+    function createTilesetForRealityDataId(iTwinId: string, realityDataId: string, type?: ITwinPlatform.RealityDataType, rootDocument?: string): Promise<Cesium3DTileset>;
+}
+
 export namespace Label {
     /**
      * Initialization options for the Label constructor
@@ -35731,216 +35951,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.
@@ -35971,17 +36191,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.
@@ -35994,19 +36214,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();
      */
@@ -36445,10 +36665,18 @@ export class MetadataClassProperty {
     readonly semantic: string;
     /**
      * The offset to be added to property values as part of the value transform.
+    
+    This is always defined, even when `hasValueTransform` is `false`. If
+    the class property JSON itself did not define it, then it will be
+    initialized to the default value.
      */
     readonly offset: number | number[] | number[][];
     /**
      * The scale to be multiplied to property values as part of the value transform.
+    
+    This is always defined, even when `hasValueTransform` is `false`. If
+    the class property JSON itself did not define it, then it will be
+    initialized to the default value.
      */
     readonly scale: number | number[] | number[][];
     /**
@@ -36671,6 +36899,26 @@ export class MetadataSchema {
     readonly extensions: any;
 }
 
+/**
+ * An instance of a metadata value.<br>
+<br>
+This can be one of the following types:
+<ul>
+  <li><code>number</code> for type <code>SCALAR</code> and numeric component types except for <code>INT64</code> or <code>UINT64</code></li>
+  <li><code>bigint</code> for type <code>SCALAR</code> and component type <code>INT64</code> or <code>UINT64</code></li>
+  <li><code>string</code> for type <code>STRING</code> or <code>ENUM</code></li>
+  <li><code>boolean</code> for type <code>BOOLEAN</code></li>
+  <li><code>Cartesian2</code> for type <code>VEC2</code></li>
+  <li><code>Cartesian3</code> for type <code>VEC3</code></li>
+  <li><code>Cartesian4</code> for type <code>VEC4</code></li>
+  <li><code>Matrix2</code> for type <code>MAT2</code></li>
+  <li><code>Matrix3</code> for type <code>MAT3</code></li>
+  <li><code>Matrix4</code> for type <code>MAT4</code></li>
+  <li>Arrays of these types when the metadata value is an array</li>
+</ul>
+ */
+export type MetadataValue = number | bigint | string | boolean | Cartesian2 | Cartesian3 | Cartesian4 | Matrix2 | Matrix3 | Matrix4 | number[] | bigint[] | string[] | boolean[] | Cartesian2[] | Cartesian3[] | Cartesian4[] | Matrix2[] | Matrix3[] | Matrix4[];
+
 /**
  * An enum of metadata types. These metadata types are containers containing
 one or more components of type {@link MetadataComponentType}
@@ -38987,10 +39235,19 @@ export var className: string;
 export var propertyName: string;
 
 /**
- * The optional ID of the metadata schema
+ * The the `MetadataClassProperty` that is described by this
+structure, as obtained from the `MetadataSchema`
  */
 export var classProperty: MetadataClassProperty;
 
+/**
+ * The `PropertyTextureProperty` or `PropertyAttributeProperty` that
+is described by this structure, as obtained from the property texture
+or property attribute of the `StructuralMetadata` that matches the
+class name and property name.
+ */
+export var metadataProperty: any;
+
 /**
  * Compute the rectangle that describes the part of the drawing buffer
 that is relevant for picking.
@@ -39984,32 +40241,20 @@ export class PostProcessStageCollection {
     surface receives light and regardless of the light's position.
     </p>
     <p>
-    The uniforms have the following properties: <code>intensity</code>, <code>bias</code>, <code>lengthCap</code>,
-    <code>stepSize</code>, <code>frustumLength</code>, <code>ambientOcclusionOnly</code>,
-    <code>delta</code>, <code>sigma</code>, and <code>blurStepSize</code>.
-    </p>
+    The uniforms have the following properties:
     <ul>
     <li><code>intensity</code> is a scalar value used to lighten or darken the shadows exponentially. Higher values make the shadows darker. The default value is <code>3.0</code>.</li>
-    
     <li><code>bias</code> is a scalar value representing an angle in radians. If the dot product between the normal of the sample and the vector to the camera is less than this value,
     sampling stops in the current direction. This is used to remove shadows from near planar edges. The default value is <code>0.1</code>.</li>
-    
     <li><code>lengthCap</code> is a scalar value representing a length in meters. If the distance from the current sample to first sample is greater than this value,
     sampling stops in the current direction. The default value is <code>0.26</code>.</li>
-    
-    <li><code>stepSize</code> is a scalar value indicating the distance to the next texel sample in the current direction. The default value is <code>1.95</code>.</li>
-    
-    <li><code>frustumLength</code> is a scalar value in meters. If the current fragment has a distance from the camera greater than this value, ambient occlusion is not computed for the fragment.
-    The default value is <code>1000.0</code>.</li>
-    
+    <li><code>directionCount</code> is the number of directions along which the ray marching will search for occluders. The default value is <code>8</code>.</li>
+    <li><code>stepCount</code> is the number of steps the ray marching will take along each direction. The default value is <code>32</code>.</li>
+    <li><code>randomTexture</code> is a texture where the red channel is a random value in [0.0, 1.0]. The default value is <code>undefined</code>. This texture needs to be set.</li>
     <li><code>ambientOcclusionOnly</code> is a boolean value. When <code>true</code>, only the shadows generated are written to the output. When <code>false</code>, the input texture is modulated
     with the ambient occlusion. This is a useful debug option for seeing the effects of changing the uniform values. The default value is <code>false</code>.</li>
     </ul>
     <p>
-    <code>delta</code>, <code>sigma</code>, and <code>blurStepSize</code> are the same properties as {@link PostProcessStageLibrary#createBlurStage}.
-    The blur is applied to the shadows generated from the image to make them smoother.
-    </p>
-    <p>
     When enabled, this stage will execute before all others.
     </p>
      */
@@ -40406,88 +40651,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.
@@ -40523,67 +40768,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;
     /**
@@ -40616,60 +40861,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();
      */
@@ -40832,15 +41077,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.
@@ -40876,14 +41121,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;
     /**
@@ -40920,106 +41165,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;
     /**
@@ -41028,33 +41273,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;
     /**
@@ -41063,13 +41308,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;
     /**
@@ -41086,18 +41331,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;
     /**
@@ -41114,7 +41359,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;
     /**
@@ -41199,48 +41444,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;
     /**
@@ -41249,8 +41494,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;
     /**
@@ -41263,7 +41508,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;
     /**
@@ -41276,14 +41521,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;
     /**
@@ -41318,30 +41563,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.
@@ -41350,15 +41595,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.
@@ -41369,33 +41614,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
-     * @returns The metadata value
+     * values from
+     * @returns The metadata value, or `undefined` when
+     * no matching metadata was found at the given position
      */
-    pickMetadata(windowPosition: Cartesian2, schemaId: string | undefined, className: string, propertyName: string): any;
+    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.
@@ -41403,9 +41649,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.
@@ -41417,16 +41663,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.
@@ -41435,16 +41681,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.
@@ -41454,20 +41700,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.
@@ -41476,19 +41722,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.
@@ -41497,15 +41743,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.
@@ -41534,34 +41780,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();
      */
@@ -41570,11 +41816,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.
  */
@@ -41835,13 +42081,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();
@@ -43100,13 +43346,13 @@ const positron = new Cesium.UrlTemplateImageryProvider({
 });
 // Access a Web Map Service (WMS) server.
 const wms = new Cesium.UrlTemplateImageryProvider({
-   url : 'https://programs.communications.gov.au/geoserver/ows?tiled=true&' +
-         'transparent=true&format=image%2Fpng&exceptions=application%2Fvnd.ogc.se_xml&' +
-         'styles=&service=WMS&version=1.1.1&request=GetMap&' +
-         'layers=public%3AMyBroadband_Availability&srs=EPSG%3A3857&' +
+   url : 'https://services.ga.gov.au/gis/services/NM_Hydrology_and_Marine_Points/MapServer/WMSServer?' +
+         'tiled=true&transparent=true&format=image%2Fpng&exceptions=application%2Fvnd.ogc.se_xml&' +
+         'styles=&service=WMS&version=1.3.0&request=GetMap&' +
+         'layers=Bores&crs=EPSG%3A3857&' +
          'bbox={westProjected}%2C{southProjected}%2C{eastProjected}%2C{northProjected}&' +
          'width=256&height=256',
-   rectangle : Cesium.Rectangle.fromDegrees(96.799393, -43.598214999057824, 153.63925700000001, -9.2159219997013)
+   rectangle : Cesium.Rectangle.fromDegrees(95.0, -55.0, 170.0, -1.0)  // From GetCapabilities EX_GeographicBoundingBox
 });
 // Using custom tags in your template url.
 const custom = new Cesium.UrlTemplateImageryProvider({
@@ -43715,31 +43961,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.
@@ -43772,12 +44018,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 {
@@ -43820,35 +44066,35 @@ export class WebMapServiceImageryProvider {
     readonly rectangle: Rectangle;
     /**
      * Gets the tile discard policy.  If not undefined, the discard policy is responsible
-    for filtering out "missing" tiles via its shouldDiscardImage function.  If this function
-    returns undefined, no tiles are filtered.
+     * for filtering out "missing" tiles via its shouldDiscardImage function.  If this function
+     * returns undefined, no tiles are filtered.
      */
     readonly tileDiscardPolicy: TileDiscardPolicy;
     /**
      * Gets an event that is raised when the imagery provider encounters an asynchronous error.  By subscribing
-    to the event, you will be notified of the error and can potentially recover from it.  Event listeners
-    are passed an instance of {@link TileProviderError}.
+     * to the event, you will be notified of the error and can potentially recover from it.  Event listeners
+     * are passed an instance of {@link TileProviderError}.
      */
     readonly errorEvent: Event;
     /**
      * Gets the credit to display when this imagery provider is active.  Typically this is used to credit
-    the source of the imagery.
+     * the source of the imagery.
      */
     readonly credit: Credit;
     /**
      * Gets a value indicating whether or not the images provided by this imagery provider
-    include an alpha channel.  If this property is false, an alpha channel, if present, will
-    be ignored.  If this property is true, any images without an alpha channel will be treated
-    as if their alpha is 1.0 everywhere.  When this property is false, memory usage
-    and texture upload time are reduced.
+     * include an alpha channel.  If this property is false, an alpha channel, if present, will
+     * be ignored.  If this property is true, any images without an alpha channel will be treated
+     * as if their alpha is 1.0 everywhere.  When this property is false, memory usage
+     * and texture upload time are reduced.
      */
     readonly hasAlphaChannel: boolean;
     /**
      * Gets or sets a value indicating whether feature picking is enabled.  If true, {@link WebMapServiceImageryProvider#pickFeatures} will
-    invoke the <code>GetFeatureInfo</code> service on the WMS server and attempt to interpret the features included in the response.  If false,
-    {@link WebMapServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable
-    features) without communicating with the server.  Set this property to false if you know your data
-    source does not support picking features or if you don't want this provider's features to be pickable.
+     * invoke the <code>GetFeatureInfo</code> service on the WMS server and attempt to interpret the features included in the response.  If false,
+     * {@link WebMapServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable
+     * features) without communicating with the server.  Set this property to false if you know your data
+     * source does not support picking features or if you don't want this provider's features to be pickable.
      */
     enablePickFeatures: boolean;
     /**
@@ -43857,8 +44103,8 @@ export class WebMapServiceImageryProvider {
     clock: Clock;
     /**
      * Gets or sets a time interval collection that is used to get time dynamic parameters. The data of each
-    TimeInterval is an object containing the keys and values of the properties that are used during
-    tile requests.
+     * TimeInterval is an object containing the keys and values of the properties that are used during
+     * tile requests.
      */
     times: TimeIntervalCollection;
     /**
@@ -43880,36 +44126,36 @@ export class WebMapServiceImageryProvider {
      * @param level - The tile level.
      * @param [request] - The request object. Intended for internal use only.
      * @returns A promise for the image that will resolve when the image is available, or
-             undefined if there are too many active requests to the server, and the request should be retried later.
+     *          undefined if there are too many active requests to the server, and the request should be retried later.
      */
     requestImage(x: number, y: number, level: number, request?: Request): Promise<ImageryTypes> | undefined;
     /**
      * Asynchronously determines what features, if any, are located at a given longitude and latitude within
-    a tile.
+     * a tile.
      * @param x - The tile X coordinate.
      * @param y - The tile Y coordinate.
      * @param level - The tile level.
      * @param longitude - The longitude at which to pick features.
      * @param latitude - The latitude at which to pick features.
      * @returns A promise for the picked features that will resolve when the asynchronous
-                      picking completes.  The resolved value is an array of {@link ImageryLayerFeatureInfo}
-                      instances.  The array may be empty if no features are found at the given location.
+     *                   picking completes.  The resolved value is an array of {@link ImageryLayerFeatureInfo}
+     *                   instances.  The array may be empty if no features are found at the given location.
      */
     pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
     /**
      * The default parameters to include in the WMS URL to obtain images.  The values are as follows:
-       service=WMS
-       version=1.1.1
-       request=GetMap
-       styles=
-       format=image/jpeg
+     *    service=WMS
+     *    version=1.1.1
+     *    request=GetMap
+     *    styles=
+     *    format=image/jpeg
      */
     static readonly DefaultParameters: any;
     /**
      * The default parameters to include in the WMS URL to get feature information.  The values are as follows:
-        service=WMS
-        version=1.1.1
-        request=GetFeatureInfo
+     *     service=WMS
+     *     version=1.1.1
+     *     request=GetFeatureInfo
      */
     static readonly GetFeatureInfoDefaultParameters: any;
 }
@@ -44709,12 +44955,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[];
     /**
@@ -44755,7 +45001,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: {
@@ -44779,7 +45025,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;
     /**
@@ -46340,7 +46586,7 @@ export namespace Viewer {
      * @property [baseLayerPicker = true] - If set to false, the BaseLayerPicker widget will not be created.
      * @property [fullscreenButton = true] - If set to false, the FullscreenButton widget will not be created.
      * @property [vrButton = false] - If set to true, the VRButton widget will be created.
-     * @property [geocoder = true] - If set to false, the Geocoder widget will not be created.
+     * @property [geocoder = IonGeocodeProviderType.DEFAULT] - The geocoding service or services to use when searching with the Geocoder widget. If set to false, the Geocoder widget will not be created.
      * @property [homeButton = true] - If set to false, the HomeButton widget will not be created.
      * @property [infoBox = true] - If set to false, the InfoBox widget will not be created.
      * @property [sceneModePicker = true] - If set to false, the SceneModePicker widget will not be created.
@@ -46355,7 +46601,7 @@ export namespace Viewer {
      * @property [imageryProviderViewModels = createDefaultImageryProviderViewModels()] - The array of ProviderViewModels to be selectable from the BaseLayerPicker.  This value is only valid if `baseLayerPicker` is set to true.
      * @property [selectedTerrainProviderViewModel] - The view model for the current base terrain layer, if not supplied the first available base layer is used.  This value is only valid if `baseLayerPicker` is set to true.
      * @property [terrainProviderViewModels = createDefaultTerrainProviderViewModels()] - The array of ProviderViewModels to be selectable from the BaseLayerPicker.  This value is only valid if `baseLayerPicker` is set to true.
-     * @property [baseLayer = ImageryLayer.fromWorldImagery()] - The bottommost imagery layer applied to the globe. If set to <code>false</code>, no imagery provider will be added. This value is only valid if `baseLayerPicker` is set to false.
+     * @property [baseLayer = ImageryLayer.fromWorldImagery()] - The bottommost imagery layer applied to the globe. If set to <code>false</code>, no imagery provider will be added. This value is only valid if `baseLayerPicker` is set to false. Cannot be used when `globe` is set to false.
      * @property [ellipsoid = Ellipsoid.default] - The default ellipsoid.
      * @property [terrainProvider = new EllipsoidTerrainProvider()] - The terrain provider to use
      * @property [terrain] - A terrain object which handles asynchronous terrain provider. Can only specify if options.terrainProvider is undefined.
@@ -46391,7 +46637,7 @@ export namespace Viewer {
         baseLayerPicker?: boolean;
         fullscreenButton?: boolean;
         vrButton?: boolean;
-        geocoder?: boolean | GeocoderService[];
+        geocoder?: boolean | IonGeocodeProviderType | GeocoderService[];
         homeButton?: boolean;
         infoBox?: boolean;
         sceneModePicker?: boolean;