@cesium/engine 13.1.0 → 15.0.0

package/index.d.ts

@@ -3553,11 +3553,11 @@ export class Color {
     static clone(color: Color, result?: Color): Color;
     /**
      * Returns true if the first Color equals the second color.
-     * @param left - The first Color to compare for equality.
-     * @param right - The second Color to compare for equality.
+     * @param [left] - The first Color to compare for equality.
+     * @param [right] - The second Color to compare for equality.
      * @returns <code>true</code> if the Colors are equal; otherwise, <code>false</code>.
      */
-    static equals(left: Color, right: Color): boolean;
+    static equals(left?: Color, right?: Color): boolean;
     /**
      * Returns a duplicate of a Color instance.
      * @param [result] - The object to store the result in, if undefined a new instance will be created.
@@ -3566,10 +3566,10 @@ export class Color {
     clone(result?: Color): Color;
     /**
      * Returns true if this Color equals other.
-     * @param other - The Color to compare for equality.
+     * @param [other] - The Color to compare for equality.
      * @returns <code>true</code> if the Colors are equal; otherwise, <code>false</code>.
      */
-    equals(other: Color): boolean;
+    equals(other?: Color): boolean;
     /**
      * Returns <code>true</code> if this Color equals other componentwise within the specified epsilon.
      * @param other - The Color to compare for equality.
@@ -4963,17 +4963,17 @@ export class Credit {
     readonly element: HTMLElement;
     /**
      * Returns true if the credits are equal
-     * @param left - The first credit
-     * @param right - The second credit
+     * @param [left] - The first credit
+     * @param [right] - The second credit
      * @returns <code>true</code> if left and right are equal, <code>false</code> otherwise.
      */
-    static equals(left: Credit, right: Credit): boolean;
+    static equals(left?: Credit, right?: Credit): boolean;
     /**
      * Returns true if the credits are equal
-     * @param credit - The credit to compare to.
+     * @param [credit] - The credit to compare to.
      * @returns <code>true</code> if left and right are equal, <code>false</code> otherwise.
      */
-    equals(credit: Credit): boolean;
+    equals(credit?: Credit): boolean;
     /**
      * Duplicates a Credit instance.
      * @param [credit] - The Credit to duplicate.
@@ -5349,11 +5349,11 @@ export class DistanceDisplayCondition {
     static unpack(array: number[], startingIndex?: number, result?: DistanceDisplayCondition): DistanceDisplayCondition;
     /**
      * Determines if two distance display conditions are equal.
-     * @param left - A distance display condition.
-     * @param right - Another distance display condition.
+     * @param [left] - A distance display condition.
+     * @param [right] - Another distance display condition.
      * @returns Whether the two distance display conditions are equal.
      */
-    static equals(left: DistanceDisplayCondition, right: DistanceDisplayCondition): boolean;
+    static equals(left?: DistanceDisplayCondition, right?: DistanceDisplayCondition): boolean;
     /**
      * Duplicates a distance display condition instance.
      * @param [value] - The distance display condition to duplicate.
@@ -5369,10 +5369,10 @@ export class DistanceDisplayCondition {
     clone(result?: DistanceDisplayCondition): DistanceDisplayCondition;
     /**
      * Determines if this distance display condition is equal to another.
-     * @param other - Another distance display condition.
+     * @param [other] - Another distance display condition.
      * @returns Whether this distance display condition is equal to the other.
      */
-    equals(other: DistanceDisplayCondition): boolean;
+    equals(other?: DistanceDisplayCondition): boolean;
 }
 
 /**
@@ -6212,7 +6212,7 @@ export class EllipsoidRhumbLine {
     interpolateUsingFraction(fraction: number, result?: Cartographic): Cartographic;
     /**
      * Provides the location of a point at the indicated distance along the rhumb line.
-     * @param distance - The distance from the inital point to the point of interest along the rhumbLine.
+     * @param distance - The distance from the initial point to the point of interest along the rhumbLine.
      * @param [result] - The object in which to store the result.
      * @returns The location of the point along the rhumb line.
      */
@@ -12024,11 +12024,11 @@ export class OrientedBoundingBox {
     /**
      * Compares the provided OrientedBoundingBox componentwise and returns
      * <code>true</code> if they are equal, <code>false</code> otherwise.
-     * @param left - The first OrientedBoundingBox.
-     * @param right - The second OrientedBoundingBox.
+     * @param [left] - The first OrientedBoundingBox.
+     * @param [right] - The second OrientedBoundingBox.
      * @returns <code>true</code> if left and right are equal, <code>false</code> otherwise.
      */
-    static equals(left: OrientedBoundingBox, right: OrientedBoundingBox): boolean;
+    static equals(left?: OrientedBoundingBox, right?: OrientedBoundingBox): boolean;
     /**
      * Duplicates this OrientedBoundingBox instance.
      * @param [result] - The object onto which to store the result.
@@ -16175,11 +16175,11 @@ export class Spherical {
     static normalize(spherical: Spherical, result?: Spherical): Spherical;
     /**
      * Returns true if the first spherical is equal to the second spherical, false otherwise.
-     * @param left - The first Spherical to be compared.
-     * @param right - The second Spherical to be compared.
+     * @param [left] - The first Spherical to be compared.
+     * @param [right] - The second Spherical to be compared.
      * @returns true if the first spherical is equal to the second spherical, false otherwise.
      */
-    static equals(left: Spherical, right: Spherical): boolean;
+    static equals(left?: Spherical, right?: Spherical): boolean;
     /**
      * Returns true if the first spherical is within the provided epsilon of the second spherical, false otherwise.
      * @param left - The first Spherical to be compared.
@@ -16190,10 +16190,10 @@ export class Spherical {
     static equalsEpsilon(left: Spherical, right: Spherical, epsilon?: number): boolean;
     /**
      * Returns true if this spherical is equal to the provided spherical, false otherwise.
-     * @param other - The Spherical to be compared.
+     * @param [other] - The Spherical to be compared.
      * @returns true if this spherical is equal to the provided spherical, false otherwise.
      */
-    equals(other: Spherical): boolean;
+    equals(other?: Spherical): boolean;
     /**
      * Creates a duplicate of this Spherical.
      * @param [result] - The object to store the result into, if undefined a new instance will be created.
@@ -18761,7 +18761,6 @@ export function subdivideArray(array: any[], numberOfArrays: number): void;
  * @param text - The text to write.
  * @param [options] - Object with the following properties:
  * @param [options.font = '10px sans-serif'] - The CSS font to use.
- * @param [options.textBaseline = 'bottom'] - The baseline of the text.
  * @param [options.fill = true] - Whether to fill the text.
  * @param [options.stroke = false] - Whether to stroke the text.
  * @param [options.fillColor = Color.WHITE] - The fill color.
@@ -18775,7 +18774,6 @@ export function subdivideArray(array: any[], numberOfArrays: number): void;
  */
 export function writeTextToCanvas(text: string, options?: {
     font?: string;
-    textBaseline?: string;
     fill?: boolean;
     stroke?: boolean;
     fillColor?: Color;
@@ -19041,6 +19039,21 @@ export class BillboardVisualizer {
     destroy(): void;
 }
 
+/**
+ * The BoundingSphere has been computed.
+ */
+export const DONE = 0;
+
+/**
+ * The BoundingSphere is still being computed.
+ */
+export const PENDING = 1;
+
+/**
+ * The BoundingSphere does not exist.
+ */
+export const FAILED = 2;
+
 /**
  * A {@link GeometryUpdater} for boxes.
  * Clients do not normally create this class directly, but instead rely on {@link DataSourceDisplay}.
@@ -20438,10 +20451,10 @@ export class DataSourceClock {
     clone(result?: DataSourceClock): DataSourceClock;
     /**
      * Returns true if this DataSourceClock is equivalent to the other
-     * @param other - The other DataSourceClock to compare to.
+     * @param [other] - The other DataSourceClock to compare to.
      * @returns <code>true</code> if the DataSourceClocks are equal; otherwise, <code>false</code>.
      */
-    equals(other: DataSourceClock): boolean;
+    equals(other?: DataSourceClock): boolean;
     /**
      * Assigns each unassigned property on this object to the value
      * of the same property on the provided source object.
@@ -26370,11 +26383,11 @@ export class Billboard {
     /**
      * Gets or sets a width for the billboard. If undefined, the image width will be used.
      */
-    width: number;
+    width: number | undefined;
     /**
      * Gets or sets a height for the billboard. If undefined, the image height will be used.
      */
-    height: number;
+    height: number | undefined;
     /**
      * 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.
@@ -26475,10 +26488,10 @@ export class Billboard {
     /**
      * Determines if this billboard equals another billboard.  Billboards are equal if all their properties
      * are equal.  Billboards in different collections can be equal.
-     * @param other - The billboard to compare for equality.
+     * @param [other] - The billboard to compare for equality.
      * @returns <code>true</code> if the billboards are equal; otherwise, <code>false</code>.
      */
-    equals(other: Billboard): boolean;
+    equals(other?: Billboard): boolean;
 }
 
 /**
@@ -26577,7 +26590,7 @@ export class BillboardCollection {
      * {@link BillboardCollection#get} to iterate over all the billboards
      * in the collection.
      */
-    length: number;
+    readonly length: number;
     /**
      * Creates and adds a billboard with the specified initial properties to the collection.
      * The added billboard is returned so it can be modified or removed from the collection later.
@@ -27568,12 +27581,12 @@ export class Camera {
     getPixelSize(boundingSphere: BoundingSphere, drawingBufferWidth: number, drawingBufferHeight: number): number;
     /**
      * Cancels the current camera flight and leaves the camera at its current location.
-     * If no flight is in progress, this this function does nothing.
+     * If no flight is in progress, this function does nothing.
      */
     cancelFlight(): void;
     /**
      * Completes the current camera flight and moves the camera immediately to its final destination.
-     * If no flight is in progress, this this function does nothing.
+     * If no flight is in progress, this function does nothing.
      */
     completeFlight(): void;
     /**
@@ -29100,6 +29113,44 @@ export class Cesium3DTileStyle {
     meta: StyleExpression;
 }
 
+export namespace Cesium3DTilesVoxelProvider {
+    /**
+     * Initialization options for the Cesium3DTilesVoxelProvider constructor
+     * @property className - The class in the tileset schema describing voxel metadata.
+     * @property names - The metadata names.
+     * @property types - The metadata types.
+     * @property componentTypes - The metadata component types.
+     * @property shape - The {@link VoxelShapeType}.
+     * @property dimensions - The number of voxels per dimension of a tile. This is the same for all tiles in the dataset.
+     * @property [paddingBefore = Cartesian3.ZERO] - The number of padding voxels before the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
+     * @property [paddingAfter = Cartesian3.ZERO] - The number of padding voxels after the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
+     * @property [globalTransform = Matrix4.IDENTITY] - A transform from local space to global space.
+     * @property [shapeTransform = Matrix4.IDENTITY] - A transform from shape space to local space.
+     * @property [minBounds] - The minimum bounds.
+     * @property [maxBounds] - The maximum bounds.
+     * @property [minimumValues] - The metadata minimum values.
+     * @property [maximumValues] - The metadata maximum values.
+     * @property [maximumTileCount] - The maximum number of tiles that exist for this provider. This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory. If this value is not known it can be undefined.
+     */
+    type ConstructorOptions = {
+        className: string;
+        names: string[];
+        types: MetadataType[];
+        componentTypes: MetadataComponentType[];
+        shape: VoxelShapeType;
+        dimensions: Cartesian3;
+        paddingBefore?: Cartesian3;
+        paddingAfter?: Cartesian3;
+        globalTransform?: Matrix4;
+        shapeTransform?: Matrix4;
+        minBounds?: Cartesian3;
+        maxBounds?: Cartesian3;
+        minimumValues?: number[][];
+        maximumValues?: number[][];
+        maximumTileCount?: number;
+    };
+}
+
 /**
  * A {@link VoxelProvider} that fetches voxel data from a 3D Tiles tileset.
  * <p>
@@ -29108,102 +29159,116 @@ export class Cesium3DTileStyle {
  * <div class="notice">
  * This object is normally not instantiated directly, use {@link Cesium3DTilesVoxelProvider.fromUrl}.
  * </div>
- * @param options - Object with the following properties:
+ * @param options - An object describing initialization options
  */
 export class Cesium3DTilesVoxelProvider extends VoxelProvider {
-    constructor(options: any);
+    constructor(options: Cesium3DTilesVoxelProvider.ConstructorOptions);
     /**
-     * Creates a {@link VoxelProvider} that fetches voxel data from a 3D Tiles tileset.
-     * @param url - The URL to a tileset JSON file
-     * @returns The created provider
+     * A transform from local space to global space.
      */
-    static fromUrl(url: Resource | string): Promise<Cesium3DTilesVoxelProvider>;
-    /**
-     * A transform from local space to global space. If undefined, the identity matrix will be used instead.
-     */
-    readonly globalTransform: Matrix4 | undefined;
+    readonly globalTransform: Matrix4;
     /**
-     * A transform from shape space to local space. If undefined, the identity matrix will be used instead.
+     * A transform from shape space to local space.
      */
-    readonly shapeTransform: Matrix4 | undefined;
+    readonly shapeTransform: Matrix4;
     /**
      * Gets the {@link VoxelShapeType}
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly shape: VoxelShapeType;
     /**
      * Gets the minimum bounds.
      * If undefined, the shape's default minimum bounds will be used instead.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly minBounds: Cartesian3 | undefined;
     /**
      * Gets the maximum bounds.
      * If undefined, the shape's default maximum bounds will be used instead.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maxBounds: Cartesian3 | undefined;
     /**
      * Gets the number of voxels per dimension of a tile. This is the same for all tiles in the dataset.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly dimensions: Cartesian3;
     /**
      * Gets the number of padding voxels before the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
-    readonly paddingBefore: Cartesian3 | undefined;
+    readonly paddingBefore: Cartesian3;
     /**
      * Gets the number of padding voxels after the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
-    readonly paddingAfter: Cartesian3 | undefined;
+    readonly paddingAfter: Cartesian3;
+    /**
+     * The metadata class for this tileset.
+     */
+    readonly className: string;
     /**
      * Gets the metadata names.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly names: string[];
     /**
      * Gets the metadata types.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly types: MetadataType[];
     /**
      * Gets the metadata component types.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly componentTypes: MetadataComponentType[];
+    /**
+     * Gets the ordering of the metadata in the buffers.
+     */
+    readonly metadataOrder: VoxelMetadataOrder;
     /**
      * Gets the metadata minimum values.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly minimumValues: number[][] | undefined;
     /**
      * Gets the metadata maximum values.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maximumValues: number[][] | undefined;
     /**
-     * The maximum number of tiles that exist for this provider. This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory. If this value is not known it can be undefined.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
+     * The maximum number of tiles that exist for this provider.
+     * This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory.
+     * If this value is not known it can be undefined.
      */
     readonly maximumTileCount: number | undefined;
     /**
-     * Requests the data for a given tile. The data is a flattened 3D array ordered by X, then Y, then Z.
-     * This function should not be called before {@link VoxelProvider#ready} returns true.
+     * The number of levels of detail containing available tiles in the tileset.
+     */
+    readonly availableLevels: number | undefined;
+    /**
+     * Creates a {@link Cesium3DTilesVoxelProvider} that fetches voxel data from a 3D Tiles tileset.
+     * @example
+     * try {
+     *   const voxelProvider = await Cesium3DTilesVoxelProvider.fromUrl(
+     *     "http://localhost:8002/tilesets/voxel/tileset.json"
+     *   );
+     *   const voxelPrimitive = new VoxelPrimitive({
+     *     provider: voxelProvider,
+     *     customShader: customShader,
+     *   });
+     *   scene.primitives.add(voxelPrimitive);
+     * } catch (error) {
+     *   console.error(`Error creating voxel primitive: ${error}`);
+     * }
+     * @param url - The URL to a tileset JSON file
+     * @returns The created provider
+     */
+    static fromUrl(url: Resource | string): Promise<Cesium3DTilesVoxelProvider>;
+    /**
+     * Requests the data for a given tile.
      * @param [options] - Object with the following properties:
      * @param [options.tileLevel = 0] - The tile's level.
      * @param [options.tileX = 0] - The tile's X coordinate.
      * @param [options.tileY = 0] - The tile's Y coordinate.
      * @param [options.tileZ = 0] - The tile's Z coordinate.
-     * @returns A promise to an array of typed arrays containing the requested voxel data or undefined if there was a problem loading the data.
+     * @returns A promise resolving to a VoxelContent containing the data for the tile, or undefined if the request could not be scheduled this frame.
      */
     requestData(options?: {
         tileLevel?: number;
         tileX?: number;
         tileY?: number;
         tileZ?: number;
-    }): Promise<any[][]> | undefined;
+    }): Promise<VoxelContent> | undefined;
 }
 
 export namespace Cesium3DTileset {
@@ -30646,7 +30711,7 @@ export class ClippingPolygon {
      * @param right - The second polygon.
      * @returns <code>true</code> if left and right are equal, <code>false</code> otherwise.
      */
-    static equals(left: Plane, right: Plane): boolean;
+    static equals(left: ClippingPolygon, right: ClippingPolygon): boolean;
     /**
      * Computes a cartographic rectangle which encloses the polygon defined by the list of positions, including cases over the international date line and the poles.
      * @param [result] - An object in which to store the result.
@@ -34033,6 +34098,13 @@ export namespace ITwinData {
      * @param [rootDocument] - The path of the root document for this reality data
      */
     function createDataSourceForRealityDataId(iTwinId: string, realityDataId: string, type?: ITwinPlatform.RealityDataType, rootDocument?: string): Promise<GeoJsonDataSource | KmlDataSource>;
+    /**
+     * Load data from the Geospatial Features API as GeoJSON.
+     * @param iTwinId - The id of the iTwin to load data from
+     * @param collectionId - The id of the data collection to load
+     * @param [limit = 10000] - number of items per page, must be between 1 and 10,000 inclusive
+     */
+    function loadGeospatialFeatures(iTwinId: string, collectionId: string, limit?: number): Promise<GeoJsonDataSource>;
 }
 
 /**
@@ -34386,10 +34458,10 @@ export class ImageryLayer {
      *   alert(`Encountered an error while creating an imagery layer! ${error}`);
      * });
      * @param imageryProviderPromise - A promise which resolves to a imagery provider
-     * @param options - An object describing initialization options
+     * @param [options] - An object describing initialization options
      * @returns The created imagery layer.
      */
-    static fromProviderAsync(imageryProviderPromise: Promise<ImageryProvider>, options: ImageryLayer.ConstructorOptions): ImageryLayer;
+    static fromProviderAsync(imageryProviderPromise: Promise<ImageryProvider>, options?: ImageryLayer.ConstructorOptions): ImageryLayer;
     /**
      * Create a new imagery layer for ion's default global base imagery layer, currently Bing Maps. The layer will handle any asynchronous loads or errors, and begin rendering the imagery layer once ready.
      * @example
@@ -35217,10 +35289,10 @@ export class Label {
     /**
      * Determines if this label equals another label.  Labels are equal if all their properties
      * are equal.  Labels in different collections can be equal.
-     * @param other - The label to compare for equality.
+     * @param [other] - The label to compare for equality.
      * @returns <code>true</code> if the labels are equal; otherwise, <code>false</code>.
      */
-    equals(other: Label): boolean;
+    equals(other?: Label): boolean;
     /**
      * Returns true if this object was destroyed; otherwise, false.
      * <br /><br />
@@ -35344,7 +35416,7 @@ export class LabelCollection {
      * {@link LabelCollection#get} to iterate over all the labels
      * in the collection.
      */
-    length: number;
+    readonly 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.
@@ -36911,6 +36983,25 @@ export class CustomShader {
      * @param value - The new value of the uniform.
      */
     setUniform(uniformName: string, value: boolean | number | Cartesian2 | Cartesian3 | Cartesian4 | Matrix2 | Matrix3 | Matrix4 | string | Resource | TextureUniform): 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.
+     * @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.
+     * @example
+     * customShader = customShader && customShader.destroy();
+     */
+    destroy(): void;
 }
 
 /**
@@ -39282,10 +39373,10 @@ export class PointPrimitive {
     /**
      * Determines if this point equals another point.  Points are equal if all their properties
      * are equal.  Points in different collections can be equal.
-     * @param other - The point to compare for equality.
+     * @param [other] - The point to compare for equality.
      * @returns <code>true</code> if the points are equal; otherwise, <code>false</code>.
      */
-    equals(other: PointPrimitive): boolean;
+    equals(other?: PointPrimitive): boolean;
 }
 
 /**
@@ -43498,6 +43589,40 @@ export class VoxelCell {
     getProperty(name: string): any;
 }
 
+/**
+ * <div class="notice">
+ * To construct a VoxelContent, call {@link VoxelContent.fromMetadataArray} or {@link VoxelContent.fromGltf}. Do not call the constructor directly.
+ * </div>
+ * An object representing voxel content for a {@link Cesium3DTilesVoxelProvider}.
+ */
+export class VoxelContent {
+    constructor();
+    /**
+     * Constructs a VoxelContent from an array of metadata.
+     * @param metadata - The metadata to use for this voxel content.
+     * @returns A VoxelContent containing the specified metadata.
+     */
+    static fromMetadataArray(metadata: Int8Array[] | Uint8Array[] | Int16Array[] | Uint16Array[] | Int32Array[] | Uint32Array[] | Float32Array[] | Float64Array[]): VoxelContent;
+}
+
+/**
+ * The metadata for this voxel content.
+ * The metadata is an array of typed arrays, one for each field.
+ * The data for one field is a flattened 3D array ordered by X, then Y, then Z.
+ */
+export const metadata: Int8Array[] | Uint8Array[] | Int16Array[] | Uint16Array[] | Int32Array[] | Uint32Array[] | Float32Array[] | Float64Array[];
+
+/**
+ * Metadata ordering for voxel content.
+ * In all cases, x data is contiguous in strides along the y axis,
+ * and each group of y strides represents a z slice.
+ * However, the orientation of the axes follows different conventions.
+ */
+export enum VoxelMetadataOrder {
+    XYZ = 0,
+    GLTF = 1
+}
+
 /**
  * A primitive that renders voxel data from a {@link VoxelProvider}.
  * @param [options] - Object with the following properties:
@@ -43505,6 +43630,7 @@ export class VoxelCell {
  * @param [options.modelMatrix = Matrix4.IDENTITY] - The model matrix used to transform the primitive.
  * @param [options.customShader] - The custom shader used to style the primitive.
  * @param [options.clock] - The clock used to control time dynamic behavior.
+ * @param [options.calculateStatistics] - Generate statistics for performance profile.
  */
 export class VoxelPrimitive {
     constructor(options?: {
@@ -43512,7 +43638,93 @@ export class VoxelPrimitive {
         modelMatrix?: Matrix4;
         customShader?: CustomShader;
         clock?: Clock;
+        calculateStatistics?: boolean;
     });
+    /**
+     * The event fired to indicate that a tile's content was loaded.
+     * <p>
+     * This event is fired during the tileset traversal while the frame is being rendered
+     * so that updates to the tile take effect in the same frame.  Do not create or modify
+     * Cesium entities or primitives during the event listener.
+     * </p>
+     * @example
+     * voxelPrimitive.tileLoad.addEventListener(function() {
+     *     console.log('A tile was loaded.');
+     * });
+     */
+    tileLoad: Event;
+    /**
+     * This event fires once for each visible tile in a frame.
+     * <p>
+     * This event is fired during the traversal while the frame is being rendered.
+     * @example
+     * voxelPrimitive.tileVisible.addEventListener(function() {
+     *     console.log('A tile is visible.');
+     * });
+     */
+    tileVisible: Event;
+    /**
+     * The event fired to indicate that a tile's content failed to load.
+     * @example
+     * voxelPrimitive.tileFailed.addEventListener(function() {
+     *     console.log('An error occurred loading tile.');
+     * });
+     */
+    tileFailed: Event;
+    /**
+     * The event fired to indicate that a tile's content was unloaded.
+     * @example
+     * voxelPrimitive.tileUnload.addEventListener(function() {
+     *     console.log('A tile was unloaded from the cache.');
+     * });
+     */
+    tileUnload: Event;
+    /**
+     * The event fired to indicate progress of loading new tiles. This event is fired when a new tile
+     * is requested, when a requested tile is finished downloading, and when a downloaded tile has been
+     * processed and is ready to render.
+     * <p>
+     * The number of pending tile requests, <code>numberOfPendingRequests</code>, and number of tiles
+     * processing, <code>numberOfTilesProcessing</code> are passed to the event listener.
+     * </p>
+     * <p>
+     * This event is fired at the end of the frame after the scene is rendered.
+     * </p>
+     * @example
+     * voxelPrimitive.loadProgress.addEventListener(function(numberOfPendingRequests, numberOfTilesProcessing) {
+     *     if ((numberOfPendingRequests === 0) && (numberOfTilesProcessing === 0)) {
+     *         console.log('Finished loading');
+     *         return;
+     *     }
+     *
+     *     console.log(`Loading: requests: ${numberOfPendingRequests}, processing: ${numberOfTilesProcessing}`);
+     * });
+     */
+    loadProgress: Event;
+    /**
+     * The event fired to indicate that all tiles that meet the screen space error this frame are loaded. The voxel
+     * primitive is completely loaded for this view.
+     * <p>
+     * This event is fired at the end of the frame after the scene is rendered.
+     * </p>
+     * @example
+     * voxelPrimitive.allTilesLoaded.addEventListener(function() {
+     *     console.log('All tiles are loaded');
+     * });
+     */
+    allTilesLoaded: Event;
+    /**
+     * The event fired to indicate that all tiles that meet the screen space error this frame are loaded. This event
+     * is fired once when all tiles in the initial view are loaded.
+     * <p>
+     * This event is fired at the end of the frame after the scene is rendered.
+     * </p>
+     * @example
+     * voxelPrimitive.initialTilesLoaded.addEventListener(function() {
+     *     console.log('Initial tiles are loaded');
+     * });
+     */
+    initialTilesLoaded: Event;
     /**
      * Gets a value indicating whether or not the primitive is ready for use.
      */
@@ -43538,9 +43750,23 @@ export class VoxelPrimitive {
      */
     readonly shape: VoxelShapeType;
     /**
-     * Gets the voxel dimensions.
+     * Gets the dimensions of each voxel tile, in z-up orientation.
+     * Does not include padding.
      */
     readonly dimensions: Cartesian3;
+    /**
+     * Gets the dimensions of one tile of the input voxel data, in the input orientation.
+     * Includes padding.
+     */
+    readonly inputDimensions: Cartesian3;
+    /**
+     * Gets the padding before the voxel data.
+     */
+    readonly paddingBefore: Cartesian3;
+    /**
+     * Gets the padding after the voxel data.
+     */
+    readonly paddingAfter: Cartesian3;
     /**
      * Gets the minimum value per channel of the voxel data.
      */
@@ -43642,105 +43868,90 @@ export class VoxelPrimitive {
 export class VoxelProvider {
     constructor();
     /**
-     * A transform from local space to global space. If undefined, the identity matrix will be used instead.
+     * A transform from local space to global space.
      */
-    readonly globalTransform: Matrix4 | undefined;
+    readonly globalTransform: Matrix4;
     /**
-     * A transform from shape space to local space. If undefined, the identity matrix will be used instead.
+     * A transform from shape space to local space.
      */
-    readonly shapeTransform: Matrix4 | undefined;
+    readonly shapeTransform: Matrix4;
     /**
      * Gets the {@link VoxelShapeType}
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly shape: VoxelShapeType;
     /**
      * Gets the minimum bounds.
      * If undefined, the shape's default minimum bounds will be used instead.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly minBounds: Cartesian3 | undefined;
     /**
      * Gets the maximum bounds.
      * If undefined, the shape's default maximum bounds will be used instead.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maxBounds: Cartesian3 | undefined;
     /**
      * Gets the number of voxels per dimension of a tile. This is the same for all tiles in the dataset.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly dimensions: Cartesian3;
     /**
      * Gets the number of padding voxels before the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
-    readonly paddingBefore: Cartesian3 | undefined;
+    readonly paddingBefore: Cartesian3;
     /**
      * Gets the number of padding voxels after the tile. This improves rendering quality when sampling the edge of a tile, but it increases memory usage.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
-    readonly paddingAfter: Cartesian3 | undefined;
+    readonly paddingAfter: Cartesian3;
     /**
      * Gets the metadata names.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly names: string[];
     /**
      * Gets the metadata types.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly types: MetadataType[];
     /**
      * Gets the metadata component types.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly componentTypes: MetadataComponentType[];
+    /**
+     * Gets the ordering of the metadata in the buffers.
+     */
+    readonly metadataOrder: VoxelMetadataOrder;
     /**
      * Gets the metadata minimum values.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly minimumValues: number[][] | undefined;
     /**
      * Gets the metadata maximum values.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
      */
     readonly maximumValues: number[][] | undefined;
     /**
-     * The maximum number of tiles that exist for this provider. This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory. If this value is not known it can be undefined.
-     * This should not be called before {@link VoxelProvider#ready} returns true.
+     * The maximum number of tiles that exist for this provider.
+     * This value is used as a hint to the voxel renderer to allocate an appropriate amount of GPU memory.
+     * If this value is not known it can be undefined.
      */
     readonly maximumTileCount: number | undefined;
     /**
-     * Requests the data for a given tile. The data is a flattened 3D array ordered by X, then Y, then Z.
-     * This function should not be called before {@link VoxelProvider#ready} returns true.
+     * Requests the data for a given tile.
      * @param [options] - Object with the following properties:
      * @param [options.tileLevel = 0] - The tile's level.
      * @param [options.tileX = 0] - The tile's X coordinate.
      * @param [options.tileY = 0] - The tile's Y coordinate.
      * @param [options.tileZ = 0] - The tile's Z coordinate.
-     * @returns A promise to an array of typed arrays containing the requested voxel data or undefined if there was a problem loading the data.
+     * @returns A promise resolving to a VoxelContent containing the data for the tile, or undefined if the request could not be scheduled this frame.
      */
     requestData(options?: {
         tileLevel?: number;
         tileX?: number;
         tileY?: number;
         tileZ?: number;
-    }): Promise<any[][]> | undefined;
+    }): Promise<VoxelContent> | undefined;
 }
 
-export const shaderUniforms: {
-    [key: string]: any;
-};
-
-export const shaderDefines: {
-    [key: string]: any;
-};
-
 /**
- * The maximum number of intersections against the shape for any ray direction.
+ * The number of levels of detail containing available tiles in the tileset.
  */
-export const shaderMaximumIntersectionsLength: number;
+export const availableLevels: number | undefined;
 
 /**
  * An enum of voxel shapes. The shape controls how the voxel grid is mapped to 3D space.
@@ -44029,7 +44240,7 @@ export namespace WebMapTileServiceImageryProvider {
  * @example
  * // Example 1. USGS shaded relief tiles (KVP)
  * const shadedRelief1 = new Cesium.WebMapTileServiceImageryProvider({
- *     url : 'http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS',
+ *     url : 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS',
  *     layer : 'USGSShadedReliefOnly',
  *     style : 'default',
  *     format : 'image/jpeg',
@@ -44042,7 +44253,7 @@ export namespace WebMapTileServiceImageryProvider {
  * @example
  * // Example 2. USGS shaded relief tiles (RESTful)
  * const shadedRelief2 = new Cesium.WebMapTileServiceImageryProvider({
- *     url : 'http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS/tile/1.0.0/USGSShadedReliefOnly/{Style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.jpg',
+ *     url : 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS/tile/1.0.0/USGSShadedReliefOnly/{Style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.jpg',
  *     layer : 'USGSShadedReliefOnly',
  *     style : 'default',
  *     format : 'image/jpeg',