mars3d-cesium 1.138.0 → 1.139.0

package/Build/Cesium/Cesium.d.ts

@@ -1151,7 +1151,7 @@ export class BoundingSphere {
      * @param [result] - The object onto which to store the result.
      * @returns The modified result parameter or a new BoundingSphere instance if one was not provided.
      */
-    static fromVertices(positions?: number[], center?: Cartesian3, stride?: number, result?: BoundingSphere): BoundingSphere;
+    static fromVertices(positions?: number[] | TypedArray, center?: Cartesian3, stride?: number, result?: BoundingSphere): BoundingSphere;
     /**
      * Computes a tight-fitting bounding sphere enclosing a list of EncodedCartesian3s, where the points are
     stored in parallel flat arrays in X, Y, Z, order.  The bounding sphere is computed by running two
@@ -8310,7 +8310,11 @@ export class GoogleGeocoderService {
  * Default settings for accessing the Google Maps API.
 <br/>
 An API key is only required if you are directly using any Google Maps APIs, such as through {@link createGooglePhotorealistic3DTileset}.
-Follow instructions for managing API keys for the Google Maps Platform at {@link https://developers.google.com/maps/documentation/embed/get-api-key}
+Follow instructions for managing API keys for the Google Maps Platform at {@link https://developers.google.com/maps/documentation/embed/get-api-key}.
+<br/>
+You can enable multiple Google Maps Platform APIs on a single API key.
+However, a separate {@link GoogleMaps.defaultStreetViewStaticApiKey}
+is available if you prefer to use a dedicated key for the Street View Static API.
  */
 export namespace GoogleMaps {
     /**
@@ -8321,6 +8325,14 @@ export namespace GoogleMaps {
      * Gets or sets the default Google Map Tiles API endpoint.
      */
     var mapTilesApiEndpoint: string | Resource;
+    /**
+     * Gets or sets the default Google Maps Street View Static API key.
+     */
+    var defaultStreetViewStaticApiKey: undefined | string;
+    /**
+     * Gets or sets the default Google Street View Static API endpoint.
+     */
+    var streetViewStaticApiEndpoint: string | Resource;
 }
 
 /**
@@ -27576,6 +27588,565 @@ export class BoxEmitter {
     dimensions: Cartesian3;
 }
 
+/**
+ * View bound to the underlying buffer data of a {@link BufferPointCollection}.
+
+<p>BufferPoint instances are {@link https://en.wikipedia.org/wiki/Flyweight_pattern|flyweights}:
+a single BufferPoint instance can be temporarily bound to any conceptual
+"point" in a BufferPointCollection, allowing very large collections to be
+iterated and updated with a minimal memory footprint.</p>
+
+Represented as one (1) position.
+ */
+export class BufferPoint extends BufferPrimitive {
+    /**
+     * Copies data from source point to result.
+     */
+    static clone(point: BufferPoint, result: BufferPoint): BufferPoint;
+    /**
+     * Count of positions (vertices) in this primitive. Always 1.
+     */
+    readonly vertexCount: number;
+    /**
+     * Gets the position of this point.
+     */
+    getPosition(result?: Cartesian3): Cartesian3;
+    /**
+     * Sets the position of this point.
+     */
+    setPosition(position: Cartesian3): void;
+    /**
+     * Returns a JSON-serializable object representing the point. This encoding
+    is not memory-efficient, and should generally be used for debugging and
+    testing.
+     * @returns JSON-serializable object.
+     */
+    toJSON(): any;
+}
+
+export type BufferPointOptions = {
+    show?: boolean;
+    color?: Color;
+    position?: Cartesian3;
+};
+
+/**
+ * Collection of points held in ArrayBuffer storage for performance and memory optimization.
+
+<p>Default buffer memory allocation is arbitrary, and collections cannot be resized,
+so specific per-buffer capacities should be provided in the collection
+constructor when available.</p>
+ * @example
+ * const collection = new BufferPointCollection({primitiveCountMax: 1024});
+
+const point = new BufferPoint();
+
+// Create a new point, temporarily bound to 'point' local variable.
+collection.add({
+  position: new Cartesian3(0.0, 0.0, 0.0),
+  color: Color.WHITE,
+}, point);
+
+// Iterate over all points in collection, temporarily binding 'point'
+// local variable to each, and updating point color.
+for (let i = 0; i < collection.primitiveCount; i++) {
+  collection.get(i, point);
+  point.setColor(Color.RED);
+}
+ */
+export class BufferPointCollection extends BufferPrimitiveCollection<BufferPoint> {
+    constructor(options: {
+        primitiveCountMax?: number;
+        show?: boolean;
+        debugShowBoundingVolume?: boolean;
+    });
+    /**
+     * Adds a new point to the collection, with the specified options. A
+    {@link BufferPoint} instance is linked to the new point, using
+    the 'result' argument if given, or a new instance if not. For repeated
+    calls, prefer to reuse a single BufferPoint instance rather than
+    allocating a new instance on each call.
+     */
+    add(options: BufferPointOptions, result: BufferPoint): BufferPoint;
+}
+
+/**
+ * View bound to the underlying buffer data of a {@link BufferPolygonCollection}.
+
+<p>BufferPolygon instances are {@link https://en.wikipedia.org/wiki/Flyweight_pattern|flyweights}:
+a single BufferPolygon instance can be temporarily bound to any conceptual
+"polygon" in a BufferPolygonCollection, allowing very large collections to be
+iterated and updated with a minimal memory footprint.</p>
+
+<p>Represented as one (1) external linear ring of three (3) or more positions.
+May optionally define one or more internal linear rings ("holes") within the
+polygon. Each hole is represented as a single index into the positions array,
+where the vertex at that index is the start of an internal linear ring that
+continues along the following vertices until reaching either the vertex
+index of the next hole, or the end of the vertex list. Stores a precomputed
+triangulation, represented as three vertex indices per triangle.</p>
+ */
+export class BufferPolygon extends BufferPrimitive {
+    /**
+     * Copies data from source polygon to result. If the result polygon is not
+    new (the last polygon in the collection) then source and result polygons
+    must have the same vertex counts, hole counts, and triangle counts.
+     */
+    static clone(polygon: BufferPolygon, result: BufferPolygon): BufferPolygon;
+    /**
+     * Count of positions (vertices) in this polygon, including both outer ring and
+    internal rings (holes), number of VEC3 elements.
+     */
+    readonly vertexCount: number;
+    /**
+     * Returns an array view of this polygon's vertex positions. If 'result'
+    argument is given, vertex positions are written to that array and returned.
+    Otherwise, returns an ArrayView on collection memory — changes to this array
+    will not trigger render updates, which requires `.setPositions()`.
+     * @param [result] - return {Float64Array}
+     */
+    getPositions(result?: Float64Array): void;
+    setPositions(positions: Float64Array): void;
+    /**
+     * Offset in collection position array to first vertex in polygon's outer
+    linear ring, number of VEC3 elements.
+     */
+    readonly outerVertexOffset: number;
+    /**
+     * Count of positions (vertices) in this polygon's outer linear ring, number
+    of VEC3 elements.
+     */
+    readonly outerVertexCount: number;
+    /**
+     * Returns an array view of this polygon's outer linear ring vertex positions.
+    If 'result' argument is given, vertex positions are written to that array
+    and returned. Otherwise, returns an ArrayView on collection memory —
+    changes to this array will not trigger render updates, which requires
+    `.setPositions()`.
+     */
+    getOuterPositions(result?: Float64Array): Float64Array;
+    /**
+     * Count of holes (indices) in this polygon.
+     */
+    readonly holeCount: number;
+    /**
+     * Gets this polygon's hole indices, with each hole represented as a single
+    offset into this polygon's positions array. Each hole implicitly
+    continues along an internal linear ring from that vertex offset until
+    reaching either the end of the positions array, or the next hole offset.
+    
+    If 'result' argument is given, hole indices are written to that array and
+    returned. Otherwise, returns an ArrayView on collection memory — changes
+    to this array will not trigger render updates, which requires `.setHoles()`.
+     */
+    getHoles(result?: Uint32Array): Uint32Array;
+    /**
+     * Sets this polygon's hole indices, with holes represented as a single
+    offset into this polygon's positions array. Each hole implicitly
+    continues along an internal linear ring from that vertex offset until
+    reaching either the end of the positions array, or the next hole offset.
+     */
+    setHoles(holes: Uint32Array): void;
+    /**
+     * Returns the number of (VEC3) vertices in the specified hole.
+     */
+    getHoleVertexCount(holeIndex: number): number;
+    /**
+     * Returns an array view of the inner linear ring vertex positions for the
+    specified hole. If 'result' argument is given, vertex positions are written
+    to that array and returned. Otherwise, returns an ArrayView on collection
+    memory — changes to this array will not trigger render updates, which
+    requires `.setPositions()`.
+     * @param [result] - return {Float64Array}
+     */
+    getHolePositions(holeIndex: number, result?: Float64Array): void;
+    /**
+     * Count of triangles in this polygon, number of VEC3 elements.
+     */
+    readonly triangleCount: number;
+    /**
+     * Returns an array view of this polygon's triangle indices, represented as
+    three vertex indices per triangle.
+    
+    If 'result' argument is given, triangle indices are written to that array
+    and returned. Otherwise, returns an ArrayView on collection memory —
+    changes to this array will not trigger render updates, which requires
+    `.setTriangles()`.
+     */
+    getTriangles(result?: Uint32Array): Uint32Array;
+    /**
+     * Sets this polygon's triangle indices, represented as three vertex indices
+    per triangle.
+     */
+    setTriangles(indices: Uint32Array): void;
+    /**
+     * Returns a JSON-serializable object representing the polygon. This encoding
+    is not memory-efficient, and should generally be used for debugging and
+    testing.
+     * @returns JSON-serializable object.
+     */
+    toJSON(): any;
+}
+
+export type BufferPolygonOptions = {
+    show?: boolean;
+    color?: Color;
+    positions?: Float64Array;
+    holes?: Uint32Array;
+    triangles?: Uint32Array;
+};
+
+/**
+ * Collection of polygons held in ArrayBuffer storage for performance and memory optimization.
+
+<p>Default buffer memory allocation is arbitrary, and collections cannot be resized,
+so specific per-buffer capacities should be provided in the collection
+constructor when available.</p>
+ * @example
+ * import earcut from "earcut";
+
+const collection = new BufferPolygonCollection({
+  primitiveCountMax: 1024,
+  vertexCountMax: 4096,
+  holeCountMax: 1024,
+  triangleCountMax: 2048,
+});
+
+const polygon = new BufferPolygon();
+const positions = [ ... ];
+const holes = [ ... ];
+
+// Create a new polygon, temporarily bound to 'polygon' local variable.
+collection.add({
+  positions: new Float64Array(positions),
+  holes: new Uint32Array(holes),
+  triangles: new Uint32Array(earcut(positions, holes, 3)),
+  color: Color.WHITE,
+}, polygon);
+
+// Iterate over all polygons in collection, temporarily binding 'polygon'
+// local variable to each, and updating polygon color.
+for (let i = 0; i < collection.primitiveCount; i++) {
+  collection.get(i, polygon);
+  polygon.setColor(Color.RED);
+}
+ */
+export class BufferPolygonCollection extends BufferPrimitiveCollection<BufferPolygon> {
+    constructor(options: {
+        primitiveCountMax?: number;
+        vertexCountMax?: number;
+        holeCountMax?: number;
+        triangleCountMax?: number;
+        show?: boolean;
+        debugShowBoundingVolume?: boolean;
+    });
+    /**
+     * Duplicates the contents of this collection into the result collection.
+    Result collection is not resized, and must contain enough space for all
+    primitives in the source collection. Existing polygons in the result
+    collection will be overwritten.
+    
+    <p>Useful when allocating more space for a collection that has reached its
+    capacity, and efficiently transferring polygons to the new collection.</p>
+     * @example
+     * const result = new BufferPolygonCollection({ ... }); // allocate larger 'result' collection
+    BufferPolygonCollection.clone(collection, result);   // copy polygons from 'collection' into 'result'
+     */
+    static clone(collection: BufferPolygonCollection, result: BufferPolygonCollection): BufferPolygonCollection;
+    /**
+     * Adds a new polygon to the collection, with the specified options. A
+    {@link BufferPolygon} instance is linked to the new polygon, using
+    the 'result' argument if given, or a new instance if not. For repeated
+    calls, prefer to reuse a single BufferPolygon instance rather than
+    allocating a new instance on each call.
+     */
+    add(options: BufferPolygonOptions, result: BufferPolygon): BufferPolygon;
+    /**
+     * Total byte length of buffers owned by this collection. Includes any unused
+    space allocated by {@link primitiveCountMax}, even if no polygons have
+    yet been added in that space.
+     */
+    readonly byteLength: number;
+    /**
+     * Number of holes in collection. Must be <= {@link holeCountMax}.
+     */
+    readonly holeCount: number;
+    /**
+     * Maximum number of holes in collection. Must be >= {@link holeCount}.
+     */
+    readonly holeCountMax: number;
+    /**
+     * Number of triangles in collection. Must be <= {@link triangleCountMax}.
+     */
+    readonly triangleCount: number;
+    /**
+     * Maximum number of triangles in collection. Must be >= {@link triangleCount}.
+     */
+    readonly triangleCountMax: number;
+}
+
+/**
+ * View bound to the underlying buffer data of a {@link BufferPolylineCollection}.
+
+<p>BufferPolyline instances are {@link https://en.wikipedia.org/wiki/Flyweight_pattern|flyweights}:
+a single BufferPolyline instance can be temporarily bound to any conceptual
+"polyline" in a BufferPolylineCollection, allowing very large collections to be
+iterated and updated with a minimal memory footprint.</p>
+
+Represented as two (2) or more positions.
+ */
+export class BufferPolyline extends BufferPrimitive {
+    /**
+     * Copies data from source polyline to result. If the result polyline is not
+    new (the last polyline in the collection) then source and result polylines
+    must have the same vertex counts.
+     */
+    static clone(polyline: BufferPolyline, result: BufferPolyline): BufferPolyline;
+    /**
+     * Count of positions (vertices) in this polyline, number of VEC3 elements.
+     */
+    readonly vertexCount: number;
+    /**
+     * Returns an array view of this polyline's vertex positions. If 'result'
+    argument is given, vertex positions are written to that array and returned.
+    Otherwise, returns an ArrayView on collection memory — changes to this array
+    will not trigger render updates, which requires `.setPositions()`.
+     * @param [result] - return {Float64Array}
+     */
+    getPositions(result?: Float64Array): void;
+    setPositions(positions: Float64Array): void;
+    /**
+     * Width of polyline, 0–255px.
+     */
+    width: number;
+    /**
+     * Returns a JSON-serializable object representing the polyline. This encoding
+    is not memory-efficient, and should generally be used for debugging and
+    testing.
+     * @returns JSON-serializable object.
+     */
+    toJSON(): any;
+}
+
+export type BufferPolylineOptions = {
+    show?: boolean;
+    color?: Color;
+    positions?: Float64Array;
+    width?: number;
+};
+
+/**
+ * Collection of polylines held in ArrayBuffer storage for performance and memory optimization.
+
+<p>Default buffer memory allocation is arbitrary, and collections cannot be resized,
+so specific per-buffer capacities should be provided in the collection
+constructor when available.</p>
+ * @example
+ * const collection = new BufferPolylineCollection({
+  primitiveCountMax: 1024,
+  vertexCountMax: 4096,
+});
+
+const polyline = new BufferPolyline();
+
+// Create a new polyline, temporarily bound to 'polyline' local variable.
+collection.add({
+  positions: new Float64Array([ ... ]),
+  color: Color.WHITE,
+}, polyline);
+
+// Iterate over all polylines in collection, temporarily binding 'polyline'
+// local variable to each, and updating polyline color.
+for (let i = 0; i < collection.primitiveCount; i++) {
+  collection.get(i, polyline);
+  polyline.setColor(Color.RED);
+}
+ */
+export class BufferPolylineCollection extends BufferPrimitiveCollection<BufferPolyline> {
+    /**
+     * Adds a new polyline to the collection, with the specified options. A
+    {@link BufferPolyline} instance is linked to the new polyline, using
+    the 'result' argument if given, or a new instance if not. For repeated
+    calls, prefer to reuse a single BufferPolyline instance rather than
+    allocating a new instance on each call.
+     */
+    add(options: BufferPolylineOptions, result: BufferPolyline): BufferPolyline;
+}
+
+/**
+ * View bound to the underlying buffer data of a {@link BufferPrimitiveCollection}. Abstract.
+
+<p>BufferPrimitive instances are intended to be reused when iterating over large collections,
+and temporarily bound to a primitive index while performing read/write operations on that primitive,
+before being rebound to the next primitive, using the
+{@link https://en.wikipedia.org/wiki/Flyweight_pattern|flyweight pattern}.</p>
+ */
+export class BufferPrimitive {
+    /**
+     * Copies data from source primitive to result. If the result primitive is not
+    new (the last primitive in the collection) then source and result primitives
+    must have the same vertex counts.
+     */
+    static clone(primitive: BufferPrimitive, result: BufferPrimitive): BufferPrimitive;
+    /**
+     * Feature ID associated with the primitive; not required to be unique.
+     */
+    featureId: number;
+    /**
+     * Whether primitive is shown.
+     */
+    show: boolean;
+    /**
+     * Returns the color of primitive.
+     */
+    getColor(result: Color): Color;
+    /**
+     * Updates the color of primitive.
+     */
+    setColor(color: Color): void;
+    /**
+     * Returns a JSON-serializable object representing the primitive. This encoding
+    is not memory-efficient, and should generally be used for debugging and
+    testing.
+     * @returns JSON-serializable object.
+     */
+    toJSON(): any;
+}
+
+export type BufferPrimitiveOptions = {
+    show?: boolean;
+    color?: Color;
+};
+
+/**
+ * Collection of primitives held in ArrayBuffer storage for performance and memory optimization.
+
+<p>To get the full performance benefit of using a BufferPrimitiveCollection containing "N" primitives,
+be careful to avoid allocating "N" instances of any related JavaScript object. {@link BufferPrimitive},
+{@link Color}, {@link Cartesian3}, and other objects can all be reused when working with large collections,
+using the {@link https://en.wikipedia.org/wiki/Flyweight_pattern|flyweight pattern}.</p>
+ */
+export class BufferPrimitiveCollection<T extends BufferPrimitive> {
+    constructor(options: {
+        primitiveCountMax?: number;
+        vertexCountMax?: number;
+        show?: boolean;
+        debugShowBoundingVolume?: boolean;
+    });
+    /**
+     * Default capacity of buffers on new collections. A quantity of elements:
+    number of vertices in the vertex buffer, primitives in the primitive
+    buffer, etc. This value is arbitrary, and collections cannot be resized,
+    so specific per-buffer capacities should be provided in the collection
+    constructor when available.
+     */
+    readonly DEFAULT_CAPACITY: number;
+    /**
+     * Determines if primitives in this collection will be shown.
+     */
+    show: boolean;
+    /**
+     * Bounding volume for all primitives in the collection, including both
+    shown and hidden primitives.
+     */
+    boundingVolume: BoundingSphere;
+    /**
+     * This property is for debugging only; it is not for production use nor is it optimized.
+    <p>
+    Draws the bounding sphere for each draw command in the primitive.
+    </p>
+     */
+    debugShowBoundingVolume: boolean;
+    /**
+     * Returns true if this object was destroyed; otherwise, false.
+     * @returns True if this object was destroyed; otherwise, false.
+     */
+    isDestroyed(): boolean;
+    /**
+     * Sorts primitives of the collection.
+    
+    Because sorting changes the indices (but not the feature IDs) of primitives
+    in the collection, the function also returns an array mapping from previous
+    index to new index. When sorting repeatedly, the array can be reused and
+    passed as the 'result' argument for each call.
+     * @returns Mapping from previous index to new index.
+     */
+    sort(sortFn: (...params: any[]) => any, result: Uint32Array): Uint32Array;
+    /**
+     * Duplicates the contents of this collection into the result collection.
+    Result collection is not resized, and must contain enough space for all
+    primitives in the source collection. Existing primitives in the result
+    collection will be overwritten.
+    
+    <p>Useful when allocating more space for a collection that has reached its
+    capacity, and efficiently transferring features to the new collection.</p>
+     * @example
+     * const result = new BufferPrimitiveCollection({ ... }); // allocate larger 'result' collection
+    BufferPrimitiveCollection.clone(collection, result);   // copy primitives from 'collection' into 'result'
+     */
+    static clone<T extends BufferPrimitive>(collection: BufferPrimitiveCollection<T>, result: BufferPrimitiveCollection<T>): void;
+    /**
+     * Makes the given {@link BufferPrimitive} a view onto this collection's
+    primitive at the given index, for use when reading/writing primitive
+    properties. When iterating over a large collection, prefer to reuse
+    the same BufferPrimitive instance throughout the loop — rebinding
+    an existing instance to a different primitive is cheap, and avoids
+    allocating in-memory objects for every object.
+     * @example
+     * const primitive = new BufferPrimitive();
+    for (let i = 0; i < collection.primitiveCount; i++) {
+      collection.get(i, primitive);
+      primitive.setColor(Color.RED);
+    }
+     * @returns The BufferPrimitive instance passed as the
+    'result' argument, now bound to the specified primitive index.
+     */
+    get(index: number, result: BufferPrimitive): BufferPrimitive;
+    /**
+     * Adds a new primitive to the collection, with the specified options. A
+    {@link BufferPrimitive} instance is linked to the new primitive, using
+    the 'result' argument if given, or a new instance if not. For repeated
+    calls, prefer to reuse a single BufferPrimitive instance rather than
+    allocating a new instance on each call.
+     */
+    add(options: BufferPrimitiveOptions, result: BufferPrimitive): BufferPrimitive;
+    update(frameState: any): void;
+    /**
+     * Number of primitives in collection. Must be <= {@link primitiveCountMax}.
+     */
+    readonly primitiveCount: number;
+    /**
+     * Maximum number of primitives this collection can contain. Must be >=
+    {@link primitiveCount}.
+     */
+    readonly primitiveCountMax: number;
+    /**
+     * Total byte length of buffers owned by this collection. Includes any unused
+    space allocated by {@link primitiveCountMax}, even if no primitives have
+    yet been added in that space.
+     */
+    readonly byteLength: number;
+    /**
+     * Number of vertices in collection. Must be <= {@link vertexCountMax}.
+     */
+    readonly vertexCount: number;
+    /**
+     * Maximum number of vertices this collection can contain. Must be >=
+    {@link vertexCount}.
+     */
+    readonly vertexCountMax: number;
+    /**
+     * Returns a JSON-serializable array representing the collection. This encoding
+    is not memory-efficient, and should generally be used for debugging and
+    testing.
+     * @example
+     * console.table(collection.toJSON());
+     * @returns List of JSON-serializable objects, one for each
+    primitive in the collection.
+     */
+    toJSON(): object[];
+}
+
 /**
  * An orientation given by a pair of unit vectors
  * @property direction - The unit "direction" vector
@@ -31964,6 +32535,97 @@ export class CreditDisplay {
     static cesiumCredit: Credit;
 }
 
+export namespace CubeMapPanorama {
+    /**
+     * Initialization options for the CubeMapPanorama constructor
+     * @property [options.sources] - The source URL or <code>Image</code> object for each of the six cube map faces.  See the example below.
+     * @property [options.transform] - A 4x4 transformation matrix that defines the panorama’s position and orientation
+     * @property [options.show = true] - Determines if this primitive will be shown.
+     * @property [options.credit] - A credit for the panorama, which is displayed on the canvas.
+     */
+    type ConstructorOptions = {};
+}
+
+/**
+ * A {@link Panorama} that displays imagery in cube map format in a scene.
+<p>
+This is only supported in 3D.  The cube map panorama is faded out when morphing to 2D or Columbus view.  The size of
+the cube map panorama must not exceed {@link Scene#maximumSkyBoxSize}.
+</p>
+ * @example
+ * const modelMatrix = Cesium.Matrix4.getMatrix3(
+  Cesium.Transforms.localFrameToFixedFrameGenerator("north", "down")(
+    Cesium.Cartesian3.fromDegrees(longitude, latitude, height),
+    Cesium.Ellipsoid.default
+  ),
+  new Cesium.Matrix3()
+);
+
+
+scene.primitives.add(new Cesium.CubeMapPanorama({
+  sources : {
+    positiveX : 'cubemap_px.png',
+    negativeX : 'cubemap_nx.png',
+    positiveY : 'cubemap_py.png',
+    negativeY : 'cubemap_ny.png',
+    positiveZ : 'cubemap_pz.png',
+    negativeZ : 'cubemap_nz.png'
+  }
+  transform: modelMatrix,
+}));
+ * @param options - Object describing initialization options
+ */
+export class CubeMapPanorama {
+    constructor(options: CubeMapPanorama.ConstructorOptions);
+    /**
+     * The sources used to create the cube map faces: an object
+    with <code>positiveX</code>, <code>negativeX</code>, <code>positiveY</code>,
+    <code>negativeY</code>, <code>positiveZ</code>, and <code>negativeZ</code> properties.
+    These can be either URLs or <code>Image</code> objects.
+     */
+    sources: any;
+    /**
+     * Determines if the cube map panorama will be shown.
+     */
+    show: boolean;
+    /**
+     * Gets the transform of the panorama.
+     */
+    readonly transform: Matrix4;
+    /**
+     * Gets the credits of the panorama.
+     */
+    readonly credit: Credit;
+    /**
+     * Called when {@link Viewer} or {@link CesiumWidget} render the scene to
+    get the draw commands needed to render this primitive.
+    <p>
+    Do not call this function directly.  This is documented just to
+    list the exceptions that may be propagated when the scene is rendered:
+    </p>
+     */
+    update(): void;
+    /**
+     * Returns true if this object was destroyed; otherwise, false.
+    <br /><br />
+    If this object was destroyed, it should not be used; calling any function other than
+    <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+     * @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
+     * cubeMapPanorama = cubeMapPanorama && cubeMapPanorama.destroy();
+     */
+    destroy(): void;
+}
+
 /**
  * Determines which triangles, if any, are culled.
  */
@@ -32379,16 +33041,6 @@ export enum DepthFunction {
     ALWAYS = WebGLConstants.ALWAYS
 }
 
-/**
- * Returns the type that the given class property has in a GLSL shader.
- *
- * It returns the same string as `PropertyTextureProperty.prototype.getGlslType`
- * for a property texture property with the given class property
- * @param classProperty - The class property
- * @returns The GLSL shader type string for the property
- */
-export function getGlslType(classProperty: MetadataClassProperty): string;
-
 /**
  * Returns a shader statement that applies the inverse of the
  * value transform to the given value, based on the given offset
@@ -32788,6 +33440,104 @@ export class EllipsoidSurfaceAppearance {
     getRenderState(): any;
 }
 
+export namespace EquirectangularPanorama {
+    /**
+     * Initialization options for the EquirectangularPanorama constructor
+     * @property options.transform - A 4x4 transformation matrix that defines the panorama’s position and orientation
+    (for example, derived from a position and heading-pitch-roll).
+     * @property options.image - A URL to an image resource, or a preloaded image object.
+     * @property [options.radius = 100000.0] - The radius of the panorama in meters.
+     * @property [options.repeatHorizontal = 1.0] - The number of times to repeat the texture horizontally.
+     * @property [options.repeatVertical = 1.0] - The number of times to repeat the texture vertically.
+     * @property [options.credit] - A credit for the panorama, which is displayed on the canvas.
+     */
+    type ConstructorOptions = {};
+}
+
+/**
+ * A {@link Panorama} that displays imagery in equirectangular format in a scene.
+ * @example
+ * const position = Cesium.Cartesian3.fromDegrees(
+  -75.1699,  // longitude
+  39.9522,   // latitude
+  100.0      // height in meters
+);
+
+const heading = Cesium.Math.toRadians(45.0); // rotation about up axis
+const pitch = Cesium.Math.toRadians(-30.0);   // pitch (negative looks down)
+const roll = Cesium.Math.toRadians(10.0);    // roll about forward axis
+
+const hpr = new Cesium.HeadingPitchRoll(
+  heading,
+  pitch,
+  roll
+);
+
+const modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(
+  position,
+  hpr,
+  Cesium.Ellipsoid.WGS84,
+  Cesium.Transforms.eastNorthUpToFixedFrame
+);
+
+scene.primitives.add(new Cesium.EquirectangularPanorama({
+  transform: modelMatrix,
+  image: 'path/to/image',
+}));
+ * @param options - Object describing initialization options
+ */
+export class EquirectangularPanorama {
+    constructor(options: EquirectangularPanorama.ConstructorOptions);
+    /**
+     * Gets the radius of the panorama.
+     */
+    readonly radius: number;
+    /**
+     * Gets the source image of the panorama.
+     */
+    readonly image: string | HTMLImageElement | HTMLCanvasElement | ImageBitmap;
+    /**
+     * Gets the transform of the panorama.
+     */
+    readonly transform: Matrix4;
+    /**
+     * Gets the credits of the panorama.
+     */
+    readonly credit: Credit;
+    /**
+     * Determines if the equirectangular panorama will be shown.
+     */
+    show: boolean;
+    /**
+     * Called when {@link Viewer} or {@link CesiumWidget} render the scene to
+    get the draw commands needed to render this primitive.
+    <p>
+    Do not call this function directly.  This is documented just to
+    list the exceptions that may be propagated when the scene is rendered:
+    </p>
+     */
+    update(): void;
+    /**
+     * 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
+     * equirectangularPanorama = equirectangularPanorama && equirectangularPanorama.destroy();
+     */
+    destroy(): 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 <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+     */
+    isDestroyed(): boolean;
+}
+
 /**
  * An expression for a style applied to a {@link Cesium3DTileset}.
 <p>
@@ -34088,6 +34838,87 @@ export class GoogleEarthEnterpriseMapsProvider {
     static logoUrl: string;
 }
 
+/**
+ * <div class="notice">
+This object is normally not instantiated directly, use {@link GoogleStreetViewCubeMapPanoramaProvider.fromUrl}.
+</div>
+
+
+Creates a {@link PanoramaProvider} which provides imagery from {@link https://developers.google.com/maps/documentation/streetview|Google Street View Static API} to be displayed in a panorama.
+ */
+export class GoogleStreetViewCubeMapPanoramaProvider {
+    constructor();
+    /**
+     * Gets the panorama primitive for a requested position and orientation.
+     * @example
+     * const provider = await Cesium.GoogleStreetViewCubeMapPanoramaProvider.fromUrl({
+      key: 'your Google Streetview Static api key'
+    })
+    
+    const panoIdObject = provider.getNearestPanoId(position);
+    const position = Cartographic.fromDegrees(panoIdObject.location.lng, panoIdObject.location.lat, 0);
+    
+    const primitive = await provider.loadPanorama({
+      cartographic: position,
+      panoId: panoIdObject.panoId
+    });
+    viewer.scene.primitive.add(primitive);
+     * @param options - Object with the following properties:
+     * @param options.cartographic - The position to place the panorama in the scene.
+     * @param [options.panoId] - The panoramaId identifier for the image in the Google API. If not provided this will be looked up for the provided cartographic location.
+     * @param [options.tileSize] - Optional tile size override (square).
+     * @param [options.signature] - Optional signature for signed URLs. See {@link https://developers.google.com/maps/documentation/streetview/digital-signature} for more information.
+     * @param [options.credit] - A credit for the data source, which is displayed on the canvas.
+     * @returns The panorama primitive textured with imagery.
+     */
+    loadPanorama(options: {
+        cartographic: Cartographic;
+        panoId?: string;
+        tileSize?: number;
+        signature?: string;
+        credit?: Credit | string;
+    }): CubeMapPanorama;
+    /**
+     * Gets the panoIds for the given cartographic location. See {@link https://developers.google.com/maps/documentation/tile/streetview#panoid-search}.
+     * @example
+     * const provider = await Cesium.GoogleStreetViewCubeMapPanoramaProvider.fromUrl({
+      key: 'your Google Streetview Static api key'
+    })
+    const panoIds = provider.getNearestPanoId(position);
+     * @param position - The position to search for the nearest panoId.
+     * @param [radius = 50] - The radius in meters to search for the nearest panoId.
+     * @returns an object containing a panoId, latitude, and longitude of the closest panorama
+     */
+    getNearestPanoId(position: Cartographic, radius?: number): any;
+    /**
+     * Gets metadata for panoId. See {@link https://developers.google.com/maps/documentation/tile/streetview#metadata_response} for response object.
+     * @example
+     * const panoIdObject = provider.getNearestPanoId(position);
+    const panoIdMetadata = provider.getPanoIdMetadata(panoIdObject.panoId);
+     * @returns object containing metadata for the panoId.
+     */
+    getPanoIdMetadata(panoId: string): any;
+    /**
+     * Creates a {@link PanoramaProvider} which provides cube face images from the {@link https://developers.google.com/maps/documentation/streetview|Google Street View Static API}.
+     * @example
+     * const provider = await Cesium.GoogleStreetViewCubeMapPanoramaProvider.fromUrl({
+      key: 'your Google Streetview Static api key'
+    })
+     * @param options - Object with the following properties:
+     * @param [options.key = GoogleMaps.defaultStreetViewStaticApiKey] - Your API key to access Google Street View Static API. See {@link https://developers.google.com/maps/documentation/javascript/get-api-key} for instructions on how to create your own key. If undefined, defaults to {@link GoogleMaps.defaultStreetViewStaticApiKey}. If that value is unavailable, falls back to {@link GoogleMaps.defaultApiKey}.
+     * @param [options.url = GoogleMaps.streetViewStaticApiEndpoint] - The URL to access Google Street View Static API. See {@link https://developers.google.com/maps/documentation/streetview/overview} for more information.
+     * @param [options.tileSize = 600] - Default width and height (in pixels) of each square tile.
+     * @param [options.credit] - A credit for the data source, which is displayed on the canvas.
+     * @returns A promise that resolves to the created GoogleStreetViewCubeMapPanoramaProvider.'
+     */
+    static fromUrl(options: {
+        key?: string;
+        url?: string | Resource;
+        tileSize?: number;
+        credit?: Credit | string;
+    }): Promise<GoogleStreetViewCubeMapPanoramaProvider>;
+}
+
 export namespace GridImageryProvider {
     /**
      * Initialization options for the GridImageryProvider constructor
@@ -37695,8 +38526,8 @@ export class MetadataClassProperty {
         max?: number | number[] | number[][];
         offset?: number | number[] | number[][];
         scale?: number | number[] | number[][];
-        noData?: boolean | number | string | any[];
-        default?: boolean | number | string | any[];
+        noData?: number | string | any[];
+        default?: number | string | any[];
         required?: boolean;
         name?: string;
         description?: string;
@@ -37758,11 +38589,11 @@ export class MetadataClassProperty {
     /**
      * The no-data sentinel value that represents null values
      */
-    readonly noData: boolean | number | string | any[];
+    readonly noData: number | string | any[];
     /**
      * A default value to use when an entity's property value is not defined.
      */
-    readonly default: boolean | number | string | any[];
+    readonly default: number | string | any[];
     /**
      * Whether the property is required.
      */
@@ -37826,11 +38657,11 @@ export enum MetadataComponentType {
      */
     UINT32 = "UINT32",
     /**
-     * A 64-bit signed integer. This type requires BigInt support.
+     * A 64-bit signed integer.
      */
     INT64 = "INT64",
     /**
-     * A 64-bit signed integer. This type requires BigInt support
+     * A 64-bit signed integer.
      */
     UINT64 = "UINT64",
     /**
@@ -39898,6 +40729,45 @@ export class OpenStreetMapImageryProvider extends UrlTemplateImageryProvider {
     constructor(options: OpenStreetMapImageryProvider.ConstructorOptions);
 }
 
+/**
+ * Displays panorama imagery in a scene. This type describes an interface and is not intended to be instantiated directly.
+ */
+export class Panorama {
+    constructor();
+    /**
+     * Determines if the panorama will be shown.
+     */
+    show: boolean;
+    /**
+     * Gets the transform of the panorama.
+     */
+    readonly transform: Matrix4;
+    /**
+     * Gets the credits of the panorama.
+     */
+    readonly credit: Credit;
+}
+
+/**
+ * Provides imagery to be displayed on the surface of an ellipsoid.  This type describes an
+interface and is not intended to be instantiated directly.
+ */
+export class PanoramaProvider {
+    constructor();
+    /**
+     * Returns a panorama provider.
+     * @param options - Input options to create the panorama provider.
+     * @returns The panorama provider for loading panoramas into a scene.
+     */
+    static fromUrl(options: any): PanoramaProvider;
+    /**
+     * Returns a panorama primitive.
+     * @param options - Input options to create the panorama primitive.
+     * @returns The panorama primitive for displaying panoramas in a scene.
+     */
+    loadPanorama(options: any): Panorama;
+}
+
 /**
  * A particle emitted by a {@link ParticleSystem}.
  * @param options - An object with the following properties:
@@ -43657,17 +44527,14 @@ export class SkyBox {
         sources?: any;
         show?: boolean;
     });
-    /**
-     * The sources used to create the cube map faces: an object
-    with <code>positiveX</code>, <code>negativeX</code>, <code>positiveY</code>,
-    <code>negativeY</code>, <code>positiveZ</code>, and <code>negativeZ</code> properties.
-    These can be either URLs or <code>Image</code> objects.
-     */
-    sources: any;
     /**
      * Determines if the sky box will be shown.
      */
     show: boolean;
+    /**
+     * Gets or sets the the primitive object.
+     */
+    sources: any;
     /**
      * Called when {@link Viewer} or {@link CesiumWidget} render the scene to
     get the draw commands needed to render this primitive.