@cesium/engine 8.0.0 → 9.1.0

package/index.d.ts

@@ -2982,6 +2982,136 @@ export class CesiumTerrainProvider {
     loadTileDataAvailability(x: number, y: number, level: number): undefined | Promise<void>;
 }
 
+
+/**
+ * Contains functions for checking that supplied arguments are of a specified type
+ * or meet specified conditions
+ */
+export const Check: {
+  /**
+   * Throws if test is not defined
+   *
+   * @param {string} name The name of the variable being tested
+   * @param {*} test The value that is to be checked
+   * @exception {DeveloperError} test must be defined
+   */
+  defined<T>(name: string, test: T): asserts test is NonNullable<T>;
+  /**
+   * Contains type checking functions, all using the typeof operator
+   */
+  typeOf: {
+    /**
+     * Throws if test is not typeof 'string'
+     *
+     * @param {string} name The name of the variable being tested
+     * @param {*} test The value to test
+     * @exception {DeveloperError} test must be typeof 'string'
+     */
+    string(name: string, test: any): asserts test is string;
+    /**
+     * Throws if test is not typeof 'function'
+     *
+     * @param {string} name The name of the variable being tested
+     * @param {*} test The value to test
+     * @exception {DeveloperError} test must be typeof 'function'
+     */
+    func(name: string, test: any): asserts test is Function;
+    /**
+     * Throws if test is not typeof 'object'
+     *
+     * @param {string} name The name of the variable being tested
+     * @param {*} test The value to test
+     * @exception {DeveloperError} test must be typeof 'object'
+     */
+    object(name: string, test: any): asserts test is object;
+    /**
+     * Throws if test is not typeof 'boolean'
+     *
+     * @param {string} name The name of the variable being tested
+     * @param {*} test The value to test
+     * @exception {DeveloperError} test must be typeof 'boolean'
+     */
+    bool(name: string, test: any): asserts test is boolean;
+    /**
+     * Throws if test is not typeof 'bigint'
+     *
+     * @param {string} name The name of the variable being tested
+     * @param {*} test The value to test
+     * @exception {DeveloperError} test must be typeof 'bigint'
+     */
+    bigint(name: string, test: any): asserts test is bigint;
+    /**
+     * Throws if test is not typeof 'number'
+     *
+     * @param {string} name The name of the variable being tested
+     * @param {*} test The value to test
+     * @exception {DeveloperError} test must be typeof 'number'
+     */
+    number: {
+      (name: string, test: any): void;
+      /**
+       * Throws if test is not typeof 'number' and less than limit
+       *
+       * @param {string} name The name of the variable being tested
+       * @param {*} test The value to test
+       * @param {number} limit The limit value to compare against
+       * @exception {DeveloperError} test must be typeof 'number' and less than limit
+       */
+      lessThan(name: string, test: any, limit: number): asserts test is number;
+      /**
+       * Throws if test is not typeof 'number' and less than or equal to limit
+       *
+       * @param {string} name The name of the variable being tested
+       * @param {*} test The value to test
+       * @param {number} limit The limit value to compare against
+       * @exception {DeveloperError} test must be typeof 'number' and less than or equal to limit
+       */
+      lessThanOrEquals(
+        name: string,
+        test: any,
+        limit: number
+      ): asserts test is number;
+      /**
+       * Throws if test is not typeof 'number' and greater than limit
+       *
+       * @param {string} name The name of the variable being tested
+       * @param {*} test The value to test
+       * @param {number} limit The limit value to compare against
+       * @exception {DeveloperError} test must be typeof 'number' and greater than limit
+       */
+      greaterThan(
+        name: string,
+        test: any,
+        limit: number
+      ): asserts test is number;
+      /**
+       * Throws if test is not typeof 'number' and greater than or equal to limit
+       *
+       * @param {string} name The name of the variable being tested
+       * @param {*} test The value to test
+       * @param {number} limit The limit value to compare against
+       * @exception {DeveloperError} test must be typeof 'number' and greater than or equal to limit
+       */
+      greaterThanOrEquals(
+        name: string,
+        test: any,
+        limit: number
+      ): asserts test is number;
+      /**
+       * Throws if test1 and test2 is not typeof 'number' and not equal in value
+       *
+       * @param {string} name1 The name of the first variable being tested
+       * @param {string} name2 The name of the second variable being tested against
+       * @param {*} test1 The value to test
+       * @param {*} test2 The value to test against
+       * @exception {DeveloperError} test1 and test2 should be type of 'number' and be equal in value
+       */
+      equals(name1: string, name2: string, test1: any, test2: any): void;
+    };
+  };
+};
+
+
 /**
  * A description of a circle on the ellipsoid. Circle geometry can be rendered with both {@link Primitive} and {@link GroundPrimitive}.
  * @example
@@ -6295,7 +6425,7 @@ export class Event<Listener extends (...args: any[]) => void = (...args: any[])
      * Raises the event by calling each registered listener with all supplied arguments.
      * @param arguments - This method takes any number of parameters and passes them through to the listener functions.
      */
-    raiseEvent(...arguments: Parameters<Listener>[]): void;
+    raiseEvent(...arguments: Parameters<Listener>): void;
 }
 
 export namespace Event {
@@ -6803,7 +6933,7 @@ export class Geometry {
      * <ul>
      *    <li><code>position3DHigh</code> - High 32 bits for encoded 64-bit position computed with {@link GeometryPipeline.encodeAttribute}.  32-bit floating-point.  4 components per attribute.</li>
      *    <li><code>position3DLow</code> - Low 32 bits for encoded 64-bit position computed with {@link GeometryPipeline.encodeAttribute}.  32-bit floating-point.  4 components per attribute.</li>
-     *    <li><code>position3DHigh</code> - High 32 bits for encoded 64-bit 2D (Columbus view) position computed with {@link GeometryPipeline.encodeAttribute}.  32-bit floating-point.  4 components per attribute.</li>
+     *    <li><code>position2DHigh</code> - High 32 bits for encoded 64-bit 2D (Columbus view) position computed with {@link GeometryPipeline.encodeAttribute}.  32-bit floating-point.  4 components per attribute.</li>
      *    <li><code>position2DLow</code> - Low 32 bits for encoded 64-bit 2D (Columbus view) position computed with {@link GeometryPipeline.encodeAttribute}.  32-bit floating-point.  4 components per attribute.</li>
      *    <li><code>color</code> - RGBA color (normalized) usually from {@link GeometryInstance#color}.  32-bit floating-point.  4 components per attribute.</li>
      *    <li><code>pickColor</code> - RGBA color used for picking.  32-bit floating-point.  4 components per attribute.</li>
@@ -14080,6 +14210,14 @@ export class Rectangle {
      * @returns The modified result parameter or a new Rectangle instance if none was provided.
      */
     static fromCartesianArray(cartesians: Cartesian3[], ellipsoid?: Ellipsoid, result?: Rectangle): Rectangle;
+    /**
+     * Create a rectangle from a bounding sphere, ignoring height.
+     * @param boundingSphere - The bounding sphere.
+     * @param [ellipsoid = Ellipsoid.WGS84] - The ellipsoid.
+     * @param [result] - The object onto which to store the result, or undefined if a new instance should be created.
+     * @returns The modified result parameter or a new Rectangle instance if none was provided.
+     */
+    static fromBoundingSphere(boundingSphere: BoundingSphere, ellipsoid?: Ellipsoid, result?: Rectangle): Rectangle;
     /**
      * Duplicates a Rectangle.
      * @param rectangle - The rectangle to clone.
@@ -18180,7 +18318,7 @@ export function defaultValue(a: any, b: any): any;
  * @param value - The object.
  * @returns Returns true if the object is defined, returns false otherwise.
  */
-export function defined(value: any): boolean;
+export function defined<Type>(value: Type): value is NonNullable<Type>;
 
 /**
  * Destroys an object.  Each of the object's functions, including functions in its prototype,
@@ -25684,6 +25822,63 @@ export enum Axis {
     Z = 2
 }
 
+export namespace Billboard {
+    /**
+     * Initialization options for the first param of Billboard constructor
+     * @property position - The cartesian position of the billboard.
+     * @property [id] - A user-defined object to return when the billboard is picked with {@link Scene#pick}.
+     * @property [show = true] - Determines if this billboard will be shown.
+     * @property [image] - A loaded HTMLImageElement, ImageData, or a url to an image to use for the billboard.
+     * @property [scale = 1.0] - A number specifying the uniform scale that is multiplied with the billboard's image size in pixels.
+     * @property [pixelOffset = Cartesian2.ZERO] - A {@link Cartesian2} Specifying the pixel offset in screen space from the origin of this billboard.
+     * @property [eyeOffset = Cartesian3.ZERO] - A {@link Cartesian3} Specifying the 3D Cartesian offset applied to this billboard in eye coordinates.
+     * @property [horizontalOrigin = HorizontalOrigin.CENTER] - A {@link HorizontalOrigin} Specifying the horizontal origin of this billboard.
+     * @property [verticalOrigin = VerticalOrigin.CENTER] - A {@link VerticalOrigin} Specifying the vertical origin of this billboard.
+     * @property [heightReference = HeightReference.NONE] - A {@link HeightReference} Specifying the height reference of this billboard.
+     * @property [color = Color.WHITE] - A {@link Color} Specifying the color that is multiplied with the billboard's texture.
+     * @property [rotation = 0] - A number specifying the rotation angle in radians.
+     * @property [alignedAxis = Cartesian3.ZERO] - A {@link Cartesian3} Specifying the aligned axis in world space.
+     * @property [sizeInMeters] - A boolean specifying if the billboard size is in meters or pixels.
+     * @property [width] - A number specifying the width of the billboard. If undefined, the image width will be used.
+     * @property [height] - A number specifying the height of the billboard. If undefined, the image height will be used.
+     * @property [scaleByDistance] - A {@link NearFarScalar} Specifying near and far scaling properties of a Billboard based on the billboard's distance from the camera.
+     * @property [translucencyByDistance] - A {@link NearFarScalar} Specifying near and far translucency properties of a Billboard based on the billboard's distance from the camera.
+     * @property [pixelOffsetScaleByDistance] - A {@link NearFarScalar} Specifying near and far pixel offset scaling properties of a Billboard based on the billboard's distance from the camera.
+     * @property [imageSubRegion] - A {@link BoundingRectangle} Specifying the sub-region of the image to use for the billboard, rather than the entire image.
+     * @property [distanceDisplayCondition] - A {@link DistanceDisplayCondition} Specifying the distance from the camera at which this billboard will be displayed.
+     * @property [disableDepthTestDistance] - A number specifying the distance from the camera at which to disable the depth test to, for example, prevent clipping against terrain.
+     */
+    type ConstructorOptions = {
+        position: Cartesian3;
+        id?: string;
+        show?: boolean;
+        image?: string | HTMLCanvasElement;
+        scale?: number;
+        pixelOffset?: Cartesian2;
+        eyeOffset?: Cartesian3;
+        horizontalOrigin?: HorizontalOrigin;
+        verticalOrigin?: VerticalOrigin;
+        heightReference?: HeightReference;
+        color?: Color;
+        rotation?: number;
+        alignedAxis?: Cartesian3;
+        sizeInMeters?: boolean;
+        width?: number;
+        height?: number;
+        scaleByDistance?: NearFarScalar;
+        translucencyByDistance?: NearFarScalar;
+        pixelOffsetScaleByDistance?: NearFarScalar;
+        imageSubRegion?: BoundingRectangle;
+        distanceDisplayCondition?: DistanceDisplayCondition;
+        disableDepthTestDistance?: number;
+    };
+    /**
+     * A function that creates an image.
+     * @param id - The identifier of the image to load.
+     */
+    type CreateImageCallback = (id: string) => HTMLImageElement | HTMLCanvasElement | Promise<HTMLImageElement | HTMLCanvasElement>;
+}
+
 /**
  * <div class="notice">
  * A billboard is created and its initial
@@ -25696,9 +25891,11 @@ export enum Axis {
  * <img src='Images/Billboard.png' width='400' height='300' /><br />
  * Example billboards
  * </div>
+ * @param options - Object describing initialization options
+ * @param billboardCollection - Instance of BillboardCollection
  */
 export class Billboard {
-    constructor();
+    constructor(options: Billboard.ConstructorOptions, billboardCollection: BillboardCollection);
     /**
      * 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.
@@ -26001,14 +26198,6 @@ export class Billboard {
     equals(other: Billboard): boolean;
 }
 
-export namespace Billboard {
-    /**
-     * A function that creates an image.
-     * @param id - The identifier of the image to load.
-     */
-    type CreateImageCallback = (id: string) => HTMLImageElement | HTMLCanvasElement | Promise<HTMLImageElement | HTMLCanvasElement>;
-}
-
 /**
  * A renderable collection of billboards.  Billboards are viewport-aligned
  * images positioned in the 3D scene.
@@ -26142,7 +26331,7 @@ export class BillboardCollection {
      * @param [options] - A template describing the billboard's properties as shown in Example 1.
      * @returns The billboard that was added to the collection.
      */
-    add(options?: any): Billboard;
+    add(options?: Billboard.ConstructorOptions): Billboard;
     /**
      * Removes a billboard from the collection.
      * @example
@@ -28768,6 +28957,7 @@ export namespace Cesium3DTileset {
      * @property [immediatelyLoadDesiredLevelOfDetail = false] - When <code>skipLevelOfDetail</code> is <code>true</code>, only tiles that meet the maximum screen space error will ever be downloaded. Skipping factors are ignored and just the desired tiles are loaded.
      * @property [loadSiblings = false] - When <code>skipLevelOfDetail</code> is <code>true</code>, determines whether siblings of visible tiles are always downloaded during traversal.
      * @property [clippingPlanes] - The {@link ClippingPlaneCollection} used to selectively disable rendering the tileset.
+     * @property [clippingPolygons] - The {@link ClippingPolygonCollection} used to selectively disable rendering the tileset.
      * @property [classificationType] - Determines whether terrain, 3D Tiles or both will be classified by this tileset. See {@link Cesium3DTileset#classificationType} for details about restrictions and limitations.
      * @property [ellipsoid = Ellipsoid.WGS84] - The ellipsoid determining the size and shape of the globe.
      * @property [pointCloudShading] - Options for constructing a {@link PointCloudShading} object to control point attenuation based on geometric error and lighting.
@@ -28784,7 +28974,6 @@ export namespace Cesium3DTileset {
      * @property [showCreditsOnScreen = false] - Whether to display the credits of this tileset on screen.
      * @property [splitDirection = SplitDirection.NONE] - The {@link SplitDirection} split to apply to this tileset.
      * @property [enableCollision = false] - When <code>true</code>, enables collisions for camera or CPU picking. While this is <code>true</code> the camera will be prevented from going below the tileset surface if {@link ScreenSpaceCameraController#enableCollisionDetection} is true.
-     * @property [disableCollision = true] - Whether to turn off collisions for camera collisions or picking. While this is <code>true</code> the camera will be allowed to go in or below the tileset surface if {@link ScreenSpaceCameraController#enableCollisionDetection} is true. Deprecated.
      * @property [projectTo2D = false] - Whether to accurately project the tileset to 2D. If this is true, the tileset will be projected accurately to 2D, but it will use more memory to do so. If this is false, the tileset will use less memory and will still render in 2D / CV mode, but its projected positions may be inaccurate. This cannot be set after the tileset has been created.
      * @property [enablePick = false] - Whether to allow collision and CPU picking with <code>pick</code> when using WebGL 1. If using WebGL 2 or above, this option will be ignored. If using WebGL 1 and this is true, the <code>pick</code> operation will work correctly, but it will use more memory to do so. If running with WebGL 1 and this is false, the model will use less memory, but <code>pick</code> will always return <code>undefined</code>. This cannot be set after the tileset has loaded.
      * @property [debugHeatmapTilePropertyName] - The tile variable to colorize as a heatmap. All rendered tiles will be colorized relative to each other's specified variable value.
@@ -28832,6 +29021,7 @@ export namespace Cesium3DTileset {
         immediatelyLoadDesiredLevelOfDetail?: boolean;
         loadSiblings?: boolean;
         clippingPlanes?: ClippingPlaneCollection;
+        clippingPolygons?: ClippingPolygonCollection;
         classificationType?: ClassificationType;
         ellipsoid?: Ellipsoid;
         pointCloudShading?: any;
@@ -28848,7 +29038,6 @@ export namespace Cesium3DTileset {
         showCreditsOnScreen?: boolean;
         splitDirection?: SplitDirection;
         enableCollision?: boolean;
-        disableCollision?: boolean;
         projectTo2D?: boolean;
         enablePick?: boolean;
         debugHeatmapTilePropertyName?: string;
@@ -29336,10 +29525,6 @@ export class Cesium3DTileset {
      * Function for examining vector lines as they are being streamed.
      */
     examineVectorLinesFunction: (...params: any[]) => any;
-    /**
-     * Whether to turn off collisions for camera collisions or picking. While this is <code>true</code> the camera will be allowed to go in or below the tileset surface if {@link ScreenSpaceCameraController#enableCollisionDetection} is true.
-     */
-    disableCollision: boolean;
     /**
      * Gets the tileset's asset object property, which contains metadata about the tileset.
      * <p>
@@ -29356,6 +29541,10 @@ export class Cesium3DTileset {
      * The {@link ClippingPlaneCollection} used to selectively disable rendering the tileset.
      */
     clippingPlanes: ClippingPlaneCollection;
+    /**
+     * The {@link ClippingPolygonCollection} used to selectively disable rendering the tileset.
+     */
+    clippingPolygons: ClippingPolygonCollection;
     /**
      * Gets the tileset's properties dictionary object, which contains metadata about per-feature properties.
      * <p>
@@ -30111,6 +30300,200 @@ export class ClippingPlaneCollection {
     destroy(): void;
 }
 
+/**
+ * A geodesic polygon to be used with {@link ClippingPlaneCollection} for selectively hiding regions in a model, a 3D tileset, or the globe.
+ * @example
+ * const positions = Cesium.Cartesian3.fromRadiansArray([
+ *     -1.3194369277314022,
+ *     0.6988062530900625,
+ *     -1.31941,
+ *     0.69879,
+ *     -1.3193955980204217,
+ *     0.6988091578771254,
+ *     -1.3193931220959367,
+ *     0.698743632490865,
+ *     -1.3194358224045408,
+ *     0.6987471965556998,
+ * ]);
+ *
+ * const polygon = new Cesium.ClippingPolygon({
+ *     positions: positions
+ * });
+ * @param options - Object with the following properties:
+ * @param options.positions - A list of three or more Cartesian coordinates defining the outer ring of the clipping polygon.
+ */
+export class ClippingPolygon {
+    constructor(options: {
+        positions: Cartesian3[];
+        ellipsoid?: Ellipsoid;
+    });
+    /**
+     * Returns the total number of positions in the polygon, include any holes.
+     */
+    readonly length: number;
+    /**
+     * Returns the outer ring of positions.
+     */
+    readonly positions: Cartesian3[];
+    /**
+     * Returns the ellipsoid used to project the polygon onto surfaces when clipping.
+     */
+    readonly ellipsoid: Ellipsoid;
+    /**
+     * Clones the ClippingPolygon without setting its ownership.
+     * @param polygon - The ClippingPolygon to be cloned
+     * @param [result] - The object on which to store the cloned parameters.
+     * @returns a clone of the input ClippingPolygon
+     */
+    static clone(polygon: ClippingPolygon, result?: ClippingPolygon): ClippingPolygon;
+    /**
+     * Compares the provided ClippingPolygons and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     * @param left - The first polygon.
+     * @param right - The second polygon.
+     * @returns <code>true</code> if left and right are equal, <code>false</code> otherwise.
+     */
+    static equals(left: Plane, right: Plane): boolean;
+    /**
+     * Computes a cartographic rectangle which encloses the polygon defined by the list of positions, including cases over the international date line and the poles.
+     * @param [result] - An object in which to store the result.
+     * @returns The result rectangle
+     */
+    computeRectangle(result?: Rectangle): Rectangle;
+}
+
+/**
+ * Specifies a set of clipping polygons. Clipping polygons selectively disable rendering in a region
+ * inside or outside the specified list of {@link ClippingPolygon} objects for a single glTF model, 3D Tileset, or the globe.
+ *
+ * Clipping Polygons are only supported in WebGL 2 contexts.
+ * @example
+ * const positions = Cesium.Cartesian3.fromRadiansArray([
+ *     -1.3194369277314022,
+ *     0.6988062530900625,
+ *     -1.31941,
+ *     0.69879,
+ *     -1.3193955980204217,
+ *     0.6988091578771254,
+ *     -1.3193931220959367,
+ *     0.698743632490865,
+ *     -1.3194358224045408,
+ *     0.6987471965556998,
+ * ]);
+ *
+ * const polygon = new Cesium.ClippingPolygon({
+ *     positions: positions
+ * });
+ *
+ * const polygons = new Cesium.ClippingPolygonCollection({
+ *    polygons: [ polygon ]
+ * });
+ * @param [options] - Object with the following properties:
+ * @param [options.polygons = []] - An array of {@link ClippingPolygon} objects used to selectively disable rendering on the inside of each polygon.
+ * @param [options.enabled = true] - Determines whether the clipping polygons are active.
+ * @param [options.inverse = false] - If true, a region will be clipped if it is outside of every polygon in the collection. Otherwise, a region will only be clipped if it is on the inside of any polygon.
+ */
+export class ClippingPolygonCollection {
+    constructor(options?: {
+        polygons?: ClippingPolygon[];
+        enabled?: boolean;
+        inverse?: boolean;
+    });
+    /**
+     * An event triggered when a new clipping polygon is added to the collection.  Event handlers
+     * are passed the new polygon and the index at which it was added.
+     */
+    polygonAdded: Event;
+    /**
+     * An event triggered when a new clipping polygon is removed from the collection.  Event handlers
+     * are passed the new polygon and the index from which it was removed.
+     */
+    polygonRemoved: Event;
+    /**
+     * Returns the number of polygons in this collection.  This is commonly used with
+     * {@link ClippingPolygonCollection#get} to iterate over all the polygons
+     * in the collection.
+     */
+    readonly length: number;
+    /**
+     * Adds the specified {@link ClippingPolygon} to the collection to be used to selectively disable rendering
+     * on the inside of each polygon. Use {@link ClippingPolygonCollection#unionClippingRegions} to modify
+     * how modify the clipping behavior of multiple polygons.
+     * @example
+     * const polygons = new Cesium.ClippingPolygonCollection();
+     *
+     * const positions = Cesium.Cartesian3.fromRadiansArray([
+     *     -1.3194369277314022,
+     *     0.6988062530900625,
+     *     -1.31941,
+     *     0.69879,
+     *     -1.3193955980204217,
+     *     0.6988091578771254,
+     *     -1.3193931220959367,
+     *     0.698743632490865,
+     *     -1.3194358224045408,
+     *     0.6987471965556998,
+     * ]);
+     *
+     * polygons.add(new Cesium.ClippingPolygon({
+     *     positions: positions
+     * }));
+     * @param polygon - The ClippingPolygon to add to the collection.
+     * @returns The added ClippingPolygon.
+     */
+    add(polygon: ClippingPolygon): ClippingPolygon;
+    /**
+     * Returns the clipping polygon in the collection at the specified index.  Indices are zero-based
+     * and increase as polygons are added.  Removing a polygon polygon all polygons after
+     * it to the left, changing their indices.  This function is commonly used with
+     * {@link ClippingPolygonCollection#length} to iterate over all the polygons
+     * in the collection.
+     * @param index - The zero-based index of the polygon.
+     * @returns The ClippingPolygon at the specified index.
+     */
+    get(index: number): ClippingPolygon;
+    /**
+     * Checks whether this collection contains a ClippingPolygon equal to the given ClippingPolygon.
+     * @param polygon - The ClippingPolygon to check for.
+     * @returns true if this collection contains the ClippingPolygon, false otherwise.
+     */
+    contains(polygon: ClippingPolygon): boolean;
+    /**
+     * Removes the first occurrence of the given ClippingPolygon from the collection.
+     * @returns <code>true</code> if the polygon was removed; <code>false</code> if the polygon was not found in the collection.
+     */
+    remove(polygon: ClippingPolygon): boolean;
+    /**
+     * Removes all polygons from the collection.
+     */
+    removeAll(): void;
+    /**
+     * Function for checking if the context will allow clipping polygons, which require floating point textures.
+     * @param scene - The scene that will contain clipped objects and clipping textures.
+     * @returns <code>true</code> if the context supports clipping polygons.
+     */
+    static isSupported(scene: Scene | any): 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.
+     * @returns <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+     */
+    isDestroyed(): boolean;
+    /**
+     * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
+     * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+     * <br /><br />
+     * Once an object is destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+     * assign the return value (<code>undefined</code>) to the object as done in the example.
+     * @example
+     * clippingPolygons = clippingPolygons && clippingPolygons.destroy();
+     */
+    destroy(): void;
+}
+
 /**
  * A renderable collection of clouds in the 3D scene.
  * <br /><br />
@@ -31520,6 +31903,10 @@ export class Globe {
      * A property specifying a {@link ClippingPlaneCollection} used to selectively disable rendering on the outside of each plane.
      */
     clippingPlanes: ClippingPlaneCollection;
+    /**
+     * A property specifying a {@link ClippingPolygonCollection} used to selectively disable rendering inside or outside a list of polygons.
+     */
+    clippingPolygons: ClippingPolygonCollection;
     /**
      * A property specifying a {@link Rectangle} used to limit globe rendering to a cartographic area.
      * Defaults to the maximum extent of cartographic coordinates.
@@ -31538,20 +31925,6 @@ export class Globe {
      * Gets an event that's raised when the terrain provider is changed
      */
     readonly terrainProviderChanged: Event;
-    /**
-     * A scalar used to exaggerate the terrain. Defaults to <code>1.0</code> (no exaggeration).
-     * A value of <code>2.0</code> scales the terrain by 2x.
-     * A value of <code>0.0</code> makes the terrain completely flat.
-     * Note that terrain exaggeration will not modify any other primitive as they are positioned relative to the ellipsoid.
-     */
-    terrainExaggeration: number;
-    /**
-     * The height from which terrain is exaggerated. Defaults to <code>0.0</code> (scaled relative to ellipsoid surface).
-     * Terrain that is above this height will scale upwards and terrain that is below this height will scale downwards.
-     * Note that terrain exaggeration will not modify any other primitive as they are positioned relative to the ellipsoid.
-     * If {@link Globe#terrainExaggeration} is <code>1.0</code> this value will have no effect.
-     */
-    terrainExaggerationRelativeHeight: number;
     /**
      * Gets an event that's raised when the length of the tile load queue has changed since the last render frame.  When the load queue is empty,
      * all terrain and imagery for the current view have been loaded.  The event passes the new length of the tile load queue.
@@ -34020,13 +34393,69 @@ export enum IonWorldImageryStyle {
     ROAD = 4
 }
 
+export namespace Label {
+    /**
+     * Initialization options for the Label constructor
+     * @property position - The cartesian position of the label.
+     * @property [id] - A user-defined object to return when the label is picked with {@link Scene#pick}.
+     * @property [show = true] - Determines if this label will be shown.
+     * @property [text] - A string specifying the text of the label.
+     * @property [font = '30px sans-serif'] - A string specifying the font used to draw this label. Fonts are specified using the same syntax as the CSS 'font' property.
+     * @property [style = LabelStyle.FILL] - A {@link LabelStyle} specifying the style of the label.
+     * @property [scale = 1.0] - A number specifying the uniform scale that is multiplied with the label size.
+     * @property [showBackground = false] - Determines if a background behind this label will be shown.
+     * @property [backgroundColor = new Color(0.165, 0.165, 0.165, 0.8)] - A {@link Color} specifying the background color of the label.
+     * @property [backgroundPadding = new Cartesian2(7, 5)] - A {@link Cartesian2} Specifying the horizontal and vertical background padding in pixels.
+     * @property [pixelOffset = Cartesian2.ZERO] - A {@link Cartesian2} specifying the pixel offset in screen space from the origin of this label.
+     * @property [eyeOffset = Cartesian3.ZERO] - A {@link Cartesian3} specifying the 3D Cartesian offset applied to this label in eye coordinates.
+     * @property [horizontalOrigin = HorizontalOrigin.CENTER] - A {@link HorizontalOrigin} specifying the horizontal origin of this label.
+     * @property [verticalOrigin = VerticalOrigin.CENTER] - A {@link VerticalOrigin} specifying the vertical origin of this label.
+     * @property [heightReference = HeightReference.NONE] - A {@link HeightReference} specifying the height reference of this label.
+     * @property [fillColor = Color.WHITE] - A {@link Color} specifying the fill color of the label.
+     * @property [outlineColor = Color.BLACK] - A {@link Color} specifying the outline color of the label.
+     * @property [outlineWidth = 1.0] - A number specifying the outline width of the label.
+     * @property [translucencyByDistance] - A {@link NearFarScalar} specifying near and far translucency properties of the label based on the label's distance from the camera.
+     * @property [pixelOffsetScaleByDistance] - A {@link NearFarScalar} specifying near and far pixel offset scaling properties of the label based on the label's distance from the camera.
+     * @property [scaleByDistance] - A {@link NearFarScalar} specifying near and far scaling properties of the label based on the label's distance from the camera.
+     * @property [distanceDisplayCondition] - A {@link DistanceDisplayCondition} specifying at what distance from the camera that this label will be displayed.
+     * @property [disableDepthTestDistance] - A number specifying the distance from the camera at which to disable the depth test to, for example, prevent clipping against terrain.
+     */
+    type ConstructorOptions = {
+        position: Cartesian3;
+        id?: string;
+        show?: boolean;
+        text?: string;
+        font?: string;
+        style?: LabelStyle;
+        scale?: number;
+        showBackground?: boolean;
+        backgroundColor?: Color;
+        backgroundPadding?: Cartesian2;
+        pixelOffset?: Cartesian2;
+        eyeOffset?: Cartesian3;
+        horizontalOrigin?: HorizontalOrigin;
+        verticalOrigin?: VerticalOrigin;
+        heightReference?: HeightReference;
+        fillColor?: Color;
+        outlineColor?: Color;
+        outlineWidth?: number;
+        translucencyByDistance?: NearFarScalar;
+        pixelOffsetScaleByDistance?: NearFarScalar;
+        scaleByDistance?: NearFarScalar;
+        distanceDisplayCondition?: DistanceDisplayCondition;
+        disableDepthTestDistance?: number;
+    };
+}
+
 /**
  * <div class="notice">
  * Create labels by calling {@link LabelCollection#add}. Do not call the constructor directly.
  * </div>
+ * @param options - Object describing initialization options
+ * @param labelCollection - Instance of LabelCollection
  */
 export class Label {
-    constructor();
+    constructor(options: Label.ConstructorOptions, labelCollection: LabelCollection);
     /**
      * Determines if this label will be shown.  Use this to hide or show a label, instead
      * of removing it and re-adding it to the collection.
@@ -34411,7 +34840,7 @@ export class LabelCollection {
      * @param [options] - A template describing the label's properties as shown in Example 1.
      * @returns The label that was added to the collection.
      */
-    add(options?: any): Label;
+    add(options?: Label.ConstructorOptions): Label;
     /**
      * Removes a label from the collection.  Once removed, a label is no longer usable.
      * @example
@@ -36194,6 +36623,10 @@ export class Model {
      * The {@link ClippingPlaneCollection} used to selectively disable rendering the model.
      */
     clippingPlanes: ClippingPlaneCollection;
+    /**
+     * The {@link ClippingPolygonCollection} used to selectively disable rendering the model.
+     */
+    clippingPolygons: ClippingPolygonCollection;
     /**
      * The light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
      * <p>
@@ -36431,6 +36864,7 @@ export class Model {
      * @param [options.showOutline = true] - Whether to display the outline for models using the {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline} extension. When true, outlines are displayed. When false, outlines are not displayed.
      * @param [options.outlineColor = Color.BLACK] - The color to use when rendering outlines.
      * @param [options.clippingPlanes] - The {@link ClippingPlaneCollection} used to selectively disable rendering the model.
+     * @param [options.clippingPolygons] - The {@link ClippingPolygonCollection} used to selectively disable rendering the model.
      * @param [options.lightColor] - The light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
      * @param [options.imageBasedLighting] - The properties for managing image-based lighting on this model.
      * @param [options.backFaceCulling = true] - Whether to cull back-facing geometry. When true, back face culling is determined by the material's doubleSided property; when false, back face culling is disabled. Back faces are not culled if the model's color is translucent.
@@ -36482,6 +36916,7 @@ export class Model {
         showOutline?: boolean;
         outlineColor?: Color;
         clippingPlanes?: ClippingPlaneCollection;
+        clippingPolygons?: ClippingPolygonCollection;
         lightColor?: Cartesian3;
         imageBasedLighting?: ImageBasedLighting;
         backFaceCulling?: boolean;
@@ -41068,6 +41503,14 @@ export class Terrain {
      * are passed the created instance of {@link TerrainProvider}.
      */
     readonly readyEvent: Event<Terrain.ReadyEventCallback>;
+    /**
+     * Returns true when the terrain provider has been successfully created. Otherwise, returns false.
+     */
+    readonly ready: boolean;
+    /**
+     * The terrain provider providing surface geometry to a globe. Do not use until {@link Terrain.readyEvent} is raised.
+     */
+    readonly provider: TerrainProvider;
     /**
      * Creates a {@link Terrain} instance for {@link https://cesium.com/content/#cesium-world-terrain|Cesium World Terrain}.
      * @example