mars3d-cesium 1.92.0 → 1.92.3

package/Build/Cesium/Cesium.d.ts

@@ -8725,20 +8725,20 @@ export class IonResource extends Resource {
     clone(result?: Resource): Resource;
     /**
      * Asynchronously loads the given image resource.  Returns a promise that will resolve to
-     * an {@link https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap|ImageBitmap} if <code>preferImageBitmap</code> is true and the browser supports <code>createImageBitmap</code> or otherwise an
-     * {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement|Image} once loaded, or reject if the image failed to load.
+    an {@link https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap|ImageBitmap} if <code>preferImageBitmap</code> is true and the browser supports <code>createImageBitmap</code> or otherwise an
+    {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement|Image} once loaded, or reject if the image failed to load.
      * @example
      * // load a single image asynchronously
-     * resource.fetchImage().then(function(image) {
-     *     // use the loaded image
-     * }).catch(function(error) {
-     *     // an error occurred
-     * });
-     *
-     * // load several images in parallel
-     * Promise.all([resource1.fetchImage(), resource2.fetchImage()]).then(function(images) {
-     *     // images is an array containing all the loaded images
-     * });
+    resource.fetchImage().then(function(image) {
+        // use the loaded image
+    }).catch(function(error) {
+        // an error occurred
+    });
+    
+    // load several images in parallel
+    Promise.all([resource1.fetchImage(), resource2.fetchImage()]).then(function(images) {
+        // images is an array containing all the loaded images
+    });
      * @param [options] - An object with the following properties.
      * @param [options.preferBlob = false] - If true, we will load the image via a blob.
      * @param [options.preferImageBitmap = false] - If true, image will be decoded during fetch and an <code>ImageBitmap</code> is returned.
@@ -14750,33 +14750,33 @@ export enum RequestType {
  * A resource that includes the location and any other parameters we need to retrieve it or create derived resources. It also provides the ability to retry requests.
  * @example
  * function refreshTokenRetryCallback(resource, error) {
- *   if (error.statusCode === 403) {
- *     // 403 status code means a new token should be generated
- *     return getNewAccessToken()
- *       .then(function(token) {
- *         resource.queryParameters.access_token = token;
- *         return true;
- *       })
- *       .catch(function() {
- *         return false;
- *       });
- *   }
- *
- *   return false;
- * }
- *
- * const resource = new Resource({
- *    url: 'http://server.com/path/to/resource.json',
- *    proxy: new DefaultProxy('/proxy/'),
- *    headers: {
- *      'X-My-Header': 'valueOfHeader'
- *    },
- *    queryParameters: {
- *      'access_token': '123-435-456-000'
- *    },
- *    retryCallback: refreshTokenRetryCallback,
- *    retryAttempts: 1
- * });
+  if (error.statusCode === 403) {
+    // 403 status code means a new token should be generated
+    return getNewAccessToken()
+      .then(function(token) {
+        resource.queryParameters.access_token = token;
+        return true;
+      })
+      .catch(function() {
+        return false;
+      });
+  }
+
+  return false;
+}
+
+const resource = new Resource({
+   url: 'http://server.com/path/to/resource.json',
+   proxy: new DefaultProxy('/proxy/'),
+   headers: {
+     'X-My-Header': 'valueOfHeader'
+   },
+   queryParameters: {
+     'access_token': '123-435-456-000'
+   },
+   retryCallback: refreshTokenRetryCallback,
+   retryAttempts: 1
+});
  * @param options - A url or an object with the following properties
  * @param options.url - The url of the resource.
  * @param [options.queryParameters] - An object containing query parameters that will be sent when retrieving the resource.
@@ -14856,7 +14856,7 @@ export class Resource {
     hasHeaders: boolean;
     /**
      * Override Object#toString so that implicit string conversion gives the
-     * complete URL represented by this Resource.
+    complete URL represented by this Resource.
      * @returns The URL represented by this Resource
      */
     toString(): string;
@@ -14869,20 +14869,20 @@ export class Resource {
     getUrlComponent(query?: boolean, proxy?: boolean): string;
     /**
      * Combines the specified object and the existing query parameters. This allows you to add many parameters at once,
-     *  as opposed to adding them one at a time to the queryParameters property. If a value is already set, it will be replaced with the new value.
+     as opposed to adding them one at a time to the queryParameters property. If a value is already set, it will be replaced with the new value.
      * @param params - The query parameters
      * @param [useAsDefault = false] - If true the params will be used as the default values, so they will only be set if they are undefined.
      */
     setQueryParameters(params: any, useAsDefault?: boolean): void;
     /**
      * Combines the specified object and the existing query parameters. This allows you to add many parameters at once,
-     *  as opposed to adding them one at a time to the queryParameters property.
+     as opposed to adding them one at a time to the queryParameters property.
      * @param params - The query parameters
      */
     appendQueryParameters(params: any): void;
     /**
      * Combines the specified object and the existing template values. This allows you to add many values at once,
-     *  as opposed to adding them one at a time to the templateValues property. If a value is already set, it will become an array and the new value will be appended.
+     as opposed to adding them one at a time to the templateValues property. If a value is already set, it will become an array and the new value will be appended.
      * @param template - The template values
      * @param [useAsDefault = false] - If true the values will be used as the default values, so they will only be set if they are undefined.
      */
@@ -14930,16 +14930,16 @@ export class Resource {
     appendForwardSlash(): void;
     /**
      * Asynchronously loads the resource as raw binary data.  Returns a promise that will resolve to
-     * an ArrayBuffer once loaded, or reject if the resource failed to load.  The data is loaded
-     * using XMLHttpRequest, which means that in order to make requests to another origin,
-     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
+    an ArrayBuffer once loaded, or reject if the resource failed to load.  The data is loaded
+    using XMLHttpRequest, which means that in order to make requests to another origin,
+    the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
      * @example
      * // load a single URL asynchronously
-     * resource.fetchArrayBuffer().then(function(arrayBuffer) {
-     *     // use the data
-     * }).catch(function(error) {
-     *     // an error occurred
-     * });
+    resource.fetchArrayBuffer().then(function(arrayBuffer) {
+        // use the data
+    }).catch(function(error) {
+        // an error occurred
+    });
      * @returns a promise that will resolve to the requested data when loaded. Returns undefined if <code>request.throttle</code> is true and the request does not have high enough priority.
      */
     fetchArrayBuffer(): Promise<ArrayBuffer> | undefined;
@@ -14968,16 +14968,16 @@ export class Resource {
     }): Promise<ArrayBuffer> | undefined;
     /**
      * Asynchronously loads the given resource as a blob.  Returns a promise that will resolve to
-     * a Blob once loaded, or reject if the resource failed to load.  The data is loaded
-     * using XMLHttpRequest, which means that in order to make requests to another origin,
-     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
+    a Blob once loaded, or reject if the resource failed to load.  The data is loaded
+    using XMLHttpRequest, which means that in order to make requests to another origin,
+    the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
      * @example
      * // load a single URL asynchronously
-     * resource.fetchBlob().then(function(blob) {
-     *     // use the data
-     * }).catch(function(error) {
-     *     // an error occurred
-     * });
+    resource.fetchBlob().then(function(blob) {
+        // use the data
+    }).catch(function(error) {
+        // an error occurred
+    });
      * @returns a promise that will resolve to the requested data when loaded. Returns undefined if <code>request.throttle</code> is true and the request does not have high enough priority.
      */
     fetchBlob(): Promise<Blob> | undefined;
@@ -15006,20 +15006,20 @@ export class Resource {
     }): Promise<Blob> | undefined;
     /**
      * Asynchronously loads the given image resource.  Returns a promise that will resolve to
-     * an {@link https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap|ImageBitmap} if <code>preferImageBitmap</code> is true and the browser supports <code>createImageBitmap</code> or otherwise an
-     * {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement|Image} once loaded, or reject if the image failed to load.
+    an {@link https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap|ImageBitmap} if <code>preferImageBitmap</code> is true and the browser supports <code>createImageBitmap</code> or otherwise an
+    {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement|Image} once loaded, or reject if the image failed to load.
      * @example
      * // load a single image asynchronously
-     * resource.fetchImage().then(function(image) {
-     *     // use the loaded image
-     * }).catch(function(error) {
-     *     // an error occurred
-     * });
-     *
-     * // load several images in parallel
-     * Promise.all([resource1.fetchImage(), resource2.fetchImage()]).then(function(images) {
-     *     // images is an array containing all the loaded images
-     * });
+    resource.fetchImage().then(function(image) {
+        // use the loaded image
+    }).catch(function(error) {
+        // an error occurred
+    });
+    
+    // load several images in parallel
+    Promise.all([resource1.fetchImage(), resource2.fetchImage()]).then(function(images) {
+        // images is an array containing all the loaded images
+    });
      * @param [options] - An object with the following properties.
      * @param [options.preferBlob = false] - If true, we will load the image via a blob.
      * @param [options.preferImageBitmap = false] - If true, image will be decoded during fetch and an <code>ImageBitmap</code> is returned.
@@ -15066,22 +15066,22 @@ export class Resource {
     }): Promise<ImageBitmap> | Promise<HTMLImageElement> | undefined;
     /**
      * Asynchronously loads the given resource as text.  Returns a promise that will resolve to
-     * a String once loaded, or reject if the resource failed to load.  The data is loaded
-     * using XMLHttpRequest, which means that in order to make requests to another origin,
-     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
+    a String once loaded, or reject if the resource failed to load.  The data is loaded
+    using XMLHttpRequest, which means that in order to make requests to another origin,
+    the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
      * @example
      * // load text from a URL, setting a custom header
-     * const resource = new Resource({
-     *   url: 'http://someUrl.com/someJson.txt',
-     *   headers: {
-     *     'X-Custom-Header' : 'some value'
-     *   }
-     * });
-     * resource.fetchText().then(function(text) {
-     *     // Do something with the text
-     * }).catch(function(error) {
-     *     // an error occurred
-     * });
+    const resource = new Resource({
+      url: 'http://someUrl.com/someJson.txt',
+      headers: {
+        'X-Custom-Header' : 'some value'
+      }
+    });
+    resource.fetchText().then(function(text) {
+        // Do something with the text
+    }).catch(function(error) {
+        // an error occurred
+    });
      * @returns a promise that will resolve to the requested data when loaded. Returns undefined if <code>request.throttle</code> is true and the request does not have high enough priority.
      */
     fetchText(): Promise<string> | undefined;
@@ -15110,17 +15110,17 @@ export class Resource {
     }): Promise<string> | undefined;
     /**
      * Asynchronously loads the given resource as JSON.  Returns a promise that will resolve to
-     * a JSON object once loaded, or reject if the resource failed to load.  The data is loaded
-     * using XMLHttpRequest, which means that in order to make requests to another origin,
-     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled. This function
-     * adds 'Accept: application/json,&#42;&#47;&#42;;q=0.01' to the request headers, if not
-     * already specified.
+    a JSON object once loaded, or reject if the resource failed to load.  The data is loaded
+    using XMLHttpRequest, which means that in order to make requests to another origin,
+    the server must have Cross-Origin Resource Sharing (CORS) headers enabled. This function
+    adds 'Accept: application/json,&#42;&#47;&#42;;q=0.01' to the request headers, if not
+    already specified.
      * @example
      * resource.fetchJson().then(function(jsonData) {
-     *     // Do something with the JSON object
-     * }).catch(function(error) {
-     *     // an error occurred
-     * });
+        // Do something with the JSON object
+    }).catch(function(error) {
+        // an error occurred
+    });
      * @returns a promise that will resolve to the requested data when loaded. Returns undefined if <code>request.throttle</code> is true and the request does not have high enough priority.
      */
     fetchJson(): Promise<any> | undefined;
@@ -15149,18 +15149,18 @@ export class Resource {
     }): Promise<any> | undefined;
     /**
      * Asynchronously loads the given resource as XML.  Returns a promise that will resolve to
-     * an XML Document once loaded, or reject if the resource failed to load.  The data is loaded
-     * using XMLHttpRequest, which means that in order to make requests to another origin,
-     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
+    an XML Document once loaded, or reject if the resource failed to load.  The data is loaded
+    using XMLHttpRequest, which means that in order to make requests to another origin,
+    the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
      * @example
      * // load XML from a URL, setting a custom header
-     * Cesium.loadXML('http://someUrl.com/someXML.xml', {
-     *   'X-Custom-Header' : 'some value'
-     * }).then(function(document) {
-     *     // Do something with the document
-     * }).catch(function(error) {
-     *     // an error occurred
-     * });
+    Cesium.loadXML('http://someUrl.com/someXML.xml', {
+      'X-Custom-Header' : 'some value'
+    }).then(function(document) {
+        // Do something with the document
+    }).catch(function(error) {
+        // an error occurred
+    });
      * @returns a promise that will resolve to the requested data when loaded. Returns undefined if <code>request.throttle</code> is true and the request does not have high enough priority.
      */
     fetchXML(): Promise<XMLDocument> | undefined;
@@ -15191,11 +15191,11 @@ export class Resource {
      * Requests a resource using JSONP.
      * @example
      * // load a data asynchronously
-     * resource.fetchJsonp().then(function(data) {
-     *     // use the loaded data
-     * }).catch(function(error) {
-     *     // an error occurred
-     * });
+    resource.fetchJsonp().then(function(data) {
+        // use the loaded data
+    }).catch(function(error) {
+        // an error occurred
+    });
      * @param [callbackParameterName = 'callback'] - The callback parameter name that the server expects.
      * @returns a promise that will resolve to the requested data when loaded. Returns undefined if <code>request.throttle</code> is true and the request does not have high enough priority.
      */
@@ -15227,17 +15227,17 @@ export class Resource {
     }): Promise<any> | undefined;
     /**
      * Asynchronously loads the given resource.  Returns a promise that will resolve to
-     * the result once loaded, or reject if the resource failed to load.  The data is loaded
-     * using XMLHttpRequest, which means that in order to make requests to another origin,
-     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled. It's recommended that you use
-     * the more specific functions eg. fetchJson, fetchBlob, etc.
+    the result once loaded, or reject if the resource failed to load.  The data is loaded
+    using XMLHttpRequest, which means that in order to make requests to another origin,
+    the server must have Cross-Origin Resource Sharing (CORS) headers enabled. It's recommended that you use
+    the more specific functions eg. fetchJson, fetchBlob, etc.
      * @example
      * resource.fetch()
-     *   .then(function(body) {
-     *       // use the data
-     *   }).catch(function(error) {
-     *       // an error occurred
-     *   });
+      .then(function(body) {
+          // use the data
+      }).catch(function(error) {
+          // an error occurred
+      });
      * @param [options] - Object with the following properties:
      * @param [options.responseType] - The type of response.  This controls the type of item returned.
      * @param [options.headers] - Additional HTTP headers to send with the request, if any.
@@ -15278,16 +15278,16 @@ export class Resource {
     }): Promise<any> | undefined;
     /**
      * Asynchronously deletes the given resource.  Returns a promise that will resolve to
-     * the result once loaded, or reject if the resource failed to load.  The data is loaded
-     * using XMLHttpRequest, which means that in order to make requests to another origin,
-     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
+    the result once loaded, or reject if the resource failed to load.  The data is loaded
+    using XMLHttpRequest, which means that in order to make requests to another origin,
+    the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
      * @example
      * resource.delete()
-     *   .then(function(body) {
-     *       // use the data
-     *   }).catch(function(error) {
-     *       // an error occurred
-     *   });
+      .then(function(body) {
+          // use the data
+      }).catch(function(error) {
+          // an error occurred
+      });
      * @param [options] - Object with the following properties:
      * @param [options.responseType] - The type of response.  This controls the type of item returned.
      * @param [options.headers] - Additional HTTP headers to send with the request, if any.
@@ -15330,16 +15330,16 @@ export class Resource {
     }): Promise<any> | undefined;
     /**
      * Asynchronously gets headers the given resource.  Returns a promise that will resolve to
-     * the result once loaded, or reject if the resource failed to load.  The data is loaded
-     * using XMLHttpRequest, which means that in order to make requests to another origin,
-     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
+    the result once loaded, or reject if the resource failed to load.  The data is loaded
+    using XMLHttpRequest, which means that in order to make requests to another origin,
+    the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
      * @example
      * resource.head()
-     *   .then(function(headers) {
-     *       // use the data
-     *   }).catch(function(error) {
-     *       // an error occurred
-     *   });
+      .then(function(headers) {
+          // use the data
+      }).catch(function(error) {
+          // an error occurred
+      });
      * @param [options] - Object with the following properties:
      * @param [options.responseType] - The type of response.  This controls the type of item returned.
      * @param [options.headers] - Additional HTTP headers to send with the request, if any.
@@ -15380,16 +15380,16 @@ export class Resource {
     }): Promise<any> | undefined;
     /**
      * Asynchronously gets options the given resource.  Returns a promise that will resolve to
-     * the result once loaded, or reject if the resource failed to load.  The data is loaded
-     * using XMLHttpRequest, which means that in order to make requests to another origin,
-     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
+    the result once loaded, or reject if the resource failed to load.  The data is loaded
+    using XMLHttpRequest, which means that in order to make requests to another origin,
+    the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
      * @example
      * resource.options()
-     *   .then(function(headers) {
-     *       // use the data
-     *   }).catch(function(error) {
-     *       // an error occurred
-     *   });
+      .then(function(headers) {
+          // use the data
+      }).catch(function(error) {
+          // an error occurred
+      });
      * @param [options] - Object with the following properties:
      * @param [options.responseType] - The type of response.  This controls the type of item returned.
      * @param [options.headers] - Additional HTTP headers to send with the request, if any.
@@ -15430,16 +15430,16 @@ export class Resource {
     }): Promise<any> | undefined;
     /**
      * Asynchronously posts data to the given resource.  Returns a promise that will resolve to
-     * the result once loaded, or reject if the resource failed to load.  The data is loaded
-     * using XMLHttpRequest, which means that in order to make requests to another origin,
-     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
+    the result once loaded, or reject if the resource failed to load.  The data is loaded
+    using XMLHttpRequest, which means that in order to make requests to another origin,
+    the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
      * @example
      * resource.post(data)
-     *   .then(function(result) {
-     *       // use the result
-     *   }).catch(function(error) {
-     *       // an error occurred
-     *   });
+      .then(function(result) {
+          // use the result
+      }).catch(function(error) {
+          // an error occurred
+      });
      * @param data - Data that is posted with the resource.
      * @param [options] - Object with the following properties:
      * @param [options.data] - Data that is posted with the resource.
@@ -15485,16 +15485,16 @@ export class Resource {
     }): Promise<any> | undefined;
     /**
      * Asynchronously puts data to the given resource.  Returns a promise that will resolve to
-     * the result once loaded, or reject if the resource failed to load.  The data is loaded
-     * using XMLHttpRequest, which means that in order to make requests to another origin,
-     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
+    the result once loaded, or reject if the resource failed to load.  The data is loaded
+    using XMLHttpRequest, which means that in order to make requests to another origin,
+    the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
      * @example
      * resource.put(data)
-     *   .then(function(result) {
-     *       // use the result
-     *   }).catch(function(error) {
-     *       // an error occurred
-     *   });
+      .then(function(result) {
+          // use the result
+      }).catch(function(error) {
+          // an error occurred
+      });
      * @param data - Data that is posted with the resource.
      * @param [options] - Object with the following properties:
      * @param [options.responseType] - The type of response.  This controls the type of item returned.
@@ -15538,16 +15538,16 @@ export class Resource {
     }): Promise<any> | undefined;
     /**
      * Asynchronously patches data to the given resource.  Returns a promise that will resolve to
-     * the result once loaded, or reject if the resource failed to load.  The data is loaded
-     * using XMLHttpRequest, which means that in order to make requests to another origin,
-     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
+    the result once loaded, or reject if the resource failed to load.  The data is loaded
+    using XMLHttpRequest, which means that in order to make requests to another origin,
+    the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
      * @example
      * resource.patch(data)
-     *   .then(function(result) {
-     *       // use the result
-     *   }).catch(function(error) {
-     *       // an error occurred
-     *   });
+      .then(function(result) {
+          // use the result
+      }).catch(function(error) {
+          // an error occurred
+      });
      * @param data - Data that is posted with the resource.
      * @param [options] - Object with the following properties:
      * @param [options.responseType] - The type of response.  This controls the type of item returned.
@@ -21469,76 +21469,92 @@ export class KmlCamera {
 export namespace KmlDataSource {
     /**
      * Initialization options for the `load` method.
-     * @property camera - The camera that is used for viewRefreshModes and sending camera properties to network links.
-     * @property canvas - The canvas that is used for sending viewer properties to network links.
      * @property [sourceUri] - Overrides the url to use for resolving relative links and other KML network features.
      * @property [clampToGround = false] - true if we want the geometry features (Polygons, LineStrings and LinearRings) clamped to the ground.
      * @property [ellipsoid = Ellipsoid.WGS84] - The global ellipsoid used for geographical calculations.
-     * @property [credit] - A credit for the data source, which is displayed on the canvas.
      * @property [screenOverlayContainer] - A container for ScreenOverlay images.
      */
     type LoadOptions = {
-        camera: Camera;
-        canvas: HTMLCanvasElement;
         sourceUri?: string;
         clampToGround?: boolean;
         ellipsoid?: Ellipsoid;
+        screenOverlayContainer?: Element | string;
+    };
+    /**
+     * Options for constructing a new KmlDataSource, or calling the static `load` method.
+     * @property [camera] - The camera that is used for viewRefreshModes and sending camera properties to network links.
+     * @property [canvas] - The canvas that is used for sending viewer properties to network links.
+     * @property [credit] - A credit for the data source, which is displayed on the canvas.
+     * @property [sourceUri] - Overrides the url to use for resolving relative links and other KML network features.
+     * @property [clampToGround = false] - true if we want the geometry features (Polygons, LineStrings and LinearRings) clamped to the ground.
+     * @property [ellipsoid = Ellipsoid.WGS84] - The global ellipsoid used for geographical calculations.
+     * @property [screenOverlayContainer] - A container for ScreenOverlay images.
+     */
+    type ConstructorOptions = {
+        camera?: Camera;
+        canvas?: HTMLCanvasElement;
         credit?: Credit | string;
+        sourceUri?: string;
+        clampToGround?: boolean;
+        ellipsoid?: Ellipsoid;
         screenOverlayContainer?: Element | string;
     };
 }
 
 /**
  * A {@link DataSource} which processes Keyhole Markup Language 2.2 (KML).
-<p>
-KML support in Cesium is incomplete, but a large amount of the standard,
-as well as Google's <code>gx</code> extension namespace, is supported. See Github issue
-{@link https://github.com/CesiumGS/cesium/issues/873|#873} for a
-detailed list of what is and isn't supported. Cesium will also write information to the
-console when it encounters most unsupported features.
-</p>
-<p>
-Non visual feature data, such as <code>atom:author</code> and <code>ExtendedData</code>
-is exposed via an instance of {@link KmlFeatureData}, which is added to each {@link Entity}
-under the <code>kml</code> property.
-</p>
+ * <p>
+ * KML support in Cesium is incomplete, but a large amount of the standard,
+ * as well as Google's <code>gx</code> extension namespace, is supported. See Github issue
+ * {@link https://github.com/CesiumGS/cesium/issues/873|#873} for a
+ * detailed list of what is and isn't supported. Cesium will also write information to the
+ * console when it encounters most unsupported features.
+ * </p>
+ * <p>
+ * Non visual feature data, such as <code>atom:author</code> and <code>ExtendedData</code>
+ * is exposed via an instance of {@link KmlFeatureData}, which is added to each {@link Entity}
+ * under the <code>kml</code> property.
+ * </p>
  * @example
  * const viewer = new Cesium.Viewer('cesiumContainer');
-viewer.dataSources.add(Cesium.KmlDataSource.load('../../SampleData/facilities.kmz',
-     {
-          camera: viewer.scene.camera,
-          canvas: viewer.scene.canvas
-     })
-);
- * @param options - An object with the following properties:
- * @param options.camera - The camera that is used for viewRefreshModes and sending camera properties to network links.
- * @param options.canvas - The canvas that is used for sending viewer properties to network links.
- * @param [options.ellipsoid = Ellipsoid.WGS84] - The global ellipsoid used for geographical calculations.
- * @param [options.credit] - A credit for the data source, which is displayed on the canvas.
+ * viewer.dataSources.add(Cesium.KmlDataSource.load('../../SampleData/facilities.kmz',
+ *      {
+ *           camera: viewer.scene.camera,
+ *           canvas: viewer.scene.canvas
+ *      })
+ * );
+ * @param [options] - Object describing initialization options
  */
 export class KmlDataSource {
-    constructor(options: {
-        camera: Camera;
-        canvas: HTMLCanvasElement;
-        ellipsoid?: Ellipsoid;
-        credit?: Credit | string;
-    });
+    constructor(options?: KmlDataSource.ConstructorOptions);
+    /**
+     * The current size of this Canvas will be used to populate the Link parameters
+     * for client height and width.
+     */
+    canvas: HTMLCanvasElement | undefined;
+    /**
+     * The position and orientation of this {@link Camera} will be used to
+     * populate various camera parameters when making network requests.
+     * Camera movement will determine when to trigger NetworkLink refresh if
+     * <code>viewRefreshMode</code> is <code>onStop</code>.
+     */
+    camera: Camera | undefined;
     /**
      * Creates a Promise to a new instance loaded with the provided KML data.
      * @param data - A url, parsed KML document, or Blob containing binary KMZ data or a parsed KML document.
      * @param [options] - An object specifying configuration options
      * @returns A promise that will resolve to a new KmlDataSource instance once the KML is loaded.
      */
-    static load(data: Resource | string | Document | Blob, options?: KmlDataSource.LoadOptions): Promise<KmlDataSource>;
+    static load(data: Resource | string | Document | Blob, options?: KmlDataSource.ConstructorOptions): Promise<KmlDataSource>;
     /**
      * Gets or sets a human-readable name for this instance.
-    This will be automatically be set to the KML document name on load.
+     * This will be automatically be set to the KML document name on load.
      */
     name: string;
     /**
      * Gets the clock settings defined by the loaded KML. This represents the total
-    availability interval for all time-dynamic data. If the KML does not contain
-    time-dynamic data, this value is undefined.
+     * availability interval for all time-dynamic data. If the KML does not contain
+     * time-dynamic data, this value is undefined.
      */
     clock: DataSourceClock;
     /**
@@ -21588,19 +21604,10 @@ export class KmlDataSource {
     /**
      * Asynchronously loads the provided KML data, replacing any existing data.
      * @param data - A url, parsed KML document, or Blob containing binary KMZ data or a parsed KML document.
-     * @param [options] - An object with the following properties:
-     * @param [options.sourceUri] - Overrides the url to use for resolving relative links and other KML network features.
-     * @param [options.clampToGround = false] - true if we want the geometry features (Polygons, LineStrings and LinearRings) clamped to the ground. If true, lines will use corridors so use Entity.corridor instead of Entity.polyline.
-     * @param [options.ellipsoid = Ellipsoid.WGS84] - The global ellipsoid used for geographical calculations.
-     * @param [options.screenOverlayContainer] - A container for ScreenOverlay images.
+     * @param [options] - An object specifying configuration options
      * @returns A promise that will resolve to this instances once the KML is loaded.
      */
-    load(data: Resource | string | Document | Blob, options?: {
-        sourceUri?: Resource | string;
-        clampToGround?: boolean;
-        ellipsoid?: Ellipsoid;
-        screenOverlayContainer?: Element | string;
-    }): Promise<KmlDataSource>;
+    load(data: Resource | string | Document | Blob, options?: KmlDataSource.LoadOptions): Promise<KmlDataSource>;
     /**
      * Cleans up any non-entity elements created by the data source. Currently this only affects ScreenOverlay elements.
      */
@@ -21640,8 +21647,8 @@ export class KmlFeatureData {
     snippet: string;
     /**
      * Gets the extended data, parsed into a JSON object.
-    Currently only the <code>Data</code> property is supported.
-    <code>SchemaData</code> and custom data are ignored.
+     * Currently only the <code>Data</code> property is supported.
+     * <code>SchemaData</code> and custom data are ignored.
      */
     extendedData: string;
 }
@@ -22289,7 +22296,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.
      */
@@ -25216,19 +25223,19 @@ export enum Axis {
 
 /**
  * A viewport-aligned image positioned in the 3D scene, that is created
-and rendered using a {@link BillboardCollection}.  A billboard is created and its initial
-properties are set by calling {@link BillboardCollection#add}.
-<br /><br />
-<div align='center'>
-<img src='Images/Billboard.png' width='400' height='300' /><br />
-Example billboards
-</div>
+ * and rendered using a {@link BillboardCollection}.  A billboard is created and its initial
+ * properties are set by calling {@link BillboardCollection#add}.
+ * <br /><br />
+ * <div align='center'>
+ * <img src='Images/Billboard.png' width='400' height='300' /><br />
+ * Example billboards
+ * </div>
  */
 export class Billboard {
     constructor();
     /**
      * Determines if this billboard will be shown.  Use this to hide or show a billboard, instead
-    of removing it and re-adding it to the collection.
+     * of removing it and re-adding it to the collection.
      */
     show: boolean;
     /**
@@ -25241,159 +25248,159 @@ export class Billboard {
     heightReference: HeightReference;
     /**
      * Gets or sets the pixel offset in screen space from the origin of this billboard.  This is commonly used
-    to align multiple billboards and labels at the same position, e.g., an image and text.  The
-    screen space origin is the top, left corner of the canvas; <code>x</code> increases from
-    left to right, and <code>y</code> increases from top to bottom.
-    <br /><br />
-    <div align='center'>
-    <table border='0' cellpadding='5'><tr>
-    <td align='center'><code>default</code><br/><img src='Images/Billboard.setPixelOffset.default.png' width='250' height='188' /></td>
-    <td align='center'><code>b.pixeloffset = new Cartesian2(50, 25);</code><br/><img src='Images/Billboard.setPixelOffset.x50y-25.png' width='250' height='188' /></td>
-    </tr></table>
-    The billboard's origin is indicated by the yellow point.
-    </div>
+     * to align multiple billboards and labels at the same position, e.g., an image and text.  The
+     * screen space origin is the top, left corner of the canvas; <code>x</code> increases from
+     * left to right, and <code>y</code> increases from top to bottom.
+     * <br /><br />
+     * <div align='center'>
+     * <table border='0' cellpadding='5'><tr>
+     * <td align='center'><code>default</code><br/><img src='Images/Billboard.setPixelOffset.default.png' width='250' height='188' /></td>
+     * <td align='center'><code>b.pixeloffset = new Cartesian2(50, 25);</code><br/><img src='Images/Billboard.setPixelOffset.x50y-25.png' width='250' height='188' /></td>
+     * </tr></table>
+     * The billboard's origin is indicated by the yellow point.
+     * </div>
      */
     pixelOffset: Cartesian2;
     /**
      * Gets or sets near and far scaling properties of a Billboard based on the billboard's distance from the camera.
-    A billboard's scale will interpolate between the {@link NearFarScalar#nearValue} and
-    {@link NearFarScalar#farValue} while the camera distance falls within the lower and upper bounds
-    of the specified {@link NearFarScalar#near} and {@link NearFarScalar#far}.
-    Outside of these ranges the billboard's scale remains clamped to the nearest bound.  If undefined,
-    scaleByDistance will be disabled.
+     * A billboard's scale will interpolate between the {@link NearFarScalar#nearValue} and
+     * {@link NearFarScalar#farValue} while the camera distance falls within the lower and upper bounds
+     * of the specified {@link NearFarScalar#near} and {@link NearFarScalar#far}.
+     * Outside of these ranges the billboard's scale remains clamped to the nearest bound.  If undefined,
+     * scaleByDistance will be disabled.
      * @example
      * // Example 1.
-    // Set a billboard's scaleByDistance to scale by 1.5 when the
-    // camera is 1500 meters from the billboard and disappear as
-    // the camera distance approaches 8.0e6 meters.
-    b.scaleByDistance = new Cesium.NearFarScalar(1.5e2, 1.5, 8.0e6, 0.0);
+     * // Set a billboard's scaleByDistance to scale by 1.5 when the
+     * // camera is 1500 meters from the billboard and disappear as
+     * // the camera distance approaches 8.0e6 meters.
+     * b.scaleByDistance = new Cesium.NearFarScalar(1.5e2, 1.5, 8.0e6, 0.0);
      * @example
      * // Example 2.
-    // disable scaling by distance
-    b.scaleByDistance = undefined;
+     * // disable scaling by distance
+     * b.scaleByDistance = undefined;
      */
     scaleByDistance: NearFarScalar;
     /**
      * Gets or sets near and far translucency properties of a Billboard based on the billboard's distance from the camera.
-    A billboard's translucency will interpolate between the {@link NearFarScalar#nearValue} and
-    {@link NearFarScalar#farValue} while the camera distance falls within the lower and upper bounds
-    of the specified {@link NearFarScalar#near} and {@link NearFarScalar#far}.
-    Outside of these ranges the billboard's translucency remains clamped to the nearest bound.  If undefined,
-    translucencyByDistance will be disabled.
+     * A billboard's translucency will interpolate between the {@link NearFarScalar#nearValue} and
+     * {@link NearFarScalar#farValue} while the camera distance falls within the lower and upper bounds
+     * of the specified {@link NearFarScalar#near} and {@link NearFarScalar#far}.
+     * Outside of these ranges the billboard's translucency remains clamped to the nearest bound.  If undefined,
+     * translucencyByDistance will be disabled.
      * @example
      * // Example 1.
-    // Set a billboard's translucency to 1.0 when the
-    // camera is 1500 meters from the billboard and disappear as
-    // the camera distance approaches 8.0e6 meters.
-    b.translucencyByDistance = new Cesium.NearFarScalar(1.5e2, 1.0, 8.0e6, 0.0);
+     * // Set a billboard's translucency to 1.0 when the
+     * // camera is 1500 meters from the billboard and disappear as
+     * // the camera distance approaches 8.0e6 meters.
+     * b.translucencyByDistance = new Cesium.NearFarScalar(1.5e2, 1.0, 8.0e6, 0.0);
      * @example
      * // Example 2.
-    // disable translucency by distance
-    b.translucencyByDistance = undefined;
+     * // disable translucency by distance
+     * b.translucencyByDistance = undefined;
      */
     translucencyByDistance: NearFarScalar;
     /**
      * Gets or sets near and far pixel offset scaling properties of a Billboard based on the billboard's distance from the camera.
-    A billboard's pixel offset will be scaled between the {@link NearFarScalar#nearValue} and
-    {@link NearFarScalar#farValue} while the camera distance falls within the lower and upper bounds
-    of the specified {@link NearFarScalar#near} and {@link NearFarScalar#far}.
-    Outside of these ranges the billboard's pixel offset scale remains clamped to the nearest bound.  If undefined,
-    pixelOffsetScaleByDistance will be disabled.
+     * A billboard's pixel offset will be scaled between the {@link NearFarScalar#nearValue} and
+     * {@link NearFarScalar#farValue} while the camera distance falls within the lower and upper bounds
+     * of the specified {@link NearFarScalar#near} and {@link NearFarScalar#far}.
+     * Outside of these ranges the billboard's pixel offset scale remains clamped to the nearest bound.  If undefined,
+     * pixelOffsetScaleByDistance will be disabled.
      * @example
      * // Example 1.
-    // Set a billboard's pixel offset scale to 0.0 when the
-    // camera is 1500 meters from the billboard and scale pixel offset to 10.0 pixels
-    // in the y direction the camera distance approaches 8.0e6 meters.
-    b.pixelOffset = new Cesium.Cartesian2(0.0, 1.0);
-    b.pixelOffsetScaleByDistance = new Cesium.NearFarScalar(1.5e2, 0.0, 8.0e6, 10.0);
+     * // Set a billboard's pixel offset scale to 0.0 when the
+     * // camera is 1500 meters from the billboard and scale pixel offset to 10.0 pixels
+     * // in the y direction the camera distance approaches 8.0e6 meters.
+     * b.pixelOffset = new Cesium.Cartesian2(0.0, 1.0);
+     * b.pixelOffsetScaleByDistance = new Cesium.NearFarScalar(1.5e2, 0.0, 8.0e6, 10.0);
      * @example
      * // Example 2.
-    // disable pixel offset by distance
-    b.pixelOffsetScaleByDistance = undefined;
+     * // disable pixel offset by distance
+     * b.pixelOffsetScaleByDistance = undefined;
      */
     pixelOffsetScaleByDistance: NearFarScalar;
     /**
      * Gets or sets the 3D Cartesian offset applied to this billboard in eye coordinates.  Eye coordinates is a left-handed
-    coordinate system, where <code>x</code> points towards the viewer's right, <code>y</code> points up, and
-    <code>z</code> points into the screen.  Eye coordinates use the same scale as world and model coordinates,
-    which is typically meters.
-    <br /><br />
-    An eye offset is commonly used to arrange multiple billboards or objects at the same position, e.g., to
-    arrange a billboard above its corresponding 3D model.
-    <br /><br />
-    Below, the billboard is positioned at the center of the Earth but an eye offset makes it always
-    appear on top of the Earth regardless of the viewer's or Earth's orientation.
-    <br /><br />
-    <div align='center'>
-    <table border='0' cellpadding='5'><tr>
-    <td align='center'><img src='Images/Billboard.setEyeOffset.one.png' width='250' height='188' /></td>
-    <td align='center'><img src='Images/Billboard.setEyeOffset.two.png' width='250' height='188' /></td>
-    </tr></table>
-    <code>b.eyeOffset = new Cartesian3(0.0, 8000000.0, 0.0);</code><br /><br />
-    </div>
+     * coordinate system, where <code>x</code> points towards the viewer's right, <code>y</code> points up, and
+     * <code>z</code> points into the screen.  Eye coordinates use the same scale as world and model coordinates,
+     * which is typically meters.
+     * <br /><br />
+     * An eye offset is commonly used to arrange multiple billboards or objects at the same position, e.g., to
+     * arrange a billboard above its corresponding 3D model.
+     * <br /><br />
+     * Below, the billboard is positioned at the center of the Earth but an eye offset makes it always
+     * appear on top of the Earth regardless of the viewer's or Earth's orientation.
+     * <br /><br />
+     * <div align='center'>
+     * <table border='0' cellpadding='5'><tr>
+     * <td align='center'><img src='Images/Billboard.setEyeOffset.one.png' width='250' height='188' /></td>
+     * <td align='center'><img src='Images/Billboard.setEyeOffset.two.png' width='250' height='188' /></td>
+     * </tr></table>
+     * <code>b.eyeOffset = new Cartesian3(0.0, 8000000.0, 0.0);</code><br /><br />
+     * </div>
      */
     eyeOffset: Cartesian3;
     /**
      * Gets or sets the horizontal origin of this billboard, which determines if the billboard is
-    to the left, center, or right of its anchor position.
-    <br /><br />
-    <div align='center'>
-    <img src='Images/Billboard.setHorizontalOrigin.png' width='648' height='196' /><br />
-    </div>
+     * to the left, center, or right of its anchor position.
+     * <br /><br />
+     * <div align='center'>
+     * <img src='Images/Billboard.setHorizontalOrigin.png' width='648' height='196' /><br />
+     * </div>
      * @example
      * // Use a bottom, left origin
-    b.horizontalOrigin = Cesium.HorizontalOrigin.LEFT;
-    b.verticalOrigin = Cesium.VerticalOrigin.BOTTOM;
+     * b.horizontalOrigin = Cesium.HorizontalOrigin.LEFT;
+     * b.verticalOrigin = Cesium.VerticalOrigin.BOTTOM;
      */
     horizontalOrigin: HorizontalOrigin;
     /**
      * Gets or sets the vertical origin of this billboard, which determines if the billboard is
-    to the above, below, or at the center of its anchor position.
-    <br /><br />
-    <div align='center'>
-    <img src='Images/Billboard.setVerticalOrigin.png' width='695' height='175' /><br />
-    </div>
+     * to the above, below, or at the center of its anchor position.
+     * <br /><br />
+     * <div align='center'>
+     * <img src='Images/Billboard.setVerticalOrigin.png' width='695' height='175' /><br />
+     * </div>
      * @example
      * // Use a bottom, left origin
-    b.horizontalOrigin = Cesium.HorizontalOrigin.LEFT;
-    b.verticalOrigin = Cesium.VerticalOrigin.BOTTOM;
+     * b.horizontalOrigin = Cesium.HorizontalOrigin.LEFT;
+     * b.verticalOrigin = Cesium.VerticalOrigin.BOTTOM;
      */
     verticalOrigin: VerticalOrigin;
     /**
      * Gets or sets the uniform scale that is multiplied with the billboard's image size in pixels.
-    A scale of <code>1.0</code> does not change the size of the billboard; a scale greater than
-    <code>1.0</code> enlarges the billboard; a positive scale less than <code>1.0</code> shrinks
-    the billboard.
-    <br /><br />
-    <div align='center'>
-    <img src='Images/Billboard.setScale.png' width='400' height='300' /><br/>
-    From left to right in the above image, the scales are <code>0.5</code>, <code>1.0</code>,
-    and <code>2.0</code>.
-    </div>
+     * A scale of <code>1.0</code> does not change the size of the billboard; a scale greater than
+     * <code>1.0</code> enlarges the billboard; a positive scale less than <code>1.0</code> shrinks
+     * the billboard.
+     * <br /><br />
+     * <div align='center'>
+     * <img src='Images/Billboard.setScale.png' width='400' height='300' /><br/>
+     * From left to right in the above image, the scales are <code>0.5</code>, <code>1.0</code>,
+     * and <code>2.0</code>.
+     * </div>
      */
     scale: number;
     /**
      * Gets or sets the color that is multiplied with the billboard's texture.  This has two common use cases.  First,
-    the same white texture may be used by many different billboards, each with a different color, to create
-    colored billboards.  Second, the color's alpha component can be used to make the billboard translucent as shown below.
-    An alpha of <code>0.0</code> makes the billboard transparent, and <code>1.0</code> makes the billboard opaque.
-    <br /><br />
-    <div align='center'>
-    <table border='0' cellpadding='5'><tr>
-    <td align='center'><code>default</code><br/><img src='Images/Billboard.setColor.Alpha255.png' width='250' height='188' /></td>
-    <td align='center'><code>alpha : 0.5</code><br/><img src='Images/Billboard.setColor.Alpha127.png' width='250' height='188' /></td>
-    </tr></table>
-    </div>
-    <br />
-    The red, green, blue, and alpha values are indicated by <code>value</code>'s <code>red</code>, <code>green</code>,
-    <code>blue</code>, and <code>alpha</code> properties as shown in Example 1.  These components range from <code>0.0</code>
-    (no intensity) to <code>1.0</code> (full intensity).
+     * the same white texture may be used by many different billboards, each with a different color, to create
+     * colored billboards.  Second, the color's alpha component can be used to make the billboard translucent as shown below.
+     * An alpha of <code>0.0</code> makes the billboard transparent, and <code>1.0</code> makes the billboard opaque.
+     * <br /><br />
+     * <div align='center'>
+     * <table border='0' cellpadding='5'><tr>
+     * <td align='center'><code>default</code><br/><img src='Images/Billboard.setColor.Alpha255.png' width='250' height='188' /></td>
+     * <td align='center'><code>alpha : 0.5</code><br/><img src='Images/Billboard.setColor.Alpha127.png' width='250' height='188' /></td>
+     * </tr></table>
+     * </div>
+     * <br />
+     * The red, green, blue, and alpha values are indicated by <code>value</code>'s <code>red</code>, <code>green</code>,
+     * <code>blue</code>, and <code>alpha</code> properties as shown in Example 1.  These components range from <code>0.0</code>
+     * (no intensity) to <code>1.0</code> (full intensity).
      * @example
      * // Example 1. Assign yellow.
-    b.color = Cesium.Color.YELLOW;
+     * b.color = Cesium.Color.YELLOW;
      * @example
      * // Example 2. Make a billboard 50% translucent.
-    b.color = new Cesium.Color(1.0, 1.0, 1.0, 0.5);
+     * b.color = new Cesium.Color(1.0, 1.0, 1.0, 0.5);
      */
     color: Color;
     /**
@@ -25402,20 +25409,20 @@ export class Billboard {
     rotation: number;
     /**
      * Gets or sets the aligned axis in world space. The aligned axis is the unit vector that the billboard up vector points towards.
-    The default is the zero vector, which means the billboard is aligned to the screen up vector.
+     * The default is the zero vector, which means the billboard is aligned to the screen up vector.
      * @example
      * // Example 1.
-    // Have the billboard up vector point north
-    billboard.alignedAxis = Cesium.Cartesian3.UNIT_Z;
+     * // Have the billboard up vector point north
+     * billboard.alignedAxis = Cesium.Cartesian3.UNIT_Z;
      * @example
      * // Example 2.
-    // Have the billboard point east.
-    billboard.alignedAxis = Cesium.Cartesian3.UNIT_Z;
-    billboard.rotation = -Cesium.Math.PI_OVER_TWO;
+     * // Have the billboard point east.
+     * billboard.alignedAxis = Cesium.Cartesian3.UNIT_Z;
+     * billboard.rotation = -Cesium.Math.PI_OVER_TWO;
      * @example
      * // Example 3.
-    // Reset the aligned axis
-    billboard.alignedAxis = Cesium.Cartesian3.ZERO;
+     * // Reset the aligned axis
+     * billboard.alignedAxis = Cesium.Cartesian3.ZERO;
      */
     alignedAxis: Cartesian3;
     /**
@@ -25428,7 +25435,7 @@ export class Billboard {
     height: number;
     /**
      * Gets or sets if the billboard size is in meters or pixels. <code>true</code> to size the billboard in meters;
-    otherwise, the size is in pixels.
+     * otherwise, the size is in pixels.
      */
     sizeInMeters: boolean;
     /**
@@ -25437,7 +25444,7 @@ export class Billboard {
     distanceDisplayCondition: DistanceDisplayCondition;
     /**
      * Gets or sets the distance from the camera at which to disable the depth test to, for example, prevent clipping against terrain.
-    When set to zero, the depth test is always applied. When set to Number.POSITIVE_INFINITY, the depth test is never applied.
+     * When set to zero, the depth test is always applied. When set to Number.POSITIVE_INFINITY, the depth test is never applied.
      */
     disableDepthTestDistance: number;
     /**
@@ -25446,72 +25453,72 @@ export class Billboard {
     id: any;
     /**
      * <p>
-    Gets or sets the image to be used for this billboard.  If a texture has already been created for the
-    given image, the existing texture is used.
-    </p>
-    <p>
-    This property can be set to a loaded Image, a URL which will be loaded as an Image automatically,
-    a canvas, or another billboard's image property (from the same billboard collection).
-    </p>
+     * Gets or sets the image to be used for this billboard.  If a texture has already been created for the
+     * given image, the existing texture is used.
+     * </p>
+     * <p>
+     * This property can be set to a loaded Image, a URL which will be loaded as an Image automatically,
+     * a canvas, or another billboard's image property (from the same billboard collection).
+     * </p>
      * @example
      * // load an image from a URL
-    b.image = 'some/image/url.png';
-    
-    // assuming b1 and b2 are billboards in the same billboard collection,
-    // use the same image for both billboards.
-    b2.image = b1.image;
+     * b.image = 'some/image/url.png';
+     *
+     * // assuming b1 and b2 are billboards in the same billboard collection,
+     * // use the same image for both billboards.
+     * b2.image = b1.image;
      */
     image: string;
     /**
      * When <code>true</code>, this billboard is ready to render, i.e., the image
-    has been downloaded and the WebGL resources are created.
+     * has been downloaded and the WebGL resources are created.
      */
     readonly ready: boolean;
     /**
      * <p>
-    Sets the image to be used for this billboard.  If a texture has already been created for the
-    given id, the existing texture is used.
-    </p>
-    <p>
-    This function is useful for dynamically creating textures that are shared across many billboards.
-    Only the first billboard will actually call the function and create the texture, while subsequent
-    billboards created with the same id will simply re-use the existing texture.
-    </p>
-    <p>
-    To load an image from a URL, setting the {@link Billboard#image} property is more convenient.
-    </p>
+     * Sets the image to be used for this billboard.  If a texture has already been created for the
+     * given id, the existing texture is used.
+     * </p>
+     * <p>
+     * This function is useful for dynamically creating textures that are shared across many billboards.
+     * Only the first billboard will actually call the function and create the texture, while subsequent
+     * billboards created with the same id will simply re-use the existing texture.
+     * </p>
+     * <p>
+     * To load an image from a URL, setting the {@link Billboard#image} property is more convenient.
+     * </p>
      * @example
      * // create a billboard image dynamically
-    function drawImage(id) {
-      // create and draw an image using a canvas
-      const canvas = document.createElement('canvas');
-      const context2D = canvas.getContext('2d');
-      // ... draw image
-      return canvas;
-    }
-    // drawImage will be called to create the texture
-    b.setImage('myImage', drawImage);
-    
-    // subsequent billboards created in the same collection using the same id will use the existing
-    // texture, without the need to create the canvas or draw the image
-    b2.setImage('myImage', drawImage);
+     * function drawImage(id) {
+     *   // create and draw an image using a canvas
+     *   const canvas = document.createElement('canvas');
+     *   const context2D = canvas.getContext('2d');
+     *   // ... draw image
+     *   return canvas;
+     * }
+     * // drawImage will be called to create the texture
+     * b.setImage('myImage', drawImage);
+     *
+     * // subsequent billboards created in the same collection using the same id will use the existing
+     * // texture, without the need to create the canvas or draw the image
+     * b2.setImage('myImage', drawImage);
      * @param id - The id of the image.  This can be any string that uniquely identifies the image.
      * @param image - The image to load.  This parameter
-           can either be a loaded Image or Canvas, a URL which will be loaded as an Image automatically,
-           or a function which will be called to create the image if it hasn't been loaded already.
+     *        can either be a loaded Image or Canvas, a URL which will be loaded as an Image automatically,
+     *        or a function which will be called to create the image if it hasn't been loaded already.
      */
     setImage(id: string, image: HTMLImageElement | HTMLCanvasElement | string | Resource | Billboard.CreateImageCallback): void;
     /**
      * Uses a sub-region of the image with the given id as the image for this billboard,
-    measured in pixels from the bottom-left.
+     * measured in pixels from the bottom-left.
      * @param id - The id of the image to use.
      * @param subRegion - The sub-region of the image.
      */
     setImageSubRegion(id: string, subRegion: BoundingRectangle): void;
     /**
      * Computes the screen-space position of the billboard's origin, taking into account eye and pixel offsets.
-    The screen space origin is the top, left corner of the canvas; <code>x</code> increases from
-    left to right, and <code>y</code> increases from top to bottom.
+     * The screen space origin is the top, left corner of the canvas; <code>x</code> increases from
+     * left to right, and <code>y</code> increases from top to bottom.
      * @example
      * console.log(b.computeScreenSpacePosition(scene).toString());
      * @param scene - The scene.
@@ -25521,7 +25528,7 @@ export class Billboard {
     computeScreenSpacePosition(scene: Scene, result?: Cartesian2): Cartesian2;
     /**
      * Determines if this billboard equals another billboard.  Billboards are equal if all their properties
-    are equal.  Billboards in different collections can be equal.
+     * are equal.  Billboards in different collections can be equal.
      * @param other - The billboard to compare for equality.
      * @returns <code>true</code> if the billboards are equal; otherwise, <code>false</code>.
      */
@@ -27490,32 +27497,32 @@ export class Cesium3DTilePointFeature {
 
 /**
  * A {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification|3D Tiles tileset},
- * used for streaming massive heterogeneous 3D geospatial datasets.
+used for streaming massive heterogeneous 3D geospatial datasets.
  * @example
  * const tileset = scene.primitives.add(new Cesium.Cesium3DTileset({
- *      url : 'http://localhost:8002/tilesets/Seattle/tileset.json'
- * }));
+     url : 'http://localhost:8002/tilesets/Seattle/tileset.json'
+}));
  * @example
  * // Common setting for the skipLevelOfDetail optimization
- * const tileset = scene.primitives.add(new Cesium.Cesium3DTileset({
- *      url : 'http://localhost:8002/tilesets/Seattle/tileset.json',
- *      skipLevelOfDetail : true,
- *      baseScreenSpaceError : 1024,
- *      skipScreenSpaceErrorFactor : 16,
- *      skipLevels : 1,
- *      immediatelyLoadDesiredLevelOfDetail : false,
- *      loadSiblings : false,
- *      cullWithChildrenBounds : true
- * }));
+const tileset = scene.primitives.add(new Cesium.Cesium3DTileset({
+     url : 'http://localhost:8002/tilesets/Seattle/tileset.json',
+     skipLevelOfDetail : true,
+     baseScreenSpaceError : 1024,
+     skipScreenSpaceErrorFactor : 16,
+     skipLevels : 1,
+     immediatelyLoadDesiredLevelOfDetail : false,
+     loadSiblings : false,
+     cullWithChildrenBounds : true
+}));
  * @example
  * // Common settings for the dynamicScreenSpaceError optimization
- * const tileset = scene.primitives.add(new Cesium.Cesium3DTileset({
- *      url : 'http://localhost:8002/tilesets/Seattle/tileset.json',
- *      dynamicScreenSpaceError : true,
- *      dynamicScreenSpaceErrorDensity : 0.00278,
- *      dynamicScreenSpaceErrorFactor : 4.0,
- *      dynamicScreenSpaceErrorHeightFalloff : 0.25
- * }));
+const tileset = scene.primitives.add(new Cesium.Cesium3DTileset({
+     url : 'http://localhost:8002/tilesets/Seattle/tileset.json',
+     dynamicScreenSpaceError : true,
+     dynamicScreenSpaceErrorDensity : 0.00278,
+     dynamicScreenSpaceErrorFactor : 4.0,
+     dynamicScreenSpaceErrorHeightFalloff : 0.25
+}));
  * @param options - Object with the following properties:
  * @param options.url - The url to a tileset JSON file.
  * @param [options.show = true] - Determines if the tileset will be shown.
@@ -27661,68 +27668,68 @@ export class Cesium3DTileset {
     preloadFlightDestinations: boolean;
     /**
      * Optimization option. Whether the tileset should refine based on a dynamic screen space error. Tiles that are further
-     * away will be rendered with lower detail than closer tiles. This improves performance by rendering fewer
-     * tiles and making less requests, but may result in a slight drop in visual quality for tiles in the distance.
-     * The algorithm is biased towards "street views" where the camera is close to the ground plane of the tileset and looking
-     * at the horizon. In addition results are more accurate for tightly fitting bounding volumes like box and region.
+    away will be rendered with lower detail than closer tiles. This improves performance by rendering fewer
+    tiles and making less requests, but may result in a slight drop in visual quality for tiles in the distance.
+    The algorithm is biased towards "street views" where the camera is close to the ground plane of the tileset and looking
+    at the horizon. In addition results are more accurate for tightly fitting bounding volumes like box and region.
      */
     dynamicScreenSpaceError: boolean;
     /**
      * Optimization option. Prioritize loading tiles in the center of the screen by temporarily raising the
-     * screen space error for tiles around the edge of the screen. Screen space error returns to normal once all
-     * the tiles in the center of the screen as determined by the {@link Cesium3DTileset#foveatedConeSize} are loaded.
+    screen space error for tiles around the edge of the screen. Screen space error returns to normal once all
+    the tiles in the center of the screen as determined by the {@link Cesium3DTileset#foveatedConeSize} are loaded.
      */
     foveatedScreenSpaceError: boolean;
     /**
      * Gets or sets a callback to control how much to raise the screen space error for tiles outside the foveated cone,
-     * interpolating between {@link Cesium3DTileset#foveatedMinimumScreenSpaceErrorRelaxation} and {@link Cesium3DTileset#maximumScreenSpaceError}.
+    interpolating between {@link Cesium3DTileset#foveatedMinimumScreenSpaceErrorRelaxation} and {@link Cesium3DTileset#maximumScreenSpaceError}.
      */
     foveatedInterpolationCallback: Cesium3DTileset.foveatedInterpolationCallback;
     /**
      * Optimization option. Used when {@link Cesium3DTileset#foveatedScreenSpaceError} is true to control
-     * how long in seconds to wait after the camera stops moving before deferred tiles start loading in.
-     * This time delay prevents requesting tiles around the edges of the screen when the camera is moving.
-     * Setting this to 0.0 will immediately request all tiles in any given view.
+    how long in seconds to wait after the camera stops moving before deferred tiles start loading in.
+    This time delay prevents requesting tiles around the edges of the screen when the camera is moving.
+    Setting this to 0.0 will immediately request all tiles in any given view.
      */
     foveatedTimeDelay: number;
     /**
      * A scalar that determines the density used to adjust the dynamic screen space error, similar to {@link Fog}. Increasing this
-     * value has the effect of increasing the maximum screen space error for all tiles, but in a non-linear fashion.
-     * The error starts at 0.0 and increases exponentially until a midpoint is reached, and then approaches 1.0 asymptotically.
-     * This has the effect of keeping high detail in the closer tiles and lower detail in the further tiles, with all tiles
-     * beyond a certain distance all roughly having an error of 1.0.
-     * <p>
-     * The dynamic error is in the range [0.0, 1.0) and is multiplied by <code>dynamicScreenSpaceErrorFactor</code> to produce the
-     * final dynamic error. This dynamic error is then subtracted from the tile's actual screen space error.
-     * </p>
-     * <p>
-     * Increasing <code>dynamicScreenSpaceErrorDensity</code> has the effect of moving the error midpoint closer to the camera.
-     * It is analogous to moving fog closer to the camera.
-     * </p>
+    value has the effect of increasing the maximum screen space error for all tiles, but in a non-linear fashion.
+    The error starts at 0.0 and increases exponentially until a midpoint is reached, and then approaches 1.0 asymptotically.
+    This has the effect of keeping high detail in the closer tiles and lower detail in the further tiles, with all tiles
+    beyond a certain distance all roughly having an error of 1.0.
+    <p>
+    The dynamic error is in the range [0.0, 1.0) and is multiplied by <code>dynamicScreenSpaceErrorFactor</code> to produce the
+    final dynamic error. This dynamic error is then subtracted from the tile's actual screen space error.
+    </p>
+    <p>
+    Increasing <code>dynamicScreenSpaceErrorDensity</code> has the effect of moving the error midpoint closer to the camera.
+    It is analogous to moving fog closer to the camera.
+    </p>
      */
     dynamicScreenSpaceErrorDensity: number;
     /**
      * A factor used to increase the screen space error of tiles for dynamic screen space error. As this value increases less tiles
-     * are requested for rendering and tiles in the distance will have lower detail. If set to zero, the feature will be disabled.
+    are requested for rendering and tiles in the distance will have lower detail. If set to zero, the feature will be disabled.
      */
     dynamicScreenSpaceErrorFactor: number;
     /**
      * A ratio of the tileset's height at which the density starts to falloff. If the camera is below this height the
-     * full computed density is applied, otherwise the density falls off. This has the effect of higher density at
-     * street level views.
-     * <p>
-     * Valid values are between 0.0 and 1.0.
-     * </p>
+    full computed density is applied, otherwise the density falls off. This has the effect of higher density at
+    street level views.
+    <p>
+    Valid values are between 0.0 and 1.0.
+    </p>
      */
     dynamicScreenSpaceErrorHeightFalloff: number;
     /**
      * Determines whether the tileset casts or receives shadows from light sources.
-     * <p>
-     * Enabling shadows has a performance impact. A tileset that casts shadows must be rendered twice, once from the camera and again from the light's point of view.
-     * </p>
-     * <p>
-     * Shadows are rendered only when {@link Viewer#shadows} is <code>true</code>.
-     * </p>
+    <p>
+    Enabling shadows has a performance impact. A tileset that casts shadows must be rendered twice, once from the camera and again from the light's point of view.
+    </p>
+    <p>
+    Shadows are rendered only when {@link Viewer#shadows} is <code>true</code>.
+    </p>
      */
     shadows: ShadowMode;
     /**
@@ -27731,212 +27738,212 @@ export class Cesium3DTileset {
     show: boolean;
     /**
      * Defines how per-feature colors set from the Cesium API or declarative styling blend with the source colors from
-     * the original feature, e.g. glTF material or per-point color in the tile.
+    the original feature, e.g. glTF material or per-point color in the tile.
      */
     colorBlendMode: Cesium3DTileColorBlendMode;
     /**
      * Defines the value used to linearly interpolate between the source color and feature color when the {@link Cesium3DTileset#colorBlendMode} is <code>MIX</code>.
-     * A value of 0.0 results in the source color while a value of 1.0 results in the feature color, with any value in-between
-     * resulting in a mix of the source color and feature color.
+    A value of 0.0 results in the source color while a value of 1.0 results in the feature color, with any value in-between
+    resulting in a mix of the source color and feature color.
      */
     colorBlendAmount: number;
     /**
      * The event fired to indicate progress of loading new tiles.  This event is fired when a new tile
-     * is requested, when a requested tile is finished downloading, and when a downloaded tile has been
-     * processed and is ready to render.
-     * <p>
-     * The number of pending tile requests, <code>numberOfPendingRequests</code>, and number of tiles
-     * processing, <code>numberOfTilesProcessing</code> are passed to the event listener.
-     * </p>
-     * <p>
-     * This event is fired at the end of the frame after the scene is rendered.
-     * </p>
+    is requested, when a requested tile is finished downloading, and when a downloaded tile has been
+    processed and is ready to render.
+    <p>
+    The number of pending tile requests, <code>numberOfPendingRequests</code>, and number of tiles
+    processing, <code>numberOfTilesProcessing</code> are passed to the event listener.
+    </p>
+    <p>
+    This event is fired at the end of the frame after the scene is rendered.
+    </p>
      * @example
      * tileset.loadProgress.addEventListener(function(numberOfPendingRequests, numberOfTilesProcessing) {
-     *     if ((numberOfPendingRequests === 0) && (numberOfTilesProcessing === 0)) {
-     *         console.log('Stopped loading');
-     *         return;
-     *     }
-     *
-     *     console.log('Loading: requests: ' + numberOfPendingRequests + ', processing: ' + numberOfTilesProcessing);
-     * });
+        if ((numberOfPendingRequests === 0) && (numberOfTilesProcessing === 0)) {
+            console.log('Stopped loading');
+            return;
+        }
+    
+        console.log('Loading: requests: ' + numberOfPendingRequests + ', processing: ' + numberOfTilesProcessing);
+    });
      */
     loadProgress: Event;
     /**
      * The event fired to indicate that all tiles that meet the screen space error this frame are loaded. The tileset
-     * is completely loaded for this view.
-     * <p>
-     * This event is fired at the end of the frame after the scene is rendered.
-     * </p>
+    is completely loaded for this view.
+    <p>
+    This event is fired at the end of the frame after the scene is rendered.
+    </p>
      * @example
      * tileset.allTilesLoaded.addEventListener(function() {
-     *     console.log('All tiles are loaded');
-     * });
+        console.log('All tiles are loaded');
+    });
      */
     allTilesLoaded: Event;
     /**
      * The event fired to indicate that all tiles that meet the screen space error this frame are loaded. This event
-     * is fired once when all tiles in the initial view are loaded.
-     * <p>
-     * This event is fired at the end of the frame after the scene is rendered.
-     * </p>
+    is fired once when all tiles in the initial view are loaded.
+    <p>
+    This event is fired at the end of the frame after the scene is rendered.
+    </p>
      * @example
      * tileset.initialTilesLoaded.addEventListener(function() {
-     *     console.log('Initial tiles are loaded');
-     * });
+        console.log('Initial tiles are loaded');
+    });
      */
     initialTilesLoaded: Event;
     /**
      * The event fired to indicate that a tile's content was loaded.
-     * <p>
-     * The loaded {@link Cesium3DTile} is passed to the event listener.
-     * </p>
-     * <p>
-     * This event is fired during the tileset traversal while the frame is being rendered
-     * so that updates to the tile take effect in the same frame.  Do not create or modify
-     * Cesium entities or primitives during the event listener.
-     * </p>
+    <p>
+    The loaded {@link Cesium3DTile} is passed to the event listener.
+    </p>
+    <p>
+    This event is fired during the tileset traversal while the frame is being rendered
+    so that updates to the tile take effect in the same frame.  Do not create or modify
+    Cesium entities or primitives during the event listener.
+    </p>
      * @example
      * tileset.tileLoad.addEventListener(function(tile) {
-     *     console.log('A tile was loaded.');
-     * });
+        console.log('A tile was loaded.');
+    });
      */
     tileLoad: Event;
     /**
      * The event fired to indicate that a tile's content was unloaded.
-     * <p>
-     * The unloaded {@link Cesium3DTile} is passed to the event listener.
-     * </p>
-     * <p>
-     * This event is fired immediately before the tile's content is unloaded while the frame is being
-     * rendered so that the event listener has access to the tile's content.  Do not create
-     * or modify Cesium entities or primitives during the event listener.
-     * </p>
+    <p>
+    The unloaded {@link Cesium3DTile} is passed to the event listener.
+    </p>
+    <p>
+    This event is fired immediately before the tile's content is unloaded while the frame is being
+    rendered so that the event listener has access to the tile's content.  Do not create
+    or modify Cesium entities or primitives during the event listener.
+    </p>
      * @example
      * tileset.tileUnload.addEventListener(function(tile) {
-     *     console.log('A tile was unloaded from the cache.');
-     * });
+        console.log('A tile was unloaded from the cache.');
+    });
      */
     tileUnload: Event;
     /**
      * The event fired to indicate that a tile's content failed to load.
-     * <p>
-     * If there are no event listeners, error messages will be logged to the console.
-     * </p>
-     * <p>
-     * The error object passed to the listener contains two properties:
-     * <ul>
-     * <li><code>url</code>: the url of the failed tile.</li>
-     * <li><code>message</code>: the error message.</li>
-     * </ul>
-     * <p>
-     * If multiple contents are present, this event is raised once per inner content with errors.
-     * </p>
+    <p>
+    If there are no event listeners, error messages will be logged to the console.
+    </p>
+    <p>
+    The error object passed to the listener contains two properties:
+    <ul>
+    <li><code>url</code>: the url of the failed tile.</li>
+    <li><code>message</code>: the error message.</li>
+    </ul>
+    <p>
+    If multiple contents are present, this event is raised once per inner content with errors.
+    </p>
      * @example
      * tileset.tileFailed.addEventListener(function(error) {
-     *     console.log('An error occurred loading tile: ' + error.url);
-     *     console.log('Error: ' + error.message);
-     * });
+        console.log('An error occurred loading tile: ' + error.url);
+        console.log('Error: ' + error.message);
+    });
      */
     tileFailed: Event;
     /**
      * This event fires once for each visible tile in a frame.  This can be used to manually
-     * style a tileset.
-     * <p>
-     * The visible {@link Cesium3DTile} is passed to the event listener.
-     * </p>
-     * <p>
-     * This event is fired during the tileset traversal while the frame is being rendered
-     * so that updates to the tile take effect in the same frame.  Do not create or modify
-     * Cesium entities or primitives during the event listener.
-     * </p>
+    style a tileset.
+    <p>
+    The visible {@link Cesium3DTile} is passed to the event listener.
+    </p>
+    <p>
+    This event is fired during the tileset traversal while the frame is being rendered
+    so that updates to the tile take effect in the same frame.  Do not create or modify
+    Cesium entities or primitives during the event listener.
+    </p>
      * @example
      * tileset.tileVisible.addEventListener(function(tile) {
-     *     if (tile.content instanceof Cesium.Batched3DModel3DTileContent) {
-     *         console.log('A Batched 3D Model tile is visible.');
-     *     }
-     * });
+        if (tile.content instanceof Cesium.Batched3DModel3DTileContent) {
+            console.log('A Batched 3D Model tile is visible.');
+        }
+    });
      * @example
      * // Apply a red style and then manually set random colors for every other feature when the tile becomes visible.
-     * tileset.style = new Cesium.Cesium3DTileStyle({
-     *     color : 'color("red")'
-     * });
-     * tileset.tileVisible.addEventListener(function(tile) {
-     *     const content = tile.content;
-     *     const featuresLength = content.featuresLength;
-     *     for (let i = 0; i < featuresLength; i+=2) {
-     *         content.getFeature(i).color = Cesium.Color.fromRandom();
-     *     }
-     * });
+    tileset.style = new Cesium.Cesium3DTileStyle({
+        color : 'color("red")'
+    });
+    tileset.tileVisible.addEventListener(function(tile) {
+        const content = tile.content;
+        const featuresLength = content.featuresLength;
+        for (let i = 0; i < featuresLength; i+=2) {
+            content.getFeature(i).color = Cesium.Color.fromRandom();
+        }
+    });
      */
     tileVisible: Event;
     /**
      * Optimization option. Determines if level of detail skipping should be applied during the traversal.
-     * <p>
-     * The common strategy for replacement-refinement traversal is to store all levels of the tree in memory and require
-     * all children to be loaded before the parent can refine. With this optimization levels of the tree can be skipped
-     * entirely and children can be rendered alongside their parents. The tileset requires significantly less memory when
-     * using this optimization.
-     * </p>
+    <p>
+    The common strategy for replacement-refinement traversal is to store all levels of the tree in memory and require
+    all children to be loaded before the parent can refine. With this optimization levels of the tree can be skipped
+    entirely and children can be rendered alongside their parents. The tileset requires significantly less memory when
+    using this optimization.
+    </p>
      */
     skipLevelOfDetail: boolean;
     /**
      * The screen space error that must be reached before skipping levels of detail.
-     * <p>
-     * Only used when {@link Cesium3DTileset#skipLevelOfDetail} is <code>true</code>.
-     * </p>
+    <p>
+    Only used when {@link Cesium3DTileset#skipLevelOfDetail} is <code>true</code>.
+    </p>
      */
     baseScreenSpaceError: number;
     /**
      * Multiplier defining the minimum screen space error to skip.
-     * For example, if a tile has screen space error of 100, no tiles will be loaded unless they
-     * are leaves or have a screen space error <code><= 100 / skipScreenSpaceErrorFactor</code>.
-     * <p>
-     * Only used when {@link Cesium3DTileset#skipLevelOfDetail} is <code>true</code>.
-     * </p>
+    For example, if a tile has screen space error of 100, no tiles will be loaded unless they
+    are leaves or have a screen space error <code><= 100 / skipScreenSpaceErrorFactor</code>.
+    <p>
+    Only used when {@link Cesium3DTileset#skipLevelOfDetail} is <code>true</code>.
+    </p>
      */
     skipScreenSpaceErrorFactor: number;
     /**
      * Constant defining the minimum number of levels to skip when loading tiles. When it is 0, no levels are skipped.
-     * For example, if a tile is level 1, no tiles will be loaded unless they are at level greater than 2.
-     * <p>
-     * Only used when {@link Cesium3DTileset#skipLevelOfDetail} is <code>true</code>.
-     * </p>
+    For example, if a tile is level 1, no tiles will be loaded unless they are at level greater than 2.
+    <p>
+    Only used when {@link Cesium3DTileset#skipLevelOfDetail} is <code>true</code>.
+    </p>
      */
     skipLevels: number;
     /**
      * When true, only tiles that meet the maximum screen space error will ever be downloaded.
-     * Skipping factors are ignored and just the desired tiles are loaded.
-     * <p>
-     * Only used when {@link Cesium3DTileset#skipLevelOfDetail} is <code>true</code>.
-     * </p>
+    Skipping factors are ignored and just the desired tiles are loaded.
+    <p>
+    Only used when {@link Cesium3DTileset#skipLevelOfDetail} is <code>true</code>.
+    </p>
      */
     immediatelyLoadDesiredLevelOfDetail: boolean;
     /**
      * Determines whether siblings of visible tiles are always downloaded during traversal.
-     * This may be useful for ensuring that tiles are already available when the viewer turns left/right.
-     * <p>
-     * Only used when {@link Cesium3DTileset#skipLevelOfDetail} is <code>true</code>.
-     * </p>
+    This may be useful for ensuring that tiles are already available when the viewer turns left/right.
+    <p>
+    Only used when {@link Cesium3DTileset#skipLevelOfDetail} is <code>true</code>.
+    </p>
      */
     loadSiblings: boolean;
     /**
      * The light color when shading models. When <code>undefined</code> the scene's light color is used instead.
-     * <p>
-     * For example, disabling additional light sources by setting <code>model.imageBasedLighting.imageBasedLightingFactor = new Cartesian2(0.0, 0.0)</code> will make the
-     * model much darker. Here, increasing the intensity of the light source will make the model brighter.
-     * </p>
+    <p>
+    For example, disabling additional light sources by setting <code>model.imageBasedLighting.imageBasedLightingFactor = new Cartesian2(0.0, 0.0)</code> will make the
+    model much darker. Here, increasing the intensity of the light source will make the model brighter.
+    </p>
      */
     lightColor: Cartesian3;
     /**
      * 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.
+    by the glTF material's doubleSided property; when false, back face culling is disabled.
      */
     backFaceCulling: boolean;
     /**
      * 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.
+    {@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.
      */
     readonly showOutline: boolean;
     /**
@@ -27945,79 +27952,79 @@ export class Cesium3DTileset {
     splitDirection: SplitDirection;
     /**
      * This property is for debugging only; it is not optimized for production use.
-     * <p>
-     * Determines if only the tiles from last frame should be used for rendering.  This
-     * effectively "freezes" the tileset to the previous frame so it is possible to zoom
-     * out and see what was rendered.
-     * </p>
+    <p>
+    Determines if only the tiles from last frame should be used for rendering.  This
+    effectively "freezes" the tileset to the previous frame so it is possible to zoom
+    out and see what was rendered.
+    </p>
      */
     debugFreezeFrame: boolean;
     /**
      * This property is for debugging only; it is not optimized for production use.
-     * <p>
-     * When true, assigns a random color to each tile.  This is useful for visualizing
-     * what features belong to what tiles, especially with additive refinement where features
-     * from parent tiles may be interleaved with features from child tiles.
-     * </p>
+    <p>
+    When true, assigns a random color to each tile.  This is useful for visualizing
+    what features belong to what tiles, especially with additive refinement where features
+    from parent tiles may be interleaved with features from child tiles.
+    </p>
      */
     debugColorizeTiles: boolean;
     /**
      * This property is for debugging only; it is not optimized for production use.
-     * <p>
-     * When true, renders each tile's content as a wireframe.
-     * </p>
+    <p>
+    When true, renders each tile's content as a wireframe.
+    </p>
      */
     debugWireframe: boolean;
     /**
      * This property is for debugging only; it is not optimized for production use.
-     * <p>
-     * When true, renders the bounding volume for each visible tile.  The bounding volume is
-     * white if the tile has a content bounding volume or is empty; otherwise, it is red.  Tiles that don't meet the
-     * screen space error and are still refining to their descendants are yellow.
-     * </p>
+    <p>
+    When true, renders the bounding volume for each visible tile.  The bounding volume is
+    white if the tile has a content bounding volume or is empty; otherwise, it is red.  Tiles that don't meet the
+    screen space error and are still refining to their descendants are yellow.
+    </p>
      */
     debugShowBoundingVolume: boolean;
     /**
      * This property is for debugging only; it is not optimized for production use.
-     * <p>
-     * When true, renders the bounding volume for each visible tile's content. The bounding volume is
-     * blue if the tile has a content bounding volume; otherwise it is red.
-     * </p>
+    <p>
+    When true, renders the bounding volume for each visible tile's content. The bounding volume is
+    blue if the tile has a content bounding volume; otherwise it is red.
+    </p>
      */
     debugShowContentBoundingVolume: boolean;
     /**
      * This property is for debugging only; it is not optimized for production use.
-     * <p>
-     * When true, renders the viewer request volume for each tile.
-     * </p>
+    <p>
+    When true, renders the viewer request volume for each tile.
+    </p>
      */
     debugShowViewerRequestVolume: boolean;
     /**
      * This property is for debugging only; it is not optimized for production use.
-     * <p>
-     * When true, draws labels to indicate the geometric error of each tile.
-     * </p>
+    <p>
+    When true, draws labels to indicate the geometric error of each tile.
+    </p>
      */
     debugShowGeometricError: boolean;
     /**
      * This property is for debugging only; it is not optimized for production use.
-     * <p>
-     * When true, draws labels to indicate the number of commands, points, triangles and features of each tile.
-     * </p>
+    <p>
+    When true, draws labels to indicate the number of commands, points, triangles and features of each tile.
+    </p>
      */
     debugShowRenderingStatistics: boolean;
     /**
      * This property is for debugging only; it is not optimized for production use.
-     * <p>
-     * When true, draws labels to indicate the geometry and texture memory usage of each tile.
-     * </p>
+    <p>
+    When true, draws labels to indicate the geometry and texture memory usage of each tile.
+    </p>
      */
     debugShowMemoryUsage: boolean;
     /**
      * This property is for debugging only; it is not optimized for production use.
-     * <p>
-     * When true, draws labels to indicate the url of each tile.
-     * </p>
+    <p>
+    When true, draws labels to indicate the url of each tile.
+    </p>
      */
     debugShowUrl: boolean;
     /**
@@ -28026,10 +28033,10 @@ export class Cesium3DTileset {
     examineVectorLinesFunction: (...params: any[]) => any;
     /**
      * Gets the tileset's asset object property, which contains metadata about the tileset.
-     * <p>
-     * See the {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification#reference-asset|asset schema reference}
-     * in the 3D Tiles spec for the full set of properties.
-     * </p>
+    <p>
+    See the {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification#reference-asset|asset schema reference}
+    in the 3D Tiles spec for the full set of properties.
+    </p>
      */
     readonly asset: any;
     /**
@@ -28042,40 +28049,40 @@ export class Cesium3DTileset {
     clippingPlanes: ClippingPlaneCollection;
     /**
      * Gets the tileset's properties dictionary object, which contains metadata about per-feature properties.
-     * <p>
-     * See the {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification#reference-properties|properties schema reference}
-     * in the 3D Tiles spec for the full set of properties.
-     * </p>
+    <p>
+    See the {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification#reference-properties|properties schema reference}
+    in the 3D Tiles spec for the full set of properties.
+    </p>
      * @example
      * console.log('Maximum building height: ' + tileset.properties.height.maximum);
-     * console.log('Minimum building height: ' + tileset.properties.height.minimum);
+    console.log('Minimum building height: ' + tileset.properties.height.minimum);
      */
     readonly properties: any;
     /**
      * When <code>true</code>, the tileset's root tile is loaded and the tileset is ready to render.
-     * This is set to <code>true</code> right before {@link Cesium3DTileset#readyPromise} is resolved.
+    This is set to <code>true</code> right before {@link Cesium3DTileset#readyPromise} is resolved.
      */
     readonly ready: boolean;
     /**
      * Gets the promise that will be resolved when the tileset's root tile is loaded and the tileset is ready to render.
-     * <p>
-     * This promise is resolved at the end of the frame before the first frame the tileset is rendered in.
-     * </p>
+    <p>
+    This promise is resolved at the end of the frame before the first frame the tileset is rendered in.
+    </p>
      * @example
      * tileset.readyPromise.then(function(tileset) {
-     *     // tile.properties is not defined until readyPromise resolves.
-     *     const properties = tileset.properties;
-     *     if (Cesium.defined(properties)) {
-     *         for (const name in properties) {
-     *             console.log(properties[name]);
-     *         }
-     *     }
-     * });
+        // tile.properties is not defined until readyPromise resolves.
+        const properties = tileset.properties;
+        if (Cesium.defined(properties)) {
+            for (const name in properties) {
+                console.log(properties[name]);
+            }
+        }
+    });
      */
     readonly readyPromise: Promise<Cesium3DTileset>;
     /**
      * When <code>true</code>, all tiles that meet the screen space error this frame are loaded. The tileset is
-     * completely loaded for this view.
+    completely loaded for this view.
      */
     readonly tilesLoaded: boolean;
     /**
@@ -28088,82 +28095,82 @@ export class Cesium3DTileset {
     readonly basePath: string;
     /**
      * The style, defined using the
-     * {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification/Styling|3D Tiles Styling language},
-     * applied to each feature in the tileset.
-     * <p>
-     * Assign <code>undefined</code> to remove the style, which will restore the visual
-     * appearance of the tileset to its default when no style was applied.
-     * </p>
-     * <p>
-     * The style is applied to a tile before the {@link Cesium3DTileset#tileVisible}
-     * event is raised, so code in <code>tileVisible</code> can manually set a feature's
-     * properties (e.g. color and show) after the style is applied. When
-     * a new style is assigned any manually set properties are overwritten.
-     * </p>
-     * <p>
-     * Use an always "true" condition to specify the Color for all objects that are not
-     * overridden by pre-existing conditions. Otherwise, the default color Cesium.Color.White
-     * will be used. Similarly, use an always "true" condition to specify the show property
-     * for all objects that are not overridden by pre-existing conditions. Otherwise, the
-     * default show value true will be used.
-     * </p>
+    {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification/Styling|3D Tiles Styling language},
+    applied to each feature in the tileset.
+    <p>
+    Assign <code>undefined</code> to remove the style, which will restore the visual
+    appearance of the tileset to its default when no style was applied.
+    </p>
+    <p>
+    The style is applied to a tile before the {@link Cesium3DTileset#tileVisible}
+    event is raised, so code in <code>tileVisible</code> can manually set a feature's
+    properties (e.g. color and show) after the style is applied. When
+    a new style is assigned any manually set properties are overwritten.
+    </p>
+    <p>
+    Use an always "true" condition to specify the Color for all objects that are not
+    overridden by pre-existing conditions. Otherwise, the default color Cesium.Color.White
+    will be used. Similarly, use an always "true" condition to specify the show property
+    for all objects that are not overridden by pre-existing conditions. Otherwise, the
+    default show value true will be used.
+    </p>
      * @example
      * tileset.style = new Cesium.Cesium3DTileStyle({
-     *    color : {
-     *        conditions : [
-     *            ['${Height} >= 100', 'color("purple", 0.5)'],
-     *            ['${Height} >= 50', 'color("red")'],
-     *            ['true', 'color("blue")']
-     *        ]
-     *    },
-     *    show : '${Height} > 0',
-     *    meta : {
-     *        description : '"Building id ${id} has height ${Height}."'
-     *    }
-     * });
+       color : {
+           conditions : [
+               ['${Height} >= 100', 'color("purple", 0.5)'],
+               ['${Height} >= 50', 'color("red")'],
+               ['true', 'color("blue")']
+           ]
+       },
+       show : '${Height} > 0',
+       meta : {
+           description : '"Building id ${id} has height ${Height}."'
+       }
+    });
      */
     style: Cesium3DTileStyle | undefined;
     /**
      * A custom shader to apply to all tiles in the tileset. Only used for
-     * contents that use {@link ModelExperimental}. Using custom shaders with a
-     * {@link Cesium3DTileStyle} may lead to undefined behavior.
-     * <p>
-     * To enable {@link ModelExperimental}, set {@link ExperimentalFeatures.enableModelExperimental} or tileset.enableModelExperimental to <code>true</code>.
-     * </p>
+    contents that use {@link ModelExperimental}. Using custom shaders with a
+    {@link Cesium3DTileStyle} may lead to undefined behavior.
+    <p>
+    To enable {@link ModelExperimental}, set {@link ExperimentalFeatures.enableModelExperimental} or tileset.enableModelExperimental to <code>true</code>.
+    </p>
      */
     customShader: CustomShader | undefined;
     /**
      * The maximum screen space error used to drive level of detail refinement.  This value helps determine when a tile
-     * refines to its descendants, and therefore plays a major role in balancing performance with visual quality.
-     * <p>
-     * A tile's screen space error is roughly equivalent to the number of pixels wide that would be drawn if a sphere with a
-     * radius equal to the tile's <b>geometric error</b> were rendered at the tile's position. If this value exceeds
-     * <code>maximumScreenSpaceError</code> the tile refines to its descendants.
-     * </p>
-     * <p>
-     * Depending on the tileset, <code>maximumScreenSpaceError</code> may need to be tweaked to achieve the right balance.
-     * Higher values provide better performance but lower visual quality.
-     * </p>
+    refines to its descendants, and therefore plays a major role in balancing performance with visual quality.
+    <p>
+    A tile's screen space error is roughly equivalent to the number of pixels wide that would be drawn if a sphere with a
+    radius equal to the tile's <b>geometric error</b> were rendered at the tile's position. If this value exceeds
+    <code>maximumScreenSpaceError</code> the tile refines to its descendants.
+    </p>
+    <p>
+    Depending on the tileset, <code>maximumScreenSpaceError</code> may need to be tweaked to achieve the right balance.
+    Higher values provide better performance but lower visual quality.
+    </p>
      */
     maximumScreenSpaceError: number;
     /**
      * The maximum amount of GPU memory (in MB) that may be used to cache tiles. This value is estimated from
-     * geometry, textures, and batch table textures of loaded tiles. For point clouds, this value also
-     * includes per-point metadata.
-     * <p>
-     * Tiles not in view are unloaded to enforce this.
-     * </p>
-     * <p>
-     * If decreasing this value results in unloading tiles, the tiles are unloaded the next frame.
-     * </p>
-     * <p>
-     * If tiles sized more than <code>maximumMemoryUsage</code> are needed
-     * to meet the desired screen space error, determined by {@link Cesium3DTileset#maximumScreenSpaceError},
-     * for the current view, then the memory usage of the tiles loaded will exceed
-     * <code>maximumMemoryUsage</code>.  For example, if the maximum is 256 MB, but
-     * 300 MB of tiles are needed to meet the screen space error, then 300 MB of tiles may be loaded.  When
-     * these tiles go out of view, they will be unloaded.
-     * </p>
+    geometry, textures, and batch table textures of loaded tiles. For point clouds, this value also
+    includes per-point metadata.
+    <p>
+    Tiles not in view are unloaded to enforce this.
+    </p>
+    <p>
+    If decreasing this value results in unloading tiles, the tiles are unloaded the next frame.
+    </p>
+    <p>
+    If tiles sized more than <code>maximumMemoryUsage</code> are needed
+    to meet the desired screen space error, determined by {@link Cesium3DTileset#maximumScreenSpaceError},
+    for the current view, then the memory usage of the tiles loaded will exceed
+    <code>maximumMemoryUsage</code>.  For example, if the maximum is 256 MB, but
+    300 MB of tiles are needed to meet the screen space error, then 300 MB of tiles may be loaded.  When
+    these tiles go out of view, they will be unloaded.
+    </p>
      */
     maximumMemoryUsage: number;
     /**
@@ -28178,26 +28185,26 @@ export class Cesium3DTileset {
      * The tileset's bounding sphere.
      * @example
      * const tileset = viewer.scene.primitives.add(new Cesium.Cesium3DTileset({
-     *     url : 'http://localhost:8002/tilesets/Seattle/tileset.json'
-     * }));
-     *
-     * tileset.readyPromise.then(function(tileset) {
-     *     // Set the camera to view the newly added tileset
-     *     viewer.camera.viewBoundingSphere(tileset.boundingSphere, new Cesium.HeadingPitchRange(0, -0.5, 0));
-     * });
+        url : 'http://localhost:8002/tilesets/Seattle/tileset.json'
+    }));
+    
+    tileset.readyPromise.then(function(tileset) {
+        // Set the camera to view the newly added tileset
+        viewer.camera.viewBoundingSphere(tileset.boundingSphere, new Cesium.HeadingPitchRange(0, -0.5, 0));
+    });
      */
     readonly boundingSphere: BoundingSphere;
     /**
      * A 4x4 transformation matrix that transforms the entire tileset.
      * @example
      * // Adjust a tileset's height from the globe's surface.
-     * const heightOffset = 20.0;
-     * const boundingSphere = tileset.boundingSphere;
-     * const cartographic = Cesium.Cartographic.fromCartesian(boundingSphere.center);
-     * const surface = Cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, 0.0);
-     * const offset = Cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, heightOffset);
-     * const translation = Cesium.Cartesian3.subtract(offset, surface, new Cesium.Cartesian3());
-     * tileset.modelMatrix = Cesium.Matrix4.fromTranslation(translation);
+    const heightOffset = 20.0;
+    const boundingSphere = tileset.boundingSphere;
+    const cartographic = Cesium.Cartographic.fromCartesian(boundingSphere.center);
+    const surface = Cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, 0.0);
+    const offset = Cesium.Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, heightOffset);
+    const translation = Cesium.Cartesian3.subtract(offset, surface, new Cesium.Cartesian3());
+    tileset.modelMatrix = Cesium.Matrix4.fromTranslation(translation);
      */
     modelMatrix: Matrix4;
     /**
@@ -28206,28 +28213,28 @@ export class Cesium3DTileset {
     readonly timeSinceLoad: number;
     /**
      * The total amount of GPU memory in bytes used by the tileset. This value is estimated from
-     * geometry, texture, and batch table textures of loaded tiles. For point clouds, this value also
-     * includes per-point metadata.
+    geometry, texture, and batch table textures of loaded tiles. For point clouds, this value also
+    includes per-point metadata.
      */
     readonly totalMemoryUsageInBytes: number;
     /**
      * Determines whether terrain, 3D Tiles or both will be classified by this tileset.
-     * <p>
-     * This option is only applied to tilesets containing batched 3D models, geometry data, or vector data. Even when undefined, vector data and geometry data
-     * must render as classifications and will default to rendering on both terrain and other 3D Tiles tilesets.
-     * </p>
-     * <p>
-     * When enabled for batched 3D model tilesets, there are a few requirements/limitations on the glTF:
-     * <ul>
-     *     <li>POSITION and _BATCHID semantics are required.</li>
-     *     <li>All indices with the same batch id must occupy contiguous sections of the index buffer.</li>
-     *     <li>All shaders and techniques are ignored. The generated shader simply multiplies the position by the model-view-projection matrix.</li>
-     *     <li>The only supported extensions are CESIUM_RTC and WEB3D_quantized_attributes.</li>
-     *     <li>Only one node is supported.</li>
-     *     <li>Only one mesh per node is supported.</li>
-     *     <li>Only one primitive per mesh is supported.</li>
-     * </ul>
-     * </p>
+    <p>
+    This option is only applied to tilesets containing batched 3D models, geometry data, or vector data. Even when undefined, vector data and geometry data
+    must render as classifications and will default to rendering on both terrain and other 3D Tiles tilesets.
+    </p>
+    <p>
+    When enabled for batched 3D model tilesets, there are a few requirements/limitations on the glTF:
+    <ul>
+        <li>POSITION and _BATCHID semantics are required.</li>
+        <li>All indices with the same batch id must occupy contiguous sections of the index buffer.</li>
+        <li>All shaders and techniques are ignored. The generated shader simply multiplies the position by the model-view-projection matrix.</li>
+        <li>The only supported extensions are CESIUM_RTC and WEB3D_quantized_attributes.</li>
+        <li>Only one node is supported.</li>
+        <li>Only one mesh per node is supported.</li>
+        <li>Only one primitive per mesh is supported.</li>
+    </ul>
+    </p>
      */
     readonly classificationType: ClassificationType;
     /**
@@ -28236,18 +28243,18 @@ export class Cesium3DTileset {
     readonly ellipsoid: Ellipsoid;
     /**
      * Optimization option. Used when {@link Cesium3DTileset#foveatedScreenSpaceError} is true to control the cone size that determines which tiles are deferred.
-     * Tiles that are inside this cone are loaded immediately. Tiles outside the cone are potentially deferred based on how far outside the cone they are and {@link Cesium3DTileset#foveatedInterpolationCallback} and {@link Cesium3DTileset#foveatedMinimumScreenSpaceErrorRelaxation}.
-     * Setting this to 0.0 means the cone will be the line formed by the camera position and its view direction. Setting this to 1.0 means the cone encompasses the entire field of view of the camera, essentially disabling the effect.
+    Tiles that are inside this cone are loaded immediately. Tiles outside the cone are potentially deferred based on how far outside the cone they are and {@link Cesium3DTileset#foveatedInterpolationCallback} and {@link Cesium3DTileset#foveatedMinimumScreenSpaceErrorRelaxation}.
+    Setting this to 0.0 means the cone will be the line formed by the camera position and its view direction. Setting this to 1.0 means the cone encompasses the entire field of view of the camera, essentially disabling the effect.
      */
     foveatedConeSize: number;
     /**
      * Optimization option. Used when {@link Cesium3DTileset#foveatedScreenSpaceError} is true to control the starting screen space error relaxation for tiles outside the foveated cone.
-     * The screen space error will be raised starting with this value up to {@link Cesium3DTileset#maximumScreenSpaceError} based on the provided {@link Cesium3DTileset#foveatedInterpolationCallback}.
+    The screen space error will be raised starting with this value up to {@link Cesium3DTileset#maximumScreenSpaceError} based on the provided {@link Cesium3DTileset#foveatedInterpolationCallback}.
      */
     foveatedMinimumScreenSpaceErrorRelaxation: number;
     /**
      * Returns the <code>extras</code> property at the top-level of the tileset JSON, which contains application specific metadata.
-     * Returns <code>undefined</code> if <code>extras</code> does not exist.
+    Returns <code>undefined</code> if <code>extras</code> does not exist.
      */
     readonly extras: any;
     /**
@@ -28256,25 +28263,25 @@ export class Cesium3DTileset {
     imageBasedLighting: ImageBasedLighting;
     /**
      * Cesium adds lighting from the earth, sky, atmosphere, and star skybox. This cartesian is used to scale the final
-     * diffuse and specular lighting contribution from those sources to the final color. A value of 0.0 will disable those light sources.
+    diffuse and specular lighting contribution from those sources to the final color. A value of 0.0 will disable those light sources.
      */
     imageBasedLightingFactor: Cartesian2;
     /**
      * The sun's luminance at the zenith in kilo candela per meter squared to use for this model's procedural environment map.
-     * This is used when {@link Cesium3DTileset#specularEnvironmentMaps} and {@link Cesium3DTileset#sphericalHarmonicCoefficients} are not defined.
+    This is used when {@link Cesium3DTileset#specularEnvironmentMaps} and {@link Cesium3DTileset#sphericalHarmonicCoefficients} are not defined.
      */
     luminanceAtZenith: number;
     /**
      * The third order spherical harmonic coefficients used for the diffuse color of image-based lighting. When <code>undefined</code>, a diffuse irradiance
-     * computed from the atmosphere color is used.
-     * <p>
-     * There are nine <code>Cartesian3</code> coefficients.
-     * The order of the coefficients is: L<sub>0,0</sub>, L<sub>1,-1</sub>, L<sub>1,0</sub>, L<sub>1,1</sub>, L<sub>2,-2</sub>, L<sub>2,-1</sub>, L<sub>2,0</sub>, L<sub>2,1</sub>, L<sub>2,2</sub>
-     * </p>
-     *
-     * These values can be obtained by preprocessing the environment map using the <code>cmgen</code> tool of
-     * {@link https://github.com/google/filament/releases|Google's Filament project}. This will also generate a KTX file that can be
-     * supplied to {@link Cesium3DTileset#specularEnvironmentMaps}.
+    computed from the atmosphere color is used.
+    <p>
+    There are nine <code>Cartesian3</code> coefficients.
+    The order of the coefficients is: L<sub>0,0</sub>, L<sub>1,-1</sub>, L<sub>1,0</sub>, L<sub>1,1</sub>, L<sub>2,-2</sub>, L<sub>2,-1</sub>, L<sub>2,0</sub>, L<sub>2,1</sub>, L<sub>2,2</sub>
+    </p>
+    
+    These values can be obtained by preprocessing the environment map using the <code>cmgen</code> tool of
+    {@link https://github.com/google/filament/releases|Google's Filament project}. This will also generate a KTX file that can be
+    supplied to {@link Cesium3DTileset#specularEnvironmentMaps}.
      */
     sphericalHarmonicCoefficients: Cartesian3[];
     /**
@@ -28287,7 +28294,7 @@ export class Cesium3DTileset {
     vectorClassificationOnly: boolean;
     /**
      * Whether vector tiles should keep decoded positions in memory.
-     * This is used with {@link Cesium3DTileFeature.getPolylinePositions}.
+    This is used with {@link Cesium3DTileFeature.getPolylinePositions}.
      */
     vectorKeepDecodedPositions: boolean;
     /**
@@ -28296,52 +28303,52 @@ export class Cesium3DTileset {
     showCreditsOnScreen: boolean;
     /**
      * Label of the feature ID set to use for picking and styling.
-     * <p>
-     * For EXT_mesh_features, this is the feature ID's label property, or
-     * "featureId_N" (where N is the index in the featureIds array) when not
-     * specified. EXT_feature_metadata did not have a label field, so such
-     * feature ID sets are always labeled "featureId_N" where N is the index in
-     * the list of all feature Ids, where feature ID attributes are listed before
-     * feature ID textures.
-     * </p>
-     * <p>
-     * If featureIdLabel is set to an integer N, it is converted to
-     * the string "featureId_N" automatically. If both per-primitive and
-     * per-instance feature IDs are present, the instance feature IDs take
-     * priority.
-     * </p>
+    <p>
+    For EXT_mesh_features, this is the feature ID's label property, or
+    "featureId_N" (where N is the index in the featureIds array) when not
+    specified. EXT_feature_metadata did not have a label field, so such
+    feature ID sets are always labeled "featureId_N" where N is the index in
+    the list of all feature Ids, where feature ID attributes are listed before
+    feature ID textures.
+    </p>
+    <p>
+    If featureIdLabel is set to an integer N, it is converted to
+    the string "featureId_N" automatically. If both per-primitive and
+    per-instance feature IDs are present, the instance feature IDs take
+    priority.
+    </p>
      */
     featureIdLabel: string;
     /**
      * Label of the instance feature ID set used for picking and styling.
-     * <p>
-     * If instanceFeatureIdLabel is set to an integer N, it is converted to
-     * the string "instanceFeatureId_N" automatically.
-     * If both per-primitive and per-instance feature IDs are present, the
-     * instance feature IDs take priority.
-     * </p>
+    <p>
+    If instanceFeatureIdLabel is set to an integer N, it is converted to
+    the string "instanceFeatureId_N" automatically.
+    If both per-primitive and per-instance feature IDs are present, the
+    instance feature IDs take priority.
+    </p>
      */
     instanceFeatureIdLabel: string;
     /**
      * Provides a hook to override the method used to request the tileset json
-     * useful when fetching tilesets from remote servers
+    useful when fetching tilesets from remote servers
      * @param tilesetUrl - The url of the json file to be fetched
      * @returns A promise that resolves with the fetched json data
      */
     static loadJson(tilesetUrl: Resource | string): Promise<object>;
     /**
      * Marks the tileset's {@link Cesium3DTileset#style} as dirty, which forces all
-     * features to re-evaluate the style in the next frame each is visible.
+    features to re-evaluate the style in the next frame each is visible.
      */
     makeStyleDirty(): void;
     /**
      * Unloads all tiles that weren't selected the previous frame.  This can be used to
-     * explicitly manage the tile cache and reduce the total number of tiles loaded below
-     * {@link Cesium3DTileset#maximumMemoryUsage}.
-     * <p>
-     * Tile unloads occur at the next frame to keep all the WebGL delete calls
-     * within the render loop.
-     * </p>
+    explicitly manage the tile cache and reduce the total number of tiles loaded below
+    {@link Cesium3DTileset#maximumMemoryUsage}.
+    <p>
+    Tile unloads occur at the next frame to keep all the WebGL delete calls
+    within the render loop.
+    </p>
      */
     trimLoadedTiles(): void;
     /**
@@ -28352,19 +28359,19 @@ export class Cesium3DTileset {
     hasExtension(extensionName: string): 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 <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
      * tileset = tileset && tileset.destroy();
      */
@@ -28374,7 +28381,7 @@ export class Cesium3DTileset {
 export namespace Cesium3DTileset {
     /**
      * Optimization option. Used as a callback when {@link Cesium3DTileset#foveatedScreenSpaceError} is true to control how much to raise the screen space error for tiles outside the foveated cone,
-     * interpolating between {@link Cesium3DTileset#foveatedMinimumScreenSpaceErrorRelaxation} and {@link Cesium3DTileset#maximumScreenSpaceError}.
+    interpolating between {@link Cesium3DTileset#foveatedMinimumScreenSpaceErrorRelaxation} and {@link Cesium3DTileset#maximumScreenSpaceError}.
      * @param p - The start value to interpolate.
      * @param q - The end value to interpolate.
      * @param time - The time of interpolation generally in the range <code>[0.0, 1.0]</code>.
@@ -31144,8 +31151,8 @@ export namespace GoogleEarthEnterpriseImageryProvider {
      * @property metadata - A metadata object that can be used to share metadata requests with a GoogleEarthEnterpriseTerrainProvider.
      * @property [ellipsoid] - The ellipsoid.  If not specified, the WGS84 ellipsoid is used.
      * @property [tileDiscardPolicy] - The policy that determines if a tile
-           is invalid and should be discarded. If this value is not specified, a default
-           is to discard tiles that fail to download.
+     *        is invalid and should be discarded. If this value is not specified, a default
+     *        is to discard tiles that fail to download.
      * @property [credit] - A credit for the data source, which is displayed on the canvas.
      */
     type ConstructorOptions = {
@@ -31159,41 +31166,41 @@ export namespace GoogleEarthEnterpriseImageryProvider {
 
 /**
  * Provides tiled imagery using the Google Earth Enterprise REST API.
-
-Notes: This provider is for use with the 3D Earth API of Google Earth Enterprise,
-       {@link GoogleEarthEnterpriseMapsProvider} should be used with 2D Maps API.
+ *
+ * Notes: This provider is for use with the 3D Earth API of Google Earth Enterprise,
+ *        {@link GoogleEarthEnterpriseMapsProvider} should be used with 2D Maps API.
  * @example
  * const geeMetadata = new GoogleEarthEnterpriseMetadata('http://www.earthenterprise.org/3d');
-const gee = new Cesium.GoogleEarthEnterpriseImageryProvider({
-    metadata : geeMetadata
-});
+ * const gee = new Cesium.GoogleEarthEnterpriseImageryProvider({
+ *     metadata : geeMetadata
+ * });
  * @param options - Object describing initialization options
  */
 export class GoogleEarthEnterpriseImageryProvider {
     constructor(options: GoogleEarthEnterpriseImageryProvider.ConstructorOptions);
     /**
      * The default alpha blending value of this provider, with 0.0 representing fully transparent and
-    1.0 representing fully opaque.
+     * 1.0 representing fully opaque.
      */
     defaultAlpha: number | undefined;
     /**
      * The default alpha blending value on the night side of the globe of this provider, with 0.0 representing fully transparent and
-    1.0 representing fully opaque.
+     * 1.0 representing fully opaque.
      */
     defaultNightAlpha: number | undefined;
     /**
      * The default alpha blending value on the day side of the globe of this provider, with 0.0 representing fully transparent and
-    1.0 representing fully opaque.
+     * 1.0 representing fully opaque.
      */
     defaultDayAlpha: number | undefined;
     /**
      * The default brightness of this provider.  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.
      */
     defaultBrightness: number | undefined;
     /**
      * The default contrast of this provider.  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.
      */
     defaultContrast: number | undefined;
     /**
@@ -31202,7 +31209,7 @@ export class GoogleEarthEnterpriseImageryProvider {
     defaultHue: number | undefined;
     /**
      * The default saturation of this provider. 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.
      */
     defaultSaturation: number | undefined;
     /**
@@ -31227,45 +31234,45 @@ export class GoogleEarthEnterpriseImageryProvider {
     readonly proxy: Proxy;
     /**
      * Gets the width of each tile, in pixels. This function should
-    not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
+     * not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
      */
     readonly tileWidth: number;
     /**
      * Gets the height of each tile, in pixels.  This function should
-    not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
+     * not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
      */
     readonly tileHeight: number;
     /**
      * Gets the maximum level-of-detail that can be requested.  This function should
-    not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
+     * not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
      */
     readonly maximumLevel: number | undefined;
     /**
      * Gets the minimum level-of-detail that can be requested.  This function should
-    not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
+     * not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
      */
     readonly minimumLevel: number;
     /**
      * Gets the tiling scheme used by this provider.  This function should
-    not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
+     * not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
      */
     readonly tilingScheme: TilingScheme;
     /**
      * Gets the rectangle, in radians, of the imagery provided by this instance.  This function should
-    not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
+     * not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
      */
     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.  This function should
-    not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
+     * for filtering out "missing" tiles via its shouldDiscardImage function.  If this function
+     * returns undefined, no tiles are filtered.  This function should
+     * not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
      */
     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;
     /**
@@ -31278,15 +31285,15 @@ export class GoogleEarthEnterpriseImageryProvider {
     readonly readyPromise: Promise<boolean>;
     /**
      * Gets the credit to display when this imagery provider is active.  Typically this is used to credit
-    the source of the imagery.  This function should not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
+     * the source of the imagery.  This function should not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
      */
     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.  Setting this property to false reduces memory usage
-    and texture upload time.
+     * 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.  Setting this property to false reduces memory usage
+     * and texture upload time.
      */
     readonly hasAlphaChannel: boolean;
     /**
@@ -31299,29 +31306,29 @@ export class GoogleEarthEnterpriseImageryProvider {
     getTileCredits(x: number, y: number, level: number): Credit[];
     /**
      * Requests the image for a given tile.  This function should
-    not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
+     * not be called before {@link GoogleEarthEnterpriseImageryProvider#ready} returns true.
      * @param x - The tile X coordinate.
      * @param y - The tile Y coordinate.
      * @param level - The tile level.
      * @param [request] - The request object. Intended for internal use only.
      * @returns A promise for the image that will resolve when the image is available, or
-             undefined if there are too many active requests to the server, and the request
-             should be retried later.  The resolved image may be either an
-             Image or a Canvas DOM object.
+     *          undefined if there are too many active requests to the server, and the request
+     *          should be retried later.  The resolved image may be either an
+     *          Image or a Canvas DOM object.
      */
     requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement> | undefined;
     /**
      * Picking features is not currently supported by this imagery provider, so this function simply returns
-    undefined.
+     * undefined.
      * @param x - The tile X coordinate.
      * @param y - The tile Y coordinate.
      * @param level - The tile level.
      * @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.
-                      It may also be undefined if picking is not supported.
+     *                   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.
+     *                   It may also be undefined if picking is not supported.
      */
     pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
 }
@@ -31571,8 +31578,8 @@ export namespace GridImageryProvider {
      * Initialization options for the GridImageryProvider constructor
      * @property [tilingScheme = new GeographicTilingScheme()] - The tiling scheme for which to draw 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 [cells = 8] - The number of grids cells.
      * @property [color = Color(1.0, 1.0, 1.0, 0.4)] - The color to draw grid lines.
      * @property [glowColor = Color(0.0, 1.0, 0.0, 0.05)] - The color to draw glow for grid lines.
@@ -31598,34 +31605,34 @@ export namespace GridImageryProvider {
 
 /**
  * An {@link ImageryProvider} that draws a wireframe grid on every tile with controllable background and glow.
-May be useful for custom rendering effects or debugging terrain.
+ * May be useful for custom rendering effects or debugging terrain.
  * @param options - Object describing initialization options
  */
 export class GridImageryProvider {
     constructor(options: GridImageryProvider.ConstructorOptions);
     /**
      * The default alpha blending value of this provider, with 0.0 representing fully transparent and
-    1.0 representing fully opaque.
+     * 1.0 representing fully opaque.
      */
     defaultAlpha: number | undefined;
     /**
      * The default alpha blending value on the night side of the globe of this provider, with 0.0 representing fully transparent and
-    1.0 representing fully opaque.
+     * 1.0 representing fully opaque.
      */
     defaultNightAlpha: number | undefined;
     /**
      * The default alpha blending value on the day side of the globe of this provider, with 0.0 representing fully transparent and
-    1.0 representing fully opaque.
+     * 1.0 representing fully opaque.
      */
     defaultDayAlpha: number | undefined;
     /**
      * The default brightness of this provider.  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.
      */
     defaultBrightness: number | undefined;
     /**
      * The default contrast of this provider.  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.
      */
     defaultContrast: number | undefined;
     /**
@@ -31634,7 +31641,7 @@ export class GridImageryProvider {
     defaultHue: number | undefined;
     /**
      * The default saturation of this provider. 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.
      */
     defaultSaturation: number | undefined;
     /**
@@ -31655,45 +31662,45 @@ export class GridImageryProvider {
     readonly proxy: Proxy;
     /**
      * Gets the width of each tile, in pixels. This function should
-    not be called before {@link GridImageryProvider#ready} returns true.
+     * not be called before {@link GridImageryProvider#ready} returns true.
      */
     readonly tileWidth: number;
     /**
      * Gets the height of each tile, in pixels.  This function should
-    not be called before {@link GridImageryProvider#ready} returns true.
+     * not be called before {@link GridImageryProvider#ready} returns true.
      */
     readonly tileHeight: number;
     /**
      * Gets the maximum level-of-detail that can be requested.  This function should
-    not be called before {@link GridImageryProvider#ready} returns true.
+     * not be called before {@link GridImageryProvider#ready} returns true.
      */
     readonly maximumLevel: number | undefined;
     /**
      * Gets the minimum level-of-detail that can be requested.  This function should
-    not be called before {@link GridImageryProvider#ready} returns true.
+     * not be called before {@link GridImageryProvider#ready} returns true.
      */
     readonly minimumLevel: number;
     /**
      * Gets the tiling scheme used by this provider.  This function should
-    not be called before {@link GridImageryProvider#ready} returns true.
+     * not be called before {@link GridImageryProvider#ready} returns true.
      */
     readonly tilingScheme: TilingScheme;
     /**
      * Gets the rectangle, in radians, of the imagery provided by this instance.  This function should
-    not be called before {@link GridImageryProvider#ready} returns true.
+     * not be called before {@link GridImageryProvider#ready} returns true.
      */
     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.  This function should
-    not be called before {@link GridImageryProvider#ready} returns true.
+     * for filtering out "missing" tiles via its shouldDiscardImage function.  If this function
+     * returns undefined, no tiles are filtered.  This function should
+     * not be called before {@link GridImageryProvider#ready} returns true.
      */
     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;
     /**
@@ -31706,15 +31713,15 @@ export class GridImageryProvider {
     readonly readyPromise: Promise<boolean>;
     /**
      * Gets the credit to display when this imagery provider is active.  Typically this is used to credit
-    the source of the imagery.  This function should not be called before {@link GridImageryProvider#ready} returns true.
+     * the source of the imagery.  This function should not be called before {@link GridImageryProvider#ready} returns true.
      */
     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;
     /**
@@ -31735,29 +31742,29 @@ export class GridImageryProvider {
     getTileCredits(x: number, y: number, level: number): Credit[];
     /**
      * Requests the image for a given tile.  This function should
-    not be called before {@link GridImageryProvider#ready} returns true.
+     * not be called before {@link GridImageryProvider#ready} returns true.
      * @param x - The tile X coordinate.
      * @param y - The tile Y coordinate.
      * @param level - The tile level.
      * @param [request] - The request object. Intended for internal use only.
      * @returns A promise for the image that will resolve when the image is available, or
-             undefined if there are too many active requests to the server, and the request
-             should be retried later.  The resolved image may be either an
-             Image or a Canvas DOM object.
+     *          undefined if there are too many active requests to the server, and the request
+     *          should be retried later.  The resolved image may be either an
+     *          Image or a Canvas DOM object.
      */
     requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement> | undefined;
     /**
      * Picking features is not currently supported by this imagery provider, so this function simply returns
-    undefined.
+     * undefined.
      * @param x - The tile X coordinate.
      * @param y - The tile Y coordinate.
      * @param level - The tile level.
      * @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.
-                      It may also be undefined if picking is not supported.
+     *                   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.
+     *                   It may also be undefined if picking is not supported.
      */
     pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
 }
@@ -32277,85 +32284,85 @@ export class ImageBasedLighting {
 
 /**
  * An imagery layer that displays tiled image data from a single imagery provider
- * on a {@link Globe}.
+on a {@link Globe}.
  * @param imageryProvider - The imagery provider to use.
  * @param [options] - Object with the following properties:
  * @param [options.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.
  * @param [options.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.
  * @param [options.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>.
  * @param [options.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>.
  * @param [options.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.
  * @param [options.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.
  * @param [options.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.
  * @param [options.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.
  * @param [options.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.
  * @param [options.splitDirection = SplitDirection.NONE] - The {@link SplitDirection} split to apply to this layer.
  * @param [options.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>.
  * @param [options.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>.
  * @param [options.show = true] - True if the layer is shown; otherwise, false.
  * @param [options.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.
  * @param [options.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.
  * @param [options.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.
  * @param [options.cutoutRectangle] - Cartographic rectangle for cutting out a portion of this ImageryLayer.
  * @param [options.colorToAlpha] - Color to be used as alpha.
  * @param [options.colorToAlphaThreshold = 0.004] - Threshold for color-to-alpha.
@@ -32384,27 +32391,27 @@ export class ImageryLayer {
     });
     /**
      * 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;
     /**
@@ -32413,7 +32420,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;
     /**
@@ -32426,20 +32433,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;
     /**
@@ -32464,92 +32471,92 @@ export class ImageryLayer {
     readonly imageryProvider: ImageryProvider;
     /**
      * 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;
     /**
      * 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.
-     * imageryLayer.getViewableRectangle().then(function (rectangle) {
-     *     return camera.flyTo({
-     *         destination: rectangle
-     *     });
-     * });
+    imageryLayer.getViewableRectangle().then(function (rectangle) {
+        return camera.flyTo({
+            destination: rectangle
+        });
+    });
      * @returns A promise to a rectangle which defines the overall bounds of imagery that can be produced by this layer.
      */
     getViewableRectangle(): Promise<Rectangle>;
@@ -33396,33 +33403,33 @@ export class Label {
 
 /**
  * A renderable collection of labels.  Labels are viewport-aligned text positioned in the 3D scene.
-Each label can have a different font, color, scale, etc.
-<br /><br />
-<div align='center'>
-<img src='Images/Label.png' width='400' height='300' /><br />
-Example labels
-</div>
-<br /><br />
-Labels are added and removed from the collection using {@link LabelCollection#add}
-and {@link LabelCollection#remove}.
+ * Each label can have a different font, color, scale, etc.
+ * <br /><br />
+ * <div align='center'>
+ * <img src='Images/Label.png' width='400' height='300' /><br />
+ * Example labels
+ * </div>
+ * <br /><br />
+ * Labels are added and removed from the collection using {@link LabelCollection#add}
+ * and {@link LabelCollection#remove}.
  * @example
  * // Create a label collection with two labels
-const labels = scene.primitives.add(new Cesium.LabelCollection());
-labels.add({
-  position : new Cesium.Cartesian3(1.0, 2.0, 3.0),
-  text : 'A label'
-});
-labels.add({
-  position : new Cesium.Cartesian3(4.0, 5.0, 6.0),
-  text : 'Another label'
-});
+ * const labels = scene.primitives.add(new Cesium.LabelCollection());
+ * labels.add({
+ *   position : new Cesium.Cartesian3(1.0, 2.0, 3.0),
+ *   text : 'A label'
+ * });
+ * labels.add({
+ *   position : new Cesium.Cartesian3(4.0, 5.0, 6.0),
+ *   text : 'Another label'
+ * });
  * @param [options] - Object with the following properties:
  * @param [options.modelMatrix = Matrix4.IDENTITY] - The 4x4 transformation matrix that transforms each label from model to world coordinates.
  * @param [options.debugShowBoundingVolume = false] - For debugging only. Determines if this primitive's commands' bounding spheres are shown.
  * @param [options.scene] - Must be passed in for labels that use the height reference property or will be depth tested against the globe.
  * @param [options.blendOption = BlendOption.OPAQUE_AND_TRANSLUCENT] - The label blending option. The default
-is used for rendering both opaque and translucent labels. However, if either all of the labels are completely opaque or all are completely translucent,
-setting the technique to BlendOption.OPAQUE or BlendOption.TRANSLUCENT can improve performance by up to 2x.
+ * is used for rendering both opaque and translucent labels. However, if either all of the labels are completely opaque or all are completely translucent,
+ * setting the technique to BlendOption.OPAQUE or BlendOption.TRANSLUCENT can improve performance by up to 2x.
  * @param [options.show = true] - Determines if the labels in the collection will be shown.
  */
 export class LabelCollection {
@@ -33439,85 +33446,85 @@ export class LabelCollection {
     show: boolean;
     /**
      * The 4x4 transformation matrix that transforms each label in this collection from model to world coordinates.
-    When this is the identity matrix, the labels are 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}.
+     * When this is the identity matrix, the labels are 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}.
      * @example
      * const center = Cesium.Cartesian3.fromDegrees(-75.59777, 40.03883);
-    labels.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(center);
-    labels.add({
-      position : new Cesium.Cartesian3(0.0, 0.0, 0.0),
-      text     : 'Center'
-    });
-    labels.add({
-      position : new Cesium.Cartesian3(1000000.0, 0.0, 0.0),
-      text     : 'East'
-    });
-    labels.add({
-      position : new Cesium.Cartesian3(0.0, 1000000.0, 0.0),
-      text     : 'North'
-    });
-    labels.add({
-      position : new Cesium.Cartesian3(0.0, 0.0, 1000000.0),
-      text     : 'Up'
-    });
+     * labels.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(center);
+     * labels.add({
+     *   position : new Cesium.Cartesian3(0.0, 0.0, 0.0),
+     *   text     : 'Center'
+     * });
+     * labels.add({
+     *   position : new Cesium.Cartesian3(1000000.0, 0.0, 0.0),
+     *   text     : 'East'
+     * });
+     * labels.add({
+     *   position : new Cesium.Cartesian3(0.0, 1000000.0, 0.0),
+     *   text     : 'North'
+     * });
+     * labels.add({
+     *   position : new Cesium.Cartesian3(0.0, 0.0, 1000000.0),
+     *   text     : 'Up'
+     * });
      */
     modelMatrix: Matrix4;
     /**
      * 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;
     /**
      * The label blending option. The default is used for rendering both opaque and translucent labels.
-    However, if either all of the labels are completely opaque or all are completely translucent,
-    setting the technique to BlendOption.OPAQUE or BlendOption.TRANSLUCENT can improve
-    performance by up to 2x.
+     * However, if either all of the labels are completely opaque or all are completely translucent,
+     * setting the technique to BlendOption.OPAQUE or BlendOption.TRANSLUCENT can improve
+     * performance by up to 2x.
      */
     blendOption: BlendOption;
     /**
      * Returns the number of labels in this collection.  This is commonly used with
-    {@link LabelCollection#get} to iterate over all the labels
-    in the collection.
+     * {@link LabelCollection#get} to iterate over all the labels
+     * in the collection.
      */
     length: number;
     /**
      * Creates and adds a label with the specified initial properties to the collection.
-    The added label is returned so it can be modified or removed from the collection later.
+     * The added label is returned so it can be modified or removed from the collection later.
      * @example
      * // Example 1:  Add a label, specifying all the default values.
-    const l = labels.add({
-      show : true,
-      position : Cesium.Cartesian3.ZERO,
-      text : '',
-      font : '30px sans-serif',
-      fillColor : Cesium.Color.WHITE,
-      outlineColor : Cesium.Color.BLACK,
-      outlineWidth : 1.0,
-      showBackground : false,
-      backgroundColor : new Cesium.Color(0.165, 0.165, 0.165, 0.8),
-      backgroundPadding : new Cesium.Cartesian2(7, 5),
-      style : Cesium.LabelStyle.FILL,
-      pixelOffset : Cesium.Cartesian2.ZERO,
-      eyeOffset : Cesium.Cartesian3.ZERO,
-      horizontalOrigin : Cesium.HorizontalOrigin.LEFT,
-      verticalOrigin : Cesium.VerticalOrigin.BASELINE,
-      scale : 1.0,
-      translucencyByDistance : undefined,
-      pixelOffsetScaleByDistance : undefined,
-      heightReference : HeightReference.NONE,
-      distanceDisplayCondition : undefined
-    });
+     * const l = labels.add({
+     *   show : true,
+     *   position : Cesium.Cartesian3.ZERO,
+     *   text : '',
+     *   font : '30px sans-serif',
+     *   fillColor : Cesium.Color.WHITE,
+     *   outlineColor : Cesium.Color.BLACK,
+     *   outlineWidth : 1.0,
+     *   showBackground : false,
+     *   backgroundColor : new Cesium.Color(0.165, 0.165, 0.165, 0.8),
+     *   backgroundPadding : new Cesium.Cartesian2(7, 5),
+     *   style : Cesium.LabelStyle.FILL,
+     *   pixelOffset : Cesium.Cartesian2.ZERO,
+     *   eyeOffset : Cesium.Cartesian3.ZERO,
+     *   horizontalOrigin : Cesium.HorizontalOrigin.LEFT,
+     *   verticalOrigin : Cesium.VerticalOrigin.BASELINE,
+     *   scale : 1.0,
+     *   translucencyByDistance : undefined,
+     *   pixelOffsetScaleByDistance : undefined,
+     *   heightReference : HeightReference.NONE,
+     *   distanceDisplayCondition : undefined
+     * });
      * @example
      * // Example 2:  Specify only the label's cartographic position,
-    // text, and font.
-    const l = labels.add({
-      position : Cesium.Cartesian3.fromRadians(longitude, latitude, height),
-      text : 'Hello World',
-      font : '24px Helvetica',
-    });
+     * // text, and font.
+     * const l = labels.add({
+     *   position : Cesium.Cartesian3.fromRadians(longitude, latitude, height),
+     *   text : 'Hello World',
+     *   font : '24px Helvetica',
+     * });
      * @param [options] - A template describing the label's properties as shown in Example 1.
      * @returns The label that was added to the collection.
      */
@@ -33526,7 +33533,7 @@ export class LabelCollection {
      * Removes a label from the collection.  Once removed, a label is no longer usable.
      * @example
      * const l = labels.add(...);
-    labels.remove(l);  // Returns true
+     * labels.remove(l);  // Returns true
      * @param label - The label to remove.
      * @returns <code>true</code> if the label was removed; <code>false</code> if the label was not found in the collection.
      */
@@ -33535,8 +33542,8 @@ export class LabelCollection {
      * Removes all labels from the collection.
      * @example
      * labels.add(...);
-    labels.add(...);
-    labels.removeAll();
+     * labels.add(...);
+     * labels.removeAll();
      */
     removeAll(): void;
     /**
@@ -33547,36 +33554,36 @@ export class LabelCollection {
     contains(label: Label): boolean;
     /**
      * Returns the label in the collection at the specified index.  Indices are zero-based
-    and increase as labels are added.  Removing a label shifts all labels after
-    it to the left, changing their indices.  This function is commonly used with
-    {@link LabelCollection#length} to iterate over all the labels
-    in the collection.
+     * and increase as labels are added.  Removing a label shifts all labels after
+     * it to the left, changing their indices.  This function is commonly used with
+     * {@link LabelCollection#length} to iterate over all the labels
+     * in the collection.
      * @example
      * // Toggle the show property of every label in the collection
-    const len = labels.length;
-    for (let i = 0; i < len; ++i) {
-      const l = billboards.get(i);
-      l.show = !l.show;
-    }
+     * const len = labels.length;
+     * for (let i = 0; i < len; ++i) {
+     *   const l = billboards.get(i);
+     *   l.show = !l.show;
+     * }
      * @param index - The zero-based index of the billboard.
      * @returns The label at the specified index.
      */
     get(index: number): Label;
     /**
      * 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
      * labels = labels && labels.destroy();
      */
@@ -34573,56 +34580,56 @@ export namespace MaterialAppearance {
 
 /**
  * A 3D model based on glTF, the runtime asset format for WebGL, OpenGL ES, and OpenGL.
- * <p>
- * Cesium includes support for geometry and materials, glTF animations, and glTF skinning.
- * In addition, individual glTF nodes are pickable with {@link Scene#pick} and animatable
- * with {@link Model#getNode}.  glTF cameras and lights are not currently supported.
- * </p>
- * <p>
- * An external glTF asset is created with {@link Model.fromGltf}.  glTF JSON can also be
- * created at runtime and passed to this constructor function.  In either case, the
- * {@link Model#readyPromise} is resolved when the model is ready to render, i.e.,
- * when the external binary, image, and shader files are downloaded and the WebGL
- * resources are created.
- * </p>
- * <p>
- * Cesium supports glTF assets with the following extensions:
- * <ul>
- * <li>
- * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Khronos/KHR_binary_glTF/README.md|KHR_binary_glTF (glTF 1.0)}
- * </li><li>
- * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Khronos/KHR_materials_common/README.md|KHR_materials_common (glTF 1.0)}
- * </li><li>
- * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Vendor/WEB3D_quantized_attributes/README.md|WEB3D_quantized_attributes (glTF 1.0)}
- * </li><li>
- * {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/AGI_articulations/README.md|AGI_articulations}
- * </li><li>
- * {@link https://github.com/KhronosGroup/glTF/pull/1302|KHR_blend (draft)}
- * </li><li>
- * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md|KHR_draco_mesh_compression}
- * </li><li>
- * {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness/README.md|KHR_materials_pbrSpecularGlossiness}
- * </li><li>
- * {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit/README.md|KHR_materials_unlit}
- * </li><li>
- * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_techniques_webgl/README.md|KHR_techniques_webgl}
- * </li><li>
- * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_transform/README.md|KHR_texture_transform}
- * </li><li>
- * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_basisu|KHR_texture_basisu}
- * </li>
- * </ul>
- * </p>
- * <p>
- * Note: for models with compressed textures using the KHR_texture_basisu extension, we recommend power of 2 textures in both dimensions
- * for maximum compatibility. This is because some samplers require power of 2 textures ({@link https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/Tutorial/Using_textures_in_WebGL|Using textures in WebGL})
- * and KHR_texture_basisu requires multiple of 4 dimensions ({@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_basisu/README.md#additional-requirements|KHR_texture_basisu additional requirements}).
- * </p>
- * <p>
- * For high-precision rendering, Cesium supports the {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Vendor/CESIUM_RTC/README.md|CESIUM_RTC} extension, which introduces the
- * CESIUM_RTC_MODELVIEW parameter semantic that says the node is in WGS84 coordinates translated
- * relative to a local origin.
- * </p>
+<p>
+Cesium includes support for geometry and materials, glTF animations, and glTF skinning.
+In addition, individual glTF nodes are pickable with {@link Scene#pick} and animatable
+with {@link Model#getNode}.  glTF cameras and lights are not currently supported.
+</p>
+<p>
+An external glTF asset is created with {@link Model.fromGltf}.  glTF JSON can also be
+created at runtime and passed to this constructor function.  In either case, the
+{@link Model#readyPromise} is resolved when the model is ready to render, i.e.,
+when the external binary, image, and shader files are downloaded and the WebGL
+resources are created.
+</p>
+<p>
+Cesium supports glTF assets with the following extensions:
+<ul>
+<li>
+{@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Khronos/KHR_binary_glTF/README.md|KHR_binary_glTF (glTF 1.0)}
+</li><li>
+{@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Khronos/KHR_materials_common/README.md|KHR_materials_common (glTF 1.0)}
+</li><li>
+{@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Vendor/WEB3D_quantized_attributes/README.md|WEB3D_quantized_attributes (glTF 1.0)}
+</li><li>
+{@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/AGI_articulations/README.md|AGI_articulations}
+</li><li>
+{@link https://github.com/KhronosGroup/glTF/pull/1302|KHR_blend (draft)}
+</li><li>
+{@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md|KHR_draco_mesh_compression}
+</li><li>
+{@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness/README.md|KHR_materials_pbrSpecularGlossiness}
+</li><li>
+{@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit/README.md|KHR_materials_unlit}
+</li><li>
+{@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_techniques_webgl/README.md|KHR_techniques_webgl}
+</li><li>
+{@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_transform/README.md|KHR_texture_transform}
+</li><li>
+{@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_basisu|KHR_texture_basisu}
+</li>
+</ul>
+</p>
+<p>
+Note: for models with compressed textures using the KHR_texture_basisu extension, we recommend power of 2 textures in both dimensions
+for maximum compatibility. This is because some samplers require power of 2 textures ({@link https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/Tutorial/Using_textures_in_WebGL|Using textures in WebGL})
+and KHR_texture_basisu requires multiple of 4 dimensions ({@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_basisu/README.md#additional-requirements|KHR_texture_basisu additional requirements}).
+</p>
+<p>
+For high-precision rendering, Cesium supports the {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Vendor/CESIUM_RTC/README.md|CESIUM_RTC} extension, which introduces the
+CESIUM_RTC_MODELVIEW parameter semantic that says the node is in WGS84 coordinates translated
+relative to a local origin.
+</p>
  * @param [options] - Object with the following properties:
  * @param [options.gltf] - A glTF JSON object, or a binary glTF buffer.
  * @param [options.basePath = ''] - The base path that paths in the glTF JSON are relative to.
@@ -34714,30 +34721,30 @@ export class Model {
     silhouetteSize: number;
     /**
      * The 4x4 transformation matrix that transforms the model from model to world coordinates.
-     * When this is the identity matrix, the model 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}.
+    When this is the identity matrix, the model 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}.
      * @example
      * const origin = Cesium.Cartesian3.fromDegrees(-95.0, 40.0, 200000.0);
-     * m.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(origin);
+    m.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(origin);
      */
     modelMatrix: Matrix4;
     /**
      * A uniform scale applied to this model before the {@link Model#modelMatrix}.
-     * Values greater than <code>1.0</code> increase the size of the model; values
-     * less than <code>1.0</code> decrease.
+    Values greater than <code>1.0</code> increase the size of the model; values
+    less than <code>1.0</code> decrease.
      */
     scale: number;
     /**
      * The approximate minimum pixel size of the model regardless of zoom.
-     * This can be used to ensure that a model is visible even when the viewer
-     * zooms out.  When <code>0.0</code>, no minimum size is enforced.
+    This can be used to ensure that a model is visible even when the viewer
+    zooms out.  When <code>0.0</code>, no minimum size is enforced.
      */
     minimumPixelSize: number;
     /**
      * The maximum scale size for a model. This can be used to give
-     * an upper limit to the {@link Model#minimumPixelSize}, ensuring that the model
-     * is never an unreasonable scale.
+    an upper limit to the {@link Model#minimumPixelSize}, ensuring that the model
+    is never an unreasonable scale.
      */
     maximumScale: number;
     /**
@@ -34770,21 +34777,21 @@ export class Model {
     colorBlendMode: ColorBlendMode;
     /**
      * Value used to determine 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.
+    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.
      */
     colorBlendAmount: number;
     /**
      * Whether to cull back-facing geometry. When true, back face culling is
-     * determined by the material's doubleSided property; when false, back face
-     * culling is disabled. Back faces are not culled if {@link Model#color} is
-     * translucent or {@link Model#silhouetteSize} is greater than 0.0.
+    determined by the material's doubleSided property; when false, back face
+    culling is disabled. Back faces are not culled if {@link Model#color} is
+    translucent or {@link Model#silhouetteSize} is greater than 0.0.
      */
     backFaceCulling: boolean;
     /**
      * 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.
+    {@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.
      */
     readonly showOutline: boolean;
     /**
@@ -34793,66 +34800,66 @@ export class Model {
     splitDirection: SplitDirection;
     /**
      * 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 model.  A glTF primitive corresponds
-     * to one draw command.  A glTF mesh has an array of primitives, often of length one.
-     * </p>
+    <p>
+    Draws the bounding sphere for each draw command in the model.  A glTF primitive corresponds
+    to one draw command.  A glTF mesh has an array of primitives, often of length one.
+    </p>
      */
     debugShowBoundingVolume: boolean;
     /**
      * This property is for debugging only; it is not for production use nor is it optimized.
-     * <p>
-     * Draws the model in wireframe.
-     * </p>
+    <p>
+    Draws the model in wireframe.
+    </p>
      */
     debugWireframe: boolean;
     /**
      * The object for the glTF JSON, including properties with default values omitted
-     * from the JSON provided to this model.
+    from the JSON provided to this model.
      */
     readonly gltf: any;
     /**
      * The base path that paths in the glTF JSON are relative to.  The base
-     * path is the same path as the path containing the .gltf file
-     * minus the .gltf file, when binary, image, and shader files are
-     * in the same directory as the .gltf.  When this is <code>''</code>,
-     * the app's base path is used.
+    path is the same path as the path containing the .gltf file
+    minus the .gltf file, when binary, image, and shader files are
+    in the same directory as the .gltf.  When this is <code>''</code>,
+    the app's base path is used.
      */
     readonly basePath: string;
     /**
      * The model's bounding sphere in its local coordinate system.  This does not take into
-     * account glTF animations and skins nor does it take into account {@link Model#minimumPixelSize}.
+    account glTF animations and skins nor does it take into account {@link Model#minimumPixelSize}.
      * @example
      * // Center in WGS84 coordinates
-     * const center = Cesium.Matrix4.multiplyByPoint(model.modelMatrix, model.boundingSphere.center, new Cesium.Cartesian3());
+    const center = Cesium.Matrix4.multiplyByPoint(model.modelMatrix, model.boundingSphere.center, new Cesium.Cartesian3());
      */
     readonly boundingSphere: BoundingSphere;
     /**
      * When <code>true</code>, this model is ready to render, i.e., the external binary, image,
-     * and shader files were downloaded and the WebGL resources were created.  This is set to
-     * <code>true</code> right before {@link Model#readyPromise} is resolved.
+    and shader files were downloaded and the WebGL resources were created.  This is set to
+    <code>true</code> right before {@link Model#readyPromise} is resolved.
      */
     readonly ready: boolean;
     /**
      * Gets the promise that will be resolved when this model is ready to render, i.e., when the external binary, image,
-     * and shader files were downloaded and the WebGL resources were created.
-     * <p>
-     * This promise is resolved at the end of the frame before the first frame the model is rendered in.
-     * </p>
+    and shader files were downloaded and the WebGL resources were created.
+    <p>
+    This promise is resolved at the end of the frame before the first frame the model is rendered in.
+    </p>
      * @example
      * // Play all animations at half-speed when the model is ready to render
-     * Promise.resolve(model.readyPromise).then(function(model) {
-     *   model.activeAnimations.addAll({
-     *     multiplier : 0.5
-     *   });
-     * }).catch(function(error){
-     *   window.alert(error);
-     * });
+    Promise.resolve(model.readyPromise).then(function(model) {
+      model.activeAnimations.addAll({
+        multiplier : 0.5
+      });
+    }).catch(function(error){
+      window.alert(error);
+    });
      */
     readonly readyPromise: Promise<Model>;
     /**
      * Determines if model WebGL resource creation will be spread out over several frames or
-     * block until completion once all glTF files are loaded.
+    block until completion once all glTF files are loaded.
      */
     readonly asynchronous: boolean;
     /**
@@ -34877,10 +34884,10 @@ export class Model {
     clippingPlanes: ClippingPlaneCollection;
     /**
      * The light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
-     * <p>
-     * For example, disabling additional light sources by setting <code>model.imageBasedLightingFactor = new Cesium.Cartesian2(0.0, 0.0)</code> will make the
-     * model much darker. Here, increasing the intensity of the light source will make the model brighter.
-     * </p>
+    <p>
+    For example, disabling additional light sources by setting <code>model.imageBasedLightingFactor = new Cesium.Cartesian2(0.0, 0.0)</code> will make the
+    model much darker. Here, increasing the intensity of the light source will make the model brighter.
+    </p>
      */
     lightColor: Cartesian3;
     /**
@@ -34889,25 +34896,25 @@ export class Model {
     imageBasedLighting: ImageBasedLighting;
     /**
      * Cesium adds lighting from the earth, sky, atmosphere, and star skybox. This cartesian is used to scale the final
-     * diffuse and specular lighting contribution from those sources to the final color. A value of 0.0 will disable those light sources.
+    diffuse and specular lighting contribution from those sources to the final color. A value of 0.0 will disable those light sources.
      */
     imageBasedLightingFactor: Cartesian2;
     /**
      * The sun's luminance at the zenith in kilo candela per meter squared to use for this model's procedural environment map.
-     * This is used when {@link Model#specularEnvironmentMaps} and {@link Model#sphericalHarmonicCoefficients} are not defined.
+    This is used when {@link Model#specularEnvironmentMaps} and {@link Model#sphericalHarmonicCoefficients} are not defined.
      */
     luminanceAtZenith: number;
     /**
      * The third order spherical harmonic coefficients used for the diffuse color of image-based lighting. When <code>undefined</code>, a diffuse irradiance
-     * computed from the atmosphere color is used.
-     * <p>
-     * There are nine <code>Cartesian3</code> coefficients.
-     * The order of the coefficients is: L<sub>0,0</sub>, L<sub>1,-1</sub>, L<sub>1,0</sub>, L<sub>1,1</sub>, L<sub>2,-2</sub>, L<sub>2,-1</sub>, L<sub>2,0</sub>, L<sub>2,1</sub>, L<sub>2,2</sub>
-     * </p>
-     *
-     * These values can be obtained by preprocessing the environment map using the <code>cmgen</code> tool of
-     * {@link https://github.com/google/filament/releases|Google's Filament project}. This will also generate a KTX file that can be
-     * supplied to {@link Model#specularEnvironmentMaps}.
+    computed from the atmosphere color is used.
+    <p>
+    There are nine <code>Cartesian3</code> coefficients.
+    The order of the coefficients is: L<sub>0,0</sub>, L<sub>1,-1</sub>, L<sub>1,0</sub>, L<sub>1,1</sub>, L<sub>2,-2</sub>, L<sub>2,-1</sub>, L<sub>2,0</sub>, L<sub>2,1</sub>, L<sub>2,2</sub>
+    </p>
+    
+    These values can be obtained by preprocessing the environment map using the <code>cmgen</code> tool of
+    {@link https://github.com/google/filament/releases|Google's Filament project}. This will also generate a KTX file that can be
+    supplied to {@link Model#specularEnvironmentMaps}.
      */
     sphericalHarmonicCoefficients: Cartesian3[];
     /**
@@ -34930,71 +34937,71 @@ export class Model {
     static silhouetteSupported(scene: Scene): boolean;
     /**
      * <p>
-     * Creates a model from a glTF asset.  When the model is ready to render, i.e., when the external binary, image,
-     * and shader files are downloaded and the WebGL resources are created, the {@link Model#readyPromise} is resolved.
-     * </p>
-     * <p>
-     * The model can be a traditional glTF asset with a .gltf extension or a Binary glTF using the .glb extension.
-     * </p>
-     * <p>
-     * Cesium supports glTF assets with the following extensions:
-     * <ul>
-     * <li>
-     * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Khronos/KHR_binary_glTF/README.md|KHR_binary_glTF (glTF 1.0)}
-     * </li><li>
-     * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Khronos/KHR_materials_common/README.md|KHR_materials_common (glTF 1.0)}
-     * </li><li>
-     * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Vendor/WEB3D_quantized_attributes/README.md|WEB3D_quantized_attributes (glTF 1.0)}
-     * </li><li>
-     * {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/AGI_articulations/README.md|AGI_articulations}
-     * </li><li>
-     * {@link https://github.com/KhronosGroup/glTF/pull/1302|KHR_blend (draft)}
-     * </li><li>
-     * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md|KHR_draco_mesh_compression}
-     * </li><li>
-     * {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness/README.md|KHR_materials_pbrSpecularGlossiness}
-     * </li><li>
-     * {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit/README.md|KHR_materials_unlit}
-     * </li><li>
-     * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_techniques_webgl/README.md|KHR_techniques_webgl}
-     * </li><li>
-     * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_transform/README.md|KHR_texture_transform}
-     * </li><li>
-     * {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_basisu/README.md|KHR_texture_basisu}
-     * </li>
-     * </ul>
-     * </p>
-     * <p>
-     * For high-precision rendering, Cesium supports the {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Vendor/CESIUM_RTC/README.md|CESIUM_RTC} extension, which introduces the
-     * CESIUM_RTC_MODELVIEW parameter semantic that says the node is in WGS84 coordinates translated
-     * relative to a local origin.
-     * </p>
+    Creates a model from a glTF asset.  When the model is ready to render, i.e., when the external binary, image,
+    and shader files are downloaded and the WebGL resources are created, the {@link Model#readyPromise} is resolved.
+    </p>
+    <p>
+    The model can be a traditional glTF asset with a .gltf extension or a Binary glTF using the .glb extension.
+    </p>
+    <p>
+    Cesium supports glTF assets with the following extensions:
+    <ul>
+    <li>
+    {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Khronos/KHR_binary_glTF/README.md|KHR_binary_glTF (glTF 1.0)}
+    </li><li>
+    {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Khronos/KHR_materials_common/README.md|KHR_materials_common (glTF 1.0)}
+    </li><li>
+    {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Vendor/WEB3D_quantized_attributes/README.md|WEB3D_quantized_attributes (glTF 1.0)}
+    </li><li>
+    {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/AGI_articulations/README.md|AGI_articulations}
+    </li><li>
+    {@link https://github.com/KhronosGroup/glTF/pull/1302|KHR_blend (draft)}
+    </li><li>
+    {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md|KHR_draco_mesh_compression}
+    </li><li>
+    {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness/README.md|KHR_materials_pbrSpecularGlossiness}
+    </li><li>
+    {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit/README.md|KHR_materials_unlit}
+    </li><li>
+    {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_techniques_webgl/README.md|KHR_techniques_webgl}
+    </li><li>
+    {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_transform/README.md|KHR_texture_transform}
+    </li><li>
+    {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_basisu/README.md|KHR_texture_basisu}
+    </li>
+    </ul>
+    </p>
+    <p>
+    For high-precision rendering, Cesium supports the {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Vendor/CESIUM_RTC/README.md|CESIUM_RTC} extension, which introduces the
+    CESIUM_RTC_MODELVIEW parameter semantic that says the node is in WGS84 coordinates translated
+    relative to a local origin.
+    </p>
      * @example
      * // Example 1. Create a model from a glTF asset
-     * const model = scene.primitives.add(Cesium.Model.fromGltf({
-     *   url : './duck/duck.gltf'
-     * }));
+    const model = scene.primitives.add(Cesium.Model.fromGltf({
+      url : './duck/duck.gltf'
+    }));
      * @example
      * // Example 2. Create model and provide all properties and events
-     * const origin = Cesium.Cartesian3.fromDegrees(-95.0, 40.0, 200000.0);
-     * const modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(origin);
-     *
-     * const model = scene.primitives.add(Cesium.Model.fromGltf({
-     *   url : './duck/duck.gltf',
-     *   show : true,                     // default
-     *   modelMatrix : modelMatrix,
-     *   scale : 2.0,                     // double size
-     *   minimumPixelSize : 128,          // never smaller than 128 pixels
-     *   maximumScale: 20000,             // never larger than 20000 * model size (overrides minimumPixelSize)
-     *   allowPicking : false,            // not pickable
-     *   debugShowBoundingVolume : false, // default
-     *   debugWireframe : false
-     * }));
-     *
-     * model.readyPromise.then(function(model) {
-     *   // Play all animations when the model is ready to render
-     *   model.activeAnimations.addAll();
-     * });
+    const origin = Cesium.Cartesian3.fromDegrees(-95.0, 40.0, 200000.0);
+    const modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(origin);
+    
+    const model = scene.primitives.add(Cesium.Model.fromGltf({
+      url : './duck/duck.gltf',
+      show : true,                     // default
+      modelMatrix : modelMatrix,
+      scale : 2.0,                     // double size
+      minimumPixelSize : 128,          // never smaller than 128 pixels
+      maximumScale: 20000,             // never larger than 20000 * model size (overrides minimumPixelSize)
+      allowPicking : false,            // not pickable
+      debugShowBoundingVolume : false, // default
+      debugWireframe : false
+    }));
+    
+    model.readyPromise.then(function(model) {
+      // Play all animations when the model is ready to render
+      model.activeAnimations.addAll();
+    });
      * @param options - Object with the following properties:
      * @param options.url - The url to the .gltf file.
      * @param [options.basePath] - The base path that paths in the glTF JSON are relative to.
@@ -35072,11 +35079,11 @@ export class Model {
     }): Model;
     /**
      * Returns the glTF node with the given <code>name</code> property.  This is used to
-     * modify a node's transform for animation outside of glTF animations.
+    modify a node's transform for animation outside of glTF animations.
      * @example
      * // Apply non-uniform scale to node LOD3sp
-     * const node = model.getNode('LOD3sp');
-     * node.matrix = Cesium.Matrix4.fromScale(new Cesium.Cartesian3(5.0, 1.0, 1.0), node.matrix);
+    const node = model.getNode('LOD3sp');
+    node.matrix = Cesium.Matrix4.fromScale(new Cesium.Cartesian3(5.0, 1.0, 1.0), node.matrix);
      * @param name - The glTF name of the node.
      * @returns The node or <code>undefined</code> if no node with <code>name</code> exists.
      */
@@ -35095,40 +35102,40 @@ export class Model {
     getMaterial(name: string): ModelMaterial;
     /**
      * Sets the current value of an articulation stage.  After setting one or multiple stage values, call
-     * Model.applyArticulations() to cause the node matrices to be recalculated.
+    Model.applyArticulations() to cause the node matrices to be recalculated.
      * @param articulationStageKey - The name of the articulation, a space, and the name of the stage.
      * @param value - The numeric value of this stage of the articulation.
      */
     setArticulationStage(articulationStageKey: string, value: number): void;
     /**
      * Applies any modified articulation stages to the matrix of each node that participates
-     * in any articulation.  Note that this will overwrite any nodeTransformations on participating nodes.
+    in any articulation.  Note that this will overwrite any nodeTransformations on participating nodes.
      */
     applyArticulations(): void;
     /**
      * 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 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
      * model = model && model.destroy();
      */
@@ -38223,88 +38230,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.
@@ -38340,67 +38347,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;
     /**
@@ -38433,8 +38440,8 @@ 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.
      */
     readonly ready: boolean;
     /**
@@ -38443,42 +38450,42 @@ export class Primitive {
     readonly readyPromise: Promise<Primitive>;
     /**
      * 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();
      */
@@ -40155,8 +40162,8 @@ export namespace TileCoordinatesImageryProvider {
      * Initialization options for the TileCoordinatesImageryProvider constructor
      * @property [tilingScheme = new GeographicTilingScheme()] - The tiling scheme for which to draw 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 [color = Color.YELLOW] - The color to draw the tile box and label.
      * @property [tileWidth = 256] - The width of the tile for level-of-detail selection purposes.
      * @property [tileHeight = 256] - The height of the tile for level-of-detail selection purposes.
@@ -40172,35 +40179,35 @@ export namespace TileCoordinatesImageryProvider {
 
 /**
  * An {@link ImageryProvider} that draws a box around every rendered tile in the tiling scheme, and draws
-a label inside it indicating the X, Y, Level coordinates of the tile.  This is mostly useful for
-debugging terrain and imagery rendering problems.
+ * a label inside it indicating the X, Y, Level coordinates of the tile.  This is mostly useful for
+ * debugging terrain and imagery rendering problems.
  * @param [options] - Object describing initialization options
  */
 export class TileCoordinatesImageryProvider {
     constructor(options?: TileCoordinatesImageryProvider.ConstructorOptions);
     /**
      * The default alpha blending value of this provider, with 0.0 representing fully transparent and
-    1.0 representing fully opaque.
+     * 1.0 representing fully opaque.
      */
     defaultAlpha: number | undefined;
     /**
      * The default alpha blending value on the night side of the globe of this provider, with 0.0 representing fully transparent and
-    1.0 representing fully opaque.
+     * 1.0 representing fully opaque.
      */
     defaultNightAlpha: number | undefined;
     /**
      * The default alpha blending value on the day side of the globe of this provider, with 0.0 representing fully transparent and
-    1.0 representing fully opaque.
+     * 1.0 representing fully opaque.
      */
     defaultDayAlpha: number | undefined;
     /**
      * The default brightness of this provider.  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.
      */
     defaultBrightness: number | undefined;
     /**
      * The default contrast of this provider.  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.
      */
     defaultContrast: number | undefined;
     /**
@@ -40209,7 +40216,7 @@ export class TileCoordinatesImageryProvider {
     defaultHue: number | undefined;
     /**
      * The default saturation of this provider. 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.
      */
     defaultSaturation: number | undefined;
     /**
@@ -40230,45 +40237,45 @@ export class TileCoordinatesImageryProvider {
     readonly proxy: Proxy;
     /**
      * Gets the width of each tile, in pixels. This function should
-    not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
+     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
      */
     readonly tileWidth: number;
     /**
      * Gets the height of each tile, in pixels.  This function should
-    not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
+     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
      */
     readonly tileHeight: number;
     /**
      * Gets the maximum level-of-detail that can be requested.  This function should
-    not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
+     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
      */
     readonly maximumLevel: number | undefined;
     /**
      * Gets the minimum level-of-detail that can be requested.  This function should
-    not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
+     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
      */
     readonly minimumLevel: number;
     /**
      * Gets the tiling scheme used by this provider.  This function should
-    not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
+     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
      */
     readonly tilingScheme: TilingScheme;
     /**
      * Gets the rectangle, in radians, of the imagery provided by this instance.  This function should
-    not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
+     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
      */
     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.  This function should
-    not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
+     * for filtering out "missing" tiles via its shouldDiscardImage function.  If this function
+     * returns undefined, no tiles are filtered.  This function should
+     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
      */
     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;
     /**
@@ -40281,15 +40288,15 @@ export class TileCoordinatesImageryProvider {
     readonly readyPromise: Promise<boolean>;
     /**
      * Gets the credit to display when this imagery provider is active.  Typically this is used to credit
-    the source of the imagery.  This function should not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
+     * the source of the imagery.  This function should not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
      */
     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.  Setting this property to false reduces memory usage
-    and texture upload time.
+     * 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.  Setting this property to false reduces memory usage
+     * and texture upload time.
      */
     readonly hasAlphaChannel: boolean;
     /**
@@ -40302,29 +40309,29 @@ export class TileCoordinatesImageryProvider {
     getTileCredits(x: number, y: number, level: number): Credit[];
     /**
      * Requests the image for a given tile.  This function should
-    not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
+     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
      * @param x - The tile X coordinate.
      * @param y - The tile Y coordinate.
      * @param level - The tile level.
      * @param [request] - The request object. Intended for internal use only.
      * @returns A promise for the image that will resolve when the image is available, or
-             undefined if there are too many active requests to the server, and the request
-             should be retried later.  The resolved image may be either an
-             Image or a Canvas DOM object.
+     *          undefined if there are too many active requests to the server, and the request
+     *          should be retried later.  The resolved image may be either an
+     *          Image or a Canvas DOM object.
      */
     requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement> | undefined;
     /**
      * Picking features is not currently supported by this imagery provider, so this function simply returns
-    undefined.
+     * undefined.
      * @param x - The tile X coordinate.
      * @param y - The tile Y coordinate.
      * @param level - The tile level.
      * @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.
-                      It may also be undefined if picking is not supported.
+     *                   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.
+     *                   It may also be undefined if picking is not supported.
      */
     pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
 }