mars3d-cesium 1.124.0 → 1.125.1

package/Build/Cesium/Cesium.d.ts

@@ -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;
 }
 
 /**
@@ -9162,7 +9165,7 @@ export namespace ITwinPlatform {
     enum ExportType {
     }
     /**
-     * Types of Reality data
+     * Types of Reality data. This is a partial list of types we know we can support
      */
     enum RealityDataType {
     }
@@ -12361,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.
@@ -12498,19 +12501,19 @@ export class OrthographicFrustum {
 
 /**
  * The viewing frustum is defined by 6 planes.
- * Each plane is represented by a {@link Cartesian4} object, where the x, y, and z components
- * define the unit vector normal to the plane, and the w component is the distance of the
- * plane from the origin/camera position.
+Each plane is represented by a {@link Cartesian4} object, where the x, y, and z components
+define the unit vector normal to the plane, and the w component is the distance of the
+plane from the origin/camera position.
  * @example
  * const maxRadii = ellipsoid.maximumRadius;
- *
- * const frustum = new Cesium.OrthographicOffCenterFrustum();
- * frustum.right = maxRadii * Cesium.Math.PI;
- * frustum.left = -c.frustum.right;
- * frustum.top = c.frustum.right * (canvas.clientHeight / canvas.clientWidth);
- * frustum.bottom = -c.frustum.top;
- * frustum.near = 0.01 * maxRadii;
- * frustum.far = 50.0 * maxRadii;
+
+const frustum = new Cesium.OrthographicOffCenterFrustum();
+frustum.right = maxRadii * Cesium.Math.PI;
+frustum.left = -c.frustum.right;
+frustum.top = c.frustum.right * (canvas.clientHeight / canvas.clientWidth);
+frustum.bottom = -c.frustum.top;
+frustum.near = 0.01 * maxRadii;
+frustum.far = 50.0 * maxRadii;
  * @param [options] - An object with the following properties:
  * @param [options.left] - The left clipping plane distance.
  * @param [options.right] - The right clipping plane distance.
@@ -12560,8 +12563,8 @@ export class OrthographicOffCenterFrustum {
      * Creates a culling volume for this frustum.
      * @example
      * // Check if a bounding volume intersects the frustum.
-     * const cullingVolume = frustum.computeCullingVolume(cameraPosition, cameraDirection, cameraUp);
-     * const intersect = cullingVolume.computeVisibility(boundingVolume);
+    const cullingVolume = frustum.computeCullingVolume(cameraPosition, cameraDirection, cameraUp);
+    const intersect = cullingVolume.computeVisibility(boundingVolume);
      * @param position - The eye position.
      * @param direction - The view direction.
      * @param up - The up direction.
@@ -12572,8 +12575,8 @@ export class OrthographicOffCenterFrustum {
      * Returns the pixel's width and height in meters.
      * @example
      * // Example 1
-     * // Get the width and height of a pixel.
-     * const pixelSize = camera.frustum.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, 0.0, scene.pixelRatio, new Cesium.Cartesian2());
+    // Get the width and height of a pixel.
+    const pixelSize = camera.frustum.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, 0.0, scene.pixelRatio, new Cesium.Cartesian2());
      * @param drawingBufferWidth - The width of the drawing buffer.
      * @param drawingBufferHeight - The height of the drawing buffer.
      * @param distance - The distance to the near plane in meters.
@@ -12590,15 +12593,15 @@ export class OrthographicOffCenterFrustum {
     clone(result?: OrthographicOffCenterFrustum): OrthographicOffCenterFrustum;
     /**
      * Compares the provided OrthographicOffCenterFrustum componentwise and returns
-     * <code>true</code> if they are equal, <code>false</code> otherwise.
+    <code>true</code> if they are equal, <code>false</code> otherwise.
      * @param [other] - The right hand side OrthographicOffCenterFrustum.
      * @returns <code>true</code> if they are equal, <code>false</code> otherwise.
      */
     equals(other?: OrthographicOffCenterFrustum): boolean;
     /**
      * Compares the provided OrthographicOffCenterFrustum componentwise and returns
-     * <code>true</code> if they pass an absolute or relative tolerance test,
-     * <code>false</code> otherwise.
+    <code>true</code> if they pass an absolute or relative tolerance test,
+    <code>false</code> otherwise.
      * @param other - The right hand side OrthographicOffCenterFrustum.
      * @param relativeEpsilon - The relative epsilon tolerance to use for equality testing.
      * @param [absoluteEpsilon = relativeEpsilon] - The absolute epsilon tolerance to use for equality testing.
@@ -16216,7 +16219,7 @@ export namespace ScreenSpaceEventHandler {
 
 /**
  * Handles user input events. Custom functions can be added to be executed on
- * when the user enters input.
+when the user enters input.
  * @param [element = document] - The element to add events to.
  */
 export class ScreenSpaceEventHandler {
@@ -16226,14 +16229,14 @@ export class ScreenSpaceEventHandler {
      * @param action - Function to be executed when the input event occurs.
      * @param type - The ScreenSpaceEventType of input event.
      * @param [modifier] - A KeyboardEventModifier key that is held when a <code>type</code>
-     * event occurs.
+    event occurs.
      */
     setInputAction(action: ScreenSpaceEventHandler.PositionedEventCallback | ScreenSpaceEventHandler.MotionEventCallback | ScreenSpaceEventHandler.WheelEventCallback | ScreenSpaceEventHandler.TwoPointEventCallback | ScreenSpaceEventHandler.TwoPointMotionEventCallback, type: ScreenSpaceEventType, modifier?: KeyboardEventModifier): void;
     /**
      * Returns the function to be executed on an input event.
      * @param type - The ScreenSpaceEventType of input event.
      * @param [modifier] - A KeyboardEventModifier key that is held when a <code>type</code>
-     * event occurs.
+    event occurs.
      * @returns The function to be executed on an input event.
      */
     getInputAction(type: ScreenSpaceEventType, modifier?: KeyboardEventModifier): ScreenSpaceEventHandler.PositionedEventCallback | ScreenSpaceEventHandler.MotionEventCallback | ScreenSpaceEventHandler.WheelEventCallback | ScreenSpaceEventHandler.TwoPointEventCallback | ScreenSpaceEventHandler.TwoPointMotionEventCallback;
@@ -16241,35 +16244,35 @@ export class ScreenSpaceEventHandler {
      * Removes the function to be executed on an input event.
      * @param type - The ScreenSpaceEventType of input event.
      * @param [modifier] - A KeyboardEventModifier key that is held when a <code>type</code>
-     * event occurs.
+    event occurs.
      */
     removeInputAction(type: ScreenSpaceEventType, modifier?: KeyboardEventModifier): void;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-     * <br /><br />
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+    <br /><br />
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
      * @returns <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
      */
     isDestroyed(): boolean;
     /**
      * Removes listeners held by this object.
-     * <br /><br />
-     * Once an object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
+    <br /><br />
+    Once an object is destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+    assign the return value (<code>undefined</code>) to the object as done in the example.
      * @example
      * handler = handler && handler.destroy();
      */
     destroy(): void;
     /**
      * The amount of time, in milliseconds, that mouse events will be disabled after
-     * receiving any touch events, such that any emulated mouse events will be ignored.
+    receiving any touch events, such that any emulated mouse events will be ignored.
      */
     static mouseEmulationIgnoreMilliseconds: number;
     /**
      * The amount of time, in milliseconds, before a touch on the screen becomes a
-     * touch and hold.
+    touch and hold.
      */
     static touchHoldDelayMilliseconds: number;
 }
@@ -16612,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.
@@ -16627,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.
@@ -18761,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.
@@ -18775,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;
@@ -19041,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}.
@@ -20438,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.
@@ -21864,10 +21880,10 @@ export class GeometryVisualizer {
     constructor(scene: Scene, entityCollection: EntityCollection, primitives?: PrimitiveCollection, groundPrimitives?: PrimitiveCollection);
     /**
      * Updates all of the primitives created by this visualizer to match their
-     * Entity counterpart at the given time.
+    Entity counterpart at the given time.
      * @param time - The time to update to.
      * @returns True if the visualizer successfully updated to the provided time,
-     * false if the visualizer is waiting for asynchronous primitives to be created.
+    false if the visualizer is waiting for asynchronous primitives to be created.
      */
     update(time: JulianDate): boolean;
     /**
@@ -22817,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.
@@ -22842,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 | {
@@ -22949,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.
      */
@@ -22999,7 +23023,7 @@ export class ModelVisualizer {
     constructor(scene: Scene, entityCollection: EntityCollection);
     /**
      * Updates models created this visualizer to match their
-     * Entity counterpart at the given time.
+    Entity counterpart at the given time.
      * @param time - The time to update to.
      * @returns This function always returns true.
      */
@@ -24075,10 +24099,10 @@ export class PolylineVisualizer {
     constructor(scene: Scene, entityCollection: EntityCollection, primitives?: PrimitiveCollection, groundPrimitives?: PrimitiveCollection);
     /**
      * Updates all of the primitives created by this visualizer to match their
-     * Entity counterpart at the given time.
+    Entity counterpart at the given time.
      * @param time - The time to update to.
      * @returns True if the visualizer successfully updated to the provided time,
-     * false if the visualizer is waiting for asynchronous primitives to be created.
+    false if the visualizer is waiting for asynchronous primitives to be created.
      */
     update(time: JulianDate): boolean;
     /**
@@ -26467,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;
 }
 
 /**
@@ -28451,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.
@@ -28476,7 +28501,6 @@ export namespace Cesium3DTileset {
      * @property [debugShowRenderingStatistics = false] - For debugging only. When true, draws labels to indicate the number of commands, points, triangles and features for each tile.
      * @property [debugShowMemoryUsage = false] - For debugging only. When true, draws labels to indicate the texture and geometry memory in megabytes used by each tile.
      * @property [debugShowUrl = false] - For debugging only. When true, draws labels to indicate the url of each tile.
-     * @param [options.environmentMapOptions] - The properties for managing dynamic environment maps on this model.
      */
     type ConstructorOptions = {
         show?: boolean;
@@ -28516,6 +28540,7 @@ export namespace Cesium3DTileset {
         pointCloudShading?: any;
         lightColor?: Cartesian3;
         imageBasedLighting?: ImageBasedLighting;
+        environmentMapOptions?: DynamicEnvironmentMapManager.ConstructorOptions;
         backFaceCulling?: boolean;
         enableShowOutline?: boolean;
         showOutline?: boolean;
@@ -30637,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.
@@ -31745,9 +31770,9 @@ export enum DepthFunction {
 
 /**
  * Returns the type that the given class property has in a GLSL shader.
- *
- * It returns the same string as `PropertyTextureProperty.prototype.getGlslType`
- * for a property texture property with the given class property
+
+It returns the same string as `PropertyTextureProperty.prototype.getGlslType`
+for a property texture property with the given class property
  * @param classProperty - The class property
  * @returns The GLSL shader type string for the property
  */
@@ -31755,8 +31780,8 @@ export function getGlslType(classProperty: MetadataClassProperty): string;
 
 /**
  * Returns a shader statement that applies the inverse of the
- * value transform to the given value, based on the given offset
- * and scale.
+value transform to the given value, based on the given offset
+and scale.
  * @param input - The input value
  * @param offset - The offset
  * @param scale - The scale
@@ -31766,7 +31791,7 @@ export function unapplyValueTransform(input: string, offset: string, scale: stri
 
 /**
  * Returns a shader statement that applies the inverse of the
- * normalization, based on the given component type
+normalization, based on the given component type
  * @param input - The input value
  * @param componentType - The component type
  * @returns The statement
@@ -31775,20 +31800,20 @@ export function unnormalize(input: string, componentType: string): string;
 
 /**
  * Creates a shader statement that returns the value of the specified
- * property, normalized to the range [0, 1].
+property, normalized to the range [0, 1].
  * @param classProperty - The class property
  * @param metadataProperty - The metadata property, either
- * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+a `PropertyTextureProperty` or a `PropertyAttributeProperty`
  * @returns The string
  */
 export function getSourceValueStringScalar(classProperty: MetadataClassProperty, metadataProperty: any): string;
 
 /**
  * Creates a shader statement that returns the value of the specified
- * component of the given property, normalized to the range [0, 1].
+component of the given property, normalized to the range [0, 1].
  * @param classProperty - The class property
  * @param metadataProperty - The metadata property, either
- * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+a `PropertyTextureProperty` or a `PropertyAttributeProperty`
  * @param componentName - The name, in ["x", "y", "z", "w"]
  * @returns The string
  */
@@ -31901,7 +31926,7 @@ 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 = 10] - The number of mipmap levels to generate for specular maps. More mipmap levels will produce a higher resolution specular reflection.
+     * @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.
@@ -34239,81 +34264,81 @@ export namespace ImageryLayer {
     /**
      * Initialization options for the ImageryLayer constructor.
      * @property [rectangle = imageryProvider.rectangle] - The rectangle of the layer.  This rectangle
-     *        can limit the visible portion of the imagery provider.
+           can limit the visible portion of the imagery provider.
      * @property [alpha = 1.0] - The alpha blending value of this layer, from 0.0 to 1.0.
-     *                          This can either be a simple number or a function with the signature
-     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-     *                          current frame state, this layer, and the x, y, and level coordinates of the
-     *                          imagery tile for which the alpha is required, and it is expected to return
-     *                          the alpha value to use for the tile.
+                             This can either be a simple number or a function with the signature
+                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+                             current frame state, this layer, and the x, y, and level coordinates of the
+                             imagery tile for which the alpha is required, and it is expected to return
+                             the alpha value to use for the tile.
      * @property [nightAlpha = 1.0] - The alpha blending value of this layer on the night side of the globe, from 0.0 to 1.0.
-     *                          This can either be a simple number or a function with the signature
-     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-     *                          current frame state, this layer, and the x, y, and level coordinates of the
-     *                          imagery tile for which the alpha is required, and it is expected to return
-     *                          the alpha value to use for the tile. This only takes effect when <code>enableLighting</code> is <code>true</code>.
+                             This can either be a simple number or a function with the signature
+                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+                             current frame state, this layer, and the x, y, and level coordinates of the
+                             imagery tile for which the alpha is required, and it is expected to return
+                             the alpha value to use for the tile. This only takes effect when <code>enableLighting</code> is <code>true</code>.
      * @property [dayAlpha = 1.0] - The alpha blending value of this layer on the day side of the globe, from 0.0 to 1.0.
-     *                          This can either be a simple number or a function with the signature
-     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-     *                          current frame state, this layer, and the x, y, and level coordinates of the
-     *                          imagery tile for which the alpha is required, and it is expected to return
-     *                          the alpha value to use for the tile. This only takes effect when <code>enableLighting</code> is <code>true</code>.
+                             This can either be a simple number or a function with the signature
+                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+                             current frame state, this layer, and the x, y, and level coordinates of the
+                             imagery tile for which the alpha is required, and it is expected to return
+                             the alpha value to use for the tile. This only takes effect when <code>enableLighting</code> is <code>true</code>.
      * @property [brightness = 1.0] - The brightness of this layer.  1.0 uses the unmodified imagery
-     *                          color.  Less than 1.0 makes the imagery darker while greater than 1.0 makes it brighter.
-     *                          This can either be a simple number or a function with the signature
-     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-     *                          current frame state, this layer, and the x, y, and level coordinates of the
-     *                          imagery tile for which the brightness is required, and it is expected to return
-     *                          the brightness value to use for the tile.  The function is executed for every
-     *                          frame and for every tile, so it must be fast.
+                             color.  Less than 1.0 makes the imagery darker while greater than 1.0 makes it brighter.
+                             This can either be a simple number or a function with the signature
+                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+                             current frame state, this layer, and the x, y, and level coordinates of the
+                             imagery tile for which the brightness is required, and it is expected to return
+                             the brightness value to use for the tile.  The function is executed for every
+                             frame and for every tile, so it must be fast.
      * @property [contrast = 1.0] - The contrast of this layer.  1.0 uses the unmodified imagery color.
-     *                          Less than 1.0 reduces the contrast while greater than 1.0 increases it.
-     *                          This can either be a simple number or a function with the signature
-     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-     *                          current frame state, this layer, and the x, y, and level coordinates of the
-     *                          imagery tile for which the contrast is required, and it is expected to return
-     *                          the contrast value to use for the tile.  The function is executed for every
-     *                          frame and for every tile, so it must be fast.
+                             Less than 1.0 reduces the contrast while greater than 1.0 increases it.
+                             This can either be a simple number or a function with the signature
+                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+                             current frame state, this layer, and the x, y, and level coordinates of the
+                             imagery tile for which the contrast is required, and it is expected to return
+                             the contrast value to use for the tile.  The function is executed for every
+                             frame and for every tile, so it must be fast.
      * @property [hue = 0.0] - The hue of this layer.  0.0 uses the unmodified imagery color.
-     *                          This can either be a simple number or a function with the signature
-     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-     *                          current frame state, this layer, and the x, y, and level coordinates
-     *                          of the imagery tile for which the hue is required, and it is expected to return
-     *                          the contrast value to use for the tile.  The function is executed for every
-     *                          frame and for every tile, so it must be fast.
+                             This can either be a simple number or a function with the signature
+                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+                             current frame state, this layer, and the x, y, and level coordinates
+                             of the imagery tile for which the hue is required, and it is expected to return
+                             the contrast value to use for the tile.  The function is executed for every
+                             frame and for every tile, so it must be fast.
      * @property [saturation = 1.0] - The saturation of this layer.  1.0 uses the unmodified imagery color.
-     *                          Less than 1.0 reduces the saturation while greater than 1.0 increases it.
-     *                          This can either be a simple number or a function with the signature
-     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-     *                          current frame state, this layer, and the x, y, and level coordinates
-     *                          of the imagery tile for which the saturation is required, and it is expected to return
-     *                          the contrast value to use for the tile.  The function is executed for every
-     *                          frame and for every tile, so it must be fast.
+                             Less than 1.0 reduces the saturation while greater than 1.0 increases it.
+                             This can either be a simple number or a function with the signature
+                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+                             current frame state, this layer, and the x, y, and level coordinates
+                             of the imagery tile for which the saturation is required, and it is expected to return
+                             the contrast value to use for the tile.  The function is executed for every
+                             frame and for every tile, so it must be fast.
      * @property [gamma = 1.0] - The gamma correction to apply to this layer.  1.0 uses the unmodified imagery color.
-     *                          This can either be a simple number or a function with the signature
-     *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
-     *                          current frame state, this layer, and the x, y, and level coordinates of the
-     *                          imagery tile for which the gamma is required, and it is expected to return
-     *                          the gamma value to use for the tile.  The function is executed for every
-     *                          frame and for every tile, so it must be fast.
+                             This can either be a simple number or a function with the signature
+                             <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
+                             current frame state, this layer, and the x, y, and level coordinates of the
+                             imagery tile for which the gamma is required, and it is expected to return
+                             the gamma value to use for the tile.  The function is executed for every
+                             frame and for every tile, so it must be fast.
      * @property [splitDirection = SplitDirection.NONE] - The {@link SplitDirection} split to apply to this layer.
      * @property [minificationFilter = TextureMinificationFilter.LINEAR] - The
-     *                                    texture minification filter to apply to this layer. Possible values
-     *                                    are <code>TextureMinificationFilter.LINEAR</code> and
-     *                                    <code>TextureMinificationFilter.NEAREST</code>.
+                                       texture minification filter to apply to this layer. Possible values
+                                       are <code>TextureMinificationFilter.LINEAR</code> and
+                                       <code>TextureMinificationFilter.NEAREST</code>.
      * @property [magnificationFilter = TextureMagnificationFilter.LINEAR] - The
-     *                                     texture minification filter to apply to this layer. Possible values
-     *                                     are <code>TextureMagnificationFilter.LINEAR</code> and
-     *                                     <code>TextureMagnificationFilter.NEAREST</code>.
+                                        texture minification filter to apply to this layer. Possible values
+                                        are <code>TextureMagnificationFilter.LINEAR</code> and
+                                        <code>TextureMagnificationFilter.NEAREST</code>.
      * @property [show = true] - True if the layer is shown; otherwise, false.
      * @property [maximumAnisotropy = maximum supported] - The maximum anisotropy level to use
-     *        for texture filtering.  If this parameter is not specified, the maximum anisotropy supported
-     *        by the WebGL stack will be used.  Larger values make the imagery look better in horizon
-     *        views.
+           for texture filtering.  If this parameter is not specified, the maximum anisotropy supported
+           by the WebGL stack will be used.  Larger values make the imagery look better in horizon
+           views.
      * @property [minimumTerrainLevel] - The minimum terrain level-of-detail at which to show this imagery layer,
-     *                 or undefined to show it at all levels.  Level zero is the least-detailed level.
+                    or undefined to show it at all levels.  Level zero is the least-detailed level.
      * @property [maximumTerrainLevel] - The maximum terrain level-of-detail at which to show this imagery layer,
-     *                 or undefined to show it at all levels.  Level zero is the least-detailed level.
+                    or undefined to show it at all levels.  Level zero is the least-detailed level.
      * @property [cutoutRectangle] - Cartographic rectangle for cutting out a portion of this ImageryLayer.
      * @property [colorToAlpha] - Color to be used as alpha.
      * @property [colorToAlphaThreshold = 0.004] - Threshold for color-to-alpha.
@@ -34348,22 +34373,22 @@ export namespace ImageryLayer {
 
 /**
  * An imagery layer that displays tiled image data from a single imagery provider
- * on a {@link Globe}.
+on a {@link Globe}.
  * @example
  * // Add an OpenStreetMaps layer
- * const imageryLayer = new Cesium.ImageryLayer(new Cesium.OpenStreetMapImageryProvider({
- *   url: "https://tile.openstreetmap.org/"
- * }));
- * scene.imageryLayers.add(imageryLayer);
+const imageryLayer = new Cesium.ImageryLayer(new Cesium.OpenStreetMapImageryProvider({
+  url: "https://tile.openstreetmap.org/"
+}));
+scene.imageryLayers.add(imageryLayer);
  * @example
  * // Add Cesium ion's default world imagery layer
- * const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
- * scene.imageryLayers.add(imageryLayer);
+const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
+scene.imageryLayers.add(imageryLayer);
  * @example
  * // Add a new transparent layer from Cesium ion
- * const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
- * imageryLayer.alpha = 0.5;
- * scene.imageryLayers.add(imageryLayer);
+const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
+imageryLayer.alpha = 0.5;
+scene.imageryLayers.add(imageryLayer);
  * @param [imageryProvider] - The imagery provider to use.
  * @param [options] - An object describing initialization options
  */
@@ -34371,27 +34396,27 @@ export class ImageryLayer {
     constructor(imageryProvider?: ImageryProvider, options?: ImageryLayer.ConstructorOptions);
     /**
      * The alpha blending value of this layer, with 0.0 representing fully transparent and
-     * 1.0 representing fully opaque.
+    1.0 representing fully opaque.
      */
     alpha: number;
     /**
      * The alpha blending value of this layer on the night side of the globe, with 0.0 representing fully transparent and
-     * 1.0 representing fully opaque. This only takes effect when {@link Globe#enableLighting} is <code>true</code>.
+    1.0 representing fully opaque. This only takes effect when {@link Globe#enableLighting} is <code>true</code>.
      */
     nightAlpha: number;
     /**
      * The alpha blending value of this layer on the day side of the globe, with 0.0 representing fully transparent and
-     * 1.0 representing fully opaque. This only takes effect when {@link Globe#enableLighting} is <code>true</code>.
+    1.0 representing fully opaque. This only takes effect when {@link Globe#enableLighting} is <code>true</code>.
      */
     dayAlpha: number;
     /**
      * The brightness of this layer.  1.0 uses the unmodified imagery color.  Less than 1.0
-     * makes the imagery darker while greater than 1.0 makes it brighter.
+    makes the imagery darker while greater than 1.0 makes it brighter.
      */
     brightness: number;
     /**
      * The contrast of this layer.  1.0 uses the unmodified imagery color.  Less than 1.0 reduces
-     * the contrast while greater than 1.0 increases it.
+    the contrast while greater than 1.0 increases it.
      */
     contrast: number;
     /**
@@ -34400,7 +34425,7 @@ export class ImageryLayer {
     hue: number;
     /**
      * The saturation of this layer. 1.0 uses the unmodified imagery color. Less than 1.0 reduces the
-     * saturation while greater than 1.0 increases it.
+    saturation while greater than 1.0 increases it.
      */
     saturation: number;
     /**
@@ -34413,20 +34438,20 @@ export class ImageryLayer {
     splitDirection: SplitDirection;
     /**
      * The {@link TextureMinificationFilter} to apply to this layer.
-     * Possible values are {@link TextureMinificationFilter.LINEAR} (the default)
-     * and {@link TextureMinificationFilter.NEAREST}.
-     *
-     * To take effect, this property must be set immediately after adding the imagery layer.
-     * Once a texture is loaded it won't be possible to change the texture filter used.
+    Possible values are {@link TextureMinificationFilter.LINEAR} (the default)
+    and {@link TextureMinificationFilter.NEAREST}.
+    
+    To take effect, this property must be set immediately after adding the imagery layer.
+    Once a texture is loaded it won't be possible to change the texture filter used.
      */
     minificationFilter: TextureMinificationFilter;
     /**
      * The {@link TextureMagnificationFilter} to apply to this layer.
-     * Possible values are {@link TextureMagnificationFilter.LINEAR} (the default)
-     * and {@link TextureMagnificationFilter.NEAREST}.
-     *
-     * To take effect, this property must be set immediately after adding the imagery layer.
-     * Once a texture is loaded it won't be possible to change the texture filter used.
+    Possible values are {@link TextureMagnificationFilter.LINEAR} (the default)
+    and {@link TextureMagnificationFilter.NEAREST}.
+    
+    To take effect, this property must be set immediately after adding the imagery layer.
+    Once a texture is loaded it won't be possible to change the texture filter used.
      */
     magnificationFilter: TextureMagnificationFilter;
     /**
@@ -34455,158 +34480,158 @@ export class ImageryLayer {
     readonly ready: boolean;
     /**
      * Gets an event that is raised when the imagery provider has been successfully created. Event listeners
-     * are passed the created instance of {@link ImageryProvider}.
+    are passed the created instance of {@link ImageryProvider}.
      */
     readonly readyEvent: Event<ImageryLayer.ReadyEventCallback>;
     /**
      * Gets the rectangle of this layer.  If this rectangle is smaller than the rectangle of the
-     * {@link ImageryProvider}, only a portion of the imagery provider is shown.
+    {@link ImageryProvider}, only a portion of the imagery provider is shown.
      */
     readonly rectangle: Rectangle;
     /**
      * This value is used as the default brightness for the imagery layer if one is not provided during construction
-     * or by the imagery provider. This value does not modify the brightness of the imagery.
+    or by the imagery provider. This value does not modify the brightness of the imagery.
      */
     static DEFAULT_BRIGHTNESS: number;
     /**
      * This value is used as the default contrast for the imagery layer if one is not provided during construction
-     * or by the imagery provider. This value does not modify the contrast of the imagery.
+    or by the imagery provider. This value does not modify the contrast of the imagery.
      */
     static DEFAULT_CONTRAST: number;
     /**
      * This value is used as the default hue for the imagery layer if one is not provided during construction
-     * or by the imagery provider. This value does not modify the hue of the imagery.
+    or by the imagery provider. This value does not modify the hue of the imagery.
      */
     static DEFAULT_HUE: number;
     /**
      * This value is used as the default saturation for the imagery layer if one is not provided during construction
-     * or by the imagery provider. This value does not modify the saturation of the imagery.
+    or by the imagery provider. This value does not modify the saturation of the imagery.
      */
     static DEFAULT_SATURATION: number;
     /**
      * This value is used as the default gamma for the imagery layer if one is not provided during construction
-     * or by the imagery provider. This value does not modify the gamma of the imagery.
+    or by the imagery provider. This value does not modify the gamma of the imagery.
      */
     static DEFAULT_GAMMA: number;
     /**
      * This value is used as the default split for the imagery layer if one is not provided during construction
-     * or by the imagery provider.
+    or by the imagery provider.
      */
     static DEFAULT_SPLIT: SplitDirection;
     /**
      * This value is used as the default texture minification filter for the imagery layer if one is not provided
-     * during construction or by the imagery provider.
+    during construction or by the imagery provider.
      */
     static DEFAULT_MINIFICATION_FILTER: TextureMinificationFilter;
     /**
      * This value is used as the default texture magnification filter for the imagery layer if one is not provided
-     * during construction or by the imagery provider.
+    during construction or by the imagery provider.
      */
     static DEFAULT_MAGNIFICATION_FILTER: TextureMagnificationFilter;
     /**
      * This value is used as the default threshold for color-to-alpha if one is not provided
-     * during construction or by the imagery provider.
+    during construction or by the imagery provider.
      */
     static DEFAULT_APPLY_COLOR_TO_ALPHA_THRESHOLD: number;
     /**
      * Create a new imagery layer from an asynchronous imagery provider. The layer will handle any asynchronous loads or errors, and begin rendering the imagery layer once ready.
      * @example
      * // Create a new base layer
-     * const viewer = new Cesium.Viewer("cesiumContainer", {
-     *   baseLayer: Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
-     * });
+    const viewer = new Cesium.Viewer("cesiumContainer", {
+      baseLayer: Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
+    });
      * @example
      * // Add a new transparent layer
-     * const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
-     * imageryLayer.alpha = 0.5;
-     * viewer.imageryLayers.add(imageryLayer);
+    const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
+    imageryLayer.alpha = 0.5;
+    viewer.imageryLayers.add(imageryLayer);
      * @example
      * // Handle loading events
-     * const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
-     * viewer.imageryLayers.add(imageryLayer);
-     *
-     * imageryLayer.readyEvent.addEventListener(provider => {
-     *   imageryLayer.provider.errorEvent.addEventListener(error => {
-     *     alert(`Encountered an error while loading imagery tiles! ${error}`);
-     *   });
-     * });
-     *
-     * imageryLayer.errorEvent.addEventListener(error => {
-     *   alert(`Encountered an error while creating an imagery layer! ${error}`);
-     * });
+    const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
+    viewer.imageryLayers.add(imageryLayer);
+    
+    imageryLayer.readyEvent.addEventListener(provider => {
+      imageryLayer.provider.errorEvent.addEventListener(error => {
+        alert(`Encountered an error while loading imagery tiles! ${error}`);
+      });
+    });
+    
+    imageryLayer.errorEvent.addEventListener(error => {
+      alert(`Encountered an error while creating an imagery layer! ${error}`);
+    });
      * @param imageryProviderPromise - A promise which resolves to a imagery provider
-     * @param options - An object describing initialization options
+     * @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
      * // Add a new transparent layer
-     * const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
-     * imageryLayer.alpha = 0.5;
-     * viewer.imageryLayers.add(imageryLayer);
+    const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
+    imageryLayer.alpha = 0.5;
+    viewer.imageryLayers.add(imageryLayer);
      * @example
      * // Handle loading events
-     * const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
-     * viewer.imageryLayers.add(imageryLayer);
-     *
-     * imageryLayer.readyEvent.addEventListener(provider => {
-     *   imageryLayer.provider.errorEvent.addEventListener(error => {
-     *     alert(`Encountered an error while loading imagery tiles! ${error}`);
-     *   });
-     * });
-     *
-     * imageryLayer.errorEvent.addEventListener(error => {
-     *   alert(`Encountered an error while creating an imagery layer! ${error}`);
-     * });
+    const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
+    viewer.imageryLayers.add(imageryLayer);
+    
+    imageryLayer.readyEvent.addEventListener(provider => {
+      imageryLayer.provider.errorEvent.addEventListener(error => {
+        alert(`Encountered an error while loading imagery tiles! ${error}`);
+      });
+    });
+    
+    imageryLayer.errorEvent.addEventListener(error => {
+      alert(`Encountered an error while creating an imagery layer! ${error}`);
+    });
      * @param options - An object describing initialization options
      * @returns The created imagery layer.
-     *
-     * * @example
-     * // Create a new base layer
-     * const viewer = new Cesium.Viewer("cesiumContainer", {
-     *   baseLayer: Cesium.ImageryLayer.fromWorldImagery();
-     * });
+    
+    * @example
+    // Create a new base layer
+    const viewer = new Cesium.Viewer("cesiumContainer", {
+      baseLayer: Cesium.ImageryLayer.fromWorldImagery();
+    });
      */
     static fromWorldImagery(options: ImageryLayer.WorldImageryConstructorOptions): ImageryLayer;
     /**
      * Gets a value indicating whether this layer is the base layer in the
-     * {@link ImageryLayerCollection}.  The base layer is the one that underlies all
-     * others.  It is special in that it is treated as if it has global rectangle, even if
-     * it actually does not, by stretching the texels at the edges over the entire
-     * globe.
+    {@link ImageryLayerCollection}.  The base layer is the one that underlies all
+    others.  It is special in that it is treated as if it has global rectangle, even if
+    it actually does not, by stretching the texels at the edges over the entire
+    globe.
      * @returns true if this is the base layer; otherwise, false.
      */
     isBaseLayer(): boolean;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-     * <br /><br />
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+    <br /><br />
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
      * @returns True if this object was destroyed; otherwise, false.
      */
     isDestroyed(): boolean;
     /**
      * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
-     * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
-     * <br /><br />
-     * Once an object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
+    release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+    <br /><br />
+    Once an object is destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+    assign the return value (<code>undefined</code>) to the object as done in the example.
      * @example
      * imageryLayer = imageryLayer && imageryLayer.destroy();
      */
     destroy(): void;
     /**
      * Computes the intersection of this layer's rectangle with the imagery provider's availability rectangle,
-     * producing the overall bounds of imagery that can be produced by this layer.
+    producing the overall bounds of imagery that can be produced by this layer.
      * @example
      * // Zoom to an imagery layer.
-     * const imageryRectangle = imageryLayer.getImageryRectangle();
-     * scene.camera.flyTo({
-     *     destination: rectangle
-     * });
+    const imageryRectangle = imageryLayer.getImageryRectangle();
+    scene.camera.flyTo({
+        destination: rectangle
+    });
      * @returns A rectangle which defines the overall bounds of imagery that can be produced by this layer.
      */
     getImageryRectangle(): Rectangle;
@@ -34619,24 +34644,24 @@ export class ImageryLayerCollection {
     constructor();
     /**
      * An event that is raised when a layer is added to the collection.  Event handlers are passed the layer that
-     * was added and the index at which it was added.
+    was added and the index at which it was added.
      */
     layerAdded: Event;
     /**
      * An event that is raised when a layer is removed from the collection.  Event handlers are passed the layer that
-     * was removed and the index from which it was removed.
+    was removed and the index from which it was removed.
      */
     layerRemoved: Event;
     /**
      * An event that is raised when a layer changes position in the collection.  Event handlers are passed the layer that
-     * was moved, its new index after the move, and its old index prior to the move.
+    was moved, its new index after the move, and its old index prior to the move.
      */
     layerMoved: Event;
     /**
      * An event that is raised when a layer is shown or hidden by setting the
-     * {@link ImageryLayer#show} property.  Event handlers are passed a reference to this layer,
-     * the index of the layer in the collection, and a flag that is true if the layer is now
-     * shown or false if it is now hidden.
+    {@link ImageryLayer#show} property.  Event handlers are passed a reference to this layer,
+    the index of the layer in the collection, and a flag that is true if the layer is now
+    shown or false if it is now hidden.
      */
     layerShownOrHidden: Event;
     /**
@@ -34647,27 +34672,27 @@ export class ImageryLayerCollection {
      * Adds a layer to the collection.
      * @example
      * const imageryLayer = Cesium.ImageryLayer.fromWorldImagery();
-     * scene.imageryLayers.add(imageryLayer);
+    scene.imageryLayers.add(imageryLayer);
      * @example
      * const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
-     * scene.imageryLayers.add(imageryLayer);
+    scene.imageryLayers.add(imageryLayer);
      * @param layer - the layer to add.
      * @param [index] - the index to add the layer at.  If omitted, the layer will
-     *                         be added on top of all existing layers.
+                            be added on top of all existing layers.
      */
     add(layer: ImageryLayer, index?: number): void;
     /**
      * Creates a new layer using the given ImageryProvider and adds it to the collection.
      * @example
      * try {
-     *    const provider = await Cesium.IonImageryProvider.fromAssetId(3812);
-     *    scene.imageryLayers.addImageryProvider(provider);
-     * } catch (error) {
-     *   console.log(`There was an error creating the imagery layer. ${error}`)
-     * }
+       const provider = await Cesium.IonImageryProvider.fromAssetId(3812);
+       scene.imageryLayers.addImageryProvider(provider);
+    } catch (error) {
+      console.log(`There was an error creating the imagery layer. ${error}`)
+    }
      * @param imageryProvider - the imagery provider to create a new layer for.
      * @param [index] - the index to add the layer at.  If omitted, the layer will
-     *                         added on top of all existing layers.
+                            added on top of all existing layers.
      * @returns The newly created layer.
      */
     addImageryProvider(imageryProvider: ImageryProvider, index?: number): ImageryLayer;
@@ -34676,7 +34701,7 @@ export class ImageryLayerCollection {
      * @param layer - The layer to remove.
      * @param [destroy = true] - whether to destroy the layers in addition to removing them.
      * @returns true if the layer was in the collection and was removed,
-     *                    false if the layer was not in the collection.
+                       false if the layer was not in the collection.
      */
     remove(layer: ImageryLayer, destroy?: boolean): boolean;
     /**
@@ -34724,57 +34749,57 @@ export class ImageryLayerCollection {
     lowerToBottom(layer: ImageryLayer): void;
     /**
      * Determines the imagery layers that are intersected by a pick ray. To compute a pick ray from a
-     * location on the screen, use {@link Camera.getPickRay}.
+    location on the screen, use {@link Camera.getPickRay}.
      * @param ray - The ray to test for intersection.
      * @param scene - The scene.
      * @returns An array that includes all of
-     *                                 the layers that are intersected by a given pick ray. Undefined if
-     *                                 no layers are selected.
+                                    the layers that are intersected by a given pick ray. Undefined if
+                                    no layers are selected.
      */
     pickImageryLayers(ray: Ray, scene: Scene): ImageryLayer[] | undefined;
     /**
      * Asynchronously determines the imagery layer features that are intersected by a pick ray.  The intersected imagery
-     * layer features are found by invoking {@link ImageryProvider#pickFeatures} for each imagery layer tile intersected
-     * by the pick ray.  To compute a pick ray from a location on the screen, use {@link Camera.getPickRay}.
+    layer features are found by invoking {@link ImageryProvider#pickFeatures} for each imagery layer tile intersected
+    by the pick ray.  To compute a pick ray from a location on the screen, use {@link Camera.getPickRay}.
      * @example
      * const pickRay = viewer.camera.getPickRay(windowPosition);
-     * const featuresPromise = viewer.imageryLayers.pickImageryLayerFeatures(pickRay, viewer.scene);
-     * if (!Cesium.defined(featuresPromise)) {
-     *     console.log('No features picked.');
-     * } else {
-     *     Promise.resolve(featuresPromise).then(function(features) {
-     *         // This function is called asynchronously when the list if picked features is available.
-     *         console.log(`Number of features: ${features.length}`);
-     *         if (features.length > 0) {
-     *             console.log(`First feature name: ${features[0].name}`);
-     *         }
-     *     });
-     * }
+    const featuresPromise = viewer.imageryLayers.pickImageryLayerFeatures(pickRay, viewer.scene);
+    if (!Cesium.defined(featuresPromise)) {
+        console.log('No features picked.');
+    } else {
+        Promise.resolve(featuresPromise).then(function(features) {
+            // This function is called asynchronously when the list if picked features is available.
+            console.log(`Number of features: ${features.length}`);
+            if (features.length > 0) {
+                console.log(`First feature name: ${features[0].name}`);
+            }
+        });
+    }
      * @param ray - The ray to test for intersection.
      * @param scene - The scene.
      * @returns A promise that resolves to an array of features intersected by the pick ray.
-     *                                             If it can be quickly determined that no features are intersected (for example,
-     *                                             because no active imagery providers support {@link ImageryProvider#pickFeatures}
-     *                                             or because the pick ray does not intersect the surface), this function will
-     *                                             return undefined.
+                                                If it can be quickly determined that no features are intersected (for example,
+                                                because no active imagery providers support {@link ImageryProvider#pickFeatures}
+                                                or because the pick ray does not intersect the surface), this function will
+                                                return undefined.
      */
     pickImageryLayerFeatures(ray: Ray, scene: Scene): Promise<ImageryLayerFeatureInfo[]> | undefined;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-     * <br /><br />
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+    <br /><br />
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
      * @returns true if this object was destroyed; otherwise, false.
      */
     isDestroyed(): boolean;
     /**
      * Destroys the WebGL resources held by all layers in this collection.  Explicitly destroying this
-     * object allows for deterministic release of WebGL resources, instead of relying on the garbage
-     * collector.
-     * <br /><br />
-     * Once this object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
+    object allows for deterministic release of WebGL resources, instead of relying on the garbage
+    collector.
+    <br /><br />
+    Once this object is destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+    assign the return value (<code>undefined</code>) to the object as done in the example.
      * @example
      * layerCollection = layerCollection && layerCollection.destroy();
      */
@@ -35117,6 +35142,18 @@ export namespace ITwinData {
      * @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>;
 }
 
 export namespace Label {
@@ -35400,10 +35437,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 />
@@ -35951,216 +35988,216 @@ export enum MapMode2D {
 
 /**
  * A Material defines surface appearance through a combination of diffuse, specular,
- * normal, emission, and alpha components. These values are specified using a
- * JSON schema called Fabric which gets parsed and assembled into glsl shader code
- * behind-the-scenes. Check out the {@link https://github.com/CesiumGS/cesium/wiki/Fabric|wiki page}
- * for more details on Fabric.
- * <br /><br />
- * <style type="text/css">
- *  #materialDescriptions code {
- *      font-weight: normal;
- *      font-family: Consolas, 'Lucida Console', Monaco, monospace;
- *      color: #A35A00;
- *  }
- *  #materialDescriptions ul, #materialDescriptions ul ul {
- *      list-style-type: none;
- *  }
- *  #materialDescriptions ul ul {
- *      margin-bottom: 10px;
- *  }
- *  #materialDescriptions ul ul li {
- *      font-weight: normal;
- *      color: #000000;
- *      text-indent: -2em;
- *      margin-left: 2em;
- *  }
- *  #materialDescriptions ul li {
- *      font-weight: bold;
- *      color: #0053CF;
- *  }
- * </style>
- *
- * Base material types and their uniforms:
- * <div id='materialDescriptions'>
- * <ul>
- *  <li>Color</li>
- *  <ul>
- *      <li><code>color</code>:  rgba color object.</li>
- *  </ul>
- *  <li>Image</li>
- *  <ul>
- *      <li><code>image</code>:  path to image.</li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
- *  </ul>
- *  <li>DiffuseMap</li>
- *  <ul>
- *      <li><code>image</code>:  path to image.</li>
- *      <li><code>channels</code>:  Three character string containing any combination of r, g, b, and a for selecting the desired image channels.</li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
- *  </ul>
- *  <li>AlphaMap</li>
- *  <ul>
- *      <li><code>image</code>:  path to image.</li>
- *      <li><code>channel</code>:  One character string containing r, g, b, or a for selecting the desired image channel. </li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
- *  </ul>
- *  <li>SpecularMap</li>
- *  <ul>
- *      <li><code>image</code>: path to image.</li>
- *      <li><code>channel</code>: One character string containing r, g, b, or a for selecting the desired image channel. </li>
- *      <li><code>repeat</code>: Object with x and y values specifying the number of times to repeat the image.</li>
- *  </ul>
- *  <li>EmissionMap</li>
- *  <ul>
- *      <li><code>image</code>:  path to image.</li>
- *      <li><code>channels</code>:  Three character string containing any combination of r, g, b, and a for selecting the desired image channels. </li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
- *  </ul>
- *  <li>BumpMap</li>
- *  <ul>
- *      <li><code>image</code>:  path to image.</li>
- *      <li><code>channel</code>:  One character string containing r, g, b, or a for selecting the desired image channel. </li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
- *      <li><code>strength</code>:  Bump strength value between 0.0 and 1.0 where 0.0 is small bumps and 1.0 is large bumps.</li>
- *  </ul>
- *  <li>NormalMap</li>
- *  <ul>
- *      <li><code>image</code>:  path to image.</li>
- *      <li><code>channels</code>:  Three character string containing any combination of r, g, b, and a for selecting the desired image channels. </li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
- *      <li><code>strength</code>:  Bump strength value between 0.0 and 1.0 where 0.0 is small bumps and 1.0 is large bumps.</li>
- *  </ul>
- *  <li>Grid</li>
- *  <ul>
- *      <li><code>color</code>:  rgba color object for the whole material.</li>
- *      <li><code>cellAlpha</code>: Alpha value for the cells between grid lines.  This will be combined with color.alpha.</li>
- *      <li><code>lineCount</code>:  Object with x and y values specifying the number of columns and rows respectively.</li>
- *      <li><code>lineThickness</code>:  Object with x and y values specifying the thickness of grid lines (in pixels where available).</li>
- *      <li><code>lineOffset</code>:  Object with x and y values specifying the offset of grid lines (range is 0 to 1).</li>
- *  </ul>
- *  <li>Stripe</li>
- *  <ul>
- *      <li><code>horizontal</code>:  Boolean that determines if the stripes are horizontal or vertical.</li>
- *      <li><code>evenColor</code>:  rgba color object for the stripe's first color.</li>
- *      <li><code>oddColor</code>:  rgba color object for the stripe's second color.</li>
- *      <li><code>offset</code>:  Number that controls at which point into the pattern to begin drawing; with 0.0 being the beginning of the even color, 1.0 the beginning of the odd color, 2.0 being the even color again, and any multiple or fractional values being in between.</li>
- *      <li><code>repeat</code>:  Number that controls the total number of stripes, half light and half dark.</li>
- *  </ul>
- *  <li>Checkerboard</li>
- *  <ul>
- *      <li><code>lightColor</code>:  rgba color object for the checkerboard's light alternating color.</li>
- *      <li><code>darkColor</code>: rgba color object for the checkerboard's dark alternating color.</li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of columns and rows respectively.</li>
- *  </ul>
- *  <li>Dot</li>
- *  <ul>
- *      <li><code>lightColor</code>:  rgba color object for the dot color.</li>
- *      <li><code>darkColor</code>:  rgba color object for the background color.</li>
- *      <li><code>repeat</code>:  Object with x and y values specifying the number of columns and rows of dots respectively.</li>
- *  </ul>
- *  <li>Water</li>
- *  <ul>
- *      <li><code>baseWaterColor</code>:  rgba color object base color of the water.</li>
- *      <li><code>blendColor</code>:  rgba color object used when blending from water to non-water areas.</li>
- *      <li><code>specularMap</code>:  Single channel texture used to indicate areas of water.</li>
- *      <li><code>normalMap</code>:  Normal map for water normal perturbation.</li>
- *      <li><code>frequency</code>:  Number that controls the number of waves.</li>
- *      <li><code>animationSpeed</code>:  Number that controls the animations speed of the water.</li>
- *      <li><code>amplitude</code>:  Number that controls the amplitude of water waves.</li>
- *      <li><code>specularIntensity</code>:  Number that controls the intensity of specular reflections.</li>
- *  </ul>
- *  <li>RimLighting</li>
- *  <ul>
- *      <li><code>color</code>:  diffuse color and alpha.</li>
- *      <li><code>rimColor</code>:  diffuse color and alpha of the rim.</li>
- *      <li><code>width</code>:  Number that determines the rim's width.</li>
- *  </ul>
- *  <li>Fade</li>
- *  <ul>
- *      <li><code>fadeInColor</code>: diffuse color and alpha at <code>time</code></li>
- *      <li><code>fadeOutColor</code>: diffuse color and alpha at <code>maximumDistance</code> from <code>time</code></li>
- *      <li><code>maximumDistance</code>: Number between 0.0 and 1.0 where the <code>fadeInColor</code> becomes the <code>fadeOutColor</code>. A value of 0.0 gives the entire material a color of <code>fadeOutColor</code> and a value of 1.0 gives the the entire material a color of <code>fadeInColor</code></li>
- *      <li><code>repeat</code>: true if the fade should wrap around the texture coodinates.</li>
- *      <li><code>fadeDirection</code>: Object with x and y values specifying if the fade should be in the x and y directions.</li>
- *      <li><code>time</code>: Object with x and y values between 0.0 and 1.0 of the <code>fadeInColor</code> position</li>
- *  </ul>
- *  <li>PolylineArrow</li>
- *  <ul>
- *      <li><code>color</code>: diffuse color and alpha.</li>
- *  </ul>
- *  <li>PolylineDash</li>
- *  <ul>
- *      <li><code>color</code>: color for the line.</li>
- *      <li><code>gapColor</code>: color for the gaps in the line.</li>
- *      <li><code>dashLength</code>: Dash length in pixels.</li>
- *      <li><code>dashPattern</code>: The 16 bit stipple pattern for the line..</li>
- *  </ul>
- *  <li>PolylineGlow</li>
- *  <ul>
- *      <li><code>color</code>: color and maximum alpha for the glow on the line.</li>
- *      <li><code>glowPower</code>: strength of the glow, as a percentage of the total line width (less than 1.0).</li>
- *      <li><code>taperPower</code>: strength of the tapering effect, as a percentage of the total line length.  If 1.0 or higher, no taper effect is used.</li>
- *  </ul>
- *  <li>PolylineOutline</li>
- *  <ul>
- *      <li><code>color</code>: diffuse color and alpha for the interior of the line.</li>
- *      <li><code>outlineColor</code>: diffuse color and alpha for the outline.</li>
- *      <li><code>outlineWidth</code>: width of the outline in pixels.</li>
- *  </ul>
- *  <li>ElevationContour</li>
- *  <ul>
- *      <li><code>color</code>: color and alpha for the contour line.</li>
- *      <li><code>spacing</code>: spacing for contour lines in meters.</li>
- *      <li><code>width</code>: Number specifying the width of the grid lines in pixels.</li>
- *  </ul>
- *  <li>ElevationRamp</li>
- *  <ul>
- *      <li><code>image</code>: color ramp image to use for coloring the terrain.</li>
- *      <li><code>minimumHeight</code>: minimum height for the ramp.</li>
- *      <li><code>maximumHeight</code>: maximum height for the ramp.</li>
- *  </ul>
- *  <li>SlopeRamp</li>
- *  <ul>
- *      <li><code>image</code>: color ramp image to use for coloring the terrain by slope.</li>
- *  </ul>
- *  <li>AspectRamp</li>
- *  <ul>
- *      <li><code>image</code>: color ramp image to use for color the terrain by aspect.</li>
- *  </ul>
- *  <li>ElevationBand</li>
- *  <ul>
- *      <li><code>heights</code>: image of heights sorted from lowest to highest.</li>
- *      <li><code>colors</code>: image of colors at the corresponding heights.</li>
- * </ul>
- * <li>WaterMask</li>
- * <ul>
- *      <li><code>waterColor</code>: diffuse color and alpha for the areas covered by water.</li>
- *      <li><code>landColor</code>: diffuse color and alpha for the areas covered by land.</li>
- * </ul>
- * </ul>
- * </ul>
- * </div>
+normal, emission, and alpha components. These values are specified using a
+JSON schema called Fabric which gets parsed and assembled into glsl shader code
+behind-the-scenes. Check out the {@link https://github.com/CesiumGS/cesium/wiki/Fabric|wiki page}
+for more details on Fabric.
+<br /><br />
+<style type="text/css">
+ #materialDescriptions code {
+     font-weight: normal;
+     font-family: Consolas, 'Lucida Console', Monaco, monospace;
+     color: #A35A00;
+ }
+ #materialDescriptions ul, #materialDescriptions ul ul {
+     list-style-type: none;
+ }
+ #materialDescriptions ul ul {
+     margin-bottom: 10px;
+ }
+ #materialDescriptions ul ul li {
+     font-weight: normal;
+     color: #000000;
+     text-indent: -2em;
+     margin-left: 2em;
+ }
+ #materialDescriptions ul li {
+     font-weight: bold;
+     color: #0053CF;
+ }
+</style>
+
+Base material types and their uniforms:
+<div id='materialDescriptions'>
+<ul>
+ <li>Color</li>
+ <ul>
+     <li><code>color</code>:  rgba color object.</li>
+ </ul>
+ <li>Image</li>
+ <ul>
+     <li><code>image</code>:  path to image.</li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
+ </ul>
+ <li>DiffuseMap</li>
+ <ul>
+     <li><code>image</code>:  path to image.</li>
+     <li><code>channels</code>:  Three character string containing any combination of r, g, b, and a for selecting the desired image channels.</li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
+ </ul>
+ <li>AlphaMap</li>
+ <ul>
+     <li><code>image</code>:  path to image.</li>
+     <li><code>channel</code>:  One character string containing r, g, b, or a for selecting the desired image channel. </li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
+ </ul>
+ <li>SpecularMap</li>
+ <ul>
+     <li><code>image</code>: path to image.</li>
+     <li><code>channel</code>: One character string containing r, g, b, or a for selecting the desired image channel. </li>
+     <li><code>repeat</code>: Object with x and y values specifying the number of times to repeat the image.</li>
+ </ul>
+ <li>EmissionMap</li>
+ <ul>
+     <li><code>image</code>:  path to image.</li>
+     <li><code>channels</code>:  Three character string containing any combination of r, g, b, and a for selecting the desired image channels. </li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
+ </ul>
+ <li>BumpMap</li>
+ <ul>
+     <li><code>image</code>:  path to image.</li>
+     <li><code>channel</code>:  One character string containing r, g, b, or a for selecting the desired image channel. </li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
+     <li><code>strength</code>:  Bump strength value between 0.0 and 1.0 where 0.0 is small bumps and 1.0 is large bumps.</li>
+ </ul>
+ <li>NormalMap</li>
+ <ul>
+     <li><code>image</code>:  path to image.</li>
+     <li><code>channels</code>:  Three character string containing any combination of r, g, b, and a for selecting the desired image channels. </li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of times to repeat the image.</li>
+     <li><code>strength</code>:  Bump strength value between 0.0 and 1.0 where 0.0 is small bumps and 1.0 is large bumps.</li>
+ </ul>
+ <li>Grid</li>
+ <ul>
+     <li><code>color</code>:  rgba color object for the whole material.</li>
+     <li><code>cellAlpha</code>: Alpha value for the cells between grid lines.  This will be combined with color.alpha.</li>
+     <li><code>lineCount</code>:  Object with x and y values specifying the number of columns and rows respectively.</li>
+     <li><code>lineThickness</code>:  Object with x and y values specifying the thickness of grid lines (in pixels where available).</li>
+     <li><code>lineOffset</code>:  Object with x and y values specifying the offset of grid lines (range is 0 to 1).</li>
+ </ul>
+ <li>Stripe</li>
+ <ul>
+     <li><code>horizontal</code>:  Boolean that determines if the stripes are horizontal or vertical.</li>
+     <li><code>evenColor</code>:  rgba color object for the stripe's first color.</li>
+     <li><code>oddColor</code>:  rgba color object for the stripe's second color.</li>
+     <li><code>offset</code>:  Number that controls at which point into the pattern to begin drawing; with 0.0 being the beginning of the even color, 1.0 the beginning of the odd color, 2.0 being the even color again, and any multiple or fractional values being in between.</li>
+     <li><code>repeat</code>:  Number that controls the total number of stripes, half light and half dark.</li>
+ </ul>
+ <li>Checkerboard</li>
+ <ul>
+     <li><code>lightColor</code>:  rgba color object for the checkerboard's light alternating color.</li>
+     <li><code>darkColor</code>: rgba color object for the checkerboard's dark alternating color.</li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of columns and rows respectively.</li>
+ </ul>
+ <li>Dot</li>
+ <ul>
+     <li><code>lightColor</code>:  rgba color object for the dot color.</li>
+     <li><code>darkColor</code>:  rgba color object for the background color.</li>
+     <li><code>repeat</code>:  Object with x and y values specifying the number of columns and rows of dots respectively.</li>
+ </ul>
+ <li>Water</li>
+ <ul>
+     <li><code>baseWaterColor</code>:  rgba color object base color of the water.</li>
+     <li><code>blendColor</code>:  rgba color object used when blending from water to non-water areas.</li>
+     <li><code>specularMap</code>:  Single channel texture used to indicate areas of water.</li>
+     <li><code>normalMap</code>:  Normal map for water normal perturbation.</li>
+     <li><code>frequency</code>:  Number that controls the number of waves.</li>
+     <li><code>animationSpeed</code>:  Number that controls the animations speed of the water.</li>
+     <li><code>amplitude</code>:  Number that controls the amplitude of water waves.</li>
+     <li><code>specularIntensity</code>:  Number that controls the intensity of specular reflections.</li>
+ </ul>
+ <li>RimLighting</li>
+ <ul>
+     <li><code>color</code>:  diffuse color and alpha.</li>
+     <li><code>rimColor</code>:  diffuse color and alpha of the rim.</li>
+     <li><code>width</code>:  Number that determines the rim's width.</li>
+ </ul>
+ <li>Fade</li>
+ <ul>
+     <li><code>fadeInColor</code>: diffuse color and alpha at <code>time</code></li>
+     <li><code>fadeOutColor</code>: diffuse color and alpha at <code>maximumDistance</code> from <code>time</code></li>
+     <li><code>maximumDistance</code>: Number between 0.0 and 1.0 where the <code>fadeInColor</code> becomes the <code>fadeOutColor</code>. A value of 0.0 gives the entire material a color of <code>fadeOutColor</code> and a value of 1.0 gives the the entire material a color of <code>fadeInColor</code></li>
+     <li><code>repeat</code>: true if the fade should wrap around the texture coodinates.</li>
+     <li><code>fadeDirection</code>: Object with x and y values specifying if the fade should be in the x and y directions.</li>
+     <li><code>time</code>: Object with x and y values between 0.0 and 1.0 of the <code>fadeInColor</code> position</li>
+ </ul>
+ <li>PolylineArrow</li>
+ <ul>
+     <li><code>color</code>: diffuse color and alpha.</li>
+ </ul>
+ <li>PolylineDash</li>
+ <ul>
+     <li><code>color</code>: color for the line.</li>
+     <li><code>gapColor</code>: color for the gaps in the line.</li>
+     <li><code>dashLength</code>: Dash length in pixels.</li>
+     <li><code>dashPattern</code>: The 16 bit stipple pattern for the line..</li>
+ </ul>
+ <li>PolylineGlow</li>
+ <ul>
+     <li><code>color</code>: color and maximum alpha for the glow on the line.</li>
+     <li><code>glowPower</code>: strength of the glow, as a percentage of the total line width (less than 1.0).</li>
+     <li><code>taperPower</code>: strength of the tapering effect, as a percentage of the total line length.  If 1.0 or higher, no taper effect is used.</li>
+ </ul>
+ <li>PolylineOutline</li>
+ <ul>
+     <li><code>color</code>: diffuse color and alpha for the interior of the line.</li>
+     <li><code>outlineColor</code>: diffuse color and alpha for the outline.</li>
+     <li><code>outlineWidth</code>: width of the outline in pixels.</li>
+ </ul>
+ <li>ElevationContour</li>
+ <ul>
+     <li><code>color</code>: color and alpha for the contour line.</li>
+     <li><code>spacing</code>: spacing for contour lines in meters.</li>
+     <li><code>width</code>: Number specifying the width of the grid lines in pixels.</li>
+ </ul>
+ <li>ElevationRamp</li>
+ <ul>
+     <li><code>image</code>: color ramp image to use for coloring the terrain.</li>
+     <li><code>minimumHeight</code>: minimum height for the ramp.</li>
+     <li><code>maximumHeight</code>: maximum height for the ramp.</li>
+ </ul>
+ <li>SlopeRamp</li>
+ <ul>
+     <li><code>image</code>: color ramp image to use for coloring the terrain by slope.</li>
+ </ul>
+ <li>AspectRamp</li>
+ <ul>
+     <li><code>image</code>: color ramp image to use for color the terrain by aspect.</li>
+ </ul>
+ <li>ElevationBand</li>
+ <ul>
+     <li><code>heights</code>: image of heights sorted from lowest to highest.</li>
+     <li><code>colors</code>: image of colors at the corresponding heights.</li>
+</ul>
+<li>WaterMask</li>
+<ul>
+     <li><code>waterColor</code>: diffuse color and alpha for the areas covered by water.</li>
+     <li><code>landColor</code>: diffuse color and alpha for the areas covered by land.</li>
+</ul>
+</ul>
+</ul>
+</div>
  * @example
  * // Create a color material with fromType:
- * polygon.material = Cesium.Material.fromType('Color');
- * polygon.material.uniforms.color = new Cesium.Color(1.0, 1.0, 0.0, 1.0);
- *
- * // Create the default material:
- * polygon.material = new Cesium.Material();
- *
- * // Create a color material with full Fabric notation:
- * polygon.material = new Cesium.Material({
- *   fabric: {
- *     type: 'Color',
- *     uniforms: {
- *       color: new Cesium.Color(1.0, 1.0, 0.0, 1.0)
- *     }
- *   }
- * });
+polygon.material = Cesium.Material.fromType('Color');
+polygon.material.uniforms.color = new Cesium.Color(1.0, 1.0, 0.0, 1.0);
+
+// Create the default material:
+polygon.material = new Cesium.Material();
+
+// Create a color material with full Fabric notation:
+polygon.material = new Cesium.Material({
+  fabric: {
+    type: 'Color',
+    uniforms: {
+      color: new Cesium.Color(1.0, 1.0, 0.0, 1.0)
+    }
+  }
+});
  * @param [options] - Object with the following properties:
  * @param [options.strict = false] - Throws errors for issues that would normally be ignored, including unused uniforms or materials.
  * @param [options.translucent = true] - When <code>true</code> or a function that returns <code>true</code>, the geometry
- *                           with this material is expected to appear translucent.
+                          with this material is expected to appear translucent.
  * @param [options.minificationFilter = TextureMinificationFilter.LINEAR] - The {@link TextureMinificationFilter} to apply to this material's textures.
  * @param [options.magnificationFilter = TextureMagnificationFilter.LINEAR] - The {@link TextureMagnificationFilter} to apply to this material's textures.
  * @param options.fabric - The fabric JSON used to generate the material.
@@ -36191,17 +36228,17 @@ export class Material {
     uniforms: any;
     /**
      * When <code>true</code> or a function that returns <code>true</code>,
-     * the geometry is expected to appear translucent.
+    the geometry is expected to appear translucent.
      */
     translucent: boolean | ((...params: any[]) => any);
     /**
      * Creates a new material using an existing material type.
-     * <br /><br />
-     * Shorthand for: new Material({fabric : {type : type}});
+    <br /><br />
+    Shorthand for: new Material({fabric : {type : type}});
      * @example
      * const material = Cesium.Material.fromType('Color', {
-     *   color: new Cesium.Color(1.0, 0.0, 0.0, 1.0)
-     * });
+      color: new Cesium.Color(1.0, 0.0, 0.0, 1.0)
+    });
      * @param type - The base material type.
      * @param [uniforms] - Overrides for the default uniforms.
      * @returns New material object.
@@ -36214,19 +36251,19 @@ export class Material {
     isTranslucent(): boolean;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-     * <br /><br />
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+    <br /><br />
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
      * @returns True if this object was destroyed; otherwise, false.
      */
     isDestroyed(): boolean;
     /**
      * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
-     * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
-     * <br /><br />
-     * Once an object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
+    release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+    <br /><br />
+    Once an object is destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+    assign the return value (<code>undefined</code>) to the object as done in the example.
      * @example
      * material = material && material.destroy();
      */
@@ -37801,7 +37838,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`
@@ -39465,10 +39502,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;
 }
 
 /**
@@ -40651,88 +40688,88 @@ export enum PostProcessStageSampleMode {
 
 /**
  * A primitive represents geometry in the {@link Scene}.  The geometry can be from a single {@link GeometryInstance}
- * as shown in example 1 below, or from an array of instances, even if the geometry is from different
- * geometry types, e.g., an {@link RectangleGeometry} and an {@link EllipsoidGeometry} as shown in Code Example 2.
- * <p>
- * A primitive combines geometry instances with an {@link Appearance} that describes the full shading, including
- * {@link Material} and {@link RenderState}.  Roughly, the geometry instance defines the structure and placement,
- * and the appearance defines the visual characteristics.  Decoupling geometry and appearance allows us to mix
- * and match most of them and add a new geometry or appearance independently of each other.
- * </p>
- * <p>
- * Combining multiple instances into one primitive is called batching, and significantly improves performance for static data.
- * Instances can be individually picked; {@link Scene#pick} returns their {@link GeometryInstance#id}.  Using
- * per-instance appearances like {@link PerInstanceColorAppearance}, each instance can also have a unique color.
- * </p>
- * <p>
- * {@link Geometry} can either be created and batched on a web worker or the main thread. The first two examples
- * show geometry that will be created on a web worker by using the descriptions of the geometry. The third example
- * shows how to create the geometry on the main thread by explicitly calling the <code>createGeometry</code> method.
- * </p>
+as shown in example 1 below, or from an array of instances, even if the geometry is from different
+geometry types, e.g., an {@link RectangleGeometry} and an {@link EllipsoidGeometry} as shown in Code Example 2.
+<p>
+A primitive combines geometry instances with an {@link Appearance} that describes the full shading, including
+{@link Material} and {@link RenderState}.  Roughly, the geometry instance defines the structure and placement,
+and the appearance defines the visual characteristics.  Decoupling geometry and appearance allows us to mix
+and match most of them and add a new geometry or appearance independently of each other.
+</p>
+<p>
+Combining multiple instances into one primitive is called batching, and significantly improves performance for static data.
+Instances can be individually picked; {@link Scene#pick} returns their {@link GeometryInstance#id}.  Using
+per-instance appearances like {@link PerInstanceColorAppearance}, each instance can also have a unique color.
+</p>
+<p>
+{@link Geometry} can either be created and batched on a web worker or the main thread. The first two examples
+show geometry that will be created on a web worker by using the descriptions of the geometry. The third example
+shows how to create the geometry on the main thread by explicitly calling the <code>createGeometry</code> method.
+</p>
  * @example
  * // 1. Draw a translucent ellipse on the surface with a checkerboard pattern
- * const instance = new Cesium.GeometryInstance({
- *   geometry : new Cesium.EllipseGeometry({
- *       center : Cesium.Cartesian3.fromDegrees(-100.0, 20.0),
- *       semiMinorAxis : 500000.0,
- *       semiMajorAxis : 1000000.0,
- *       rotation : Cesium.Math.PI_OVER_FOUR,
- *       vertexFormat : Cesium.VertexFormat.POSITION_AND_ST
- *   }),
- *   id : 'object returned when this instance is picked and to get/set per-instance attributes'
- * });
- * scene.primitives.add(new Cesium.Primitive({
- *   geometryInstances : instance,
- *   appearance : new Cesium.EllipsoidSurfaceAppearance({
- *     material : Cesium.Material.fromType('Checkerboard')
- *   })
- * }));
+const instance = new Cesium.GeometryInstance({
+  geometry : new Cesium.EllipseGeometry({
+      center : Cesium.Cartesian3.fromDegrees(-100.0, 20.0),
+      semiMinorAxis : 500000.0,
+      semiMajorAxis : 1000000.0,
+      rotation : Cesium.Math.PI_OVER_FOUR,
+      vertexFormat : Cesium.VertexFormat.POSITION_AND_ST
+  }),
+  id : 'object returned when this instance is picked and to get/set per-instance attributes'
+});
+scene.primitives.add(new Cesium.Primitive({
+  geometryInstances : instance,
+  appearance : new Cesium.EllipsoidSurfaceAppearance({
+    material : Cesium.Material.fromType('Checkerboard')
+  })
+}));
  * @example
  * // 2. Draw different instances each with a unique color
- * const rectangleInstance = new Cesium.GeometryInstance({
- *   geometry : new Cesium.RectangleGeometry({
- *     rectangle : Cesium.Rectangle.fromDegrees(-140.0, 30.0, -100.0, 40.0),
- *     vertexFormat : Cesium.PerInstanceColorAppearance.VERTEX_FORMAT
- *   }),
- *   id : 'rectangle',
- *   attributes : {
- *     color : new Cesium.ColorGeometryInstanceAttribute(0.0, 1.0, 1.0, 0.5)
- *   }
- * });
- * const ellipsoidInstance = new Cesium.GeometryInstance({
- *   geometry : new Cesium.EllipsoidGeometry({
- *     radii : new Cesium.Cartesian3(500000.0, 500000.0, 1000000.0),
- *     vertexFormat : Cesium.VertexFormat.POSITION_AND_NORMAL
- *   }),
- *   modelMatrix : Cesium.Matrix4.multiplyByTranslation(Cesium.Transforms.eastNorthUpToFixedFrame(
- *     Cesium.Cartesian3.fromDegrees(-95.59777, 40.03883)), new Cesium.Cartesian3(0.0, 0.0, 500000.0), new Cesium.Matrix4()),
- *   id : 'ellipsoid',
- *   attributes : {
- *     color : Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.AQUA)
- *   }
- * });
- * scene.primitives.add(new Cesium.Primitive({
- *   geometryInstances : [rectangleInstance, ellipsoidInstance],
- *   appearance : new Cesium.PerInstanceColorAppearance()
- * }));
+const rectangleInstance = new Cesium.GeometryInstance({
+  geometry : new Cesium.RectangleGeometry({
+    rectangle : Cesium.Rectangle.fromDegrees(-140.0, 30.0, -100.0, 40.0),
+    vertexFormat : Cesium.PerInstanceColorAppearance.VERTEX_FORMAT
+  }),
+  id : 'rectangle',
+  attributes : {
+    color : new Cesium.ColorGeometryInstanceAttribute(0.0, 1.0, 1.0, 0.5)
+  }
+});
+const ellipsoidInstance = new Cesium.GeometryInstance({
+  geometry : new Cesium.EllipsoidGeometry({
+    radii : new Cesium.Cartesian3(500000.0, 500000.0, 1000000.0),
+    vertexFormat : Cesium.VertexFormat.POSITION_AND_NORMAL
+  }),
+  modelMatrix : Cesium.Matrix4.multiplyByTranslation(Cesium.Transforms.eastNorthUpToFixedFrame(
+    Cesium.Cartesian3.fromDegrees(-95.59777, 40.03883)), new Cesium.Cartesian3(0.0, 0.0, 500000.0), new Cesium.Matrix4()),
+  id : 'ellipsoid',
+  attributes : {
+    color : Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.AQUA)
+  }
+});
+scene.primitives.add(new Cesium.Primitive({
+  geometryInstances : [rectangleInstance, ellipsoidInstance],
+  appearance : new Cesium.PerInstanceColorAppearance()
+}));
  * @example
  * // 3. Create the geometry on the main thread.
- * scene.primitives.add(new Cesium.Primitive({
- *   geometryInstances : new Cesium.GeometryInstance({
- *     geometry : Cesium.EllipsoidGeometry.createGeometry(new Cesium.EllipsoidGeometry({
- *       radii : new Cesium.Cartesian3(500000.0, 500000.0, 1000000.0),
- *       vertexFormat : Cesium.VertexFormat.POSITION_AND_NORMAL
- *     })),
- *     modelMatrix : Cesium.Matrix4.multiplyByTranslation(Cesium.Transforms.eastNorthUpToFixedFrame(
- *       Cesium.Cartesian3.fromDegrees(-95.59777, 40.03883)), new Cesium.Cartesian3(0.0, 0.0, 500000.0), new Cesium.Matrix4()),
- *     id : 'ellipsoid',
- *     attributes : {
- *       color : Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.AQUA)
- *     }
- *   }),
- *   appearance : new Cesium.PerInstanceColorAppearance(),
- *   asynchronous : false
- * }));
+scene.primitives.add(new Cesium.Primitive({
+  geometryInstances : new Cesium.GeometryInstance({
+    geometry : Cesium.EllipsoidGeometry.createGeometry(new Cesium.EllipsoidGeometry({
+      radii : new Cesium.Cartesian3(500000.0, 500000.0, 1000000.0),
+      vertexFormat : Cesium.VertexFormat.POSITION_AND_NORMAL
+    })),
+    modelMatrix : Cesium.Matrix4.multiplyByTranslation(Cesium.Transforms.eastNorthUpToFixedFrame(
+      Cesium.Cartesian3.fromDegrees(-95.59777, 40.03883)), new Cesium.Cartesian3(0.0, 0.0, 500000.0), new Cesium.Matrix4()),
+    id : 'ellipsoid',
+    attributes : {
+      color : Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.AQUA)
+    }
+  }),
+  appearance : new Cesium.PerInstanceColorAppearance(),
+  asynchronous : false
+}));
  * @param [options] - Object with the following properties:
  * @param [options.geometryInstances] - The geometry instances - or a single geometry instance - to render.
  * @param [options.appearance] - The appearance used to render the primitive.
@@ -40768,67 +40805,67 @@ export class Primitive {
     });
     /**
      * The geometry instances rendered with this primitive.  This may
-     * be <code>undefined</code> if <code>options.releaseGeometryInstances</code>
-     * is <code>true</code> when the primitive is constructed.
-     * <p>
-     * Changing this property after the primitive is rendered has no effect.
-     * </p>
+    be <code>undefined</code> if <code>options.releaseGeometryInstances</code>
+    is <code>true</code> when the primitive is constructed.
+    <p>
+    Changing this property after the primitive is rendered has no effect.
+    </p>
      */
     readonly geometryInstances: GeometryInstance[] | GeometryInstance;
     /**
      * The {@link Appearance} used to shade this primitive. Each geometry
-     * instance is shaded with the same appearance.  Some appearances, like
-     * {@link PerInstanceColorAppearance} allow giving each instance unique
-     * properties.
+    instance is shaded with the same appearance.  Some appearances, like
+    {@link PerInstanceColorAppearance} allow giving each instance unique
+    properties.
      */
     appearance: Appearance;
     /**
      * The {@link Appearance} used to shade this primitive when it fails the depth test. Each geometry
-     * instance is shaded with the same appearance.  Some appearances, like
-     * {@link PerInstanceColorAppearance} allow giving each instance unique
-     * properties.
-     *
-     * <p>
-     * When using an appearance that requires a color attribute, like PerInstanceColorAppearance,
-     * add a depthFailColor per-instance attribute instead.
-     * </p>
-     *
-     * <p>
-     * Requires the EXT_frag_depth WebGL extension to render properly. If the extension is not supported,
-     * there may be artifacts.
-     * </p>
+    instance is shaded with the same appearance.  Some appearances, like
+    {@link PerInstanceColorAppearance} allow giving each instance unique
+    properties.
+    
+    <p>
+    When using an appearance that requires a color attribute, like PerInstanceColorAppearance,
+    add a depthFailColor per-instance attribute instead.
+    </p>
+    
+    <p>
+    Requires the EXT_frag_depth WebGL extension to render properly. If the extension is not supported,
+    there may be artifacts.
+    </p>
      */
     depthFailAppearance: Appearance;
     /**
      * The 4x4 transformation matrix that transforms the primitive (all geometry instances) from model to world coordinates.
-     * When this is the identity matrix, the primitive is drawn in world coordinates, i.e., Earth's WGS84 coordinates.
-     * Local reference frames can be used by providing a different transformation matrix, like that returned
-     * by {@link Transforms.eastNorthUpToFixedFrame}.
-     *
-     * <p>
-     * This property is only supported in 3D mode.
-     * </p>
+    When this is the identity matrix, the primitive is drawn in world coordinates, i.e., Earth's WGS84 coordinates.
+    Local reference frames can be used by providing a different transformation matrix, like that returned
+    by {@link Transforms.eastNorthUpToFixedFrame}.
+    
+    <p>
+    This property is only supported in 3D mode.
+    </p>
      * @example
      * const origin = Cesium.Cartesian3.fromDegrees(-95.0, 40.0, 200000.0);
-     * p.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(origin);
+    p.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(origin);
      */
     modelMatrix: Matrix4;
     /**
      * Determines if the primitive will be shown.  This affects all geometry
-     * instances in the primitive.
+    instances in the primitive.
      */
     show: boolean;
     /**
      * When <code>true</code>, the renderer frustum culls and horizon culls the primitive's commands
-     * based on their bounding volume.  Set this to <code>false</code> for a small performance gain
-     * if you are manually culling the primitive.
+    based on their bounding volume.  Set this to <code>false</code> for a small performance gain
+    if you are manually culling the primitive.
      */
     cull: boolean;
     /**
      * This property is for debugging only; it is not for production use nor is it optimized.
-     * <p>
-     * Draws the bounding sphere for each draw command in the primitive.
-     * </p>
+    <p>
+    Draws the bounding sphere for each draw command in the primitive.
+    </p>
      */
     debugShowBoundingVolume: boolean;
     /**
@@ -40861,60 +40898,60 @@ export class Primitive {
     readonly compressVertices: boolean;
     /**
      * Determines if the primitive is complete and ready to render.  If this property is
-     * true, the primitive will be rendered the next time that {@link Primitive#update}
-     * is called.
+    true, the primitive will be rendered the next time that {@link Primitive#update}
+    is called.
      * @example
      * // Wait for a primitive to become ready before accessing attributes
-     * const removeListener = scene.postRender.addEventListener(() => {
-     *   if (!frustumPrimitive.ready) {
-     *     return;
-     *   }
-     *
-     *   const attributes = primitive.getGeometryInstanceAttributes('an id');
-     *   attributes.color = Cesium.ColorGeometryInstanceAttribute.toValue(Cesium.Color.AQUA);
-     *
-     *   removeListener();
-     * });
+    const removeListener = scene.postRender.addEventListener(() => {
+      if (!frustumPrimitive.ready) {
+        return;
+      }
+    
+      const attributes = primitive.getGeometryInstanceAttributes('an id');
+      attributes.color = Cesium.ColorGeometryInstanceAttribute.toValue(Cesium.Color.AQUA);
+    
+      removeListener();
+    });
      */
     readonly ready: boolean;
     /**
      * Called when {@link Viewer} or {@link CesiumWidget} render the scene to
-     * get the draw commands needed to render this primitive.
-     * <p>
-     * Do not call this function directly.  This is documented just to
-     * list the exceptions that may be propagated when the scene is rendered:
-     * </p>
+    get the draw commands needed to render this primitive.
+    <p>
+    Do not call this function directly.  This is documented just to
+    list the exceptions that may be propagated when the scene is rendered:
+    </p>
      */
     update(): void;
     /**
      * Returns the modifiable per-instance attributes for a {@link GeometryInstance}.
      * @example
      * const attributes = primitive.getGeometryInstanceAttributes('an id');
-     * attributes.color = Cesium.ColorGeometryInstanceAttribute.toValue(Cesium.Color.AQUA);
-     * attributes.show = Cesium.ShowGeometryInstanceAttribute.toValue(true);
-     * attributes.distanceDisplayCondition = Cesium.DistanceDisplayConditionGeometryInstanceAttribute.toValue(100.0, 10000.0);
-     * attributes.offset = Cesium.OffsetGeometryInstanceAttribute.toValue(Cartesian3.IDENTITY);
+    attributes.color = Cesium.ColorGeometryInstanceAttribute.toValue(Cesium.Color.AQUA);
+    attributes.show = Cesium.ShowGeometryInstanceAttribute.toValue(true);
+    attributes.distanceDisplayCondition = Cesium.DistanceDisplayConditionGeometryInstanceAttribute.toValue(100.0, 10000.0);
+    attributes.offset = Cesium.OffsetGeometryInstanceAttribute.toValue(Cartesian3.IDENTITY);
      * @param id - The id of the {@link GeometryInstance}.
      * @returns The typed array in the attribute's format or undefined if the is no instance with id.
      */
     getGeometryInstanceAttributes(id: any): any;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-     * <p>
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
-     * </p>
+    <p>
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+    </p>
      * @returns <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
      */
     isDestroyed(): boolean;
     /**
      * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
-     * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
-     * <p>
-     * Once an object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
-     * </p>
+    release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+    <p>
+    Once an object is destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+    assign the return value (<code>undefined</code>) to the object as done in the example.
+    </p>
      * @example
      * e = e && e.destroy();
      */
@@ -41077,15 +41114,15 @@ export class PrimitiveCollection {
 
 /**
  * The container for all 3D graphical objects and state in a Cesium virtual scene.  Generally,
- * a scene is not created directly; instead, it is implicitly created by {@link CesiumWidget}.
+a scene is not created directly; instead, it is implicitly created by {@link CesiumWidget}.
  * @example
  * // Create scene without anisotropic texture filtering
- * const scene = new Cesium.Scene({
- *   canvas : canvas,
- *   contextOptions : {
- *     allowTextureFilterAnisotropic : false
- *   }
- * });
+const scene = new Cesium.Scene({
+  canvas : canvas,
+  contextOptions : {
+    allowTextureFilterAnisotropic : false
+  }
+});
  * @param options - Object with the following properties:
  * @param options.canvas - The HTML canvas element to create the scene for.
  * @param [options.contextOptions] - Context and WebGL creation properties.
@@ -41121,14 +41158,14 @@ export class Scene {
     });
     /**
      * Exceptions occurring in <code>render</code> are always caught in order to raise the
-     * <code>renderError</code> event.  If this property is true, the error is rethrown
-     * after the event is raised.  If this property is false, the <code>render</code> function
-     * returns normally after raising the event.
+    <code>renderError</code> event.  If this property is true, the error is rethrown
+    after the event is raised.  If this property is false, the <code>render</code> function
+    returns normally after raising the event.
      */
     rethrowRenderErrors: boolean;
     /**
      * Determines whether or not to instantly complete the
-     * scene transition animation on user input.
+    scene transition animation on user input.
      */
     completeMorphOnUserInput: boolean;
     /**
@@ -41165,106 +41202,106 @@ export class Scene {
     backgroundColor: Color;
     /**
      * The current morph transition time between 2D/Columbus View and 3D,
-     * with 0.0 being 2D or Columbus View and 1.0 being 3D.
+    with 0.0 being 2D or Columbus View and 1.0 being 3D.
      */
     morphTime: number;
     /**
      * The far-to-near ratio of the multi-frustum when using a normal depth buffer.
-     * <p>
-     * This value is used to create the near and far values for each frustum of the multi-frustum. It is only used
-     * when {@link Scene#logarithmicDepthBuffer} is <code>false</code>. When <code>logarithmicDepthBuffer</code> is
-     * <code>true</code>, use {@link Scene#logarithmicDepthFarToNearRatio}.
-     * </p>
+    <p>
+    This value is used to create the near and far values for each frustum of the multi-frustum. It is only used
+    when {@link Scene#logarithmicDepthBuffer} is <code>false</code>. When <code>logarithmicDepthBuffer</code> is
+    <code>true</code>, use {@link Scene#logarithmicDepthFarToNearRatio}.
+    </p>
      */
     farToNearRatio: number;
     /**
      * The far-to-near ratio of the multi-frustum when using a logarithmic depth buffer.
-     * <p>
-     * This value is used to create the near and far values for each frustum of the multi-frustum. It is only used
-     * when {@link Scene#logarithmicDepthBuffer} is <code>true</code>. When <code>logarithmicDepthBuffer</code> is
-     * <code>false</code>, use {@link Scene#farToNearRatio}.
-     * </p>
+    <p>
+    This value is used to create the near and far values for each frustum of the multi-frustum. It is only used
+    when {@link Scene#logarithmicDepthBuffer} is <code>true</code>. When <code>logarithmicDepthBuffer</code> is
+    <code>false</code>, use {@link Scene#farToNearRatio}.
+    </p>
      */
     logarithmicDepthFarToNearRatio: number;
     /**
      * Determines the uniform depth size in meters of each frustum of the multifrustum in 2D. If a primitive or model close
-     * to the surface shows z-fighting, decreasing this will eliminate the artifact, but decrease performance. On the
-     * other hand, increasing this will increase performance but may cause z-fighting among primitives close to the surface.
+    to the surface shows z-fighting, decreasing this will eliminate the artifact, but decrease performance. On the
+    other hand, increasing this will increase performance but may cause z-fighting among primitives close to the surface.
      */
     nearToFarDistance2D: number;
     /**
      * The vertical exaggeration of the scene.
-     * When set to 1.0, no exaggeration is applied.
+    When set to 1.0, no exaggeration is applied.
      */
     verticalExaggeration: number;
     /**
      * The reference height for vertical exaggeration of the scene.
-     * When set to 0.0, the exaggeration is applied relative to the ellipsoid surface.
+    When set to 0.0, the exaggeration is applied relative to the ellipsoid surface.
      */
     verticalExaggerationRelativeHeight: number;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * A function that determines what commands are executed.  As shown in the examples below,
-     * the function receives the command's <code>owner</code> as an argument, and returns a boolean indicating if the
-     * command should be executed.
-     * </p>
-     * <p>
-     * The default is <code>undefined</code>, indicating that all commands are executed.
-     * </p>
+    <p>
+    A function that determines what commands are executed.  As shown in the examples below,
+    the function receives the command's <code>owner</code> as an argument, and returns a boolean indicating if the
+    command should be executed.
+    </p>
+    <p>
+    The default is <code>undefined</code>, indicating that all commands are executed.
+    </p>
      * @example
      * // Do not execute any commands.
-     * scene.debugCommandFilter = function(command) {
-     *     return false;
-     * };
-     *
-     * // Execute only the billboard's commands.  That is, only draw the billboard.
-     * const billboards = new Cesium.BillboardCollection();
-     * scene.debugCommandFilter = function(command) {
-     *     return command.owner === billboards;
-     * };
+    scene.debugCommandFilter = function(command) {
+        return false;
+    };
+    
+    // Execute only the billboard's commands.  That is, only draw the billboard.
+    const billboards = new Cesium.BillboardCollection();
+    scene.debugCommandFilter = function(command) {
+        return command.owner === billboards;
+    };
      */
     debugCommandFilter: (...params: any[]) => any;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * When <code>true</code>, commands are randomly shaded.  This is useful
-     * for performance analysis to see what parts of a scene or model are
-     * command-dense and could benefit from batching.
-     * </p>
+    <p>
+    When <code>true</code>, commands are randomly shaded.  This is useful
+    for performance analysis to see what parts of a scene or model are
+    command-dense and could benefit from batching.
+    </p>
      */
     debugShowCommands: boolean;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * When <code>true</code>, commands are shaded based on the frustums they
-     * overlap.  Commands in the closest frustum are tinted red, commands in
-     * the next closest are green, and commands in the farthest frustum are
-     * blue.  If a command overlaps more than one frustum, the color components
-     * are combined, e.g., a command overlapping the first two frustums is tinted
-     * yellow.
-     * </p>
+    <p>
+    When <code>true</code>, commands are shaded based on the frustums they
+    overlap.  Commands in the closest frustum are tinted red, commands in
+    the next closest are green, and commands in the farthest frustum are
+    blue.  If a command overlaps more than one frustum, the color components
+    are combined, e.g., a command overlapping the first two frustums is tinted
+    yellow.
+    </p>
      */
     debugShowFrustums: boolean;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * Displays frames per second and time between frames.
-     * </p>
+    <p>
+    Displays frames per second and time between frames.
+    </p>
      */
     debugShowFramesPerSecond: boolean;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * Indicates which frustum will have depth information displayed.
-     * </p>
+    <p>
+    Indicates which frustum will have depth information displayed.
+    </p>
      */
     debugShowDepthFrustum: number;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * When <code>true</code>, draws outlines to show the boundaries of the camera frustums
-     * </p>
+    <p>
+    When <code>true</code>, draws outlines to show the boundaries of the camera frustums
+    </p>
      */
     debugShowFrustumPlanes: boolean;
     /**
@@ -41273,33 +41310,33 @@ export class Scene {
     useDepthPicking: boolean;
     /**
      * When <code>true</code>, enables picking translucent geometry using the depth buffer. Note that {@link Scene#useDepthPicking} must also be true for enabling this to work.
-     *
-     * <p>
-     * There is a decrease in performance when enabled. There are extra draw calls to write depth for
-     * translucent geometry.
-     * </p>
+    
+    <p>
+    There is a decrease in performance when enabled. There are extra draw calls to write depth for
+    translucent geometry.
+    </p>
      * @example
      * // picking the position of a translucent primitive
-     * viewer.screenSpaceEventHandler.setInputAction(function onLeftClick(movement) {
-     *      const pickedFeature = viewer.scene.pick(movement.position);
-     *      if (!Cesium.defined(pickedFeature)) {
-     *          // nothing picked
-     *          return;
-     *      }
-     *      const worldPosition = viewer.scene.pickPosition(movement.position);
-     * }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+    viewer.screenSpaceEventHandler.setInputAction(function onLeftClick(movement) {
+         const pickedFeature = viewer.scene.pick(movement.position);
+         if (!Cesium.defined(pickedFeature)) {
+             // nothing picked
+             return;
+         }
+         const worldPosition = viewer.scene.pickPosition(movement.position);
+    }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
      */
     pickTranslucentDepth: boolean;
     /**
      * Settings for atmosphere lighting effects affecting 3D Tiles and model rendering. This is not to be confused with
-     * {@link Scene#skyAtmosphere} which is responsible for rendering the sky.
+    {@link Scene#skyAtmosphere} which is responsible for rendering the sky.
      */
     atmosphere: Atmosphere;
     /**
      * Blends the atmosphere to geometry far from the camera for horizon views. Allows for additional
-     * performance improvements by rendering less geometry and dispatching less terrain requests.
-     *
-     * Disbaled by default if an ellipsoid other than WGS84 is used.
+    performance improvements by rendering less geometry and dispatching less terrain requests.
+    
+    Disbaled by default if an ellipsoid other than WGS84 is used.
      */
     fog: Fog;
     /**
@@ -41308,13 +41345,13 @@ export class Scene {
     shadowMap: ShadowMap;
     /**
      * When <code>false</code>, 3D Tiles will render normally. When <code>true</code>, classified 3D Tile geometry will render normally and
-     * unclassified 3D Tile geometry will render with the color multiplied by {@link Scene#invertClassificationColor}.
+    unclassified 3D Tile geometry will render with the color multiplied by {@link Scene#invertClassificationColor}.
      */
     invertClassification: boolean;
     /**
      * The highlight color of unclassified 3D Tile geometry when {@link Scene#invertClassification} is <code>true</code>.
-     * <p>When the color's alpha is less than 1.0, the unclassified portions of the 3D Tiles will not blend correctly with the classified positions of the 3D Tiles.</p>
-     * <p>Also, when the color's alpha is less than 1.0, the WEBGL_depth_texture and EXT_frag_depth WebGL extensions must be supported.</p>
+    <p>When the color's alpha is less than 1.0, the unclassified portions of the 3D Tiles will not blend correctly with the classified positions of the 3D Tiles.</p>
+    <p>Also, when the color's alpha is less than 1.0, the WEBGL_depth_texture and EXT_frag_depth WebGL extensions must be supported.</p>
      */
     invertClassificationColor: Color;
     /**
@@ -41331,18 +41368,18 @@ export class Scene {
     postProcessStages: PostProcessStageCollection;
     /**
      * When <code>true</code>, rendering a frame will only occur when needed as determined by changes within the scene.
-     * Enabling improves performance of the application, but requires using {@link Scene#requestRender}
-     * to render a new frame explicitly in this mode. This will be necessary in many cases after making changes
-     * to the scene in other parts of the API.
+    Enabling improves performance of the application, but requires using {@link Scene#requestRender}
+    to render a new frame explicitly in this mode. This will be necessary in many cases after making changes
+    to the scene in other parts of the API.
      */
     requestRenderMode: boolean;
     /**
      * If {@link Scene#requestRenderMode} is <code>true</code>, this value defines the maximum change in
-     * simulation time allowed before a render is requested. Lower values increase the number of frames rendered
-     * and higher values decrease the number of frames rendered. If <code>undefined</code>, changes to
-     * the simulation time will never request a render.
-     * This value impacts the rate of rendering for changes in the scene like lighting, entity property updates,
-     * and animations.
+    simulation time allowed before a render is requested. Lower values increase the number of frames rendered
+    and higher values decrease the number of frames rendered. If <code>undefined</code>, changes to
+    the simulation time will never request a render.
+    This value impacts the rate of rendering for changes in the scene like lighting, entity property updates,
+    and animations.
      */
     maximumRenderTimeChange: number;
     /**
@@ -41359,7 +41396,7 @@ export class Scene {
     light: Light;
     /**
      * Use this to set the default value for {@link Scene#logarithmicDepthBuffer} in newly constructed Scenes
-     * This property relies on fragmentDepth being supported.
+    This property relies on fragmentDepth being supported.
      */
     static defaultLogDepthBuffer: any;
     /**
@@ -41444,48 +41481,48 @@ export class Scene {
     readonly terrainProviderChanged: Event;
     /**
      * Gets the event that will be raised before the scene is updated or rendered.  Subscribers to the event
-     * receive the Scene instance as the first parameter and the current time as the second parameter.
+    receive the Scene instance as the first parameter and the current time as the second parameter.
      */
     readonly preUpdate: Event;
     /**
      * Gets the event that will be raised immediately after the scene is updated and before the scene is rendered.
-     * Subscribers to the event receive the Scene instance as the first parameter and the current time as the second
-     * parameter.
+    Subscribers to the event receive the Scene instance as the first parameter and the current time as the second
+    parameter.
      */
     readonly postUpdate: Event;
     /**
      * Gets the event that will be raised when an error is thrown inside the <code>render</code> function.
-     * The Scene instance and the thrown error are the only two parameters passed to the event handler.
-     * By default, errors are not rethrown after this event is raised, but that can be changed by setting
-     * the <code>rethrowRenderErrors</code> property.
+    The Scene instance and the thrown error are the only two parameters passed to the event handler.
+    By default, errors are not rethrown after this event is raised, but that can be changed by setting
+    the <code>rethrowRenderErrors</code> property.
      */
     readonly renderError: Event;
     /**
      * Gets the event that will be raised after the scene is updated and immediately before the scene is rendered.
-     * Subscribers to the event receive the Scene instance as the first parameter and the current time as the second
-     * parameter.
+    Subscribers to the event receive the Scene instance as the first parameter and the current time as the second
+    parameter.
      */
     readonly preRender: Event;
     /**
      * Gets the event that will be raised immediately after the scene is rendered.  Subscribers to the event
-     * receive the Scene instance as the first parameter and the current time as the second parameter.
+    receive the Scene instance as the first parameter and the current time as the second parameter.
      */
     readonly postRender: Event;
     /**
      * Gets the simulation time when the scene was last rendered. Returns undefined if the scene has not yet been
-     * rendered.
+    rendered.
      */
     readonly lastRenderTime: JulianDate;
     /**
      * This property is for debugging only; it is not for production use.
-     * <p>
-     * When {@link Scene.debugShowFrustums} is <code>true</code>, this contains
-     * properties with statistics about the number of command execute per frustum.
-     * <code>totalCommands</code> is the total number of commands executed, ignoring
-     * overlap. <code>commandsInFrustums</code> is an array with the number of times
-     * commands are executed redundantly, e.g., how many commands overlap two or
-     * three frustums.
-     * </p>
+    <p>
+    When {@link Scene.debugShowFrustums} is <code>true</code>, this contains
+    properties with statistics about the number of command execute per frustum.
+    <code>totalCommands</code> is the total number of commands executed, ignoring
+    overlap. <code>commandsInFrustums</code> is an array with the number of times
+    commands are executed redundantly, e.g., how many commands overlap two or
+    three frustums.
+    </p>
      */
     readonly debugFrustumStatistics: any;
     /**
@@ -41494,8 +41531,8 @@ export class Scene {
     readonly scene3DOnly: boolean;
     /**
      * Gets whether or not the scene has order independent translucency enabled.
-     * Note that this only reflects the original construction option, and there are
-     * other factors that could prevent OIT from functioning on a given system configuration.
+    Note that this only reflects the original construction option, and there are
+    other factors that could prevent OIT from functioning on a given system configuration.
      */
     readonly orderIndependentTranslucency: boolean;
     /**
@@ -41508,7 +41545,7 @@ export class Scene {
     mode: SceneMode;
     /**
      * When <code>true</code>, splits the scene into two viewports with steroscopic views for the left and right eyes.
-     * Used for cardboard and WebVR.
+    Used for cardboard and WebVR.
      */
     useWebVR: boolean;
     /**
@@ -41521,14 +41558,14 @@ export class Scene {
     splitPosition: number;
     /**
      * The distance from the camera at which to disable the depth test of billboards, labels and points
-     * to, for example, prevent clipping against terrain. When set to zero, the depth test should always
-     * be applied. When less than zero, the depth test should never be applied. Setting the disableDepthTestDistance
-     * property of a billboard, label or point will override this value.
+    to, for example, prevent clipping against terrain. When set to zero, the depth test should always
+    be applied. When less than zero, the depth test should never be applied. Setting the disableDepthTestDistance
+    property of a billboard, label or point will override this value.
      */
     minimumDisableDepthTestDistance: number;
     /**
      * Whether or not to use a logarithmic depth buffer. Enabling this option will allow for less frustums in the multi-frustum,
-     * increasing performance. This property relies on fragmentDepth being supported.
+    increasing performance. This property relies on fragmentDepth being supported.
      */
     logarithmicDepthBuffer: boolean;
     /**
@@ -41563,30 +41600,30 @@ export class Scene {
     getCompressedTextureFormatSupported(format: string): boolean;
     /**
      * Update and render the scene. It is usually not necessary to call this function
-     * directly because {@link CesiumWidget} will do it automatically.
+    directly because {@link CesiumWidget} will do it automatically.
      * @param [time] - The simulation time at which to render.
      */
     render(time?: JulianDate): void;
     /**
      * Requests a new rendered frame when {@link Scene#requestRenderMode} is set to <code>true</code>.
-     * The render rate will not exceed the {@link CesiumWidget#targetFrameRate}.
+    The render rate will not exceed the {@link CesiumWidget#targetFrameRate}.
      */
     requestRender(): void;
     /**
      * Returns an object with a `primitive` property that contains the first (top) primitive in the scene
-     * at a particular window coordinate or undefined if nothing is at the location. Other properties may
-     * potentially be set depending on the type of primitive and may be used to further identify the picked object.
-     * <p>
-     * When a feature of a 3D Tiles tileset is picked, <code>pick</code> returns a {@link Cesium3DTileFeature} object.
-     * </p>
+    at a particular window coordinate or undefined if nothing is at the location. Other properties may
+    potentially be set depending on the type of primitive and may be used to further identify the picked object.
+    <p>
+    When a feature of a 3D Tiles tileset is picked, <code>pick</code> returns a {@link Cesium3DTileFeature} object.
+    </p>
      * @example
      * // On mouse over, color the feature yellow.
-     * handler.setInputAction(function(movement) {
-     *     const feature = scene.pick(movement.endPosition);
-     *     if (feature instanceof Cesium.Cesium3DTileFeature) {
-     *         feature.color = Cesium.Color.YELLOW;
-     *     }
-     * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+    handler.setInputAction(function(movement) {
+        const feature = scene.pick(movement.endPosition);
+        if (feature instanceof Cesium.Cesium3DTileFeature) {
+            feature.color = Cesium.Color.YELLOW;
+        }
+    }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
      * @param windowPosition - Window coordinates to perform picking on.
      * @param [width = 3] - Width of the pick rectangle.
      * @param [height = 3] - Height of the pick rectangle.
@@ -41595,15 +41632,15 @@ export class Scene {
     pick(windowPosition: Cartesian2, width?: number, height?: number): any;
     /**
      * Returns a {@link VoxelCell} for the voxel sample rendered at a particular window coordinate,
-     * or undefined if no voxel is rendered at that position.
+    or undefined if no voxel is rendered at that position.
      * @example
      * On left click, report the value of the "color" property at that voxel sample.
-     * handler.setInputAction(function(movement) {
-     *   const voxelCell = scene.pickVoxel(movement.position);
-     *   if (defined(voxelCell)) {
-     *     console.log(voxelCell.getProperty("color"));
-     *   }
-     * }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+    handler.setInputAction(function(movement) {
+      const voxelCell = scene.pickVoxel(movement.position);
+      if (defined(voxelCell)) {
+        console.log(voxelCell.getProperty("color"));
+      }
+    }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
      * @param windowPosition - Window coordinates to perform picking on.
      * @param [width = 3] - Width of the pick rectangle.
      * @param [height = 3] - Height of the pick rectangle.
@@ -41614,34 +41651,34 @@ export class Scene {
      * Pick a metadata value at the given window position.
      * @param windowPosition - Window coordinates to perform picking on.
      * @param schemaId - The ID of the metadata schema to pick values
-     * from. If this is `undefined`, then it will pick the values from the object
-     * that match the given class- and property name, regardless of the schema ID.
+    from. If this is `undefined`, then it will pick the values from the object
+    that match the given class- and property name, regardless of the schema ID.
      * @param className - The name of the metadata class to pick
-     * values from
+    values from
      * @param propertyName - The name of the metadata property to pick
-     * values from
+    values from
      * @returns The metadata value, or `undefined` when
-     * no matching metadata was found at the given position
+    no matching metadata was found at the given position
      */
     pickMetadata(windowPosition: Cartesian2, schemaId: string | undefined, className: string, propertyName: string): MetadataValue | undefined;
     /**
      * Pick the schema of the metadata of the object at the given position
      * @param windowPosition - Window coordinates to perform picking on.
      * @returns The metadata schema, or `undefined` if there is no object with
-     * associated metadata at the given position.
+    associated metadata at the given position.
      */
     pickMetadataSchema(windowPosition: Cartesian2): MetadataSchema;
     /**
      * Returns the cartesian position reconstructed from the depth buffer and window position.
-     * <p>
-     * The position reconstructed from the depth buffer in 2D may be slightly different from those
-     * reconstructed in 3D and Columbus view. This is caused by the difference in the distribution
-     * of depth values of perspective and orthographic projection.
-     * </p>
-     * <p>
-     * Set {@link Scene#pickTranslucentDepth} to <code>true</code> to include the depth of
-     * translucent primitives; otherwise, this essentially picks through translucent primitives.
-     * </p>
+    <p>
+    The position reconstructed from the depth buffer in 2D may be slightly different from those
+    reconstructed in 3D and Columbus view. This is caused by the difference in the distribution
+    of depth values of perspective and orthographic projection.
+    </p>
+    <p>
+    Set {@link Scene#pickTranslucentDepth} to <code>true</code> to include the depth of
+    translucent primitives; otherwise, this essentially picks through translucent primitives.
+    </p>
      * @param windowPosition - Window coordinates to perform picking on.
      * @param [result] - The object on which to restore the result.
      * @returns The cartesian position.
@@ -41649,9 +41686,9 @@ export class Scene {
     pickPosition(windowPosition: Cartesian2, result?: Cartesian3): Cartesian3;
     /**
      * Returns a list of objects, each containing a `primitive` property, for all primitives at
-     * a particular window coordinate position. Other properties may also be set depending on the
-     * type of primitive and may be used to further identify the picked object. The primitives in
-     * the list are ordered by their visual order in the scene (front to back).
+    a particular window coordinate position. Other properties may also be set depending on the
+    type of primitive and may be used to further identify the picked object. The primitives in
+    the list are ordered by their visual order in the scene (front to back).
      * @example
      * const pickedObjects = scene.drillPick(new Cesium.Cartesian2(100.0, 200.0));
      * @param windowPosition - Window coordinates to perform picking on.
@@ -41663,16 +41700,16 @@ export class Scene {
     drillPick(windowPosition: Cartesian2, limit?: number, width?: number, height?: number): any[];
     /**
      * Returns the height of scene geometry at the given cartographic position or <code>undefined</code> if there was no
-     * scene geometry to sample height from. The height of the input position is ignored. May be used to clamp objects to
-     * the globe, 3D Tiles, or primitives in the scene.
-     * <p>
-     * This function only samples height from globe tiles and 3D Tiles that are rendered in the current view. Samples height
-     * from all other primitives regardless of their visibility.
-     * </p>
+    scene geometry to sample height from. The height of the input position is ignored. May be used to clamp objects to
+    the globe, 3D Tiles, or primitives in the scene.
+    <p>
+    This function only samples height from globe tiles and 3D Tiles that are rendered in the current view. Samples height
+    from all other primitives regardless of their visibility.
+    </p>
      * @example
      * const position = new Cesium.Cartographic(-1.31968, 0.698874);
-     * const height = viewer.scene.sampleHeight(position);
-     * console.log(height);
+    const height = viewer.scene.sampleHeight(position);
+    console.log(height);
      * @param position - The cartographic position to sample height from.
      * @param [objectsToExclude] - A list of primitives, entities, or 3D Tiles features to not sample height from.
      * @param [width = 0.1] - Width of the intersection volume in meters.
@@ -41681,16 +41718,16 @@ export class Scene {
     sampleHeight(position: Cartographic, objectsToExclude?: object[], width?: number): number;
     /**
      * Clamps the given cartesian position to the scene geometry along the geodetic surface normal. Returns the
-     * clamped position or <code>undefined</code> if there was no scene geometry to clamp to. May be used to clamp
-     * objects to the globe, 3D Tiles, or primitives in the scene.
-     * <p>
-     * This function only clamps to globe tiles and 3D Tiles that are rendered in the current view. Clamps to
-     * all other primitives regardless of their visibility.
-     * </p>
+    clamped position or <code>undefined</code> if there was no scene geometry to clamp to. May be used to clamp
+    objects to the globe, 3D Tiles, or primitives in the scene.
+    <p>
+    This function only clamps to globe tiles and 3D Tiles that are rendered in the current view. Clamps to
+    all other primitives regardless of their visibility.
+    </p>
      * @example
      * // Clamp an entity to the underlying scene geometry
-     * const position = entity.position.getValue(Cesium.JulianDate.now());
-     * entity.position = viewer.scene.clampToHeight(position);
+    const position = entity.position.getValue(Cesium.JulianDate.now());
+    entity.position = viewer.scene.clampToHeight(position);
      * @param cartesian - The cartesian position.
      * @param [objectsToExclude] - A list of primitives, entities, or 3D Tiles features to not clamp to.
      * @param [width = 0.1] - Width of the intersection volume in meters.
@@ -41700,20 +41737,20 @@ export class Scene {
     clampToHeight(cartesian: Cartesian3, objectsToExclude?: object[], width?: number, result?: Cartesian3): Cartesian3;
     /**
      * Initiates an asynchronous {@link Scene#sampleHeight} query for an array of {@link Cartographic} positions
-     * using the maximum level of detail for 3D Tilesets in the scene. The height of the input positions is ignored.
-     * Returns a promise that is resolved when the query completes. Each point height is modified in place.
-     * If a height cannot be determined because no geometry can be sampled at that location, or another error occurs,
-     * the height is set to undefined.
+    using the maximum level of detail for 3D Tilesets in the scene. The height of the input positions is ignored.
+    Returns a promise that is resolved when the query completes. Each point height is modified in place.
+    If a height cannot be determined because no geometry can be sampled at that location, or another error occurs,
+    the height is set to undefined.
      * @example
      * const positions = [
-     *     new Cesium.Cartographic(-1.31968, 0.69887),
-     *     new Cesium.Cartographic(-1.10489, 0.83923)
-     * ];
-     * const promise = viewer.scene.sampleHeightMostDetailed(positions);
-     * promise.then(function(updatedPosition) {
-     *     // positions[0].height and positions[1].height have been updated.
-     *     // updatedPositions is just a reference to positions.
-     * }
+        new Cesium.Cartographic(-1.31968, 0.69887),
+        new Cesium.Cartographic(-1.10489, 0.83923)
+    ];
+    const promise = viewer.scene.sampleHeightMostDetailed(positions);
+    promise.then(function(updatedPosition) {
+        // positions[0].height and positions[1].height have been updated.
+        // updatedPositions is just a reference to positions.
+    }
      * @param positions - The cartographic positions to update with sampled heights.
      * @param [objectsToExclude] - A list of primitives, entities, or 3D Tiles features to not sample height from.
      * @param [width = 0.1] - Width of the intersection volume in meters.
@@ -41722,19 +41759,19 @@ export class Scene {
     sampleHeightMostDetailed(positions: Cartographic[], objectsToExclude?: object[], width?: number): Promise<Cartographic[]>;
     /**
      * Initiates an asynchronous {@link Scene#clampToHeight} query for an array of {@link Cartesian3} positions
-     * using the maximum level of detail for 3D Tilesets in the scene. Returns a promise that is resolved when
-     * the query completes. Each position is modified in place. If a position cannot be clamped because no geometry
-     * can be sampled at that location, or another error occurs, the element in the array is set to undefined.
+    using the maximum level of detail for 3D Tilesets in the scene. Returns a promise that is resolved when
+    the query completes. Each position is modified in place. If a position cannot be clamped because no geometry
+    can be sampled at that location, or another error occurs, the element in the array is set to undefined.
      * @example
      * const cartesians = [
-     *     entities[0].position.getValue(Cesium.JulianDate.now()),
-     *     entities[1].position.getValue(Cesium.JulianDate.now())
-     * ];
-     * const promise = viewer.scene.clampToHeightMostDetailed(cartesians);
-     * promise.then(function(updatedCartesians) {
-     *     entities[0].position = updatedCartesians[0];
-     *     entities[1].position = updatedCartesians[1];
-     * }
+        entities[0].position.getValue(Cesium.JulianDate.now()),
+        entities[1].position.getValue(Cesium.JulianDate.now())
+    ];
+    const promise = viewer.scene.clampToHeightMostDetailed(cartesians);
+    promise.then(function(updatedCartesians) {
+        entities[0].position = updatedCartesians[0];
+        entities[1].position = updatedCartesians[1];
+    }
      * @param cartesians - The cartesian positions to update with clamped positions.
      * @param [objectsToExclude] - A list of primitives, entities, or 3D Tiles features to not clamp to.
      * @param [width = 0.1] - Width of the intersection volume in meters.
@@ -41743,15 +41780,15 @@ export class Scene {
     clampToHeightMostDetailed(cartesians: Cartesian3[], objectsToExclude?: object[], width?: number): Promise<Cartesian3[]>;
     /**
      * Transforms a position in cartesian coordinates to canvas coordinates.  This is commonly used to place an
-     * HTML element at the same screen position as an object in the scene.
+    HTML element at the same screen position as an object in the scene.
      * @example
      * // Output the canvas position of longitude/latitude (0, 0) every time the mouse moves.
-     * const scene = widget.scene;
-     * const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
-     * const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
-     * handler.setInputAction(function(movement) {
-     *     console.log(scene.cartesianToCanvasCoordinates(position));
-     * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+    const scene = widget.scene;
+    const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
+    const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
+    handler.setInputAction(function(movement) {
+        console.log(scene.cartesianToCanvasCoordinates(position));
+    }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
      * @param position - The position in cartesian coordinates.
      * @param [result] - An optional object to return the input position transformed to canvas coordinates.
      * @returns The modified result parameter or a new Cartesian2 instance if one was not provided.  This may be <code>undefined</code> if the input position is near the center of the ellipsoid.
@@ -41780,34 +41817,34 @@ export class Scene {
      * Update the terrain providing surface geometry for the globe.
      * @example
      * // Use Cesium World Terrain
-     * scene.setTerrain(Cesium.Terrain.fromWorldTerrain());
+    scene.setTerrain(Cesium.Terrain.fromWorldTerrain());
      * @example
      * // Use a custom terrain provider
-     * const terrain = new Cesium.Terrain(Cesium.CesiumTerrainProvider.fromUrl("https://myTestTerrain.com"));
-     * scene.setTerrain(terrain);
-     *
-     * terrain.errorEvent.addEventListener(error => {
-     *   alert(`Encountered an error while creating terrain! ${error}`);
-     * });
+    const terrain = new Cesium.Terrain(Cesium.CesiumTerrainProvider.fromUrl("https://myTestTerrain.com"));
+    scene.setTerrain(terrain);
+    
+    terrain.errorEvent.addEventListener(error => {
+      alert(`Encountered an error while creating terrain! ${error}`);
+    });
      * @param terrain - The terrain provider async helper
      * @returns terrain The terrain provider async helper
      */
     setTerrain(terrain: Terrain): Terrain;
     /**
      * Returns true if this object was destroyed; otherwise, false.
-     * <br /><br />
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+    <br /><br />
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
      * @returns <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
      */
     isDestroyed(): boolean;
     /**
      * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
-     * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
-     * <br /><br />
-     * Once an object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
+    release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+    <br /><br />
+    Once an object is destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+    assign the return value (<code>undefined</code>) to the object as done in the example.
      * @example
      * scene = scene && scene.destroy();
      */
@@ -41816,11 +41853,11 @@ export class Scene {
 
 /**
  * Determine how translucent surfaces will be handled.
- *
- * When OIT is enabled, then this will delegate to OIT.executeCommands.
- * Otherwise, it will just be executeTranslucentCommandsBackToFront
- * for render passes, or executeTranslucentCommandsFrontToBack for
- * other passes.
+
+When OIT is enabled, then this will delegate to OIT.executeCommands.
+Otherwise, it will just be executeTranslucentCommandsBackToFront
+for render passes, or executeTranslucentCommandsFrontToBack for
+other passes.
  * @param scene - The scene.
  * @returns A function to execute translucent commands.
  */
@@ -42081,13 +42118,13 @@ export enum SensorVolumePortionToDisplay {
 
 /**
  * <div class="notice">
- * Use {@link Viewer#shadowMap} to get the scene's shadow map. Do not construct this directly.
- * </div>
- *
- * <p>
- * The normalOffset bias pushes the shadows forward slightly, and may be disabled
- * for applications that require ultra precise shadows.
- * </p>
+Use {@link Viewer#shadowMap} to get the scene's shadow map. Do not construct this directly.
+</div>
+
+<p>
+The normalOffset bias pushes the shadows forward slightly, and may be disabled
+for applications that require ultra precise shadows.
+</p>
  */
 export class ShadowMap {
     constructor();
@@ -43961,31 +43998,31 @@ export namespace WebMapServiceImageryProvider {
      * @property [parameters = WebMapServiceImageryProvider.DefaultParameters] - Additional parameters to pass to the WMS server in the GetMap URL.
      * @property [getFeatureInfoParameters = WebMapServiceImageryProvider.GetFeatureInfoDefaultParameters] - Additional parameters to pass to the WMS server in the GetFeatureInfo URL.
      * @property [enablePickFeatures = true] - If true, {@link WebMapServiceImageryProvider#pickFeatures} will invoke
-     *        the GetFeatureInfo operation on the WMS server and return the features included in the response.  If false,
-     *        {@link WebMapServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable features)
-     *        without communicating with the server.  Set this property to false if you know your WMS server does not support
-     *        GetFeatureInfo or if you don't want this provider's features to be pickable. Note that this can be dynamically
-     *        overridden by modifying the WebMapServiceImageryProvider#enablePickFeatures property.
+           the GetFeatureInfo operation on the WMS server and return the features included in the response.  If false,
+           {@link WebMapServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable features)
+           without communicating with the server.  Set this property to false if you know your WMS server does not support
+           GetFeatureInfo or if you don't want this provider's features to be pickable. Note that this can be dynamically
+           overridden by modifying the WebMapServiceImageryProvider#enablePickFeatures property.
      * @property [getFeatureInfoFormats = WebMapServiceImageryProvider.DefaultGetFeatureInfoFormats] - The formats
-     *        in which to try WMS GetFeatureInfo requests.
+           in which to try WMS GetFeatureInfo requests.
      * @property [rectangle = Rectangle.MAX_VALUE] - The rectangle of the layer.
      * @property [tilingScheme = new GeographicTilingScheme()] - The tiling scheme to use to divide the world into tiles.
      * @property [ellipsoid] - The ellipsoid.  If the tilingScheme is specified,
-     *        this parameter is ignored and the tiling scheme's ellipsoid is used instead. If neither
-     *        parameter is specified, the WGS84 ellipsoid is used.
+           this parameter is ignored and the tiling scheme's ellipsoid is used instead. If neither
+           parameter is specified, the WGS84 ellipsoid is used.
      * @property [tileWidth = 256] - The width of each tile in pixels.
      * @property [tileHeight = 256] - The height of each tile in pixels.
      * @property [minimumLevel = 0] - The minimum level-of-detail supported by the imagery provider.  Take care when
-     *        specifying this that the number of tiles at the minimum level is small, such as four or less.  A larger number is
-     *        likely to result in rendering problems.
+           specifying this that the number of tiles at the minimum level is small, such as four or less.  A larger number is
+           likely to result in rendering problems.
      * @property [maximumLevel] - The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit.
-     *        If not specified, there is no limit.
+           If not specified, there is no limit.
      * @property [crs] - CRS specification, for use with WMS specification >= 1.3.0.
      * @property [srs] - SRS specification, for use with WMS specification 1.1.0 or 1.1.1
      * @property [credit] - A credit for the data source, which is displayed on the canvas.
      * @property [subdomains = 'abc'] - The subdomains to use for the <code>{s}</code> placeholder in the URL template.
-     *                          If this parameter is a single string, each character in the string is a subdomain.  If it is
-     *                          an array, each element in the array is a subdomain.
+                             If this parameter is a single string, each character in the string is a subdomain.  If it is
+                             an array, each element in the array is a subdomain.
      * @property [clock] - A Clock instance that is used when determining the value for the time dimension. Required when `times` is specified.
      * @property [times] - TimeIntervalCollection with its data property being an object containing time dynamic dimension and their values.
      * @property [getFeatureInfoUrl] - The getFeatureInfo URL of the WMS service. If the property is not defined then we use the property value of url.
@@ -44018,12 +44055,12 @@ export namespace WebMapServiceImageryProvider {
  * Provides tiled imagery hosted by a Web Map Service (WMS) server.
  * @example
  * const provider = new Cesium.WebMapServiceImageryProvider({
- *     url : 'https://sampleserver1.arcgisonline.com/ArcGIS/services/Specialty/ESRI_StatesCitiesRivers_USA/MapServer/WMSServer',
- *     layers : '0',
- *     proxy: new Cesium.DefaultProxy('/proxy/')
- * });
- * const imageryLayer = new Cesium.ImageryLayer(provider);
- * viewer.imageryLayers.add(imageryLayer);
+    url : 'https://sampleserver1.arcgisonline.com/ArcGIS/services/Specialty/ESRI_StatesCitiesRivers_USA/MapServer/WMSServer',
+    layers : '0',
+    proxy: new Cesium.DefaultProxy('/proxy/')
+});
+const imageryLayer = new Cesium.ImageryLayer(provider);
+viewer.imageryLayers.add(imageryLayer);
  * @param options - Object describing initialization options
  */
 export class WebMapServiceImageryProvider {
@@ -44066,35 +44103,35 @@ export class WebMapServiceImageryProvider {
     readonly rectangle: Rectangle;
     /**
      * Gets the tile discard policy.  If not undefined, the discard policy is responsible
-     * for filtering out "missing" tiles via its shouldDiscardImage function.  If this function
-     * returns undefined, no tiles are filtered.
+    for filtering out "missing" tiles via its shouldDiscardImage function.  If this function
+    returns undefined, no tiles are filtered.
      */
     readonly tileDiscardPolicy: TileDiscardPolicy;
     /**
      * Gets an event that is raised when the imagery provider encounters an asynchronous error.  By subscribing
-     * to the event, you will be notified of the error and can potentially recover from it.  Event listeners
-     * are passed an instance of {@link TileProviderError}.
+    to the event, you will be notified of the error and can potentially recover from it.  Event listeners
+    are passed an instance of {@link TileProviderError}.
      */
     readonly errorEvent: Event;
     /**
      * Gets the credit to display when this imagery provider is active.  Typically this is used to credit
-     * the source of the imagery.
+    the source of the imagery.
      */
     readonly credit: Credit;
     /**
      * Gets a value indicating whether or not the images provided by this imagery provider
-     * include an alpha channel.  If this property is false, an alpha channel, if present, will
-     * be ignored.  If this property is true, any images without an alpha channel will be treated
-     * as if their alpha is 1.0 everywhere.  When this property is false, memory usage
-     * and texture upload time are reduced.
+    include an alpha channel.  If this property is false, an alpha channel, if present, will
+    be ignored.  If this property is true, any images without an alpha channel will be treated
+    as if their alpha is 1.0 everywhere.  When this property is false, memory usage
+    and texture upload time are reduced.
      */
     readonly hasAlphaChannel: boolean;
     /**
      * Gets or sets a value indicating whether feature picking is enabled.  If true, {@link WebMapServiceImageryProvider#pickFeatures} will
-     * invoke the <code>GetFeatureInfo</code> service on the WMS server and attempt to interpret the features included in the response.  If false,
-     * {@link WebMapServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable
-     * features) without communicating with the server.  Set this property to false if you know your data
-     * source does not support picking features or if you don't want this provider's features to be pickable.
+    invoke the <code>GetFeatureInfo</code> service on the WMS server and attempt to interpret the features included in the response.  If false,
+    {@link WebMapServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable
+    features) without communicating with the server.  Set this property to false if you know your data
+    source does not support picking features or if you don't want this provider's features to be pickable.
      */
     enablePickFeatures: boolean;
     /**
@@ -44103,8 +44140,8 @@ export class WebMapServiceImageryProvider {
     clock: Clock;
     /**
      * Gets or sets a time interval collection that is used to get time dynamic parameters. The data of each
-     * TimeInterval is an object containing the keys and values of the properties that are used during
-     * tile requests.
+    TimeInterval is an object containing the keys and values of the properties that are used during
+    tile requests.
      */
     times: TimeIntervalCollection;
     /**
@@ -44126,36 +44163,36 @@ export class WebMapServiceImageryProvider {
      * @param level - The tile level.
      * @param [request] - The request object. Intended for internal use only.
      * @returns A promise for the image that will resolve when the image is available, or
-     *          undefined if there are too many active requests to the server, and the request should be retried later.
+             undefined if there are too many active requests to the server, and the request should be retried later.
      */
     requestImage(x: number, y: number, level: number, request?: Request): Promise<ImageryTypes> | undefined;
     /**
      * Asynchronously determines what features, if any, are located at a given longitude and latitude within
-     * a tile.
+    a tile.
      * @param x - The tile X coordinate.
      * @param y - The tile Y coordinate.
      * @param level - The tile level.
      * @param longitude - The longitude at which to pick features.
      * @param latitude - The latitude at which to pick features.
      * @returns A promise for the picked features that will resolve when the asynchronous
-     *                   picking completes.  The resolved value is an array of {@link ImageryLayerFeatureInfo}
-     *                   instances.  The array may be empty if no features are found at the given location.
+                      picking completes.  The resolved value is an array of {@link ImageryLayerFeatureInfo}
+                      instances.  The array may be empty if no features are found at the given location.
      */
     pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
     /**
      * The default parameters to include in the WMS URL to obtain images.  The values are as follows:
-     *    service=WMS
-     *    version=1.1.1
-     *    request=GetMap
-     *    styles=
-     *    format=image/jpeg
+       service=WMS
+       version=1.1.1
+       request=GetMap
+       styles=
+       format=image/jpeg
      */
     static readonly DefaultParameters: any;
     /**
      * The default parameters to include in the WMS URL to get feature information.  The values are as follows:
-     *     service=WMS
-     *     version=1.1.1
-     *     request=GetFeatureInfo
+        service=WMS
+        version=1.1.1
+        request=GetFeatureInfo
      */
     static readonly GetFeatureInfoDefaultParameters: any;
 }
@@ -44955,12 +44992,12 @@ export class BaseLayerPickerViewModel {
     });
     /**
      * Gets or sets an array of ProviderViewModel instances available for imagery selection.
-     * This property is observable.
+    This property is observable.
      */
     imageryProviderViewModels: ProviderViewModel[];
     /**
      * Gets or sets an array of ProviderViewModel instances available for terrain selection.
-     * This property is observable.
+    This property is observable.
      */
     terrainProviderViewModels: ProviderViewModel[];
     /**
@@ -45001,7 +45038,7 @@ export class BaseLayerPickerViewModel {
  * @param options.iconUrl - An icon representing the layer.
  * @param [options.category] - A category for the layer.
  * @param options.creationFunction - A function or Command
- *        that creates one or more providers which will be added to the globe when this item is selected.
+       that creates one or more providers which will be added to the globe when this item is selected.
  */
 export class ProviderViewModel {
     constructor(options: {
@@ -45025,7 +45062,7 @@ export class ProviderViewModel {
     iconUrl: string;
     /**
      * Gets the Command that creates one or more providers which will be added to
-     * the globe when this item is selected.
+    the globe when this item is selected.
      */
     readonly creationCommand: Command;
     /**