mars3d-cesium 1.125.2 → 1.126.0

package/Build/Cesium/Cesium.d.ts

@@ -1304,7 +1304,7 @@ export class BoundingSphere {
     static projectTo2D(sphere: BoundingSphere, projection?: any, result?: BoundingSphere): BoundingSphere;
     /**
      * Determines whether or not a sphere is hidden from view by the occluder.
-     * @param sphere - The bounding sphere surrounding the occludee object.
+     * @param sphere - The bounding sphere surrounding the occluded object.
      * @param occluder - The occluder.
      * @returns <code>true</code> if the sphere is not visible; otherwise <code>false</code>.
      */
@@ -3174,6 +3174,7 @@ export const Check: {
     };
   };
 };
+
 
 
 /**
@@ -3625,11 +3626,11 @@ export class Color {
     static clone(color: Color, result?: Color): Color;
     /**
      * Returns true if the first Color equals the second color.
-     * @param left - The first Color to compare for equality.
-     * @param right - The second Color to compare for equality.
+     * @param [left] - The first Color to compare for equality.
+     * @param [right] - The second Color to compare for equality.
      * @returns <code>true</code> if the Colors are equal; otherwise, <code>false</code>.
      */
-    static equals(left: Color, right: Color): boolean;
+    static equals(left?: Color, right?: Color): boolean;
     /**
      * Returns a duplicate of a Color instance.
      * @param [result] - The object to store the result in, if undefined a new instance will be created.
@@ -3638,10 +3639,10 @@ export class Color {
     clone(result?: Color): Color;
     /**
      * Returns true if this Color equals other.
-     * @param other - The Color to compare for equality.
+     * @param [other] - The Color to compare for equality.
      * @returns <code>true</code> if the Colors are equal; otherwise, <code>false</code>.
      */
-    equals(other: Color): boolean;
+    equals(other?: Color): boolean;
     /**
      * Returns <code>true</code> if this Color equals other componentwise within the specified epsilon.
      * @param other - The Color to compare for equality.
@@ -5134,17 +5135,17 @@ export class Credit {
     readonly element: HTMLElement;
     /**
      * Returns true if the credits are equal
-     * @param left - The first credit
-     * @param right - The second credit
+     * @param [left] - The first credit
+     * @param [right] - The second credit
      * @returns <code>true</code> if left and right are equal, <code>false</code> otherwise.
      */
-    static equals(left: Credit, right: Credit): boolean;
+    static equals(left?: Credit, right?: Credit): boolean;
     /**
      * Returns true if the credits are equal
-     * @param credit - The credit to compare to.
+     * @param [credit] - The credit to compare to.
      * @returns <code>true</code> if left and right are equal, <code>false</code> otherwise.
      */
-    equals(credit: Credit): boolean;
+    equals(credit?: Credit): boolean;
     /**
      * Duplicates a Credit instance.
      * @param [credit] - The Credit to duplicate.
@@ -5472,7 +5473,9 @@ export function defaultValue(a: any, b: any): any;
  * @param value - The object.
  * @returns Returns true if the object is defined, returns false otherwise.
  */
-export function defined<Type>(value: Type): value is NonNullable<Type>;
+
+export function defined<Type>(value: Type): value is NonNullable<Type>;
+
 
 /**
  * Destroys an object.  Each of the object's functions, including functions in its prototype,
@@ -5563,11 +5566,11 @@ export class DistanceDisplayCondition {
     static unpack(array: number[], startingIndex?: number, result?: DistanceDisplayCondition): DistanceDisplayCondition;
     /**
      * Determines if two distance display conditions are equal.
-     * @param left - A distance display condition.
-     * @param right - Another distance display condition.
+     * @param [left] - A distance display condition.
+     * @param [right] - Another distance display condition.
      * @returns Whether the two distance display conditions are equal.
      */
-    static equals(left: DistanceDisplayCondition, right: DistanceDisplayCondition): boolean;
+    static equals(left?: DistanceDisplayCondition, right?: DistanceDisplayCondition): boolean;
     /**
      * Duplicates a distance display condition instance.
      * @param [value] - The distance display condition to duplicate.
@@ -5583,10 +5586,10 @@ export class DistanceDisplayCondition {
     clone(result?: DistanceDisplayCondition): DistanceDisplayCondition;
     /**
      * Determines if this distance display condition is equal to another.
-     * @param other - Another distance display condition.
+     * @param [other] - Another distance display condition.
      * @returns Whether this distance display condition is equal to the other.
      */
-    equals(other: DistanceDisplayCondition): boolean;
+    equals(other?: DistanceDisplayCondition): boolean;
 }
 
 /**
@@ -6247,7 +6250,7 @@ export class EllipsoidGeodesic {
     interpolateUsingFraction(fraction: number, result?: Cartographic): Cartographic;
     /**
      * Provides the location of a point at the indicated distance along the geodesic.
-     * @param distance - The distance from the inital point to the point of interest along the geodesic
+     * @param distance - The distance from the initial point to the point of interest along the geodesic
      * @param [result] - The object in which to store the result.
      * @returns The location of the point along the geodesic.
      */
@@ -8010,6 +8013,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/>
@@ -8952,10 +8976,10 @@ export class Interval {
 
 /**
  * Default settings for accessing the Cesium ion API.
-
-An ion access token is only required if you are using any ion related APIs.
-A default access token is provided for evaluation purposes only.
-Sign up for a free ion account and get your own access token at {@link https://cesium.com}
+ *
+ * An ion access token is only required if you are using any ion related APIs.
+ * A default access token is provided for evaluation purposes only.
+ * Sign up for a free ion account and get your own access token at {@link https://cesium.com}
  */
 export namespace Ion {
     /**
@@ -8968,24 +8992,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 +9148,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. This is a partial list of types we know we can support
+     */
+    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
@@ -12284,11 +12364,11 @@ export class OrientedBoundingBox {
     /**
      * Compares the provided OrientedBoundingBox componentwise and returns
     <code>true</code> if they are equal, <code>false</code> otherwise.
-     * @param left - The first OrientedBoundingBox.
-     * @param right - The second OrientedBoundingBox.
+     * @param [left] - The first OrientedBoundingBox.
+     * @param [right] - The second OrientedBoundingBox.
      * @returns <code>true</code> if left and right are equal, <code>false</code> otherwise.
      */
-    static equals(left: OrientedBoundingBox, right: OrientedBoundingBox): boolean;
+    static equals(left?: OrientedBoundingBox, right?: OrientedBoundingBox): boolean;
     /**
      * Duplicates this OrientedBoundingBox instance.
      * @param [result] - The object onto which to store the result.
@@ -14661,11 +14741,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
@@ -16540,11 +16615,11 @@ export class Spherical {
     static normalize(spherical: Spherical, result?: Spherical): Spherical;
     /**
      * Returns true if the first spherical is equal to the second spherical, false otherwise.
-     * @param left - The first Spherical to be compared.
-     * @param right - The second Spherical to be compared.
+     * @param [left] - The first Spherical to be compared.
+     * @param [right] - The second Spherical to be compared.
      * @returns true if the first spherical is equal to the second spherical, false otherwise.
      */
-    static equals(left: Spherical, right: Spherical): boolean;
+    static equals(left?: Spherical, right?: Spherical): boolean;
     /**
      * Returns true if the first spherical is within the provided epsilon of the second spherical, false otherwise.
      * @param left - The first Spherical to be compared.
@@ -16555,10 +16630,10 @@ export class Spherical {
     static equalsEpsilon(left: Spherical, right: Spherical, epsilon?: number): boolean;
     /**
      * Returns true if this spherical is equal to the provided spherical, false otherwise.
-     * @param other - The Spherical to be compared.
+     * @param [other] - The Spherical to be compared.
      * @returns true if this spherical is equal to the provided spherical, false otherwise.
      */
-    equals(other: Spherical): boolean;
+    equals(other?: Spherical): boolean;
     /**
      * Creates a duplicate of this Spherical.
      * @param [result] - The object to store the result into, if undefined a new instance will be created.
@@ -17599,6 +17674,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.
  */
@@ -18661,7 +18764,6 @@ If text is blank, returns undefined.
  * @param text - The text to write.
  * @param [options] - Object with the following properties:
  * @param [options.font = '10px sans-serif'] - The CSS font to use.
- * @param [options.textBaseline = 'bottom'] - The baseline of the text.
  * @param [options.fill = true] - Whether to fill the text.
  * @param [options.stroke = false] - Whether to stroke the text.
  * @param [options.fillColor = Color.WHITE] - The fill color.
@@ -18675,7 +18777,6 @@ If text is blank, returns undefined.
  */
 export function writeTextToCanvas(text: string, options?: {
     font?: string;
-    textBaseline?: string;
     fill?: boolean;
     stroke?: boolean;
     fillColor?: Color;
@@ -18941,6 +19042,21 @@ export class BillboardVisualizer {
     destroy(): void;
 }
 
+/**
+ * The BoundingSphere has been computed.
+ */
+export const DONE = 0;
+
+/**
+ * The BoundingSphere is still being computed.
+ */
+export const PENDING = 1;
+
+/**
+ * The BoundingSphere does not exist.
+ */
+export const FAILED = 2;
+
 /**
  * A {@link GeometryUpdater} for boxes.
 Clients do not normally create this class directly, but instead rely on {@link DataSourceDisplay}.
@@ -20338,10 +20454,10 @@ export class DataSourceClock {
     clone(result?: DataSourceClock): DataSourceClock;
     /**
      * Returns true if this DataSourceClock is equivalent to the other
-     * @param other - The other DataSourceClock to compare to.
+     * @param [other] - The other DataSourceClock to compare to.
      * @returns <code>true</code> if the DataSourceClocks are equal; otherwise, <code>false</code>.
      */
-    equals(other: DataSourceClock): boolean;
+    equals(other?: DataSourceClock): boolean;
     /**
      * Assigns each unassigned property on this object to the value
     of the same property on the provided source object.
@@ -20905,6 +21021,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 +21051,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 +21118,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.
@@ -22711,6 +22833,7 @@ export namespace ModelGraphics {
      * @property [colorBlendMode = ColorBlendMode.HIGHLIGHT] - An enum Property specifying how the color blends with the model.
      * @property [colorBlendAmount = 0.5] - A numeric Property specifying the color strength when the <code>colorBlendMode</code> is <code>MIX</code>. A value of 0.0 results in the model's rendered color while a value of 1.0 results in a solid color, with any value in-between resulting in a mix of the two.
      * @property [imageBasedLightingFactor = new Cartesian2(1.0, 1.0)] - A property specifying the contribution from diffuse and specular image-based lighting.
+     * @property [environmentMapOptions] - The properties for managing dynamic environment maps on this entity.
      * @property [lightColor] - A property specifying the light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
      * @property [distanceDisplayCondition] - A Property specifying at what distance from the camera that this model will be displayed.
      * @property [nodeTransformations] - An object, where keys are names of nodes, and values are {@link TranslationRotationScale} Properties describing the transformation to apply to that node. The transformation is applied after the node's existing transformation as specified in the glTF, and does not replace the node's existing transformation.
@@ -22736,6 +22859,9 @@ export namespace ModelGraphics {
         colorBlendMode?: Property | ColorBlendMode;
         colorBlendAmount?: Property | number;
         imageBasedLightingFactor?: Property | Cartesian2;
+        environmentMapOptions?: PropertyBag | {
+            [key: string]: any;
+        };
         lightColor?: Property | Color;
         distanceDisplayCondition?: Property | DistanceDisplayCondition;
         nodeTransformations?: PropertyBag | {
@@ -22843,6 +22969,10 @@ export class ModelGraphics {
      * A property specifying the {@link Cartesian2} used to scale the diffuse and specular image-based lighting contribution to the final color.
      */
     imageBasedLightingFactor: Property | undefined;
+    /**
+     * Gets or sets the {@link DynamicEnvironmentMapManager.ConstructorOptions} to apply to this model. This is represented as an {@link PropertyBag}.
+     */
+    environmentMapOptions: PropertyBag;
     /**
      * A property specifying the {@link Cartesian3} light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
      */
@@ -24933,6 +25063,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.
@@ -25854,11 +25990,11 @@ export class ArcGisMapServerImageryProvider {
 
 /**
  * Default options for accessing the ArcGIS image tile service.
-
-An ArcGIS access token is required to access ArcGIS image tile layers.
-A default token is provided for evaluation purposes only.
-To obtain an access token, go to {@link https://developers.arcgis.com} and create a free account.
-More info can be found in the {@link https://developers.arcgis.com/documentation/mapping-apis-and-services/security/ | ArcGIS developer guide}.
+ *
+ * An ArcGIS access token is required to access ArcGIS image tile layers.
+ * A default token is provided for evaluation purposes only.
+ * To obtain an access token, go to {@link https://developers.arcgis.com} and create a free account.
+ * More info can be found in the {@link https://developers.arcgis.com/documentation/mapping-apis-and-services/security/ | ArcGIS developer guide}.
  */
 export namespace ArcGisMapService {
     /**
@@ -25953,6 +26089,12 @@ export class Atmosphere {
     be used for dynamically lighting all atmosphere-related rendering effects.
      */
     dynamicLighting: DynamicAtmosphereLightingType;
+    /**
+     * Returns <code>true</code> if the atmosphere shader requires a color correct step.
+     * @param atmosphere - The atmosphere instance to check
+     * @returns true if the atmosphere shader requires a color correct step
+     */
+    static requiresColorCorrect(atmosphere: Atmosphere): boolean;
 }
 
 /**
@@ -26349,10 +26491,10 @@ export class Billboard {
     /**
      * Determines if this billboard equals another billboard.  Billboards are equal if all their properties
     are equal.  Billboards in different collections can be equal.
-     * @param other - The billboard to compare for equality.
+     * @param [other] - The billboard to compare for equality.
      * @returns <code>true</code> if the billboards are equal; otherwise, <code>false</code>.
      */
-    equals(other: Billboard): boolean;
+    equals(other?: Billboard): boolean;
 }
 
 /**
@@ -27712,10 +27854,10 @@ export enum CameraEventType {
 
 /**
  * A tile in a {@link Cesium3DTileset}.  When a tile is first created, its content is not loaded;
-the content is loaded on-demand when needed based on the view.
-<p>
-Do not construct this directly, instead access tiles through {@link Cesium3DTileset#tileVisible}.
-</p>
+ * the content is loaded on-demand when needed based on the view.
+ * <p>
+ * Do not construct this directly, instead access tiles through {@link Cesium3DTileset#tileVisible}.
+ * </p>
  * @param tileset - The tileset
  * @param baseResource - The base resource for the tileset
  * @param header - The JSON header for the tile
@@ -27733,7 +27875,7 @@ export class Cesium3DTile {
     readonly computedTransform: Matrix4;
     /**
      * The error, in meters, introduced if this tile is rendered and its children are not.
-    This is used to compute screen space error, i.e., the error measured in pixels.
+     * This is used to compute screen space error, i.e., the error measured in pixels.
      */
     readonly geometricError: number;
     /**
@@ -27742,11 +27884,11 @@ export class Cesium3DTile {
     readonly children: Cesium3DTile[];
     /**
      * This tile's parent or <code>undefined</code> if this tile is the root.
-    <p>
-    When a tile's content points to an external tileset JSON file, the external tileset's
-    root tile's parent is not <code>undefined</code>; instead, the parent references
-    the tile (with its content pointing to an external tileset JSON file) as if the two tilesets were merged.
-    </p>
+     * <p>
+     * When a tile's content points to an external tileset JSON file, the external tileset's
+     * root tile's parent is not <code>undefined</code>; instead, the parent references
+     * the tile (with its content pointing to an external tileset JSON file) as if the two tilesets were merged.
+     * </p>
      */
     readonly parent: Cesium3DTile;
     /**
@@ -27763,7 +27905,7 @@ export class Cesium3DTile {
     readonly tileset: Cesium3DTileset;
     /**
      * The tile's content.  This represents the actual tile's payload,
-    not the content's metadata in the tileset JSON file.
+     * not the content's metadata in the tileset JSON file.
      */
     readonly content: Cesium3DTileContent;
     /**
@@ -27772,7 +27914,7 @@ export class Cesium3DTile {
     readonly boundingSphere: BoundingSphere;
     /**
      * Returns the <code>extras</code> property in the tileset JSON for this tile, which contains application specific metadata.
-    Returns <code>undefined</code> if <code>extras</code> does not exist.
+     * Returns <code>undefined</code> if <code>extras</code> does not exist.
      */
     readonly extras: any;
     /**
@@ -28333,6 +28475,7 @@ export namespace Cesium3DTileset {
      * @property [pointCloudShading] - Options for constructing a {@link PointCloudShading} object to control point attenuation based on geometric error and lighting.
      * @property [lightColor] - The light color when shading models. When <code>undefined</code> the scene's light color is used instead.
      * @property [imageBasedLighting] - The properties for managing image-based lighting for this tileset.
+     * @property [environmentMapOptions] - The properties for managing dynamic environment maps on this tileset.
      * @property [backFaceCulling = true] - Whether to cull back-facing geometry. When true, back face culling is determined by the glTF material's doubleSided property; when false, back face culling is disabled.
      * @property [enableShowOutline = true] - Whether to enable outlines for models using the {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline} extension. This can be set to false to avoid the additional processing of geometry at load time. When false, the showOutlines and outlineColor options are ignored.
      * @property [showOutline = true] - Whether to display the outline for models using the {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline} extension. When true, outlines are displayed. When false, outlines are not displayed.
@@ -28397,6 +28540,7 @@ export namespace Cesium3DTileset {
         pointCloudShading?: any;
         lightColor?: Cartesian3;
         imageBasedLighting?: ImageBasedLighting;
+        environmentMapOptions?: DynamicEnvironmentMapManager.ConstructorOptions;
         backFaceCulling?: boolean;
         enableShowOutline?: boolean;
         showOutline?: boolean;
@@ -29125,6 +29269,14 @@ export class Cesium3DTileset {
      * The properties for managing image-based lighting on this tileset.
      */
     imageBasedLighting: ImageBasedLighting;
+    /**
+     * The properties for managing dynamic environment maps on this model. Affects lighting.
+     * @example
+     * // Change the ground color used for a tileset's environment map to a forest green
+    const environmentMapManager = tileset.environmentMapManager;
+    environmentMapManager.groundColor = Cesium.Color.fromCssColorString("#203b34");
+     */
+    readonly environmentMapManager: DynamicEnvironmentMapManager;
     /**
      * Indicates that only the tileset's vector tiles should be used for classification.
      */
@@ -29964,12 +30116,12 @@ export class Cesium3DTileStyle {
 
 /**
  * A {@link VoxelProvider} that fetches voxel data from a 3D Tiles tileset.
-<p>
-Implements the {@link VoxelProvider} interface.
-</p>
-<div class="notice">
-This object is normally not instantiated directly, use {@link Cesium3DTilesVoxelProvider.fromUrl}.
-</div>
+ * <p>
+ * Implements the {@link VoxelProvider} interface.
+ * </p>
+ * <div class="notice">
+ * This object is normally not instantiated directly, use {@link Cesium3DTilesVoxelProvider.fromUrl}.
+ * </div>
  * @param options - Object with the following properties:
  */
 export class Cesium3DTilesVoxelProvider extends VoxelProvider {
@@ -29990,69 +30142,69 @@ export class Cesium3DTilesVoxelProvider extends VoxelProvider {
     readonly shapeTransform: Matrix4 | undefined;
     /**
      * Gets the {@link VoxelShapeType}
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly shape: VoxelShapeType;
     /**
      * Gets the minimum bounds.
-    If undefined, the shape's default minimum bounds will be used instead.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * If undefined, the shape's default minimum bounds will be used instead.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly minBounds: Cartesian3 | undefined;
     /**
      * Gets the maximum bounds.
-    If undefined, the shape's default maximum bounds will be used instead.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * If undefined, the shape's default maximum bounds will be used instead.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maxBounds: Cartesian3 | undefined;
     /**
      * Gets the number of voxels per dimension of a tile. This is the same for all tiles in the dataset.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly dimensions: Cartesian3;
     /**
      * Gets the number of padding voxels before the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly paddingBefore: Cartesian3 | undefined;
     /**
      * Gets the number of padding voxels after the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly paddingAfter: Cartesian3 | undefined;
     /**
      * Gets the metadata names.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly names: string[];
     /**
      * Gets the metadata types.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly types: MetadataType[];
     /**
      * Gets the metadata component types.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly componentTypes: MetadataComponentType[];
     /**
      * Gets the metadata minimum values.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly minimumValues: number[][] | undefined;
     /**
      * Gets the metadata maximum values.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maximumValues: number[][] | undefined;
     /**
      * The maximum number of tiles that exist for this provider. This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory. If this value is not known it can be undefined.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maximumTileCount: number | undefined;
     /**
      * Requests the data for a given tile. The data is a flattened 3D array ordered by X, then Y, then Z.
-    This function should not be called before {@link VoxelProvider#ready} returns true.
+     * This function should not be called before {@link VoxelProvider#ready} returns true.
      * @param [options] - Object with the following properties:
      * @param [options.tileLevel = 0] - The tile's level.
      * @param [options.tileX = 0] - The tile's X coordinate.
@@ -30510,7 +30662,7 @@ export class ClippingPolygon {
      * @param right - The second polygon.
      * @returns <code>true</code> if left and right are equal, <code>false</code> otherwise.
      */
-    static equals(left: Plane, right: Plane): boolean;
+    static equals(left: ClippingPolygon, right: ClippingPolygon): boolean;
     /**
      * Computes a cartographic rectangle which encloses the polygon defined by the list of positions, including cases over the international date line and the poles.
      * @param [result] - An object in which to store the result.
@@ -30979,32 +31131,50 @@ 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");
-
-try {
-  const tileset = await Cesium.createGooglePhotorealistic3DTileset();
-  viewer.scene.primitives.add(tileset));
-} catch (error) {
-  console.log(`Error creating tileset: ${error}`);
-}
+ * const viewer = new Cesium.Viewer("cesiumContainer", {
+ *   geocoder: Cesium.IonGeocodeProviderType.GOOGLE
+ * });
+ *
+ * try {
+ *   const tileset = await Cesium.createGooglePhotorealistic3DTileset({
+ *      onlyUsingWithGoogleGeocoder: true,
+ *   });
+ *   viewer.scene.primitives.add(tileset));
+ * } catch (error) {
+ *   console.log(`Error creating tileset: ${error}`);
+ * }
  * @example
  * // Use your own Google Maps API key
-Cesium.GoogleMaps.defaultApiKey = "your-api-key";
-
-const viewer = new Cesium.Viewer("cesiumContainer");
-
-try {
-  const tileset = await Cesium.createGooglePhotorealistic3DTileset();
-  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.
- */
-export function createGooglePhotorealistic3DTileset(key?: string, options?: Cesium3DTileset.ConstructorOptions): Promise<Cesium3DTileset>;
+ * Cesium.GoogleMaps.defaultApiKey = "your-api-key";
+ *
+ * const viewer = new Cesium.Viewer("cesiumContainer". {
+ *   geocoder: Cesium.IonGeocodeProviderType.GOOGLE
+ * });
+ *
+ * try {
+ *   const tileset = await Cesium.createGooglePhotorealistic3DTileset({
+ *      onlyUsingWithGoogleGeocoder: true,
+ *   });
+ *   viewer.scene.primitives.add(tileset));
+ * } catch (error) {
+ *   console.log(`Error creating tileset: ${error}`);
+ * }
+ * @param [apiOptions.key = GoogleMaps.defaultApiKey] - Your API key to access Google Photorealistic 3D Tiles. See {@link https://developers.google.com/maps/documentation/javascript/get-api-key} for instructions on how to create your own key.
+ * @param [apiOptions.onlyUsingWithGoogleGeocoder] - Confirmation that this tileset will only be used with the Google geocoder.
+ * @param [tilesetOptions] - An object describing initialization options.
+ */
+export function createGooglePhotorealistic3DTileset(apiOptions?: {
+    key?: string;
+    onlyUsingWithGoogleGeocoder?: true;
+}, tilesetOptions?: Cesium3DTileset.ConstructorOptions): Promise<Cesium3DTileset>;
 
 /**
  * Creates a {@link Cesium3DTileset} instance for the
@@ -31608,6 +31778,47 @@ for a property texture property with the given class 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:
@@ -31711,6 +31922,136 @@ export enum DynamicAtmosphereLightingType {
     SUNLIGHT = 2
 }
 
+export namespace DynamicEnvironmentMapManager {
+    /**
+     * Options for the DynamicEnvironmentMapManager constructor
+     * @property [enabled = true] - If true, the environment map and related properties will continue to update.
+     * @property [mipmapLevels = 7] - The number of mipmap levels to generate for specular maps. More mipmap levels will produce a higher resolution specular reflection.
+     * @property [maximumSecondsDifference = 3600] - The maximum amount of elapsed seconds before a new environment map is created.
+     * @property [maximumPositionEpsilon = 1000] - The maximum difference in position before a new environment map is created, in meters. Small differences in position will not visibly affect results.
+     * @property [atmosphereScatteringIntensity = 2.0] - The intensity of the scattered light emitted from the atmosphere. This should be adjusted relative to the value of {@link Scene.light} intensity.
+     * @property [gamma = 1.0] - The gamma correction to apply to the range of light emitted from the environment. 1.0 uses the unmodified emitted light color.
+     * @property [brightness = 1.0] - The brightness of light emitted from the environment. 1.0 uses the unmodified emitted environment color. Less than 1.0 makes the light darker while greater than 1.0 makes it brighter.
+     * @property [saturation = 1.0] - The saturation of the light emitted from the environment. 1.0 uses the unmodified emitted environment color. Less than 1.0 reduces the saturation while greater than 1.0 increases it.
+     * @property [groundColor = DynamicEnvironmentMapManager.AVERAGE_EARTH_GROUND_COLOR] - Solid color used to represent the ground.
+     * @property [groundAlbedo = 0.31] - The percentage of light reflected from the ground. The average earth albedo is 0.31.
+     */
+    type ConstructorOptions = {
+        enabled?: boolean;
+        mipmapLevels?: number;
+        maximumSecondsDifference?: number;
+        maximumPositionEpsilon?: number;
+        atmosphereScatteringIntensity?: number;
+        gamma?: number;
+        brightness?: number;
+        saturation?: number;
+        groundColor?: Color;
+        groundAlbedo?: number;
+    };
+}
+
+/**
+ * Generates an environment map at the given position based on scene's current lighting conditions. From this, it produces multiple levels of specular maps and spherical harmonic coefficients than can be used with {@link ImageBasedLighting} for models or tilesets.
+ * @example
+ * // Enable time-of-day environment mapping in a scene
+scene.atmosphere.dynamicLighting = Cesium.DynamicAtmosphereLightingType.SUNLIGHT;
+
+// Decrease the directional lighting contribution
+scene.light.intensity = 0.5
+
+// Increase the intensity of of the environment map lighting contribution
+const environmentMapManager = tileset.environmentMapManager;
+environmentMapManager.atmosphereScatteringIntensity = 3.0;
+ * @example
+ * // Change the ground color used for a model's environment map to a forest green
+const environmentMapManager = model.environmentMapManager;
+environmentMapManager.groundColor = Cesium.Color.fromCssColorString("#203b34");
+ * @param [options] - An object describing initialization options.
+ */
+export class DynamicEnvironmentMapManager {
+    constructor(options?: DynamicEnvironmentMapManager.ConstructorOptions);
+    /**
+     * If true, the environment map and related properties will continue to update.
+     */
+    enabled: boolean;
+    /**
+     * The maximum amount of elapsed seconds before a new environment map is created.
+     */
+    maximumSecondsDifference: number;
+    /**
+     * The maximum difference in position before a new environment map is created, in meters. Small differences in position will not visibly affect results.
+     */
+    maximumPositionEpsilon: number;
+    /**
+     * The intensity of the scattered light emitted from the atmosphere. This should be adjusted relative to the value of {@link Scene.light} intensity.
+     */
+    atmosphereScatteringIntensity: number;
+    /**
+     * The gamma correction to apply to the range of light emitted from the environment. 1.0 uses the unmodified incoming light color.
+     */
+    gamma: number;
+    /**
+     * The brightness of light emitted from the environment. 1.0 uses the unmodified emitted environment color. Less than 1.0
+    makes the light darker while greater than 1.0 makes it brighter.
+     */
+    brightness: number;
+    /**
+     * The saturation of the light emitted from the environment. 1.0 uses the unmodified emitted environment color. Less than 1.0 reduces the
+    saturation while greater than 1.0 increases it.
+     */
+    saturation: number;
+    /**
+     * Solid color used to represent the ground.
+     */
+    groundColor: Color;
+    /**
+     * The percentage of light reflected from the ground. The average earth albedo is 0.31.
+     */
+    groundAlbedo: number;
+    /**
+     * The position around which the environment map is generated.
+     */
+    position: Cartesian3 | 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.
+     * @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.
+     * @example
+     * 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 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[];
+}
+
 /**
  * An appearance for geometry on the surface of the ellipsoid like {@link PolygonGeometry}
 and {@link RectangleGeometry}, which supports all materials like {@link MaterialAppearance}
@@ -31894,11 +32235,18 @@ export class Fog {
     constructor();
     /**
      * <code>true</code> if fog is enabled, <code>false</code> otherwise.
+     * @example
+     * // Disable fog in the scene
+    viewer.scene.fog.enabled = false;
      */
     enabled: boolean;
     /**
      * <code>true</code> if fog is renderable in shaders, <code>false</code> otherwise.
     This allows to benefits from optimized tile loading strategy based on fog density without the actual visual rendering.
+     * @example
+     * // Use fog culling but don't render it
+    viewer.scene.fog.enabled = true;
+    viewer.scene.fog.renderable = false;
      */
     renderable: boolean;
     /**
@@ -31907,8 +32255,27 @@ export class Fog {
     The more dense the fog is, the more aggressively the terrain is culled. For example, if the camera is a height of
     1000.0m above the ellipsoid, increasing the value to 3.0e-3 will cause many tiles close to the viewer be culled.
     Decreasing the value will push the fog further from the viewer, but decrease performance as more of the terrain is rendered.
+     * @example
+     * // Double the default fog density
+    viewer.scene.fog.density = 0.0012;
      */
     density: number;
+    /**
+     * A scalar used in the function to adjust density based on the height of the camera above the terrain.
+     */
+    heightScalar: number;
+    /**
+     * The maximum height fog is applied. If the camera is above this height fog will be disabled.
+     */
+    maxHeight: number;
+    /**
+     * A scalar that impacts the visual density of fog. This value does not impact the culling of terrain.
+    Use in combination with the {@link Fog.density} to make fog appear more or less dense.
+     * @example
+     * // Increase fog appearance effect
+    viewer.scene.fog.visualDensityScalar = 0.6;
+     */
+    visualDensityScalar: number;
     /**
      * A factor used to increase the screen space error of terrain tiles when they are partially in fog. The effect is to reduce
     the number of terrain tiles requested for rendering. If set to zero, the feature will be disabled. If the value is increased
@@ -31921,6 +32288,11 @@ export class Fog {
     the brightness at all.
      */
     minimumBrightness: number;
+    /**
+     * Exponent factor used in the function to adjust how density changes based on the height of the camera above the ellipsoid. Smaller values produce a more gradual transition as camera height increases.
+    Value must be greater than 0.
+     */
+    heightFalloff: number;
 }
 
 /**
@@ -33847,7 +34219,6 @@ If a model or tileset creates an instance of ImageBasedLighting, it will handle
 Otherwise, the application is responsible for calling destroy().
 </p>
  * @param [options.imageBasedLightingFactor = Cartesian2(1.0, 1.0)] - Scales diffuse and specular image-based lighting from the earth, sky, atmosphere and star skybox.
- * @param [options.luminanceAtZenith = 0.2] - The sun's luminance at the zenith in kilo candela per meter squared to use for this model's procedural environment map.
  * @param [options.sphericalHarmonicCoefficients] - The third order spherical harmonic coefficients used for the diffuse color of image-based lighting.
  * @param [options.specularEnvironmentMaps] - A URL to a KTX2 file that contains a cube map of the specular lighting and the convoluted specular mipmaps.
  */
@@ -33860,13 +34231,6 @@ export class ImageBasedLighting {
     disable those light sources.
      */
     imageBasedLightingFactor: Cartesian2;
-    /**
-     * The sun's luminance at the zenith in kilo candela per meter squared
-    to use for this model's procedural environment map. This is used when
-    {@link ImageBasedLighting#specularEnvironmentMaps} and {@link ImageBasedLighting#sphericalHarmonicCoefficients}
-    are not defined.
-     */
-    luminanceAtZenith: number;
     /**
      * The third order spherical harmonic coefficients used for the diffuse color of image-based lighting. When <code>undefined</code>, a diffuse irradiance
     computed from the atmosphere color is used.
@@ -34196,10 +34560,10 @@ export class ImageryLayer {
       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
+     * @param [options] - An object describing initialization options
      * @returns The created imagery layer.
      */
-    static fromProviderAsync(imageryProviderPromise: Promise<ImageryProvider>, options: ImageryLayer.ConstructorOptions): ImageryLayer;
+    static fromProviderAsync(imageryProviderPromise: Promise<ImageryProvider>, options?: ImageryLayer.ConstructorOptions): 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
@@ -34746,6 +35110,59 @@ 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>;
+    /**
+     * Create a data source of the correct type for the specified reality data id.
+     * This function only works for KML and GeoJSON type data.
+     *
+     * If the <code>type</code> or <code>rootDocument</code> are not provided this function
+     * will first request the full metadata for the specified reality data to fill these values.
+     * @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 createDataSourceForRealityDataId(iTwinId: string, realityDataId: string, type?: ITwinPlatform.RealityDataType, rootDocument?: string): Promise<GeoJsonDataSource | KmlDataSource>;
+    /**
+     * Load data from the Geospatial Features API as GeoJSON.
+     * @param iTwinId - The id of the iTwin to load data from
+     * @param collectionId - The id of the data collection to load
+     * @param [limit = 10000] - number of items per page, must be between 1 and 10,000 inclusive
+     */
+    function loadGeospatialFeatures(iTwinId: string, collectionId: string, limit?: number): Promise<GeoJsonDataSource>;
+}
+
 export namespace Label {
     /**
      * Initialization options for the Label constructor
@@ -35027,10 +35444,10 @@ export class Label {
     /**
      * Determines if this label equals another label.  Labels are equal if all their properties
     are equal.  Labels in different collections can be equal.
-     * @param other - The label to compare for equality.
+     * @param [other] - The label to compare for equality.
      * @returns <code>true</code> if the labels are equal; otherwise, <code>false</code>.
      */
-    equals(other: Label): boolean;
+    equals(other?: Label): boolean;
     /**
      * Returns true if this object was destroyed; otherwise, false.
     <br /><br />
@@ -36292,10 +36709,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[][];
     /**
@@ -36518,6 +36943,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}
@@ -37285,7 +37730,7 @@ export class Model {
      */
     enableVerticalExaggeration: boolean;
     /**
-     * The light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
+     * The directional light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
     <p>
     Disabling additional light sources by setting
     <code>model.imageBasedLighting.imageBasedLightingFactor = new Cartesian2(0.0, 0.0)</code>
@@ -37297,6 +37742,14 @@ export class Model {
      * The properties for managing image-based lighting on this model.
      */
     imageBasedLighting: ImageBasedLighting;
+    /**
+     * The properties for managing dynamic environment maps on this model. Affects lighting.
+     * @example
+     * // Change the ground color used for a model's environment map to a forest green
+    const environmentMapManager = model.environmentMapManager;
+    environmentMapManager.groundColor = Cesium.Color.fromCssColorString("#203b34");
+     */
+    readonly environmentMapManager: DynamicEnvironmentMapManager;
     /**
      * Whether to cull back-facing geometry. When true, back face culling is
     determined by the material's doubleSided property; when false, back face
@@ -37392,7 +37845,7 @@ export class Model {
     
     The given name may be the name of a glTF extension, like `"EXT_example_extension"`.
     If the specified extension was present in the root of the underlying glTF asset,
-    and a loder for the specified extension has processed the extension data, then
+    and a loader for the specified extension has processed the extension data, then
     this will return the model representation of the extension.
      * @param extensionName - The name of the extension
      * @returns The object, or `undefined`
@@ -37536,6 +37989,7 @@ export class Model {
      * @param [options.clippingPolygons] - The {@link ClippingPolygonCollection} used to selectively disable rendering the model.
      * @param [options.lightColor] - The light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
      * @param [options.imageBasedLighting] - The properties for managing image-based lighting on this model.
+     * @param [options.environmentMapOptions] - The properties for managing dynamic environment maps on this model.
      * @param [options.backFaceCulling = true] - Whether to cull back-facing geometry. When true, back face culling is determined by the material's doubleSided property; when false, back face culling is disabled. Back faces are not culled if the model's color is translucent.
      * @param [options.credit] - A credit for the data source, which is displayed on the canvas.
      * @param [options.showCreditsOnScreen = false] - Whether to display the credits of this model on screen.
@@ -37589,6 +38043,7 @@ export class Model {
         clippingPolygons?: ClippingPolygonCollection;
         lightColor?: Cartesian3;
         imageBasedLighting?: ImageBasedLighting;
+        environmentMapOptions?: DynamicEnvironmentMapManager.ConstructorOptions;
         backFaceCulling?: boolean;
         credit?: Credit | string;
         showCreditsOnScreen?: boolean;
@@ -38824,10 +39279,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.
@@ -39045,10 +39509,10 @@ export class PointPrimitive {
     /**
      * Determines if this point equals another point.  Points are equal if all their properties
     are equal.  Points in different collections can be equal.
-     * @param other - The point to compare for equality.
+     * @param [other] - The point to compare for equality.
      * @returns <code>true</code> if the points are equal; otherwise, <code>false</code>.
      */
-    equals(other: PointPrimitive): boolean;
+    equals(other?: PointPrimitive): boolean;
 }
 
 /**
@@ -39821,32 +40285,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>
      */
@@ -41212,9 +41664,10 @@ export class Scene {
     values from
      * @param propertyName - The name of the metadata property to pick
     values from
-     * @returns The metadata value
+     * @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.
@@ -41446,14 +41899,14 @@ export enum SceneMode {
 export namespace SceneTransforms {
     /**
      * Transforms a position in world (WGS84 or alternative ellipsoid) coordinates to window coordinates.  This is commonly used to place an
-    HTML element at the same screen position as an object in the scene.
+     * HTML element at the same screen position as an object in the scene.
      * @example
      * // Output the window position of longitude/latitude (0, 0) every time the mouse moves.
-    const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
-    const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
-    handler.setInputAction(function(movement) {
-        console.log(Cesium.SceneTransforms.worldToWindowCoordinates(scene, position));
-    }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+     * const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
+     * const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
+     * handler.setInputAction(function(movement) {
+     *     console.log(Cesium.SceneTransforms.worldToWindowCoordinates(scene, position));
+     * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
      * @param scene - The scene.
      * @param position - The position in world (WGS84 or alternative ellipsoid) coordinates.
      * @param [result] - An optional object to return the input position transformed to window coordinates.
@@ -41462,14 +41915,14 @@ export namespace SceneTransforms {
     function worldToWindowCoordinates(scene: Scene, position: Cartesian3, result?: Cartesian2): Cartesian2 | undefined;
     /**
      * Transforms a position in world coordinates to drawing buffer coordinates.  This may produce different
-    results from SceneTransforms.worldToWindowCoordinates when the browser zoom is not 100%, or on high-DPI displays.
+     * results from SceneTransforms.worldToWindowCoordinates when the browser zoom is not 100%, or on high-DPI displays.
      * @example
      * // Output the window position of longitude/latitude (0, 0) every time the mouse moves.
-    const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
-    const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
-    handler.setInputAction(function(movement) {
-        console.log(Cesium.SceneTransforms.worldToDrawingBufferCoordinates(scene, position));
-    }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+     * const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
+     * const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
+     * handler.setInputAction(function(movement) {
+     *     console.log(Cesium.SceneTransforms.worldToDrawingBufferCoordinates(scene, position));
+     * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
      * @param scene - The scene.
      * @param position - The position in world (WGS84 or alternative ellipsoid) coordinates.
      * @param [result] - An optional object to return the input position transformed to window coordinates.
@@ -42937,13 +43390,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({
@@ -43287,6 +43740,95 @@ export class VoxelPrimitive {
         customShader?: CustomShader;
         clock?: Clock;
     });
+    /**
+     * The number of levels of detail containing available tiles in the tileset.
+     */
+    readonly availableLevels: number | undefined;
+    /**
+     * The event fired to indicate that a tile's content was loaded.
+     * <p>
+     * This event is fired during the tileset traversal while the frame is being rendered
+     * so that updates to the tile take effect in the same frame.  Do not create or modify
+     * Cesium entities or primitives during the event listener.
+     * </p>
+     * @example
+     * voxelPrimitive.tileLoad.addEventListener(function() {
+     *     console.log('A tile was loaded.');
+     * });
+     */
+    tileLoad: Event;
+    /**
+     * This event fires once for each visible tile in a frame.
+     * <p>
+     * This event is fired during the traversal while the frame is being rendered.
+     * @example
+     * voxelPrimitive.tileVisible.addEventListener(function() {
+     *     console.log('A tile is visible.');
+     * });
+     */
+    tileVisible: Event;
+    /**
+     * The event fired to indicate that a tile's content failed to load.
+     * @example
+     * voxelPrimitive.tileFailed.addEventListener(function() {
+     *     console.log('An error occurred loading tile.');
+     * });
+     */
+    tileFailed: Event;
+    /**
+     * The event fired to indicate that a tile's content was unloaded.
+     * @example
+     * voxelPrimitive.tileUnload.addEventListener(function() {
+     *     console.log('A tile was unloaded from the cache.');
+     * });
+     */
+    tileUnload: Event;
+    /**
+     * The event fired to indicate progress of loading new tiles. This event is fired when a new tile
+     * is requested, when a requested tile is finished downloading, and when a downloaded tile has been
+     * processed and is ready to render.
+     * <p>
+     * The number of pending tile requests, <code>numberOfPendingRequests</code>, and number of tiles
+     * processing, <code>numberOfTilesProcessing</code> are passed to the event listener.
+     * </p>
+     * <p>
+     * This event is fired at the end of the frame after the scene is rendered.
+     * </p>
+     * @example
+     * voxelPrimitive.loadProgress.addEventListener(function(numberOfPendingRequests, numberOfTilesProcessing) {
+     *     if ((numberOfPendingRequests === 0) && (numberOfTilesProcessing === 0)) {
+     *         console.log('Finished loading');
+     *         return;
+     *     }
+     *
+     *     console.log(`Loading: requests: ${numberOfPendingRequests}, processing: ${numberOfTilesProcessing}`);
+     * });
+     */
+    loadProgress: Event;
+    /**
+     * The event fired to indicate that all tiles that meet the screen space error this frame are loaded. The voxel
+     * primitive is completely loaded for this view.
+     * <p>
+     * This event is fired at the end of the frame after the scene is rendered.
+     * </p>
+     * @example
+     * voxelPrimitive.allTilesLoaded.addEventListener(function() {
+     *     console.log('All tiles are loaded');
+     * });
+     */
+    allTilesLoaded: Event;
+    /**
+     * The event fired to indicate that all tiles that meet the screen space error this frame are loaded. This event
+     * is fired once when all tiles in the initial view are loaded.
+     * <p>
+     * This event is fired at the end of the frame after the scene is rendered.
+     * </p>
+     * @example
+     * voxelPrimitive.initialTilesLoaded.addEventListener(function() {
+     *     console.log('Initial tiles are loaded');
+     * });
+     */
+    initialTilesLoaded: Event;
     /**
      * Gets a value indicating whether or not the primitive is ready for use.
      */
@@ -43345,35 +43887,35 @@ export class VoxelPrimitive {
     nearestSampling: boolean;
     /**
      * Gets or sets the screen space error in pixels. If the screen space size
-    of a voxel is greater than the screen space error, the tile is subdivided.
-    Lower screen space error corresponds with higher detail rendering, but could
-    result in worse performance and higher memory consumption.
+     * of a voxel is greater than the screen space error, the tile is subdivided.
+     * Lower screen space error corresponds with higher detail rendering, but could
+     * result in worse performance and higher memory consumption.
      */
     screenSpaceError: number;
     /**
      * Gets or sets the step size multiplier used during raymarching.
-    The lower the value, the higher the rendering quality, but
-    also the worse the performance.
+     * The lower the value, the higher the rendering quality, but
+     * also the worse the performance.
      */
     stepSize: number;
     /**
      * Gets or sets the minimum bounds in the shape's local coordinate system.
-    Voxel data is stretched or squashed to fit the bounds.
+     * Voxel data is stretched or squashed to fit the bounds.
      */
     minBounds: Cartesian3;
     /**
      * Gets or sets the maximum bounds in the shape's local coordinate system.
-    Voxel data is stretched or squashed to fit the bounds.
+     * Voxel data is stretched or squashed to fit the bounds.
      */
     maxBounds: Cartesian3;
     /**
      * Gets or sets the minimum clipping location in the shape's local coordinate system.
-    Any voxel content outside the range is clipped.
+     * Any voxel content outside the range is clipped.
      */
     minClippingBounds: Cartesian3;
     /**
      * Gets or sets the maximum clipping location in the shape's local coordinate system.
-    Any voxel content outside the range is clipped.
+     * Any voxel content outside the range is clipped.
      */
     maxClippingBounds: Cartesian3;
     /**
@@ -43390,19 +43932,19 @@ export class VoxelPrimitive {
     readonly customShaderCompilationEvent: Event;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-    <br /><br />
-    If this object was destroyed, it should not be used; calling any function other than
-    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+     * <br /><br />
+     * If this object was destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
      * @returns <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
      */
     isDestroyed(): boolean;
     /**
      * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
-    release of WebGL resources, instead of relying on the garbage collector to destroy this object.
-    <br /><br />
-    Once an object is destroyed, it should not be used; calling any function other than
-    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-    assign the return value (<code>undefined</code>) to the object as done in the example.
+     * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+     * <br /><br />
+     * Once an object is destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+     * assign the return value (<code>undefined</code>) to the object as done in the example.
      * @example
      * voxelPrimitive = voxelPrimitive && voxelPrimitive.destroy();
      */
@@ -43411,7 +43953,7 @@ export class VoxelPrimitive {
 
 /**
  * Provides voxel data. Intended to be used with {@link VoxelPrimitive}.
-This type describes an interface and is not intended to be instantiated directly.
+ * This type describes an interface and is not intended to be instantiated directly.
  */
 export class VoxelProvider {
     constructor();
@@ -43425,69 +43967,69 @@ export class VoxelProvider {
     readonly shapeTransform: Matrix4 | undefined;
     /**
      * Gets the {@link VoxelShapeType}
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly shape: VoxelShapeType;
     /**
      * Gets the minimum bounds.
-    If undefined, the shape's default minimum bounds will be used instead.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * If undefined, the shape's default minimum bounds will be used instead.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly minBounds: Cartesian3 | undefined;
     /**
      * Gets the maximum bounds.
-    If undefined, the shape's default maximum bounds will be used instead.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * If undefined, the shape's default maximum bounds will be used instead.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maxBounds: Cartesian3 | undefined;
     /**
      * Gets the number of voxels per dimension of a tile. This is the same for all tiles in the dataset.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly dimensions: Cartesian3;
     /**
      * Gets the number of padding voxels before the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly paddingBefore: Cartesian3 | undefined;
     /**
      * Gets the number of padding voxels after the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly paddingAfter: Cartesian3 | undefined;
     /**
      * Gets the metadata names.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly names: string[];
     /**
      * Gets the metadata types.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly types: MetadataType[];
     /**
      * Gets the metadata component types.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly componentTypes: MetadataComponentType[];
     /**
      * Gets the metadata minimum values.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly minimumValues: number[][] | undefined;
     /**
      * Gets the metadata maximum values.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maximumValues: number[][] | undefined;
     /**
      * The maximum number of tiles that exist for this provider. This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory. If this value is not known it can be undefined.
-    This should not be called before {@link VoxelProvider#ready} returns true.
+     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maximumTileCount: number | undefined;
     /**
      * Requests the data for a given tile. The data is a flattened 3D array ordered by X, then Y, then Z.
-    This function should not be called before {@link VoxelProvider#ready} returns true.
+     * This function should not be called before {@link VoxelProvider#ready} returns true.
      * @param [options] - Object with the following properties:
      * @param [options.tileLevel = 0] - The tile's level.
      * @param [options.tileX = 0] - The tile's X coordinate.
@@ -43503,6 +44045,11 @@ export class VoxelProvider {
     }): Promise<any[][]> | undefined;
 }
 
+/**
+ * The number of levels of detail containing available tiles in the tileset.
+ */
+export const availableLevels: number | undefined;
+
 export const shaderUniforms: {
     [key: string]: any;
 };
@@ -43772,8 +44319,8 @@ export namespace WebMapTileServiceImageryProvider {
      * @property [ellipsoid] - The ellipsoid.  If not specified, the WGS84 ellipsoid is used.
      * @property [credit] - A credit for the data source, which is displayed on the canvas.
      * @property [subdomains = 'abc'] - The subdomains to use for the <code>{s}</code> placeholder in the URL template.
-                             If this parameter is a single string, each character in the string is a subdomain.  If it is
-                             an array, each element in the array is a subdomain.
+     *                          If this parameter is a single string, each character in the string is a subdomain.  If it is
+     *                          an array, each element in the array is a subdomain.
      */
     type ConstructorOptions = {
         url: Resource | string;
@@ -43799,54 +44346,54 @@ export namespace WebMapTileServiceImageryProvider {
 
 /**
  * Provides tiled imagery served by {@link http://www.opengeospatial.org/standards/wmts|WMTS 1.0.0} compliant servers.
-This provider supports HTTP KVP-encoded and RESTful GetTile requests, but does not yet support the SOAP encoding.
+ * This provider supports HTTP KVP-encoded and RESTful GetTile requests, but does not yet support the SOAP encoding.
  * @example
  * // Example 1. USGS shaded relief tiles (KVP)
-const shadedRelief1 = new Cesium.WebMapTileServiceImageryProvider({
-    url : 'http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS',
-    layer : 'USGSShadedReliefOnly',
-    style : 'default',
-    format : 'image/jpeg',
-    tileMatrixSetID : 'default028mm',
-    // tileMatrixLabels : ['default028mm:0', 'default028mm:1', 'default028mm:2' ...],
-    maximumLevel: 19,
-    credit : new Cesium.Credit('U. S. Geological Survey')
-});
-viewer.imageryLayers.addImageryProvider(shadedRelief1);
+ * const shadedRelief1 = new Cesium.WebMapTileServiceImageryProvider({
+ *     url : 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS',
+ *     layer : 'USGSShadedReliefOnly',
+ *     style : 'default',
+ *     format : 'image/jpeg',
+ *     tileMatrixSetID : 'default028mm',
+ *     // tileMatrixLabels : ['default028mm:0', 'default028mm:1', 'default028mm:2' ...],
+ *     maximumLevel: 19,
+ *     credit : new Cesium.Credit('U. S. Geological Survey')
+ * });
+ * viewer.imageryLayers.addImageryProvider(shadedRelief1);
  * @example
  * // Example 2. USGS shaded relief tiles (RESTful)
-const shadedRelief2 = new Cesium.WebMapTileServiceImageryProvider({
-    url : 'http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS/tile/1.0.0/USGSShadedReliefOnly/{Style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.jpg',
-    layer : 'USGSShadedReliefOnly',
-    style : 'default',
-    format : 'image/jpeg',
-    tileMatrixSetID : 'default028mm',
-    maximumLevel: 19,
-    credit : new Cesium.Credit('U. S. Geological Survey')
-});
-viewer.imageryLayers.addImageryProvider(shadedRelief2);
+ * const shadedRelief2 = new Cesium.WebMapTileServiceImageryProvider({
+ *     url : 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS/tile/1.0.0/USGSShadedReliefOnly/{Style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.jpg',
+ *     layer : 'USGSShadedReliefOnly',
+ *     style : 'default',
+ *     format : 'image/jpeg',
+ *     tileMatrixSetID : 'default028mm',
+ *     maximumLevel: 19,
+ *     credit : new Cesium.Credit('U. S. Geological Survey')
+ * });
+ * viewer.imageryLayers.addImageryProvider(shadedRelief2);
  * @example
  * // Example 3. NASA time dynamic weather data (RESTful)
-const times = Cesium.TimeIntervalCollection.fromIso8601({
-    iso8601: '2015-07-30/2017-06-16/P1D',
-    dataCallback: function dataCallback(interval, index) {
-        return {
-            Time: Cesium.JulianDate.toIso8601(interval.start)
-        };
-    }
-});
-const weather = new Cesium.WebMapTileServiceImageryProvider({
-    url : 'https://gibs.earthdata.nasa.gov/wmts/epsg4326/best/AMSR2_Snow_Water_Equivalent/default/{Time}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.png',
-    layer : 'AMSR2_Snow_Water_Equivalent',
-    style : 'default',
-    tileMatrixSetID : '2km',
-    maximumLevel : 5,
-    format : 'image/png',
-    clock: clock,
-    times: times,
-    credit : new Cesium.Credit('NASA Global Imagery Browse Services for EOSDIS')
-});
-viewer.imageryLayers.addImageryProvider(weather);
+ * const times = Cesium.TimeIntervalCollection.fromIso8601({
+ *     iso8601: '2015-07-30/2017-06-16/P1D',
+ *     dataCallback: function dataCallback(interval, index) {
+ *         return {
+ *             Time: Cesium.JulianDate.toIso8601(interval.start)
+ *         };
+ *     }
+ * });
+ * const weather = new Cesium.WebMapTileServiceImageryProvider({
+ *     url : 'https://gibs.earthdata.nasa.gov/wmts/epsg4326/best/AMSR2_Snow_Water_Equivalent/default/{Time}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.png',
+ *     layer : 'AMSR2_Snow_Water_Equivalent',
+ *     style : 'default',
+ *     tileMatrixSetID : '2km',
+ *     maximumLevel : 5,
+ *     format : 'image/png',
+ *     clock: clock,
+ *     times: times,
+ *     credit : new Cesium.Credit('NASA Global Imagery Browse Services for EOSDIS')
+ * });
+ * viewer.imageryLayers.addImageryProvider(weather);
  * @param options - Object describing initialization options
  */
 export class WebMapTileServiceImageryProvider {
@@ -43885,14 +44432,14 @@ export class WebMapTileServiceImageryProvider {
     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;
     /**
@@ -43901,15 +44448,15 @@ export class WebMapTileServiceImageryProvider {
     readonly format: string;
     /**
      * Gets the credit to display when this imagery provider is active.  Typically this is used to credit
-    the source of the imagery.
+     * 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;
     /**
@@ -43918,8 +44465,8 @@ export class WebMapTileServiceImageryProvider {
     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;
     /**
@@ -43941,12 +44488,12 @@ export class WebMapTileServiceImageryProvider {
      * @param level - The tile level.
      * @param [request] - The request object. Intended for internal use only.
      * @returns A promise for the image that will resolve when the image is available, or
-             undefined if there are too many active requests to the server, and the request should be retried later.
+     *          undefined if there are too many active requests to the server, and the request should be retried later.
      */
     requestImage(x: number, y: number, level: number, request?: Request): Promise<ImageryTypes> | undefined;
     /**
      * Picking features is not currently supported by this imagery provider, so this function simply returns
-    undefined.
+     * undefined.
      * @param x - The tile X coordinate.
      * @param y - The tile Y coordinate.
      * @param level - The tile level.
@@ -43987,6 +44534,7 @@ const widget2 = new Cesium.CesiumWidget("cesiumContainer", {
  * @param container - The DOM element or ID that will contain the widget.
  * @param [options] - Object with the following properties:
  * @param [options.clock = new Clock()] - The clock to use to control current time.
+ * @param [options.shouldAnimate = false] - <code>true</code> if the clock should attempt to advance simulation time by default, <code>false</code> otherwise.
  * @param [options.ellipsoid = Ellipsoid.default] - The default ellipsoid.
  * @param [options.baseLayer = ImageryLayer.fromWorldImagery()] - The bottommost imagery layer applied to the globe. If set to <code>false</code>, no imagery provider will be added.
  * @param [options.terrainProvider = new EllipsoidTerrainProvider(options.ellipsoid)] - The terrain provider.
@@ -44002,14 +44550,17 @@ const widget2 = new Cesium.CesiumWidget("cesiumContainer", {
  * @param [options.useBrowserRecommendedResolution = true] - If true, render at the browser's recommended resolution and ignore <code>window.devicePixelRatio</code>.
  * @param [options.targetFrameRate] - The target frame rate when using the default render loop.
  * @param [options.showRenderLoopErrors = true] - If true, this widget will automatically display an HTML panel to the user containing the error, if a render loop error occurs.
+ * @param [options.automaticallyTrackDataSourceClocks = true] - If true, this widget will automatically track the clock settings of newly added DataSources, updating if the DataSource's clock changes.  Set this to false if you want to configure the clock independently.
  * @param [options.contextOptions] - Context and WebGL creation properties passed to {@link Scene}.
  * @param [options.creditContainer] - The DOM element or ID that will contain the {@link CreditDisplay}.  If not specified, the credits are added
        to the bottom of the widget itself.
  * @param [options.creditViewport] - The DOM element or ID that will contain the credit pop up created by the {@link CreditDisplay}.  If not specified, it will appear over the widget itself.
+ * @param [options.dataSources = new DataSourceCollection()] - The collection of data sources visualized by the widget.  If this parameter is provided,
+                              the instance is assumed to be owned by the caller and will not be destroyed when the widget is destroyed.
  * @param [options.shadows = false] - Determines if shadows are cast by light sources.
  * @param [options.terrainShadows = ShadowMode.RECEIVE_ONLY] - Determines if the terrain casts or receives shadows from light sources.
  * @param [options.mapMode2D = MapMode2D.INFINITE_SCROLL] - Determines if the 2D map is rotatable or can be scrolled infinitely in the horizontal direction.
- * @param [options.blurActiveElementOnCanvasFocus = true] - If true, the active element will blur when the viewer's canvas is clicked. Setting this to false is useful for cases when the canvas is clicked only for retrieving position or an entity data without actually meaning to set the canvas to be the active element.
+ * @param [options.blurActiveElementOnCanvasFocus = true] - If true, the active element will blur when the widget's canvas is clicked. Setting this to false is useful for cases when the canvas is clicked only for retrieving position or an entity data without actually meaning to set the canvas to be the active element.
  * @param [options.requestRenderMode = false] - If true, 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. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
  * @param [options.maximumRenderTimeChange = 0.0] - If requestRenderMode is true, this value defines the maximum change in simulation time allowed before a render is requested. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
  * @param [options.msaaSamples = 4] - If provided, this value controls the rate of multisample antialiasing. Typical multisampling rates are 2, 4, and sometimes 8 samples per pixel. Higher sampling rates of MSAA may impact performance in exchange for improved visual quality. This value only applies to WebGL2 contexts that support multisample render targets. Set to 1 to disable MSAA.
@@ -44017,6 +44568,7 @@ const widget2 = new Cesium.CesiumWidget("cesiumContainer", {
 export class CesiumWidget {
     constructor(container: Element | string, options?: {
         clock?: Clock;
+        shouldAnimate?: boolean;
         ellipsoid?: Ellipsoid;
         baseLayer?: ImageryLayer | false;
         terrainProvider?: TerrainProvider;
@@ -44032,9 +44584,11 @@ export class CesiumWidget {
         useBrowserRecommendedResolution?: boolean;
         targetFrameRate?: number;
         showRenderLoopErrors?: boolean;
+        automaticallyTrackDataSourceClocks?: boolean;
         contextOptions?: ContextOptions;
         creditContainer?: Element | string;
         creditViewport?: Element | string;
+        dataSources?: DataSourceCollection;
         shadows?: boolean;
         terrainShadows?: ShadowMode;
         mapMode2D?: MapMode2D;
@@ -44075,6 +44629,19 @@ export class CesiumWidget {
      * Manages the list of credits to display on screen and in the lightbox.
      */
     creditDisplay: CreditDisplay;
+    /**
+     * Gets the display used for {@link DataSource} visualization.
+     */
+    readonly dataSourceDisplay: DataSourceDisplay;
+    /**
+     * Gets the collection of entities not tied to a particular data source.
+    This is a shortcut to [dataSourceDisplay.defaultDataSource.entities]{@link CesiumWidget#dataSourceDisplay}.
+     */
+    readonly entities: EntityCollection;
+    /**
+     * Gets the set of {@link DataSource} instances to be visualized.
+     */
+    readonly dataSources: DataSourceCollection;
     /**
      * Gets the camera.
      */
@@ -44128,6 +44695,25 @@ export class CesiumWidget {
     this flag is true or false.
      */
     useBrowserRecommendedResolution: boolean;
+    /**
+     * Gets or sets whether or not data sources can temporarily pause
+    animation in order to avoid showing an incomplete picture to the user.
+    For example, if asynchronous primitives are being processed in the
+    background, the clock will not advance until the geometry is ready.
+     */
+    allowDataSourcesToSuspendAnimation: boolean;
+    /**
+     * Gets or sets the Entity instance currently being tracked by the camera.
+     */
+    trackedEntity: Entity | undefined;
+    /**
+     * Gets the event that is raised when the tracked entity changes.
+     */
+    readonly trackedEntityChanged: Event;
+    /**
+     * Gets or sets the data source to track with the widget's clock.
+     */
+    clockTrackedDataSource: DataSource;
     /**
      * Show an error panel to the user containing a title and a longer error message,
     which can be dismissed using an OK button.  This panel is displayed automatically
@@ -44158,6 +44744,51 @@ export class CesiumWidget {
     unless <code>useDefaultRenderLoop</code> is set to false;
      */
     render(): void;
+    /**
+     * Asynchronously sets the camera to view the provided entity, entities, or data source.
+    If the data source is still in the process of loading or the visualization is otherwise still loading,
+    this method waits for the data to be ready before performing the zoom.
+    
+    <p>The offset is heading/pitch/range in the local east-north-up reference frame centered at the center of the bounding sphere.
+    The heading and the pitch angles are defined in the local east-north-up reference frame.
+    The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
+    angles are above the plane. Negative pitch angles are below the plane. The range is the distance from the center. If the range is
+    zero, a range will be computed such that the whole bounding sphere is visible.</p>
+    
+    <p>In 2D, there must be a top down view. The camera will be placed above the target looking down. The height above the
+    target will be the range. The heading will be determined from the offset. If the heading cannot be
+    determined from the offset, the heading will be north.</p>
+     * @param target - The entity, array of entities, entity collection, data source, Cesium3DTileset, point cloud, or imagery layer to view. You can also pass a promise that resolves to one of the previously mentioned types.
+     * @param [offset] - The offset from the center of the entity in the local east-north-up reference frame.
+     * @returns A Promise that resolves to true if the zoom was successful or false if the target is not currently visualized in the scene or the zoom was cancelled.
+     */
+    zoomTo(target: Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud | Promise<Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud | VoxelPrimitive>, offset?: HeadingPitchRange): Promise<boolean>;
+    /**
+     * Flies the camera to the provided entity, entities, or data source.
+    If the data source is still in the process of loading or the visualization is otherwise still loading,
+    this method waits for the data to be ready before performing the flight.
+    
+    <p>The offset is heading/pitch/range in the local east-north-up reference frame centered at the center of the bounding sphere.
+    The heading and the pitch angles are defined in the local east-north-up reference frame.
+    The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
+    angles are above the plane. Negative pitch angles are below the plane. The range is the distance from the center. If the range is
+    zero, a range will be computed such that the whole bounding sphere is visible.</p>
+    
+    <p>In 2D, there must be a top down view. The camera will be placed above the target looking down. The height above the
+    target will be the range. The heading will be determined from the offset. If the heading cannot be
+    determined from the offset, the heading will be north.</p>
+     * @param target - The entity, array of entities, entity collection, data source, Cesium3DTileset, point cloud, or imagery layer to view. You can also pass a promise that resolves to one of the previously mentioned types.
+     * @param [options] - Object with the following properties:
+     * @param [options.duration = 3.0] - The duration of the flight in seconds.
+     * @param [options.maximumHeight] - The maximum height at the peak of the flight.
+     * @param [options.offset] - The offset from the target in the local east-north-up reference frame centered at the target.
+     * @returns A Promise that resolves to true if the flight was successful or false if the target is not currently visualized in the scene or the flight was cancelled. //TODO: Cleanup entity mentions
+     */
+    flyTo(target: Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud | Promise<Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud | VoxelPrimitive>, options?: {
+        duration?: number;
+        maximumHeight?: number;
+        offset?: HeadingPitchRange;
+    }): Promise<boolean>;
 }
 
 /**
@@ -46093,7 +46724,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.
@@ -46108,7 +46739,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.
@@ -46144,7 +46775,7 @@ export namespace Viewer {
         baseLayerPicker?: boolean;
         fullscreenButton?: boolean;
         vrButton?: boolean;
-        geocoder?: boolean | GeocoderService[];
+        geocoder?: boolean | IonGeocodeProviderType | GeocoderService[];
         homeButton?: boolean;
         infoBox?: boolean;
         sceneModePicker?: boolean;