@cesium/engine 21.0.1 → 22.1.0

package/index.d.ts

@@ -834,6 +834,13 @@ export class AxisAlignedBoundingBox {
      *                      intersects the plane.
      */
     static intersectPlane(box: AxisAlignedBoundingBox, plane: Plane): Intersect;
+    /**
+     * Determines whether two axis aligned bounding boxes intersect.
+     * @param box - first box
+     * @param other - second box
+     * @returns <code>true</code> if the boxes intersect; otherwise, <code>false</code>.
+     */
+    static intersectAxisAlignedBoundingBox(box: AxisAlignedBoundingBox, other: AxisAlignedBoundingBox): boolean;
     /**
      * Duplicates this AxisAlignedBoundingBox instance.
      * @param [result] - The object onto which to store the result.
@@ -849,6 +856,12 @@ export class AxisAlignedBoundingBox {
      *                      intersects the plane.
      */
     intersectPlane(plane: Plane): Intersect;
+    /**
+     * Determines whether some other axis aligned bounding box intersects this box.
+     * @param other - The other axis aligned bounding box.
+     * @returns <code>true</code> if the boxes intersect; otherwise, <code>false</code>.
+     */
+    intersectAxisAlignedBoundingBox(other: AxisAlignedBoundingBox): boolean;
     /**
      * Compares this AxisAlignedBoundingBox against the provided AxisAlignedBoundingBox componentwise and returns
      * <code>true</code> if they are equal, <code>false</code> otherwise.
@@ -2801,6 +2814,234 @@ export class CatmullRomSpline {
     evaluate(time: number, result?: Cartesian3): Cartesian3;
 }
 
+/**
+ * Terrain data for a single tile where the terrain data is represented as a glb (binary glTF).
+ * @param options - Object with the following properties:
+ * @param options.gltf - The parsed glTF JSON.
+ * @param options.minimumHeight - The minimum terrain height within the tile, in meters above the ellipsoid.
+ * @param options.maximumHeight - The maximum terrain height within the tile, in meters above the ellipsoid.
+ * @param options.boundingSphere - A sphere bounding all of the vertices in the mesh.
+ * @param options.orientedBoundingBox - An oriented bounding box containing all of the vertices in the mesh.
+ * @param options.horizonOcclusionPoint - The horizon occlusion point of the mesh. If this point
+ *                      is below the horizon, the entire tile is assumed to be below the horizon as well.
+ *                      The point is expressed in ellipsoid-scaled coordinates.
+ * @param options.skirtHeight - The height of the skirt to add on the edges of the tile.
+ * @param [options.requestVertexNormals = false] - Indicates whether normals should be loaded.
+ * @param [options.requestWaterMask = false] - Indicates whether water mask data should be loaded.
+ * @param [options.credits] - Array of credits for this tile.
+ * @param [options.childTileMask = 15] - A bit mask indicating which of this tile's four children exist.
+ *                 If a child's bit is set, geometry will be requested for that tile as well when it
+ *                 is needed.  If the bit is cleared, the child tile is not requested and geometry is
+ *                 instead upsampled from the parent.  The bit values are as follows:
+ *                 <table>
+ *                  <tr><th>Bit Position</th><th>Bit Value</th><th>Child Tile</th></tr>
+ *                  <tr><td>0</td><td>1</td><td>Southwest</td></tr>
+ *                  <tr><td>1</td><td>2</td><td>Southeast</td></tr>
+ *                  <tr><td>2</td><td>4</td><td>Northwest</td></tr>
+ *                  <tr><td>3</td><td>8</td><td>Northeast</td></tr>
+ *                 </table>
+ * @param [options.waterMask] - The buffer containing the water mask.
+ */
+export class Cesium3DTilesTerrainData {
+    constructor(options: {
+        gltf: {
+            [key: string]: any;
+        };
+        minimumHeight: number;
+        maximumHeight: number;
+        boundingSphere: BoundingSphere;
+        orientedBoundingBox: OrientedBoundingBox;
+        horizonOcclusionPoint: Cartesian3;
+        skirtHeight: number;
+        requestVertexNormals?: boolean;
+        requestWaterMask?: boolean;
+        credits?: Credit[];
+        childTileMask?: number;
+        waterMask?: Uint8Array;
+    });
+    /**
+     * An array of credits for this tile.
+     */
+    credits: Credit[] | undefined;
+    /**
+     * The water mask included in this terrain data, if any. A water mask is a rectangular
+     * Uint8Array or image where a value of 255 indicates water and a value of 0 indicates land.
+     * Values in between 0 and 255 are allowed as well to smoothly blend between land and water.
+     */
+    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | ImageBitmap | undefined;
+    /**
+     * Returns the terrain height at a specified longitude and latitude, or undefined if the mesh is undefined.
+     * @param rectangle - The rectangle covered by this terrain data.
+     * @param longitude - The longitude in radians.
+     * @param latitude - The latitude in radians.
+     * @returns The terrain height at the specified position, or undefined if the mesh is undefined.
+     *          If the position is outside the rectangle, this method will extrapolate the height,
+     *          which is likely to be wildly incorrect for positions far outside the rectangle.
+     */
+    interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number | undefined;
+    /**
+     * Determines if a given child tile is available, based on the
+     * {@link TerrainData#childTileMask}. The given child tile coordinates are assumed
+     * to be one of the four children of this tile. If non-child tile coordinates are
+     * given, the availability of the southeast child tile is returned.
+     * @param thisX - The tile X coordinate of this (the parent) tile.
+     * @param thisY - The tile Y coordinate of this (the parent) tile.
+     * @param childX - The tile X coordinate of the child tile to check for availability.
+     * @param childY - The tile Y coordinate of the child tile to check for availability.
+     * @returns True if the child tile is available; otherwise, false.
+     */
+    isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean;
+    /**
+     * Upsamples this terrain data for use by a descendant tile.
+     * @param tilingScheme - The tiling scheme of this terrain data.
+     * @param thisX - The X coordinate of this tile in the tiling scheme.
+     * @param thisY - The Y coordinate of this tile in the tiling scheme.
+     * @param thisLevel - The level of this tile in the tiling scheme.
+     * @param descendantX - The X coordinate within the tiling scheme of the descendant tile for which we are upsampling.
+     * @param descendantY - The Y coordinate within the tiling scheme of the descendant tile for which we are upsampling.
+     * @param descendantLevel - The level within the tiling scheme of the descendant tile for which we are upsampling.
+     * @returns A promise for upsampled terrain data for the descendant tile, or undefined if createMesh has not been called yet or too many asynchronous upsample operations are in progress and the request has been deferred.
+     */
+    upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<TerrainData> | undefined;
+    /**
+     * Gets a value indicating whether or not this terrain data was created by upsampling lower resolution
+     * terrain data. If this value is false, the data was obtained from some other source, such
+     * as by downloading it from a remote server. This method should return true for instances
+     * returned from a call to {@link Cesium3DTilesTerrainData#upsample}.
+     * @returns True if this instance was created by upsampling; otherwise, false.
+     */
+    wasCreatedByUpsampling(): boolean;
+}
+
+export namespace Cesium3DTilesTerrainProvider {
+    /**
+     * Initialization options for the Cesium3DTilesTerrainProvider constructor
+     * @property [requestVertexNormals = false] - Flag that indicates if the client should request additional lighting information from the server, in the form of per vertex normals if available.
+     * @property [requestWaterMask = false] - Flag that indicates if the client should request per tile water masks from the server, if available.
+     * @property [ellipsoid = Ellipsoid.default] - The ellipsoid.  If not specified, the WGS84 ellipsoid is used.
+     * @property [credit] - A credit for the data source, which is displayed on the canvas.
+     */
+    type ConstructorOptions = {
+        requestVertexNormals?: boolean;
+        requestWaterMask?: boolean;
+        ellipsoid?: Ellipsoid;
+        credit?: Credit | string;
+    };
+}
+
+/**
+ * <div class="notice">
+ * To construct a Cesium3DTilesTerrainProvider, call {@link Cesium3DTilesTerrainProvider.fromIonAssetId} or {@link Cesium3DTilesTerrainProvider.fromUrl}. Do not call the constructor directly.
+ * </div>
+ *
+ * A {@link TerrainProvider} that accesses terrain data in a 3D Tiles format.
+ * @param [options] - An object describing initialization options
+ */
+export class Cesium3DTilesTerrainProvider {
+    constructor(options?: Cesium3DTilesTerrainProvider.ConstructorOptions);
+    /**
+     * Creates a {@link TerrainProvider} that accesses terrain data in a Cesium 3D Tiles format.
+     * @example
+     * // Create terrain with normals.
+     * try {
+     *   const viewer = new Cesium.Viewer("cesiumContainer", {
+     *     terrainProvider: await Cesium.Cesium3DTilesTerrainProvider.fromUrl(
+     *       Cesium.IonResource.fromAssetId(3956), {
+     *         requestVertexNormals: true
+     *     })
+     *   });
+     * } catch (error) {
+     *   console.log(error);
+     * }
+     * @param url - The URL of the Cesium terrain server.
+     * @param [options] - An object describing initialization options.
+     * @returns A promise that resolves to the terrain provider.
+     */
+    static fromUrl(url: Resource | string | Promise<Resource> | Promise<string>, options?: Cesium3DTilesTerrainProvider.ConstructorOptions): Promise<Cesium3DTilesTerrainProvider>;
+    /**
+     * Creates a {@link TerrainProvider} from a Cesium ion asset ID that accesses terrain data in a Cesium 3D Tiles format
+     * @example
+     * // Create GTOPO30 with vertex normals
+     * try {
+     *   const viewer = new Cesium.Viewer("cesiumContainer", {
+     *     terrainProvider: await Cesium.Cesium3DTilesTerrainProvider.fromIonAssetId(2732686, {
+     *         requestVertexNormals: true
+     *     })
+     *   });
+     * } catch (error) {
+     *   console.log(error);
+     * }
+     * @param assetId - The Cesium ion asset id.
+     * @param [options] - An object describing initialization options.
+     */
+    static fromIonAssetId(assetId: number, options?: CesiumTerrainProvider.ConstructorOptions): Promise<CesiumTerrainProvider>;
+    /**
+     * Requests the geometry for a given tile. This function should not be called before
+     * {@link Cesium3DTilesTerrainProvider#ready} returns true. The result must include terrain data and
+     * may optionally include a water mask and an indication of which child tiles are available.
+     * @param x - The X coordinate of the tile for which to request geometry.
+     * @param y - The Y coordinate of the tile for which to request geometry.
+     * @param level - The level of the tile for which to request geometry.
+     * @param [request] - The request object. Intended for internal use only.
+     * @returns A promise for the requested geometry. If this method
+     *          returns undefined instead of a promise, it is an indication that too many requests are already
+     *          pending and the request will be retried later.
+     */
+    requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<Cesium3DTilesTerrainData> | undefined;
+    /**
+     * Determines whether data for a tile is available to be loaded.
+     * @param x - The X coordinate of the tile for which to request geometry.
+     * @param y - The Y coordinate of the tile for which to request geometry.
+     * @param level - The level of the tile for which to request geometry.
+     * @returns Undefined if not supported or availability is unknown, otherwise true or false.
+     */
+    getTileDataAvailable(x: number, y: number, level: number): boolean | undefined;
+    /**
+     * Make sure we load availability data for a tile
+     * @param _x - The X coordinate of the tile for which to request geometry.
+     * @param _y - The Y coordinate of the tile for which to request geometry.
+     * @param _level - The level of the tile for which to request geometry.
+     * @returns Undefined if nothing need to be loaded or a Promise that resolves when all required tiles are loaded
+     */
+    loadTileDataAvailability(_x: number, _y: number, _level: number): Promise<void> | undefined;
+    /**
+     * Get the maximum geometric error allowed in a tile at a given level.
+     * @param level - The tile level for which to get the maximum geometric error.
+     * @returns The maximum geometric error.
+     */
+    getLevelMaximumGeometricError(level: number): number;
+    /**
+     * Gets an event that is raised when the terrain 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}.
+     */
+    errorEvent: Event;
+    /**
+     * Gets the credit to display when this terrain provider is active. Typically this is used to credit
+     * the source of the terrain.
+     */
+    credit: Credit;
+    /**
+     * Gets the tiling scheme used by the provider.
+     */
+    tilingScheme: TilingScheme;
+    /**
+     * Gets a value indicating whether or not the provider includes a water mask. The water mask
+     * indicates which areas of the globe are water rather than land, so they can be rendered
+     * as a reflective surface with animated waves.
+     */
+    hasWaterMask: boolean;
+    /**
+     * Gets a value indicating whether or not the requested tiles include vertex normals.
+     */
+    hasVertexNormals: boolean;
+    /**
+     * Gets an object that can be used to determine availability of terrain from this provider, such as
+     * at points and in rectangles.
+     */
+    availability: TileAvailability | undefined;
+}
+
 export namespace CesiumTerrainProvider {
     /**
      * Initialization options for the CesiumTerrainProvider constructor
@@ -3602,6 +3843,12 @@ export class Color {
      * @returns The modified result parameter or a new instance if result was undefined.
      */
     toBytes(result?: number[]): number[];
+    /**
+     * Converts RGBA values in bytes to a single numeric unsigned 32-bit RGBA value, using the endianness
+     * of the system.
+     * @returns A single numeric unsigned 32-bit RGBA value.
+     */
+    static bytesToRgba(): number;
     /**
      * Converts this color to a single numeric unsigned 32-bit RGBA value, using the endianness
      * of the system.
@@ -7620,7 +7867,7 @@ export class GoogleEarthEnterpriseTerrainData {
     upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<HeightmapTerrainData> | undefined;
     /**
      * Determines if a given child tile is available, based on the
-     * {@link HeightmapTerrainData.childTileMask}.  The given child tile coordinates are assumed
+     * {@link GoogleEarthEnterpriseTerrainData.childTileMask}.  The given child tile coordinates are assumed
      * to be one of the four children of this tile.  If non-child tile coordinates are
      * given, the availability of the southeast child tile is returned.
      * @param thisX - The tile X coordinate of this (the parent) tile.
@@ -8133,7 +8380,7 @@ export class HeightmapTerrainData {
      * Uint8Array or image where a value of 255 indicates water and a value of 0 indicates land.
      * Values in between 0 and 255 are allowed as well to smoothly blend between land and water.
      */
-    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | undefined;
+    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | ImageBitmap | undefined;
     /**
      * Computes the terrain height at a specified longitude and latitude.
      * @param rectangle - The rectangle covered by this terrain data.
@@ -8617,6 +8864,13 @@ export namespace IntersectionTests {
      * @returns The interval containing scalar points along the ray or undefined if there are no intersections.
      */
     function rayEllipsoid(ray: Ray, ellipsoid: Ellipsoid): Interval;
+    /**
+     * Computes the intersection points of a ray with an axis-aligned bounding box. (axis-aligned in the same space as the ray)
+     * @param ray - The ray.
+     * @param box - The axis-aligned bounding box.
+     * @param result - The interval containing scalar points along the ray or undefined if there are no intersections.
+     */
+    function rayAxisAlignedBoundingBox(ray: Ray, box: AxisAlignedBoundingBox, result: Interval | undefined): void;
     /**
      * Provides the point along the ray which is nearest to the ellipsoid.
      * @param ray - The ray.
@@ -8821,7 +9075,7 @@ export class IonGeocoderService {
  * A {@link Resource} instance that encapsulates Cesium ion asset access.
  * This object is normally not instantiated directly, use {@link IonResource.fromAssetId}.
  * @param endpoint - The result of the Cesium ion asset endpoint service.
- * @param endpointResource - The resource used to retrieve the endpoint.
+ * @param endpointResource - The original resource used to retrieve the endpoint.
  */
 export class IonResource extends Resource {
     constructor(endpoint: any, endpointResource: Resource);
@@ -16462,7 +16716,7 @@ export class TerrainData {
      * Uint8Array or image where a value of 255 indicates water and a value of 0 indicates land.
      * Values in between 0 and 255 are allowed as well to smoothly blend between land and water.
      */
-    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | undefined;
+    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | ImageBitmap | undefined;
     /**
      * Computes the terrain height at a specified longitude and latitude.
      * @param rectangle - The rectangle covered by this terrain data.
@@ -16509,6 +16763,21 @@ export class TerrainData {
     wasCreatedByUpsampling(): boolean;
 }
 
+/**
+ * Indicates whether the terrain picker needs to be rebuilt due to changes in the underlying terrain mesh's vertices or indices.
+ */
+export var needsRebuild: boolean;
+
+/**
+ * Creates an axis-aligned bounding box for a quadtree node at the given tree-space coordinates and level.
+ * This AABB is in the tree's local space (where the root node of the tree is a unit cube in its own local space).
+ * @param x - The x coordinate of the node.
+ * @param y - The y coordinate of the node.
+ * @param level - The level of the node.
+ * @returns The axis-aligned bounding box for the node.
+ */
+export function createAABBForNode(x: number, y: number, level: number): AxisAlignedBoundingBox;
+
 export namespace TerrainProvider {
     /**
      * A function that is called when an error occurs.
@@ -18385,7 +18654,7 @@ export function barycentricCoordinates(point: Cartesian2 | Cartesian3, p0: Carte
  *        of the index before which the itemToFind should be inserted in order to maintain the
  *        sorted order of the array.
  */
-export function binarySearch(array: any[], itemToFind: any, comparator: binarySearchComparator): number;
+export function binarySearch(array: any[] | Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array, itemToFind: any, comparator: binarySearchComparator): number;
 
 /**
  * A function used to compare two items while performing a binary search.
@@ -18649,7 +18918,7 @@ export function isLeapYear(year: number): boolean;
  * @param comparator - The function to use to compare elements in the array.
  * @param [userDefinedObject] - Any item to pass as the third parameter to <code>comparator</code>.
  */
-export function mergeSort(array: any[], comparator: mergeSortComparator, userDefinedObject?: any): void;
+export function mergeSort(array: any[] | Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array, comparator: mergeSortComparator, userDefinedObject?: any): void;
 
 /**
  * A function used to compare two items while performing a merge sort.
@@ -18851,7 +19120,7 @@ export namespace BillboardGraphics {
      */
     type ConstructorOptions = {
         show?: Property | boolean;
-        image?: Property | string | HTMLCanvasElement;
+        image?: Property | string | HTMLImageElement | HTMLCanvasElement;
         scale?: Property | number;
         pixelOffset?: Property | Cartesian2;
         eyeOffset?: Property | Cartesian3;
@@ -25639,6 +25908,8 @@ export type WebGLOptions = {
     failIfMajorPerformanceCaveat?: boolean;
 };
 
+export function PickId(pickObjects: Map<number, object>, key: number, color: Color): void;
+
 /**
  * The data type of a pixel.
  */
@@ -26153,6 +26424,137 @@ export enum Axis {
     Z = 2
 }
 
+export namespace Azure2DImageryProvider {
+    /**
+     * Initialization options for the Azure2DImageryProvider constructor
+     * @property options - Object with the following properties:
+     * @property [options.url = "https://atlas.microsoft.com/"] - The Azure server url.
+     * @property options.tilesetId - The Azure tileset ID. Valid options are {@link microsoft.imagery}, {@link microsoft.base.road}, and {@link microsoft.base.labels.road}
+     * @property options.subscriptionKey - The public subscription key for the imagery.
+     * @property [options.ellipsoid = Ellipsoid.default] - The ellipsoid.  If not specified, the default ellipsoid is used.
+     * @property [options.minimumLevel = 0] - The minimum level-of-detail supported by the imagery provider.  Take care when specifying
+     *                 this that the number of tiles at the minimum level is small, such as four or less.  A larger number is likely
+     *                 to result in rendering problems.
+     * @property [options.maximumLevel = 22] - The maximum level-of-detail supported by the imagery provider.
+     * @property [options.rectangle = Rectangle.MAX_VALUE] - The rectangle, in radians, covered by the image.
+     */
+    type ConstructorOptions = {
+        options: {
+            url?: string;
+            tilesetId: string;
+            subscriptionKey: string;
+            ellipsoid?: Ellipsoid;
+            minimumLevel?: number;
+            maximumLevel?: number;
+            rectangle?: Rectangle;
+        };
+    };
+}
+
+/**
+ * Provides 2D image tiles from Azure.
+ * @example
+ * // Azure 2D imagery provider
+ * const azureImageryProvider = new Cesium.Azure2DImageryProvider({
+ *     subscriptionKey: "subscription-key",
+ *     tilesetId: "microsoft.base.road"
+ * });
+ * @param options - Object describing initialization options
+ */
+export class Azure2DImageryProvider {
+    constructor(options: Azure2DImageryProvider.ConstructorOptions);
+    /**
+     * Gets the URL of the Azure 2D Imagery server.
+     */
+    readonly url: string;
+    /**
+     * Gets the rectangle, in radians, of the imagery provided by the instance.
+     */
+    readonly rectangle: Rectangle;
+    /**
+     * Gets the width of each tile, in pixels.
+     */
+    readonly tileWidth: number;
+    /**
+     * Gets the height of each tile, in pixels.
+     */
+    readonly tileHeight: number;
+    /**
+     * Gets the maximum level-of-detail that can be requested.
+     */
+    readonly maximumLevel: number | undefined;
+    /**
+     * Gets the minimum level-of-detail that can be requested. Generally,
+     * a minimum level should only be used when the rectangle of the imagery is small
+     * enough that the number of tiles at the minimum level is small.  An imagery
+     * provider with more than a few tiles at the minimum level will lead to
+     * rendering problems.
+     */
+    readonly minimumLevel: number;
+    /**
+     * Gets the tiling scheme used by the provider.
+     */
+    readonly tilingScheme: TilingScheme;
+    /**
+     * 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.
+     */
+    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}.
+     */
+    readonly errorEvent: Event;
+    /**
+     * Gets the credit to display when this imagery provider is active.  Typically this is used to credit
+     * the source of the imagery.
+     */
+    readonly credit: Credit;
+    /**
+     * Gets the proxy used by this provider.
+     */
+    readonly proxy: Proxy;
+    /**
+     * 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.
+     */
+    readonly hasAlphaChannel: boolean;
+    /**
+     * Gets the credits to be displayed when a given tile is displayed.
+     * @param x - The tile X coordinate.
+     * @param y - The tile Y coordinate.
+     * @param level - The tile level;
+     * @returns The credits to be displayed when the tile is displayed.
+     */
+    getTileCredits(x: number, y: number, level: number): Credit[] | undefined;
+    /**
+     * Requests the image for a given tile.
+     * @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.
+     */
+    requestImage(x: number, y: number, level: number, request?: Request): Promise<ImageryTypes> | undefined;
+    /**
+     * Picking features is not currently supported by this imagery provider, so this function simply returns
+     * undefined.
+     * @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 Undefined since picking is not supported.
+     */
+    pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): undefined;
+}
+
 export namespace Billboard {
     /**
      * Initialization options for the first param of Billboard constructor
@@ -26184,7 +26586,7 @@ export namespace Billboard {
         position: Cartesian3;
         id?: any;
         show?: boolean;
-        image?: string | HTMLCanvasElement;
+        image?: string | HTMLImageElement | HTMLCanvasElement;
         scale?: number;
         pixelOffset?: Cartesian2;
         eyeOffset?: Cartesian3;
@@ -26535,6 +26937,11 @@ export class Billboard {
     equals(other?: Billboard): boolean;
 }
 
+/**
+ * Arbitrary limit on allocated SVG size, in pixels. Raster images use image resolution.
+ */
+export const SVG_MAX_SIZE_PX = 512;
+
 /**
  * A renderable collection of billboards.  Billboards are viewport-aligned
  * images positioned in the 3D scene.
@@ -32872,31 +33279,28 @@ export function removeExtension(gltf: any, extension: string): any;
 export namespace Google2DImageryProvider {
     /**
      * Initialization options for the Google2DImageryProvider constructor
-     * @property options - Object with the following properties:
-     * @property options.key - The Google api key to send with tile requests.
-     * @property options.session - The Google session token that tracks the current state of your map and viewport.
-     * @property options.url - The Google 2D maps endpoint.
-     * @property options.tileWidth - The width of each tile in pixels.
-     * @property options.tileHeight - The height of each tile in pixels.
-     * @property [options.ellipsoid = Ellipsoid.default] - The ellipsoid.  If not specified, the default ellipsoid is used.
-     * @property [options.minimumLevel = 0] - The minimum level-of-detail supported by the imagery provider.  Take care when specifying
+     * @property key - The Google api key to send with tile requests.
+     * @property session - The Google session token that tracks the current state of your map and viewport.
+     * @property url - The Google 2D maps endpoint.
+     * @property tileWidth - The width of each tile in pixels.
+     * @property tileHeight - The height of each tile in pixels.
+     * @property [ellipsoid = Ellipsoid.default] - The ellipsoid.  If not specified, the default ellipsoid is used.
+     * @property [minimumLevel = 0] - The minimum level-of-detail supported by the imagery provider.  Take care when specifying
      *                 this that the number of tiles at the minimum level is small, such as four or less.  A larger number is likely
      *                 to result in rendering problems.
-     * @property [options.maximumLevel = 22] - The maximum level-of-detail supported by the imagery provider.
-     * @property [options.rectangle = Rectangle.MAX_VALUE] - The rectangle, in radians, covered by the image.
+     * @property [maximumLevel = 22] - The maximum level-of-detail supported by the imagery provider.
+     * @property [rectangle = Rectangle.MAX_VALUE] - The rectangle, in radians, covered by the image.
      */
     type ConstructorOptions = {
-        options: {
-            key: string;
-            session: string;
-            url: string | Resource | IonResource;
-            tileWidth: string;
-            tileHeight: string;
-            ellipsoid?: Ellipsoid;
-            minimumLevel?: number;
-            maximumLevel?: number;
-            rectangle?: Rectangle;
-        };
+        key: string;
+        session: string;
+        url: string | Resource | IonResource;
+        tileWidth: string;
+        tileHeight: string;
+        ellipsoid?: Ellipsoid;
+        minimumLevel?: number;
+        maximumLevel?: number;
+        rectangle?: Rectangle;
     };
 }
 
@@ -32995,7 +33399,7 @@ export class Google2DImageryProvider {
      * });
      * @example
      * // Google 2D roadmap overlay with custom styles
-     * const googleTileProvider = Cesium.Google2DImageryProvider.fromIonAssetId({
+     * const googleTilesProvider = Cesium.Google2DImageryProvider.fromIonAssetId({
      *     assetId: 3830184,
      *     overlayLayerType: "layerRoadmap",
      *     styles: [
@@ -33051,7 +33455,7 @@ export class Google2DImageryProvider {
      * // Google 2D roadmap overlay with custom styles
      * Cesium.GoogleMaps.defaultApiKey = "your-api-key";
      *
-     * const googleTileProvider = Cesium.Google2DImageryProvider.fromUrl({
+     * const googleTilesProvider = Cesium.Google2DImageryProvider.fromUrl({
      *     overlayLayerType: "layerRoadmap",
      *     styles: [
      *         {
@@ -39723,6 +40127,20 @@ export var metadataProperty: any;
  */
 export function computePickingDrawingBufferRectangle(drawingBufferHeight: number, position: Cartesian2, width: number | undefined, height: number | undefined, result: BoundingRectangle): BoundingRectangle;
 
+/**
+ * Setup needed before picking.
+ * @param windowPosition - Window coordinates to perform picking on.
+ * @param drawingBufferRectangle - The output drawing buffer recangle.
+ * @param [width = 3] - Width of the pick rectangle.
+ * @param [height = 3] - Height of the pick rectangle.
+ */
+export function pickBegin(scene: Scene, windowPosition: Cartesian2, drawingBufferRectangle: BoundingRectangle, width?: number, height?: number): void;
+
+/**
+ * Teardown needed after picking.
+ */
+export function pickEnd(scene: Scene): void;
+
 /**
  * Information about metadata that is supposed to be picked
  * @property schemaId - The optional ID of the metadata schema
@@ -39737,6 +40155,21 @@ export type PickedMetadataInfo = {
     classProperty: MetadataClassProperty;
 };
 
+/**
+ * @param pickedResults - the results from the pickCallback
+ * @param limit - If supplied, stop drilling after collecting this many picks.
+ * @returns whether picking should end
+ */
+export function addDrillPickedResults(pickedResults: object[], limit: number, results: object[], pickedPrimitives: object[], pickedAttributes: object[], pickedFeatures: object[]): boolean;
+
+/**
+ * Drill pick by repeatedly calling a given `pickCallback`, each time stripping away the previously picked objects.
+ * @param pickCallback - Pick callback to execute each iteration
+ * @param [limit = Number.MAX_VALUE] - If supplied, stop drilling after collecting this many picks
+ * @returns List of picked results
+ */
+export function drillPick(pickCallback: (...params: any[]) => any, limit?: number): object[];
+
 /**
  * Remove all invalid binary body references from the batch table
  * JSON of the given parsed content.
@@ -41877,6 +42310,12 @@ export class Scene {
      * The light source for shading. Defaults to a directional light from the Sun.
      */
     light: Light;
+    /**
+     * Whether or not to enable edge visibility rendering for 3D tiles.
+     * When enabled, creates a framebuffer with multiple render targets
+     * for advanced edge detection and visibility techniques.
+     */
+    _enableEdgeVisibility: boolean;
     /**
      * Use this to set the default value for {@link Scene#logarithmicDepthBuffer} in newly constructed Scenes
      * This property relies on fragmentDepth being supported.
@@ -42113,6 +42552,24 @@ export class Scene {
      * @returns Object containing the picked primitive or <code>undefined</code> if nothing is at the location.
      */
     pick(windowPosition: Cartesian2, width?: number, height?: number): any | undefined;
+    /**
+     * Performs the same operation as Scene.pick but asynchonosly without blocking the main render thread.
+     * Requires WebGL2 else using fallback.
+     * @example
+     * // On mouse over, color the feature yellow.
+     * handler.setInputAction(function(movement) {
+     *     const feature = scene.pickAsync(movement.endPosition).then(function(feature) {
+     *        if (feature instanceof Cesium.Cesium3DTileFeature) {
+     *            feature.color = Cesium.Color.YELLOW;
+     *        }
+     *     });
+     * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+     * @param windowPosition - Window coordinates to perform picking on.
+     * @param [width = 3] - Width of the pick rectangle.
+     * @param [height = 3] - Height of the pick rectangle.
+     * @returns Object containing the picked primitive or <code>undefined</code> if nothing is at the location.
+     */
+    pickAsync(windowPosition: Cartesian2, width?: number, height?: number): Promise<object | undefined>;
     /**
      * Returns a {@link VoxelCell} for the voxel sample rendered at a particular window coordinate,
      * or <code>undefined</code> if no voxel is rendered at that position.