mars3d-cesium 1.101.1 → 1.102.0

package/Build/Cesium/Cesium.d.ts

@@ -6542,6 +6542,12 @@ export namespace FeatureDetection {
      * @returns true if the browsers supports Web Assembly, false if not.
      */
     function supportsWebAssembly(): boolean;
+    /**
+     * Detects whether the current browser supports a WebGL2 rendering context for the specified scene.
+     * @param scene - the Cesium scene specifying the rendering context
+     * @returns true if the browser supports a WebGL2 rendering context, false if not.
+     */
+    function supportsWebgl2(scene: Scene): boolean;
 }
 
 /**
@@ -9932,9 +9938,10 @@ export class Matrix2 implements ArrayLike<number> {
      * Sets the rotation assuming the matrix is an affine transformation.
      * @param matrix - The matrix.
      * @param rotation - The rotation matrix.
+     * @param result - The object onto which to store the result.
      * @returns The modified result parameter.
      */
-    static setRotation(matrix: Matrix2, rotation: Matrix2): Matrix2;
+    static setRotation(matrix: Matrix2, rotation: Matrix2, result: Matrix2): Matrix2;
     /**
      * Extracts the rotation matrix assuming the matrix is an affine transformation.
      * @param matrix - The matrix.
@@ -9992,7 +9999,7 @@ export class Matrix2 implements ArrayLike<number> {
      * @param result - The object onto which to store the result.
      * @returns The modified result parameter.
      */
-    static multiplyByScale(matrix: Matrix2, scale: number, result: Matrix2): Matrix2;
+    static multiplyByScale(matrix: Matrix2, scale: Cartesian2, result: Matrix2): Matrix2;
     /**
      * Computes the product of a matrix times a uniform scale, as if the scale were a scale matrix.
      * @example
@@ -10387,9 +10394,10 @@ export class Matrix3 implements ArrayLike<number> {
      * Sets the rotation assuming the matrix is an affine transformation.
      * @param matrix - The matrix.
      * @param rotation - The rotation matrix.
+     * @param result - The object onto which to store the result.
      * @returns The modified result parameter.
      */
-    static setRotation(matrix: Matrix3, rotation: Matrix3): Matrix3;
+    static setRotation(matrix: Matrix3, rotation: Matrix3, result: Matrix3): Matrix3;
     /**
      * Extracts the rotation matrix assuming the matrix is an affine transformation.
      * @param matrix - The matrix.
@@ -10447,7 +10455,7 @@ export class Matrix3 implements ArrayLike<number> {
      * @param result - The object onto which to store the result.
      * @returns The modified result parameter.
      */
-    static multiplyByScale(matrix: Matrix3, scale: number, result: Matrix3): Matrix3;
+    static multiplyByScale(matrix: Matrix3, scale: Cartesian3, result: Matrix3): Matrix3;
     /**
      * Computes the product of a matrix times a uniform scale, as if the scale were a scale matrix.
      * @example
@@ -11050,9 +11058,10 @@ export class Matrix4 implements ArrayLike<number> {
      * Sets the rotation assuming the matrix is an affine transformation.
      * @param matrix - The matrix.
      * @param rotation - The rotation matrix.
+     * @param result - The object onto which to store the result.
      * @returns The modified result parameter.
      */
-    static setRotation(matrix: Matrix4, rotation: Matrix3): Matrix4;
+    static setRotation(matrix: Matrix4, rotation: Matrix3, result: Matrix4): Matrix4;
     /**
      * Extracts the rotation matrix assuming the matrix is an affine transformation.
      * @param matrix - The matrix.
@@ -11800,7 +11809,7 @@ export class OpenCageGeocoderService {
 
 /**
  * Creates an instance of an OrientedBoundingBox.
-An OrientedBoundingBox of some object is a closed and convex cuboid. It can provide a tighter bounding volume than {@link BoundingSphere} or {@link AxisAlignedBoundingBox} in many cases.
+An OrientedBoundingBox of some object is a closed and convex rectangular cuboid. It can provide a tighter bounding volume than {@link BoundingSphere} or {@link AxisAlignedBoundingBox} in many cases.
  * @example
  * // Create an OrientedBoundingBox using a transformation matrix, a position where the box will be translated, and a scale.
 const center = new Cesium.Cartesian3(1.0, 0.0, 0.0);
@@ -11809,7 +11818,7 @@ const halfAxes = Cesium.Matrix3.fromScale(new Cesium.Cartesian3(1.0, 3.0, 2.0),
 const obb = new Cesium.OrientedBoundingBox(center, halfAxes);
  * @param [center = Cartesian3.ZERO] - The center of the box.
  * @param [halfAxes = Matrix3.ZERO] - The three orthogonal half-axes of the bounding box.
-                                         Equivalently, the transformation matrix, to rotate and scale a 0x0x0
+                                         Equivalently, the transformation matrix, to rotate and scale a 1x1x1
                                          cube centered at the origin.
  */
 export class OrientedBoundingBox {
@@ -12651,6 +12660,14 @@ export enum PixelFormat {
      * A pixel format containing an alpha channel.
      */
     ALPHA = WebGLConstants.ALPHA,
+    /**
+     * A pixel format containing a red channel
+     */
+    RED = WebGLConstants.RED,
+    /**
+     * A pixel format containing red and green channels.
+     */
+    RG = WebGLConstants.RG,
     /**
      * A pixel format containing red, green, and blue channels.
      */
@@ -17460,9 +17477,8 @@ export namespace Transforms {
     indicates that the preload has completed.
      * @example
      * const interval = new Cesium.TimeInterval(...);
-    Promise.resolve(Cesium.Transforms.preloadIcrfFixed(interval)).then(function() {
-        // the data is now loaded
-    });
+    await Cesium.Transforms.preloadIcrfFixed(interval));
+    // the data is now loaded
      * @param timeInterval - The interval to preload.
      * @returns A promise that, when resolved, indicates that the preload has completed
              and evaluation of the transformation between the fixed and ICRF axes will
@@ -24973,6 +24989,49 @@ export class WallGraphics {
     merge(source: WallGraphics): void;
 }
 
+/**
+ * Options to control the setting up of a WebGL Context.
+<p>
+<code>allowTextureFilterAnisotropic</code> defaults to true, which enables
+anisotropic texture filtering when the WebGL extension is supported.
+Setting this to false will improve performance, but hurt visual quality,
+especially for horizon views.
+</p>
+ * @property [requestWebGl1 = false] - If true and the browser supports it, use a WebGL 1 rendering context
+ * @property [allowTextureFilterAnisotropic = true] - If true, use anisotropic filtering during texture sampling
+ * @property [webgl] - WebGL options to be passed on to canvas.getContext
+ * @property [getWebGLStub] - A function to create a WebGL stub for testing
+ */
+export type ContextOptions = {
+    requestWebGl1?: boolean;
+    allowTextureFilterAnisotropic?: boolean;
+    webgl?: WebGLOptions;
+    getWebGLStub?: (...params: any[]) => any;
+};
+
+/**
+ * WebGL options to be passed on to HTMLCanvasElement.getContext().
+See {@link https://registry.khronos.org/webgl/specs/latest/1.0/#5.2|WebGLContextAttributes}
+but note the modified defaults for 'alpha', 'stencil', and 'powerPreference'
+
+<p>
+<code>alpha</code> defaults to false, which can improve performance
+compared to the standard WebGL default of true.  If an application needs
+to composite Cesium above other HTML elements using alpha-blending, set
+<code>alpha</code> to true.
+</p>
+ */
+export type WebGLOptions = {
+    alpha?: boolean;
+    depth?: boolean;
+    stencil?: boolean;
+    antialias?: boolean;
+    premultipliedAlpha?: boolean;
+    preserveDrawingBuffer?: boolean;
+    powerPreference?: "default" | "low-power" | "high-performance";
+    failIfMajorPerformanceCaveat?: boolean;
+};
+
 /**
  * The data type of a pixel.
  */
@@ -29236,6 +29295,112 @@ export class Cesium3DTileStyle {
     meta: StyleExpression;
 }
 
+/**
+ * A {@link VoxelProvider} that fetches voxel data from a 3D Tiles tileset.
+<p>
+Implements the {@link VoxelProvider} interface.
+</p>
+ * @param options - Object with the following properties:
+ * @param options.url - The URL to a tileset JSON file.
+ */
+export class Cesium3DTilesVoxelProvider extends VoxelProvider {
+    constructor(options: {
+        url: Resource | string | Promise<Resource> | Promise<string>;
+    });
+    /**
+     * Gets a value indicating whether or not the provider is ready for use.
+     */
+    readonly ready: boolean;
+    /**
+     * A transform from local space to global space. If undefined, the identity matrix will be used instead.
+     */
+    readonly globalTransform: Matrix4 | undefined;
+    /**
+     * A transform from shape space to local space. If undefined, the identity matrix will be used instead.
+     */
+    readonly shapeTransform: Matrix4 | undefined;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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 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.
+     */
+    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.
+     * @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.
+     */
+    requestData(options?: {
+        tileLevel?: number;
+        tileX?: number;
+        tileY?: number;
+        tileZ?: number;
+    }): Promise<any[][]> | undefined;
+}
+
+export var readyPromise: any;
+
 /**
  * A ParticleEmitter that emits particles from a circle.
 Particles will be positioned within a circle and have initial velocities going along the z vector.
@@ -31128,6 +31293,11 @@ export class Globe {
      * Whether to cull back-facing terrain. Back faces are not culled when the camera is underground or translucency is enabled.
      */
     backFaceCulling: boolean;
+    /**
+     * Determines the darkness of the vertex shadow.
+    This only takes effect when <code>enableLighting</code> is <code>true</code>.
+     */
+    vertexShadowDarkness: number;
     /**
      * Gets an ellipsoid describing the shape of this globe.
      */
@@ -32617,6 +32787,22 @@ export class I3SLayer {
      * Gets the I3S data for this object.
      */
     readonly data: any;
+    /**
+     * The version string of the loaded I3S dataset
+     */
+    readonly version: string;
+    /**
+     * The major version number of the loaded I3S dataset
+     */
+    readonly majorVersion: number;
+    /**
+     * The minor version number of the loaded I3S dataset
+     */
+    readonly minorVersion: number;
+    /**
+     * When <code>true</code>, when the loaded I3S version is 1.6 or older
+     */
+    readonly legacyVersion16: boolean;
 }
 
 /**
@@ -32668,6 +32854,18 @@ export class I3SNode {
      * @returns A promise that is resolved when the I3S Node fields are loaded
      */
     loadFields(): Promise<void>;
+    /**
+     * Returns the fields for a given picked position
+     * @param pickedPosition - The picked position
+     * @returns Object containing field names and their values
+     */
+    getFieldsForPickedPosition(pickedPosition: Cartesian3): any;
+    /**
+     * Returns the fields for a given feature
+     * @param featureIndex - Index of the feature whose attributes we want to get
+     * @returns Object containing field names and their values
+     */
+    getFieldsForFeature(featureIndex: number): any;
 }
 
 /**
@@ -35010,6 +35208,451 @@ export namespace MaterialAppearance {
     }
 }
 
+/**
+ * A metadata class.
+
+<p>
+See the {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata|3D Metadata Specification} for 3D Tiles
+</p>
+ * @param options - Object with the following properties:
+ * @param options.id - The ID of the class.
+ * @param [options.name] - The name of the class.
+ * @param [options.description] - The description of the class.
+ * @param [options.properties] - The class properties, where each key is the property ID.
+ * @param [options.extras] - Extra user-defined properties.
+ * @param [options.extensions] - An object containing extensions.
+ */
+export class MetadataClass {
+    constructor(options: {
+        id: string;
+        name?: string;
+        description?: string;
+        properties?: {
+            [key: string]: MetadataClassProperty;
+        };
+        extras?: any;
+        extensions?: any;
+    });
+    /**
+     * The class properties.
+     */
+    readonly properties: {
+        [key: string]: MetadataClassProperty;
+    };
+    /**
+     * The ID of the class.
+     */
+    readonly id: string;
+    /**
+     * The name of the class.
+     */
+    readonly name: string;
+    /**
+     * The description of the class.
+     */
+    readonly description: string;
+    /**
+     * Extra user-defined properties.
+     */
+    readonly extras: any;
+    /**
+     * An object containing extensions.
+     */
+    readonly extensions: any;
+}
+
+/**
+ * A metadata property, as part of a {@link MetadataClass}.
+<p>
+See the {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata|3D Metadata Specification} for 3D Tiles
+</p>
+ * @param options - Object with the following properties:
+ * @param options.id - The ID of the property.
+ * @param options.type - The type of the property such as SCALAR, VEC2, VEC3.
+ * @param [options.componentType] - The component type of the property. This includes integer (e.g. INT8 or UINT16), and floating point (FLOAT32 and FLOAT64) values.
+ * @param [options.enumType] - The enum type of the property. Only defined when type is ENUM.
+ * @param [options.isArray = false] - True if a property is an array (either fixed length or variable length), false otherwise.
+ * @param [options.isVariableLengthArray = false] - True if a property is a variable length array, false otherwise.
+ * @param [options.arrayLength] - The number of array elements. Only defined for fixed length arrays.
+ * @param [options.normalized = false] - Whether the property is normalized.
+ * @param [options.min] - A number or an array of numbers storing the minimum allowable value of this property. Only defined when type is a numeric type.
+ * @param [options.max] - A number or an array of numbers storing the maximum allowable value of this property. Only defined when type is a numeric type.
+ * @param [options.offset] - The offset to be added to property values as part of the value transform.
+ * @param [options.scale] - The scale to be multiplied to property values as part of the value transform.
+ * @param [options.noData] - The no-data sentinel value that represents null values.
+ * @param [options.default] - A default value to use when an entity's property value is not defined.
+ * @param [options.required = false] - Whether the property is required.
+ * @param [options.name] - The name of the property.
+ * @param [options.description] - The description of the property.
+ * @param [options.semantic] - An identifier that describes how this property should be interpreted.
+ * @param [options.extras] - Extra user-defined properties.
+ * @param [options.extensions] - An object containing extensions.
+ */
+export class MetadataClassProperty {
+    constructor(options: {
+        id: string;
+        type: MetadataType;
+        componentType?: MetadataComponentType;
+        enumType?: MetadataEnum;
+        isArray?: boolean;
+        isVariableLengthArray?: boolean;
+        arrayLength?: number;
+        normalized?: boolean;
+        min?: number | number[] | number[][];
+        max?: number | number[] | number[][];
+        offset?: number | number[] | number[][];
+        scale?: number | number[] | number[][];
+        noData?: boolean | number | string | any[];
+        default?: boolean | number | string | any[];
+        required?: boolean;
+        name?: string;
+        description?: string;
+        semantic?: string;
+        extras?: any;
+        extensions?: any;
+    });
+    /**
+     * The ID of the property.
+     */
+    readonly id: string;
+    /**
+     * The name of the property.
+     */
+    readonly name: string;
+    /**
+     * The description of the property.
+     */
+    readonly description: string;
+    /**
+     * The type of the property such as SCALAR, VEC2, VEC3
+     */
+    readonly type: MetadataType;
+    /**
+     * The enum type of the property. Only defined when type is ENUM.
+     */
+    readonly enumType: MetadataEnum;
+    /**
+     * The component type of the property. This includes integer
+    (e.g. INT8 or UINT16), and floating point (FLOAT32 and FLOAT64) values
+     */
+    readonly componentType: MetadataComponentType;
+    /**
+     * True if a property is an array (either fixed length or variable length),
+    false otherwise.
+     */
+    readonly isArray: boolean;
+    /**
+     * True if a property is a variable length array, false otherwise.
+     */
+    readonly isVariableLengthArray: boolean;
+    /**
+     * The number of array elements. Only defined for fixed-size
+    arrays.
+     */
+    readonly arrayLength: number;
+    /**
+     * Whether the property is normalized.
+     */
+    readonly normalized: boolean;
+    /**
+     * A number or an array of numbers storing the maximum allowable value of this property. Only defined when type is a numeric type.
+     */
+    readonly max: number | number[] | number[][];
+    /**
+     * A number or an array of numbers storing the minimum allowable value of this property. Only defined when type is a numeric type.
+     */
+    readonly min: number | number[] | number[][];
+    /**
+     * The no-data sentinel value that represents null values
+     */
+    readonly noData: boolean | number | string | any[];
+    /**
+     * A default value to use when an entity's property value is not defined.
+     */
+    readonly default: boolean | number | string | any[];
+    /**
+     * Whether the property is required.
+     */
+    readonly required: boolean;
+    /**
+     * An identifier that describes how this property should be interpreted.
+     */
+    readonly semantic: string;
+    /**
+     * The offset to be added to property values as part of the value transform.
+     */
+    readonly offset: number | number[] | number[][];
+    /**
+     * The scale to be multiplied to property values as part of the value transform.
+     */
+    readonly scale: number | number[] | number[][];
+    /**
+     * Extra user-defined properties.
+     */
+    readonly extras: any;
+    /**
+     * An object containing extensions.
+     */
+    readonly extensions: any;
+}
+
+/**
+ * An enum of metadata component types.
+ */
+export enum MetadataComponentType {
+    /**
+     * An 8-bit signed integer
+     */
+    INT8 = "INT8",
+    /**
+     * An 8-bit unsigned integer
+     */
+    UINT8 = "UINT8",
+    /**
+     * A 16-bit signed integer
+     */
+    INT16 = "INT16",
+    /**
+     * A 16-bit unsigned integer
+     */
+    UINT16 = "UINT16",
+    /**
+     * A 32-bit signed integer
+     */
+    INT32 = "INT32",
+    /**
+     * A 32-bit unsigned integer
+     */
+    UINT32 = "UINT32",
+    /**
+     * A 64-bit signed integer. This type requires BigInt support.
+     */
+    INT64 = "INT64",
+    /**
+     * A 64-bit signed integer. This type requires BigInt support
+     */
+    UINT64 = "UINT64",
+    /**
+     * A 32-bit (single precision) floating point number
+     */
+    FLOAT32 = "FLOAT32",
+    /**
+     * A 64-bit (double precision) floating point number
+     */
+    FLOAT64 = "FLOAT64"
+}
+
+/**
+ * A metadata enum.
+<p>
+See the {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata|3D Metadata Specification} for 3D Tiles
+</p>
+ * @param options - Object with the following properties:
+ * @param options.id - The ID of the enum.
+ * @param options.values - The enum values.
+ * @param [options.valueType = MetadataComponentType.UINT16] - The enum value type.
+ * @param [options.name] - The name of the enum.
+ * @param [options.description] - The description of the enum.
+ * @param [options.extras] - Extra user-defined properties.
+ * @param [options.extensions] - An object containing extensions.
+ */
+export class MetadataEnum {
+    constructor(options: {
+        id: string;
+        values: MetadataEnumValue[];
+        valueType?: MetadataComponentType;
+        name?: string;
+        description?: string;
+        extras?: any;
+        extensions?: any;
+    });
+    /**
+     * The enum values.
+     */
+    readonly values: MetadataEnumValue[];
+    /**
+     * The enum value type.
+     */
+    readonly valueType: MetadataComponentType;
+    /**
+     * The ID of the enum.
+     */
+    readonly id: string;
+    /**
+     * The name of the enum.
+     */
+    readonly name: string;
+    /**
+     * The description of the enum.
+     */
+    readonly description: string;
+    /**
+     * Extra user-defined properties.
+     */
+    readonly extras: any;
+    /**
+     * An object containing extensions.
+     */
+    readonly extensions: any;
+}
+
+/**
+ * A metadata enum value.
+<p>
+See the {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata|3D Metadata Specification} for 3D Tiles
+</p>
+ * @param options - Object with the following properties:
+ * @param options.value - The integer value.
+ * @param options.name - The name of the enum value.
+ * @param [options.description] - The description of the enum value.
+ * @param [options.extras] - Extra user-defined properties.
+ * @param [options.extensions] - An object containing extensions.
+ */
+export class MetadataEnumValue {
+    constructor(options: {
+        value: number;
+        name: string;
+        description?: string;
+        extras?: any;
+        extensions?: any;
+    });
+    /**
+     * The integer value.
+     */
+    readonly value: number;
+    /**
+     * The name of the enum value.
+     */
+    readonly name: string;
+    /**
+     * The description of the enum value.
+     */
+    readonly description: string;
+    /**
+     * Extra user-defined properties.
+     */
+    readonly extras: any;
+    /**
+     * An object containing extensions.
+     */
+    readonly extensions: any;
+}
+
+/**
+ * A schema containing classes and enums.
+<p>
+See the {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata|3D Metadata Specification} for 3D Tiles
+</p>
+ * @param options - Object with the following properties:
+ * @param [options.id] - The ID of the schema
+ * @param [options.name] - The name of the schema.
+ * @param [options.description] - The description of the schema.
+ * @param [options.version] - The application-specific version of the schema.
+ * @param [options.classes] - Classes defined in the schema, where each key is the class ID.
+ * @param [options.enums] - Enums defined in the schema, where each key is the enum ID.
+ * @param [options.extras] - Extra user-defined properties.
+ * @param [options.extensions] - An object containing extensions.
+ */
+export class MetadataSchema {
+    constructor(options: {
+        id?: string;
+        name?: string;
+        description?: string;
+        version?: string;
+        classes?: {
+            [key: string]: MetadataClass;
+        };
+        enums?: {
+            [key: string]: MetadataEnum;
+        };
+        extras?: any;
+        extensions?: any;
+    });
+    /**
+     * Classes defined in the schema.
+     */
+    readonly classes: {
+        [key: string]: MetadataClass;
+    };
+    /**
+     * Enums defined in the schema.
+     */
+    readonly enums: {
+        [key: string]: MetadataEnum;
+    };
+    /**
+     * The ID of the schema.
+     */
+    readonly id: string;
+    /**
+     * The name of the schema.
+     */
+    readonly name: string;
+    /**
+     * The description of the schema.
+     */
+    readonly description: string;
+    /**
+     * The application-specific version of the schema.
+     */
+    readonly version: string;
+    /**
+     * Extra user-defined properties.
+     */
+    readonly extras: any;
+    /**
+     * An object containing extensions.
+     */
+    readonly extensions: any;
+}
+
+/**
+ * An enum of metadata types. These metadata types are containers containing
+one or more components of type {@link MetadataComponentType}
+ */
+export enum MetadataType {
+    /**
+     * A single component
+     */
+    SCALAR = "SCALAR",
+    /**
+     * A vector with two components
+     */
+    VEC2 = "VEC2",
+    /**
+     * A vector with three components
+     */
+    VEC3 = "VEC3",
+    /**
+     * A vector with four components
+     */
+    VEC4 = "VEC4",
+    /**
+     * A 2x2 matrix, stored in column-major format.
+     */
+    MAT2 = "MAT2",
+    /**
+     * A 3x3 matrix, stored in column-major format.
+     */
+    MAT3 = "MAT3",
+    /**
+     * A 4x4 matrix, stored in column-major format.
+     */
+    MAT4 = "MAT4",
+    /**
+     * A boolean (true/false) value
+     */
+    BOOLEAN = "BOOLEAN",
+    /**
+     * A UTF-8 encoded string value
+     */
+    STRING = "STRING",
+    /**
+     * An enumerated value. This type is used in conjunction with a {@link MetadataEnum} to describe the valid values.
+     */
+    ENUM = "ENUM"
+}
+
 /**
  * An object describing a uniform, its type, and an initial value
  * @property type - The Glsl type of the uniform.
@@ -35066,7 +35709,7 @@ See the {@link https://github.com/CesiumGS/cesium/tree/main/Documentation/Custom
   `,
   fragmentShaderText: `
   void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material) {
-    material.normal = texture2D(u_normalMap, fsInput.attributes.texCoord_0);
+    material.normal = texture(u_normalMap, fsInput.attributes.texCoord_0);
     material.diffuse = v_selectedColor;
   }
   `
@@ -35185,7 +35828,7 @@ export enum LightingModel {
     /**
      * Use unlit shading, i.e. skip lighting calculations. The model's
     diffuse color (assumed to be linear RGB, not sRGB) is used directly
-    when computing <code>gl_FragColor</code>. The alpha mode is still
+    when computing <code>out_FragColor</code>. The alpha mode is still
     applied.
      */
     UNLIT = 0,
@@ -35209,22 +35852,55 @@ Cesium supports glTF assets with the following extensions:
  {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/AGI_articulations/README.md|AGI_articulations}
  </li>
  <li>
+ {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline}
+ </li>
+ <li>
+ {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Vendor/CESIUM_RTC/README.md|CESIUM_RTC}
+ </li>
+ <li>
+ {@link https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_instance_features|EXT_instance_features}
+ </li>
+ <li>
+ {@link https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_mesh_features|EXT_mesh_features}
+ </li>
+ <li>
+ {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_mesh_gpu_instancing|EXT_mesh_gpu_instancing}
+ </li>
+ <li>
+ {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_meshopt_compression|EXT_meshopt_compression}
+ </li>
+ <li>
+ {@link https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata|EXT_structural_metadata}
+ </li>
+ <li>
+ {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_texture_webp|EXT_texture_webp}
+ </li>
+ <li>
  {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md|KHR_draco_mesh_compression}
  </li>
  <li>
- {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness/README.md|KHR_materials_pbrSpecularGlossiness}
+ {@link https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Archived/KHR_techniques_webgl/README.md|KHR_techniques_webgl}
+ </li>
+ <li>
+ {@link https://github.com/KhronosGroup/glTF/blob/main/extensions/1.0/Khronos/KHR_materials_common/README.md|KHR_materials_common}
+ </li>
+ <li>
+ {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Archived/KHR_materials_pbrSpecularGlossiness|KHR_materials_pbrSpecularGlossiness}
  </li>
  <li>
  {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit/README.md|KHR_materials_unlit}
  </li>
  <li>
- {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_transform/README.md|KHR_texture_transform}
+ {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_mesh_quantization|KHR_mesh_quantization}
  </li>
  <li>
  {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_basisu|KHR_texture_basisu}
  </li>
  <li>
- {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Vendor/CESIUM_RTC/README.md|CESIUM_RTC}
+ {@link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_texture_transform/README.md|KHR_texture_transform}
+ </li>
+ <li>
+ {@link https://github.com/KhronosGroup/glTF/blob/main/extensions/1.0/Vendor/WEB3D_quantized_attributes/README.md|WEB3D_quantized_attributes}
  </li>
 </ul>
 </p>
@@ -37573,12 +38249,12 @@ export class PolylineMaterialAppearance {
  * // Simple stage to change the color
 const fs =`
     uniform sampler2D colorTexture;
-    varying vec2 v_textureCoordinates;
+    in vec2 v_textureCoordinates;
     uniform float scale;
     uniform vec3 offset;
     void main() {
-        vec4 color = texture2D(colorTexture, v_textureCoordinates);
-        gl_FragColor = vec4(color.rgb * scale + offset, 1.0);
+        vec4 color = texture(colorTexture, v_textureCoordinates);
+        out_FragColor = vec4(color.rgb * scale + offset, 1.0);
     }`;
 scene.postProcessStages.add(new Cesium.PostProcessStage({
     fragmentShader : fs,
@@ -37594,15 +38270,15 @@ scene.postProcessStages.add(new Cesium.PostProcessStage({
 // If czm_selected returns true, the current fragment belongs to geometry in the selected array.
 const fs =`
     uniform sampler2D colorTexture;
-    varying vec2 v_textureCoordinates;
+    in vec2 v_textureCoordinates;
     uniform vec4 highlight;
     void main() {
-        vec4 color = texture2D(colorTexture, v_textureCoordinates);
+        vec4 color = texture(colorTexture, v_textureCoordinates);
         if (czm_selected()) {
             vec3 highlighted = highlight.a * highlight.rgb + (1.0 - highlight.a) * color.rgb;
-            gl_FragColor = vec4(highlighted, 1.0);
+            out_FragColor = vec4(highlighted, 1.0);
         } else {
-            gl_FragColor = color;
+            out_FragColor = color;
         }
     }`;
 const stage = scene.postProcessStages.add(new Cesium.PostProcessStage({
@@ -37717,7 +38393,7 @@ export class PostProcessStage {
     if (czm_selected(v_textureCoordinates)) {
         // apply post-process stage
     } else {
-        gl_FragColor = texture2D(colorTexture, v_textureCoordinates);
+        out_FragColor = texture(colorTexture, v_textureCoordinates);
     }
     </code>
     </p>
@@ -38592,43 +39268,6 @@ export class PrimitiveCollection {
 /**
  * The container for all 3D graphical objects and state in a Cesium virtual scene.  Generally,
 a scene is not created directly; instead, it is implicitly created by {@link CesiumWidget}.
-<p>
-<em><code>contextOptions</code> parameter details:</em>
-</p>
-<p>
-The default values are:
-<code>
-{
-  webgl : {
-    alpha : false,
-    depth : true,
-    stencil : false,
-    antialias : true,
-    powerPreference: 'high-performance',
-    premultipliedAlpha : true,
-    preserveDrawingBuffer : false,
-    failIfMajorPerformanceCaveat : false
-  },
-  allowTextureFilterAnisotropic : true
-}
-</code>
-</p>
-<p>
-The <code>webgl</code> property corresponds to the {@link http://www.khronos.org/registry/webgl/specs/latest/#5.2|WebGLContextAttributes}
-object used to create the WebGL context.
-</p>
-<p>
-<code>webgl.alpha</code> defaults to false, which can improve performance compared to the standard WebGL default
-of true.  If an application needs to composite Cesium above other HTML elements using alpha-blending, set
-<code>webgl.alpha</code> to true.
-</p>
-<p>
-The other <code>webgl</code> properties match the WebGL defaults for {@link http://www.khronos.org/registry/webgl/specs/latest/#5.2|WebGLContextAttributes}.
-</p>
-<p>
-<code>allowTextureFilterAnisotropic</code> defaults to true, which enables anisotropic texture filtering when the
-WebGL extension is supported.  Setting this to false will improve performance, but hurt visual quality, especially for horizon views.
-</p>
  * @example
  * // Create scene without anisotropic texture filtering
 const scene = new Cesium.Scene({
@@ -38639,7 +39278,7 @@ const scene = new Cesium.Scene({
 });
  * @param options - Object with the following properties:
  * @param options.canvas - The HTML canvas element to create the scene for.
- * @param [options.contextOptions] - Context and WebGL creation properties.  See details above.
+ * @param [options.contextOptions] - Context and WebGL creation properties.
  * @param [options.creditContainer] - The HTML element in which the credits will be displayed.
  * @param [options.creditViewport] - The HTML element in which to display the credit popup.  If not specified, the viewport will be a added as a sibling of the canvas.
  * @param [options.mapProjection = new GeographicProjection()] - The map projection to use in 2D and Columbus View modes.
@@ -38649,13 +39288,13 @@ const scene = new Cesium.Scene({
  * @param [options.mapMode2D = MapMode2D.INFINITE_SCROLL] - Determines if the 2D map is rotatable or can be scrolled infinitely in the horizontal direction.
  * @param [options.requestRenderMode = false] - If true, rendering a frame will only occur when needed as determined by changes within the scene. Enabling improves performance of the application, but requires using {@link Scene#requestRender} to render a new frame explicitly in this mode. This will be necessary in many cases after making changes to the scene in other parts of the API. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
  * @param [options.maximumRenderTimeChange = 0.0] - If requestRenderMode is true, this value defines the maximum change in simulation time allowed before a render is requested. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
- * @param [depthPlaneEllipsoidOffset = 0.0] - Adjust the DepthPlane to address rendering artefacts below ellipsoid zero elevation.
+ * @param [options.depthPlaneEllipsoidOffset = 0.0] - Adjust the DepthPlane to address rendering artefacts below ellipsoid zero elevation.
  * @param [options.msaaSamples = 1] - If provided, this value controls the rate of multisample antialiasing. Typical multisampling rates are 2, 4, and sometimes 8 samples per pixel. Higher sampling rates of MSAA may impact performance in exchange for improved visual quality. This value only applies to WebGL2 contexts that support multisample render targets.
  */
 export class Scene {
     constructor(options: {
         canvas: HTMLCanvasElement;
-        contextOptions?: any;
+        contextOptions?: ContextOptions;
         creditContainer?: Element;
         creditViewport?: Element;
         mapProjection?: MapProjection;
@@ -38665,8 +39304,9 @@ export class Scene {
         mapMode2D?: MapMode2D;
         requestRenderMode?: boolean;
         maximumRenderTimeChange?: number;
+        depthPlaneEllipsoidOffset?: number;
         msaaSamples?: number;
-    }, depthPlaneEllipsoidOffset?: number);
+    });
     /**
      * Exceptions occurring in <code>render</code> are always caught in order to raise the
     <code>renderError</code> event.  If this property is true, the error is rethrown
@@ -39085,7 +39725,7 @@ export class Scene {
     getCompressedTextureFormatSupported(format: string): boolean;
     /**
      * Update and render the scene. It is usually not necessary to call this function
-    directly because {@link CesiumWidget} or {@link Viewer} do it automatically.
+    directly because {@link CesiumWidget} will do it automatically.
      * @param [time] - The simulation time at which to render.
      */
     render(time?: JulianDate): void;
@@ -41016,6 +41656,285 @@ export class ViewportQuad {
     destroy(): void;
 }
 
+/**
+ * A primitive that renders voxel data from a {@link VoxelProvider}.
+ * @param [options] - Object with the following properties:
+ * @param [options.provider] - The voxel provider that supplies the primitive with tile data.
+ * @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.
+ */
+export class VoxelPrimitive {
+    constructor(options?: {
+        provider?: VoxelProvider;
+        modelMatrix?: Matrix4;
+        customShader?: CustomShader;
+        clock?: Clock;
+    });
+    /**
+     * Gets a value indicating whether or not the primitive is ready for use.
+     */
+    readonly ready: boolean;
+    /**
+     * Gets the promise that will be resolved when the primitive is ready for use.
+     */
+    readonly readyPromise: Promise<VoxelPrimitive>;
+    /**
+     * Gets the {@link VoxelProvider} associated with this primitive.
+     */
+    readonly provider: VoxelProvider;
+    /**
+     * Gets the bounding sphere.
+     */
+    readonly boundingSphere: BoundingSphere;
+    /**
+     * Gets the oriented bounding box.
+     */
+    readonly orientedBoundingBox: OrientedBoundingBox;
+    /**
+     * Gets the model matrix.
+     */
+    readonly modelMatrix: Matrix4;
+    /**
+     * Gets the shape type.
+     */
+    readonly shape: VoxelShapeType;
+    /**
+     * Gets the voxel dimensions.
+     */
+    readonly dimensions: Cartesian3;
+    /**
+     * Gets the minimum value per channel of the voxel data.
+     */
+    readonly minimumValues: number[][];
+    /**
+     * Gets the maximum value per channel of the voxel data.
+     */
+    readonly maximumValues: number[][];
+    /**
+     * Gets or sets whether or not this primitive should be displayed.
+     */
+    show: boolean;
+    /**
+     * Gets or sets whether or not the primitive should update when the view changes.
+     */
+    disableUpdate: boolean;
+    /**
+     * Gets or sets whether or not to render debug visualizations.
+     */
+    debugDraw: boolean;
+    /**
+     * Gets or sets whether or not to test against depth when rendering.
+     */
+    depthTest: boolean;
+    /**
+     * Gets or sets whether or not to jitter the view ray during the raymarch.
+    This reduces stair-step artifacts but introduces noise.
+     */
+    jitter: boolean;
+    /**
+     * Gets or sets the nearest sampling.
+     */
+    nearestSampling: boolean;
+    /**
+     * Gets or sets the screen space error in pixels. If the screen space size
+    of a voxel is greater than the screen space error, the tile is subdivided.
+    Lower screen space error corresponds with higher detail rendering, but could
+    result in worse performance and higher memory consumption.
+     */
+    screenSpaceError: number;
+    /**
+     * Gets or sets the step size multiplier used during raymarching.
+    The lower the value, the higher the rendering quality, but
+    also the worse the performance.
+     */
+    stepSize: number;
+    /**
+     * Gets or sets the minimum bounds in the shape's local coordinate system.
+    Voxel data is stretched or squashed to fit the bounds.
+     */
+    minBounds: Cartesian3;
+    /**
+     * Gets or sets the maximum bounds in the shape's local coordinate system.
+    Voxel data is stretched or squashed to fit the bounds.
+     */
+    maxBounds: Cartesian3;
+    /**
+     * Gets or sets the minimum clipping location in the shape's local coordinate system.
+    Any voxel content outside the range is clipped.
+     */
+    minClippingBounds: Cartesian3;
+    /**
+     * Gets or sets the maximum clipping location in the shape's local coordinate system.
+    Any voxel content outside the range is clipped.
+     */
+    maxClippingBounds: Cartesian3;
+    /**
+     * The {@link ClippingPlaneCollection} used to selectively disable rendering the primitive.
+     */
+    clippingPlanes: ClippingPlaneCollection;
+    /**
+     * Gets or sets the custom shader. If undefined, {@link VoxelPrimitive.DefaultCustomShader} is set.
+     */
+    customShader: CustomShader;
+    /**
+     * Gets an event that is raised whenever a custom shader is compiled.
+     */
+    readonly customShaderCompilationEvent: Event;
+    /**
+     * 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
+     * voxelPrimitive = voxelPrimitive && voxelPrimitive.destroy();
+     */
+    destroy(): void;
+}
+
+/**
+ * Provides voxel data. Intended to be used with {@link VoxelPrimitive}.
+This type describes an interface and is not intended to be instantiated directly.
+ */
+export class VoxelProvider {
+    constructor();
+    /**
+     * Gets a value indicating whether or not the provider is ready for use.
+     */
+    readonly ready: boolean;
+    /**
+     * Gets the promise that will be resolved when the provider is ready for use.
+     */
+    readonly readyPromise: Promise<VoxelProvider>;
+    /**
+     * A transform from local space to global space. If undefined, the identity matrix will be used instead.
+     */
+    readonly globalTransform: Matrix4 | undefined;
+    /**
+     * A transform from shape space to local space. If undefined, the identity matrix will be used instead.
+     */
+    readonly shapeTransform: Matrix4 | undefined;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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 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.
+     */
+    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.
+     * @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.
+     */
+    requestData(options?: {
+        tileLevel?: number;
+        tileX?: number;
+        tileY?: number;
+        tileZ?: number;
+    }): Promise<any[][]> | 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.
+ */
+export const shaderMaximumIntersectionsLength: number;
+
+/**
+ * An enum of voxel shapes. The shape controls how the voxel grid is mapped to 3D space.
+ */
+export enum VoxelShapeType {
+    /**
+     * A box shape.
+     */
+    BOX = "BOX",
+    /**
+     * An ellipsoid shape.
+     */
+    ELLIPSOID = "ELLIPSOID",
+    /**
+     * A cylinder shape.
+     */
+    CYLINDER = "CYLINDER"
+}
+
 /**
  * EPSG codes known to include reverse axis orders, but are not within 4000-5000.
  */
@@ -41563,6 +42482,197 @@ export class WebMapTileServiceImageryProvider {
     pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): undefined;
 }
 
+/**
+ * A widget containing a Cesium scene.
+ * @example
+ * // For each example, include a link to CesiumWidget.css stylesheet in HTML head,
+// and in the body, include: <div id="cesiumContainer"></div>
+
+//Widget with no terrain and default Bing Maps imagery provider.
+const widget = new Cesium.CesiumWidget('cesiumContainer');
+
+//Widget with ion imagery and Cesium World Terrain.
+const widget2 = new Cesium.CesiumWidget('cesiumContainer', {
+    imageryProvider : Cesium.createWorldImagery(),
+    terrainProvider : Cesium.createWorldTerrain(),
+    skyBox : new Cesium.SkyBox({
+        sources : {
+          positiveX : 'stars/TychoSkymapII.t3_08192x04096_80_px.jpg',
+          negativeX : 'stars/TychoSkymapII.t3_08192x04096_80_mx.jpg',
+          positiveY : 'stars/TychoSkymapII.t3_08192x04096_80_py.jpg',
+          negativeY : 'stars/TychoSkymapII.t3_08192x04096_80_my.jpg',
+          positiveZ : 'stars/TychoSkymapII.t3_08192x04096_80_pz.jpg',
+          negativeZ : 'stars/TychoSkymapII.t3_08192x04096_80_mz.jpg'
+        }
+    }),
+    // Show Columbus View map with Web Mercator projection
+    sceneMode : Cesium.SceneMode.COLUMBUS_VIEW,
+    mapProjection : new Cesium.WebMercatorProjection()
+});
+ * @param container - The DOM element or ID that will contain the widget.
+ * @param [options] - Object with the following properties:
+ * @param [options.clock = new Clock()] - The clock to use to control current time.
+ * @param [options.imageryProvider = createWorldImagery()] - The imagery provider to serve as the base layer. If set to <code>false</code>, no imagery provider will be added.
+ * @param [options.terrainProvider = new EllipsoidTerrainProvider] - The terrain provider.
+ * @param [options.skyBox] - The skybox used to render the stars.  When <code>undefined</code>, the default stars are used. If set to <code>false</code>, no skyBox, Sun, or Moon will be added.
+ * @param [options.skyAtmosphere] - Blue sky, and the glow around the Earth's limb.  Set to <code>false</code> to turn it off.
+ * @param [options.sceneMode = SceneMode.SCENE3D] - The initial scene mode.
+ * @param [options.scene3DOnly = false] - When <code>true</code>, each geometry instance will only be rendered in 3D to save GPU memory.
+ * @param [options.orderIndependentTranslucency = true] - If true and the configuration supports it, use order independent translucency.
+ * @param [options.mapProjection = new GeographicProjection()] - The map projection to use in 2D and Columbus View modes.
+ * @param [options.globe = new Globe(mapProjection.ellipsoid)] - The globe to use in the scene.  If set to <code>false</code>, no globe will be added.
+ * @param [options.useDefaultRenderLoop = true] - True if this widget should control the render loop, false otherwise.
+ * @param [options.useBrowserRecommendedResolution = true] - If true, render at the browser's recommended resolution and ignore <code>window.devicePixelRatio</code>.
+ * @param [options.targetFrameRate] - The target frame rate when using the default render loop.
+ * @param [options.showRenderLoopErrors = true] - If true, this widget will automatically display an HTML panel to the user containing the error, if a render loop error occurs.
+ * @param [options.contextOptions] - Context and WebGL creation properties passed to {@link Scene}.
+ * @param [options.creditContainer] - The DOM element or ID that will contain the {@link CreditDisplay}.  If not specified, the credits are added
+       to the bottom of the widget itself.
+ * @param [options.creditViewport] - The DOM element or ID that will contain the credit pop up created by the {@link CreditDisplay}.  If not specified, it will appear over the widget itself.
+ * @param [options.shadows = false] - Determines if shadows are cast by light sources.
+ * @param [options.terrainShadows = ShadowMode.RECEIVE_ONLY] - Determines if the terrain casts or receives shadows from light sources.
+ * @param [options.mapMode2D = MapMode2D.INFINITE_SCROLL] - Determines if the 2D map is rotatable or can be scrolled infinitely in the horizontal direction.
+ * @param [options.blurActiveElementOnCanvasFocus = true] - If true, the active element will blur when the viewer's canvas is clicked. Setting this to false is useful for cases when the canvas is clicked only for retrieving position or an entity data without actually meaning to set the canvas to be the active element.
+ * @param [options.requestRenderMode = false] - If true, rendering a frame will only occur when needed as determined by changes within the scene. Enabling improves performance of the application, but requires using {@link Scene#requestRender} to render a new frame explicitly in this mode. This will be necessary in many cases after making changes to the scene in other parts of the API. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
+ * @param [options.maximumRenderTimeChange = 0.0] - If requestRenderMode is true, this value defines the maximum change in simulation time allowed before a render is requested. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
+ * @param [options.msaaSamples = 1] - If provided, this value controls the rate of multisample antialiasing. Typical multisampling rates are 2, 4, and sometimes 8 samples per pixel. Higher sampling rates of MSAA may impact performance in exchange for improved visual quality. This value only applies to WebGL2 contexts that support multisample render targets.
+ */
+export class CesiumWidget {
+    constructor(container: Element | string, options?: {
+        clock?: Clock;
+        imageryProvider?: ImageryProvider | false;
+        terrainProvider?: TerrainProvider;
+        skyBox?: SkyBox | false;
+        skyAtmosphere?: SkyAtmosphere | false;
+        sceneMode?: SceneMode;
+        scene3DOnly?: boolean;
+        orderIndependentTranslucency?: boolean;
+        mapProjection?: MapProjection;
+        globe?: Globe | false;
+        useDefaultRenderLoop?: boolean;
+        useBrowserRecommendedResolution?: boolean;
+        targetFrameRate?: number;
+        showRenderLoopErrors?: boolean;
+        contextOptions?: ContextOptions;
+        creditContainer?: Element | string;
+        creditViewport?: Element | string;
+        shadows?: boolean;
+        terrainShadows?: ShadowMode;
+        mapMode2D?: MapMode2D;
+        blurActiveElementOnCanvasFocus?: boolean;
+        requestRenderMode?: boolean;
+        maximumRenderTimeChange?: number;
+        msaaSamples?: number;
+    });
+    /**
+     * Gets the parent container.
+     */
+    readonly container: Element;
+    /**
+     * Gets the canvas.
+     */
+    readonly canvas: HTMLCanvasElement;
+    /**
+     * Gets the credit container.
+     */
+    readonly creditContainer: Element;
+    /**
+     * Gets the credit viewport
+     */
+    readonly creditViewport: Element;
+    /**
+     * Gets the scene.
+     */
+    readonly scene: Scene;
+    /**
+     * Gets the collection of image layers that will be rendered on the globe.
+     */
+    readonly imageryLayers: ImageryLayerCollection;
+    /**
+     * The terrain provider providing surface geometry for the globe.
+     */
+    terrainProvider: TerrainProvider;
+    /**
+     * Gets the camera.
+     */
+    readonly camera: Camera;
+    /**
+     * Gets the clock.
+     */
+    readonly clock: Clock;
+    /**
+     * Gets the screen space event handler.
+     */
+    readonly screenSpaceEventHandler: ScreenSpaceEventHandler;
+    /**
+     * Gets or sets the target frame rate of the widget when <code>useDefaultRenderLoop</code>
+    is true. If undefined, the browser's requestAnimationFrame implementation
+    determines the frame rate.  If defined, this value must be greater than 0.  A value higher
+    than the underlying requestAnimationFrame implementation will have no effect.
+     */
+    targetFrameRate: number;
+    /**
+     * Gets or sets whether or not this widget should control the render loop.
+    If true the widget will use requestAnimationFrame to
+    perform rendering and resizing of the widget, as well as drive the
+    simulation clock. If set to false, you must manually call the
+    <code>resize</code>, <code>render</code> methods as part of a custom
+    render loop.  If an error occurs during rendering, {@link Scene}'s
+    <code>renderError</code> event will be raised and this property
+    will be set to false.  It must be set back to true to continue rendering
+    after the error.
+     */
+    useDefaultRenderLoop: boolean;
+    /**
+     * Gets or sets a scaling factor for rendering resolution.  Values less than 1.0 can improve
+    performance on less powerful devices while values greater than 1.0 will render at a higher
+    resolution and then scale down, resulting in improved visual fidelity.
+    For example, if the widget is laid out at a size of 640x480, setting this value to 0.5
+    will cause the scene to be rendered at 320x240 and then scaled up while setting
+    it to 2.0 will cause the scene to be rendered at 1280x960 and then scaled down.
+     */
+    resolutionScale: number;
+    /**
+     * Boolean flag indicating if the browser's recommended resolution is used.
+    If true, the browser's device pixel ratio is ignored and 1.0 is used instead,
+    effectively rendering based on CSS pixels instead of device pixels. This can improve
+    performance on less powerful devices that have high pixel density. When false, rendering
+    will be in device pixels. {@link CesiumWidget#resolutionScale} will still take effect whether
+    this flag is true or false.
+     */
+    useBrowserRecommendedResolution: boolean;
+    /**
+     * Show an error panel to the user containing a title and a longer error message,
+    which can be dismissed using an OK button.  This panel is displayed automatically
+    when a render loop error occurs, if showRenderLoopErrors was not false when the
+    widget was constructed.
+     * @param title - The title to be displayed on the error panel.  This string is interpreted as text.
+     * @param [message] - A helpful, user-facing message to display prior to the detailed error information.  This string is interpreted as HTML.
+     * @param [error] - The error to be displayed on the error panel.  This string is formatted using {@link formatError} and then displayed as text.
+     */
+    showErrorPanel(title: string, message?: string, error?: string): void;
+    /**
+     * @returns true if the object has been destroyed, false otherwise.
+     */
+    isDestroyed(): boolean;
+    /**
+     * Destroys the widget.  Should be called if permanently
+    removing the widget from layout.
+     */
+    destroy(): void;
+    /**
+     * Updates the canvas size, camera aspect ratio, and viewport size.
+    This function is called automatically as needed unless
+    <code>useDefaultRenderLoop</code> is set to false.
+     */
+    resize(): void;
+    /**
+     * Renders the scene.  This function is called automatically
+    unless <code>useDefaultRenderLoop</code> is set to false;
+     */
+    render(): void;
+}
+
 /**
  * <span style="display: block; text-align: center;">
 <img src="Images/AnimationWidget.png" width="211" height="142" alt="" />
@@ -42513,197 +43623,6 @@ export class CesiumInspectorViewModel {
     destroy(): void;
 }
 
-/**
- * A widget containing a Cesium scene.
- * @example
- * // For each example, include a link to CesiumWidget.css stylesheet in HTML head,
-// and in the body, include: <div id="cesiumContainer"></div>
-
-//Widget with no terrain and default Bing Maps imagery provider.
-const widget = new Cesium.CesiumWidget('cesiumContainer');
-
-//Widget with ion imagery and Cesium World Terrain.
-const widget2 = new Cesium.CesiumWidget('cesiumContainer', {
-    imageryProvider : Cesium.createWorldImagery(),
-    terrainProvider : Cesium.createWorldTerrain(),
-    skyBox : new Cesium.SkyBox({
-        sources : {
-          positiveX : 'stars/TychoSkymapII.t3_08192x04096_80_px.jpg',
-          negativeX : 'stars/TychoSkymapII.t3_08192x04096_80_mx.jpg',
-          positiveY : 'stars/TychoSkymapII.t3_08192x04096_80_py.jpg',
-          negativeY : 'stars/TychoSkymapII.t3_08192x04096_80_my.jpg',
-          positiveZ : 'stars/TychoSkymapII.t3_08192x04096_80_pz.jpg',
-          negativeZ : 'stars/TychoSkymapII.t3_08192x04096_80_mz.jpg'
-        }
-    }),
-    // Show Columbus View map with Web Mercator projection
-    sceneMode : Cesium.SceneMode.COLUMBUS_VIEW,
-    mapProjection : new Cesium.WebMercatorProjection()
-});
- * @param container - The DOM element or ID that will contain the widget.
- * @param [options] - Object with the following properties:
- * @param [options.clock = new Clock()] - The clock to use to control current time.
- * @param [options.imageryProvider = createWorldImagery()] - The imagery provider to serve as the base layer. If set to <code>false</code>, no imagery provider will be added.
- * @param [options.terrainProvider = new EllipsoidTerrainProvider] - The terrain provider.
- * @param [options.skyBox] - The skybox used to render the stars.  When <code>undefined</code>, the default stars are used. If set to <code>false</code>, no skyBox, Sun, or Moon will be added.
- * @param [options.skyAtmosphere] - Blue sky, and the glow around the Earth's limb.  Set to <code>false</code> to turn it off.
- * @param [options.sceneMode = SceneMode.SCENE3D] - The initial scene mode.
- * @param [options.scene3DOnly = false] - When <code>true</code>, each geometry instance will only be rendered in 3D to save GPU memory.
- * @param [options.orderIndependentTranslucency = true] - If true and the configuration supports it, use order independent translucency.
- * @param [options.mapProjection = new GeographicProjection()] - The map projection to use in 2D and Columbus View modes.
- * @param [options.globe = new Globe(mapProjection.ellipsoid)] - The globe to use in the scene.  If set to <code>false</code>, no globe will be added.
- * @param [options.useDefaultRenderLoop = true] - True if this widget should control the render loop, false otherwise.
- * @param [options.useBrowserRecommendedResolution = true] - If true, render at the browser's recommended resolution and ignore <code>window.devicePixelRatio</code>.
- * @param [options.targetFrameRate] - The target frame rate when using the default render loop.
- * @param [options.showRenderLoopErrors = true] - If true, this widget will automatically display an HTML panel to the user containing the error, if a render loop error occurs.
- * @param [options.contextOptions] - Context and WebGL creation properties corresponding to <code>options</code> passed to {@link Scene}.
- * @param [options.creditContainer] - The DOM element or ID that will contain the {@link CreditDisplay}.  If not specified, the credits are added
-       to the bottom of the widget itself.
- * @param [options.creditViewport] - The DOM element or ID that will contain the credit pop up created by the {@link CreditDisplay}.  If not specified, it will appear over the widget itself.
- * @param [options.shadows = false] - Determines if shadows are cast by light sources.
- * @param [options.terrainShadows = ShadowMode.RECEIVE_ONLY] - Determines if the terrain casts or receives shadows from light sources.
- * @param [options.mapMode2D = MapMode2D.INFINITE_SCROLL] - Determines if the 2D map is rotatable or can be scrolled infinitely in the horizontal direction.
- * @param [options.blurActiveElementOnCanvasFocus = true] - If true, the active element will blur when the viewer's canvas is clicked. Setting this to false is useful for cases when the canvas is clicked only for retrieving position or an entity data without actually meaning to set the canvas to be the active element.
- * @param [options.requestRenderMode = false] - If true, rendering a frame will only occur when needed as determined by changes within the scene. Enabling improves performance of the application, but requires using {@link Scene#requestRender} to render a new frame explicitly in this mode. This will be necessary in many cases after making changes to the scene in other parts of the API. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
- * @param [options.maximumRenderTimeChange = 0.0] - If requestRenderMode is true, this value defines the maximum change in simulation time allowed before a render is requested. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
- * @param [options.msaaSamples = 1] - If provided, this value controls the rate of multisample antialiasing. Typical multisampling rates are 2, 4, and sometimes 8 samples per pixel. Higher sampling rates of MSAA may impact performance in exchange for improved visual quality. This value only applies to WebGL2 contexts that support multisample render targets.
- */
-export class CesiumWidget {
-    constructor(container: Element | string, options?: {
-        clock?: Clock;
-        imageryProvider?: ImageryProvider | false;
-        terrainProvider?: TerrainProvider;
-        skyBox?: SkyBox | false;
-        skyAtmosphere?: SkyAtmosphere | false;
-        sceneMode?: SceneMode;
-        scene3DOnly?: boolean;
-        orderIndependentTranslucency?: boolean;
-        mapProjection?: MapProjection;
-        globe?: Globe | false;
-        useDefaultRenderLoop?: boolean;
-        useBrowserRecommendedResolution?: boolean;
-        targetFrameRate?: number;
-        showRenderLoopErrors?: boolean;
-        contextOptions?: any;
-        creditContainer?: Element | string;
-        creditViewport?: Element | string;
-        shadows?: boolean;
-        terrainShadows?: ShadowMode;
-        mapMode2D?: MapMode2D;
-        blurActiveElementOnCanvasFocus?: boolean;
-        requestRenderMode?: boolean;
-        maximumRenderTimeChange?: number;
-        msaaSamples?: number;
-    });
-    /**
-     * Gets the parent container.
-     */
-    readonly container: Element;
-    /**
-     * Gets the canvas.
-     */
-    readonly canvas: HTMLCanvasElement;
-    /**
-     * Gets the credit container.
-     */
-    readonly creditContainer: Element;
-    /**
-     * Gets the credit viewport
-     */
-    readonly creditViewport: Element;
-    /**
-     * Gets the scene.
-     */
-    readonly scene: Scene;
-    /**
-     * Gets the collection of image layers that will be rendered on the globe.
-     */
-    readonly imageryLayers: ImageryLayerCollection;
-    /**
-     * The terrain provider providing surface geometry for the globe.
-     */
-    terrainProvider: TerrainProvider;
-    /**
-     * Gets the camera.
-     */
-    readonly camera: Camera;
-    /**
-     * Gets the clock.
-     */
-    readonly clock: Clock;
-    /**
-     * Gets the screen space event handler.
-     */
-    readonly screenSpaceEventHandler: ScreenSpaceEventHandler;
-    /**
-     * Gets or sets the target frame rate of the widget when <code>useDefaultRenderLoop</code>
-    is true. If undefined, the browser's requestAnimationFrame implementation
-    determines the frame rate.  If defined, this value must be greater than 0.  A value higher
-    than the underlying requestAnimationFrame implementation will have no effect.
-     */
-    targetFrameRate: number;
-    /**
-     * Gets or sets whether or not this widget should control the render loop.
-    If true the widget will use requestAnimationFrame to
-    perform rendering and resizing of the widget, as well as drive the
-    simulation clock. If set to false, you must manually call the
-    <code>resize</code>, <code>render</code> methods as part of a custom
-    render loop.  If an error occurs during rendering, {@link Scene}'s
-    <code>renderError</code> event will be raised and this property
-    will be set to false.  It must be set back to true to continue rendering
-    after the error.
-     */
-    useDefaultRenderLoop: boolean;
-    /**
-     * Gets or sets a scaling factor for rendering resolution.  Values less than 1.0 can improve
-    performance on less powerful devices while values greater than 1.0 will render at a higher
-    resolution and then scale down, resulting in improved visual fidelity.
-    For example, if the widget is laid out at a size of 640x480, setting this value to 0.5
-    will cause the scene to be rendered at 320x240 and then scaled up while setting
-    it to 2.0 will cause the scene to be rendered at 1280x960 and then scaled down.
-     */
-    resolutionScale: number;
-    /**
-     * Boolean flag indicating if the browser's recommended resolution is used.
-    If true, the browser's device pixel ratio is ignored and 1.0 is used instead,
-    effectively rendering based on CSS pixels instead of device pixels. This can improve
-    performance on less powerful devices that have high pixel density. When false, rendering
-    will be in device pixels. {@link CesiumWidget#resolutionScale} will still take effect whether
-    this flag is true or false.
-     */
-    useBrowserRecommendedResolution: boolean;
-    /**
-     * Show an error panel to the user containing a title and a longer error message,
-    which can be dismissed using an OK button.  This panel is displayed automatically
-    when a render loop error occurs, if showRenderLoopErrors was not false when the
-    widget was constructed.
-     * @param title - The title to be displayed on the error panel.  This string is interpreted as text.
-     * @param [message] - A helpful, user-facing message to display prior to the detailed error information.  This string is interpreted as HTML.
-     * @param [error] - The error to be displayed on the error panel.  This string is formatted using {@link formatError} and then displayed as text.
-     */
-    showErrorPanel(title: string, message?: string, error?: string): void;
-    /**
-     * @returns true if the object has been destroyed, false otherwise.
-     */
-    isDestroyed(): boolean;
-    /**
-     * Destroys the widget.  Should be called if permanently
-    removing the widget from layout.
-     */
-    destroy(): void;
-    /**
-     * Updates the canvas size, camera aspect ratio, and viewport size.
-    This function is called automatically as needed unless
-    <code>useDefaultRenderLoop</code> is set to false.
-     */
-    resize(): void;
-    /**
-     * Renders the scene.  This function is called automatically
-    unless <code>useDefaultRenderLoop</code> is set to false;
-     */
-    render(): void;
-}
-
 /**
  * A view model which exposes a {@link Clock} for user interfaces.
  * @param [clock] - The clock object wrapped by this view model, if undefined a new instance will be created.
@@ -43683,7 +44602,7 @@ export namespace Viewer {
      * @property [showRenderLoopErrors = true] - If true, this widget will automatically display an HTML panel to the user containing the error, if a render loop error occurs.
      * @property [useBrowserRecommendedResolution = true] - If true, render at the browser's recommended resolution and ignore <code>window.devicePixelRatio</code>.
      * @property [automaticallyTrackDataSourceClocks = true] - If true, this widget will automatically track the clock settings of newly added DataSources, updating if the DataSource's clock changes.  Set this to false if you want to configure the clock independently.
-     * @property [contextOptions] - Context and WebGL creation properties corresponding to <code>options</code> passed to {@link Scene}.
+     * @property [contextOptions] - Context and WebGL creation properties passed to {@link Scene}.
      * @property [sceneMode = SceneMode.SCENE3D] - The initial scene mode.
      * @property [mapProjection = new GeographicProjection()] - The map projection to use in 2D and Columbus View modes.
      * @property [globe = new Globe(mapProjection.ellipsoid)] - The globe to use in the scene.  If set to <code>false</code>, no globe will be added.
@@ -43732,7 +44651,7 @@ export namespace Viewer {
         showRenderLoopErrors?: boolean;
         useBrowserRecommendedResolution?: boolean;
         automaticallyTrackDataSourceClocks?: boolean;
-        contextOptions?: any;
+        contextOptions?: ContextOptions;
         sceneMode?: SceneMode;
         mapProjection?: MapProjection;
         globe?: Globe | false;
@@ -44042,7 +44961,7 @@ export class Viewer {
      * @param [offset] - The offset from the center of the entity in the local east-north-up reference frame.
      * @returns A Promise that resolves to true if the zoom was successful or false if the target is not currently visualized in the scene or the zoom was cancelled.
      */
-    zoomTo(target: Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud | Promise<Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud>, offset?: HeadingPitchRange): Promise<boolean>;
+    zoomTo(target: Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud | Promise<Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud | VoxelPrimitive>, offset?: HeadingPitchRange): Promise<boolean>;
     /**
      * Flies the camera to the provided entity, entities, or data source.
     If the data source is still in the process of loading or the visualization is otherwise still loading,
@@ -44064,7 +44983,7 @@ export class Viewer {
      * @param [options.offset] - The offset from the target in the local east-north-up reference frame centered at the target.
      * @returns A Promise that resolves to true if the flight was successful or false if the target is not currently visualized in the scene or the flight was cancelled. //TODO: Cleanup entity mentions
      */
-    flyTo(target: Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud | Promise<Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud>, options?: {
+    flyTo(target: Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud | Promise<Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Cesium3DTileset | TimeDynamicPointCloud | VoxelPrimitive>, options?: {
         duration?: number;
         maximumHeight?: number;
         offset?: HeadingPitchRange;
@@ -44139,6 +45058,100 @@ export function viewerPerformanceWatchdogMixin(viewer: Viewer, options?: {
     lowFrameRateMessage?: string;
 }): void;
 
+/**
+ * A mixin which adds the {@link VoxelInspector} widget to the {@link Viewer} widget.
+Rather than being called directly, this function is normally passed as
+a parameter to {@link Viewer#extend}, as shown in the example below.
+ * @example
+ * var viewer = new Cesium.Viewer('cesiumContainer');
+viewer.extend(Cesium.viewerVoxelInspectorMixin);
+ * @param viewer - The viewer instance.
+ */
+export function viewerVoxelInspectorMixin(viewer: Viewer): void;
+
+/**
+ * Inspector widget to aid in debugging voxels
+ * @param container - The DOM element or ID that will contain the widget.
+ * @param scene - the Scene instance to use.
+ */
+export class VoxelInspector {
+    constructor(container: Element | string, scene: Scene);
+    /**
+     * Gets the parent container.
+     */
+    container: Element;
+    /**
+     * Gets the view model.
+     */
+    viewModel: VoxelInspectorViewModel;
+    /**
+     * @returns true if the object has been destroyed, false otherwise.
+     */
+    isDestroyed(): boolean;
+    /**
+     * Destroys the widget.  Should be called if permanently
+    removing the widget from layout.
+     */
+    destroy(): void;
+}
+
+/**
+ * The view model for {@link VoxelInspector}.
+ * @param scene - The scene instance to use.
+ */
+export class VoxelInspectorViewModel {
+    constructor(scene: Scene);
+    /**
+     * Gets the scene
+     */
+    readonly scene: Scene;
+    /**
+     * Gets or sets the primitive of the view model.
+     */
+    voxelPrimitive: VoxelPrimitive;
+    /**
+     * Toggles the inspector visibility
+     */
+    toggleInspector(): void;
+    /**
+     * Toggles the visibility of the display section
+     */
+    toggleDisplay(): void;
+    /**
+     * Toggles the visibility of the transform section
+     */
+    toggleTransform(): void;
+    /**
+     * Toggles the visibility of the bounds section
+     */
+    toggleBounds(): void;
+    /**
+     * Toggles the visibility of the clipping section
+     */
+    toggleClipping(): void;
+    /**
+     * Toggles the visibility of the shader section
+     */
+    toggleShader(): void;
+    /**
+     * Compiles the shader in the shader editor.
+     */
+    compileShader(): void;
+    /**
+     * Handles key press events on the shader editor.
+     */
+    shaderEditorKeyPress(): void;
+    /**
+     * @returns true if the object has been destroyed, false otherwise.
+     */
+    isDestroyed(): boolean;
+    /**
+     * Destroys the widget.  Should be called if permanently
+    removing the widget from layout.
+     */
+    destroy(): void;
+}
+
 /**
  * A single button widget for toggling vr mode.
  * @param container - The DOM element or ID that will contain the widget.
@@ -44210,432 +45223,3 @@ export class VRButtonViewModel {
 
 }
 
-declare module "cesium/Source/Core/ArcGISTiledElevationTerrainProvider" { import { ArcGISTiledElevationTerrainProvider } from 'mars3d-cesium'; export default ArcGISTiledElevationTerrainProvider; }
-declare module "cesium/Source/Core/AssociativeArray" { import { AssociativeArray } from 'mars3d-cesium'; export default AssociativeArray; }
-declare module "cesium/Source/Core/AxisAlignedBoundingBox" { import { AxisAlignedBoundingBox } from 'mars3d-cesium'; export default AxisAlignedBoundingBox; }
-declare module "cesium/Source/Core/barycentricCoordinates" { import { barycentricCoordinates } from 'mars3d-cesium'; export default barycentricCoordinates; }
-declare module "cesium/Source/Core/binarySearch" { import { binarySearch } from 'mars3d-cesium'; export default binarySearch; }
-declare module "cesium/Source/Core/BingMapsGeocoderService" { import { BingMapsGeocoderService } from 'mars3d-cesium'; export default BingMapsGeocoderService; }
-declare module "cesium/Source/Core/BoundingRectangle" { import { BoundingRectangle } from 'mars3d-cesium'; export default BoundingRectangle; }
-declare module "cesium/Source/Core/BoundingSphere" { import { BoundingSphere } from 'mars3d-cesium'; export default BoundingSphere; }
-declare module "cesium/Source/Core/BoxGeometry" { import { BoxGeometry } from 'mars3d-cesium'; export default BoxGeometry; }
-declare module "cesium/Source/Core/BoxOutlineGeometry" { import { BoxOutlineGeometry } from 'mars3d-cesium'; export default BoxOutlineGeometry; }
-declare module "cesium/Source/Core/buildModuleUrl" { import { buildModuleUrl } from 'mars3d-cesium'; export default buildModuleUrl; }
-declare module "cesium/Source/Core/cancelAnimationFrame" { import { cancelAnimationFrame } from 'mars3d-cesium'; export default cancelAnimationFrame; }
-declare module "cesium/Source/Core/Cartesian2" { import { Cartesian2 } from 'mars3d-cesium'; export default Cartesian2; }
-declare module "cesium/Source/Core/Cartesian3" { import { Cartesian3 } from 'mars3d-cesium'; export default Cartesian3; }
-declare module "cesium/Source/Core/Cartesian4" { import { Cartesian4 } from 'mars3d-cesium'; export default Cartesian4; }
-declare module "cesium/Source/Core/Cartographic" { import { Cartographic } from 'mars3d-cesium'; export default Cartographic; }
-declare module "cesium/Source/Core/CartographicGeocoderService" { import { CartographicGeocoderService } from 'mars3d-cesium'; export default CartographicGeocoderService; }
-declare module "cesium/Source/Core/CatmullRomSpline" { import { CatmullRomSpline } from 'mars3d-cesium'; export default CatmullRomSpline; }
-declare module "cesium/Source/Core/CesiumTerrainProvider" { import { CesiumTerrainProvider } from 'mars3d-cesium'; export default CesiumTerrainProvider; }
-declare module "cesium/Source/Core/CircleGeometry" { import { CircleGeometry } from 'mars3d-cesium'; export default CircleGeometry; }
-declare module "cesium/Source/Core/CircleOutlineGeometry" { import { CircleOutlineGeometry } from 'mars3d-cesium'; export default CircleOutlineGeometry; }
-declare module "cesium/Source/Core/Clock" { import { Clock } from 'mars3d-cesium'; export default Clock; }
-declare module "cesium/Source/Core/clone" { import { clone } from 'mars3d-cesium'; export default clone; }
-declare module "cesium/Source/Core/Color" { import { Color } from 'mars3d-cesium'; export default Color; }
-declare module "cesium/Source/Core/ColorGeometryInstanceAttribute" { import { ColorGeometryInstanceAttribute } from 'mars3d-cesium'; export default ColorGeometryInstanceAttribute; }
-declare module "cesium/Source/Core/combine" { import { combine } from 'mars3d-cesium'; export default combine; }
-declare module "cesium/Source/Core/CompressedTextureBuffer" { import { CompressedTextureBuffer } from 'mars3d-cesium'; export default CompressedTextureBuffer; }
-declare module "cesium/Source/Core/ConstantSpline" { import { ConstantSpline } from 'mars3d-cesium'; export default ConstantSpline; }
-declare module "cesium/Source/Core/CoplanarPolygonGeometry" { import { CoplanarPolygonGeometry } from 'mars3d-cesium'; export default CoplanarPolygonGeometry; }
-declare module "cesium/Source/Core/CoplanarPolygonOutlineGeometry" { import { CoplanarPolygonOutlineGeometry } from 'mars3d-cesium'; export default CoplanarPolygonOutlineGeometry; }
-declare module "cesium/Source/Core/CorridorGeometry" { import { CorridorGeometry } from 'mars3d-cesium'; export default CorridorGeometry; }
-declare module "cesium/Source/Core/CorridorOutlineGeometry" { import { CorridorOutlineGeometry } from 'mars3d-cesium'; export default CorridorOutlineGeometry; }
-declare module "cesium/Source/Core/createGuid" { import { createGuid } from 'mars3d-cesium'; export default createGuid; }
-declare module "cesium/Source/Core/createWorldTerrain" { import { createWorldTerrain } from 'mars3d-cesium'; export default createWorldTerrain; }
-declare module "cesium/Source/Core/Credit" { import { Credit } from 'mars3d-cesium'; export default Credit; }
-declare module "cesium/Source/Core/CubicRealPolynomial" { import { CubicRealPolynomial } from 'mars3d-cesium'; export default CubicRealPolynomial; }
-declare module "cesium/Source/Core/CullingVolume" { import { CullingVolume } from 'mars3d-cesium'; export default CullingVolume; }
-declare module "cesium/Source/Core/CustomHeightmapTerrainProvider" { import { CustomHeightmapTerrainProvider } from 'mars3d-cesium'; export default CustomHeightmapTerrainProvider; }
-declare module "cesium/Source/Core/CylinderGeometry" { import { CylinderGeometry } from 'mars3d-cesium'; export default CylinderGeometry; }
-declare module "cesium/Source/Core/CylinderOutlineGeometry" { import { CylinderOutlineGeometry } from 'mars3d-cesium'; export default CylinderOutlineGeometry; }
-declare module "cesium/Source/Core/DefaultProxy" { import { DefaultProxy } from 'mars3d-cesium'; export default DefaultProxy; }
-declare module "cesium/Source/Core/defaultValue" { import { defaultValue } from 'mars3d-cesium'; export default defaultValue; }
-declare module "cesium/Source/Core/defined" { import { defined } from 'mars3d-cesium'; export default defined; }
-declare module "cesium/Source/Core/destroyObject" { import { destroyObject } from 'mars3d-cesium'; export default destroyObject; }
-declare module "cesium/Source/Core/DeveloperError" { import { DeveloperError } from 'mars3d-cesium'; export default DeveloperError; }
-declare module "cesium/Source/Core/DistanceDisplayCondition" { import { DistanceDisplayCondition } from 'mars3d-cesium'; export default DistanceDisplayCondition; }
-declare module "cesium/Source/Core/DistanceDisplayConditionGeometryInstanceAttribute" { import { DistanceDisplayConditionGeometryInstanceAttribute } from 'mars3d-cesium'; export default DistanceDisplayConditionGeometryInstanceAttribute; }
-declare module "cesium/Source/Core/EasingFunction" { import { EasingFunction } from 'mars3d-cesium'; export default EasingFunction; }
-declare module "cesium/Source/Core/EllipseGeometry" { import { EllipseGeometry } from 'mars3d-cesium'; export default EllipseGeometry; }
-declare module "cesium/Source/Core/EllipseOutlineGeometry" { import { EllipseOutlineGeometry } from 'mars3d-cesium'; export default EllipseOutlineGeometry; }
-declare module "cesium/Source/Core/Ellipsoid" { import { Ellipsoid } from 'mars3d-cesium'; export default Ellipsoid; }
-declare module "cesium/Source/Core/EllipsoidGeodesic" { import { EllipsoidGeodesic } from 'mars3d-cesium'; export default EllipsoidGeodesic; }
-declare module "cesium/Source/Core/EllipsoidGeometry" { import { EllipsoidGeometry } from 'mars3d-cesium'; export default EllipsoidGeometry; }
-declare module "cesium/Source/Core/EllipsoidOutlineGeometry" { import { EllipsoidOutlineGeometry } from 'mars3d-cesium'; export default EllipsoidOutlineGeometry; }
-declare module "cesium/Source/Core/EllipsoidRhumbLine" { import { EllipsoidRhumbLine } from 'mars3d-cesium'; export default EllipsoidRhumbLine; }
-declare module "cesium/Source/Core/EllipsoidTangentPlane" { import { EllipsoidTangentPlane } from 'mars3d-cesium'; export default EllipsoidTangentPlane; }
-declare module "cesium/Source/Core/EllipsoidTerrainProvider" { import { EllipsoidTerrainProvider } from 'mars3d-cesium'; export default EllipsoidTerrainProvider; }
-declare module "cesium/Source/Core/Event" { import { Event } from 'mars3d-cesium'; export default Event; }
-declare module "cesium/Source/Core/EventHelper" { import { EventHelper } from 'mars3d-cesium'; export default EventHelper; }
-declare module "cesium/Source/Core/FeatureDetection" { import { FeatureDetection } from 'mars3d-cesium'; export default FeatureDetection; }
-declare module "cesium/Source/Core/formatError" { import { formatError } from 'mars3d-cesium'; export default formatError; }
-declare module "cesium/Source/Core/FrustumGeometry" { import { FrustumGeometry } from 'mars3d-cesium'; export default FrustumGeometry; }
-declare module "cesium/Source/Core/FrustumOutlineGeometry" { import { FrustumOutlineGeometry } from 'mars3d-cesium'; export default FrustumOutlineGeometry; }
-declare module "cesium/Source/Core/Fullscreen" { import { Fullscreen } from 'mars3d-cesium'; export default Fullscreen; }
-declare module "cesium/Source/Core/GeocoderService" { import { GeocoderService } from 'mars3d-cesium'; export default GeocoderService; }
-declare module "cesium/Source/Core/GeographicProjection" { import { GeographicProjection } from 'mars3d-cesium'; export default GeographicProjection; }
-declare module "cesium/Source/Core/GeographicTilingScheme" { import { GeographicTilingScheme } from 'mars3d-cesium'; export default GeographicTilingScheme; }
-declare module "cesium/Source/Core/Geometry" { import { Geometry } from 'mars3d-cesium'; export default Geometry; }
-declare module "cesium/Source/Core/GeometryAttribute" { import { GeometryAttribute } from 'mars3d-cesium'; export default GeometryAttribute; }
-declare module "cesium/Source/Core/GeometryAttributes" { import { GeometryAttributes } from 'mars3d-cesium'; export default GeometryAttributes; }
-declare module "cesium/Source/Core/GeometryFactory" { import { GeometryFactory } from 'mars3d-cesium'; export default GeometryFactory; }
-declare module "cesium/Source/Core/GeometryInstance" { import { GeometryInstance } from 'mars3d-cesium'; export default GeometryInstance; }
-declare module "cesium/Source/Core/GeometryInstanceAttribute" { import { GeometryInstanceAttribute } from 'mars3d-cesium'; export default GeometryInstanceAttribute; }
-declare module "cesium/Source/Core/GeometryPipeline" { import { GeometryPipeline } from 'mars3d-cesium'; export default GeometryPipeline; }
-declare module "cesium/Source/Core/getAbsoluteUri" { import { getAbsoluteUri } from 'mars3d-cesium'; export default getAbsoluteUri; }
-declare module "cesium/Source/Core/getBaseUri" { import { getBaseUri } from 'mars3d-cesium'; export default getBaseUri; }
-declare module "cesium/Source/Core/getExtensionFromUri" { import { getExtensionFromUri } from 'mars3d-cesium'; export default getExtensionFromUri; }
-declare module "cesium/Source/Core/getFilenameFromUri" { import { getFilenameFromUri } from 'mars3d-cesium'; export default getFilenameFromUri; }
-declare module "cesium/Source/Core/getImagePixels" { import { getImagePixels } from 'mars3d-cesium'; export default getImagePixels; }
-declare module "cesium/Source/Core/getTimestamp" { import { getTimestamp } from 'mars3d-cesium'; export default getTimestamp; }
-declare module "cesium/Source/Core/GoogleEarthEnterpriseMetadata" { import { GoogleEarthEnterpriseMetadata } from 'mars3d-cesium'; export default GoogleEarthEnterpriseMetadata; }
-declare module "cesium/Source/Core/GoogleEarthEnterpriseTerrainData" { import { GoogleEarthEnterpriseTerrainData } from 'mars3d-cesium'; export default GoogleEarthEnterpriseTerrainData; }
-declare module "cesium/Source/Core/GoogleEarthEnterpriseTerrainProvider" { import { GoogleEarthEnterpriseTerrainProvider } from 'mars3d-cesium'; export default GoogleEarthEnterpriseTerrainProvider; }
-declare module "cesium/Source/Core/GregorianDate" { import { GregorianDate } from 'mars3d-cesium'; export default GregorianDate; }
-declare module "cesium/Source/Core/GroundPolylineGeometry" { import { GroundPolylineGeometry } from 'mars3d-cesium'; export default GroundPolylineGeometry; }
-declare module "cesium/Source/Core/HeadingPitchRange" { import { HeadingPitchRange } from 'mars3d-cesium'; export default HeadingPitchRange; }
-declare module "cesium/Source/Core/HeadingPitchRoll" { import { HeadingPitchRoll } from 'mars3d-cesium'; export default HeadingPitchRoll; }
-declare module "cesium/Source/Core/HeightmapTerrainData" { import { HeightmapTerrainData } from 'mars3d-cesium'; export default HeightmapTerrainData; }
-declare module "cesium/Source/Core/HermitePolynomialApproximation" { import { HermitePolynomialApproximation } from 'mars3d-cesium'; export default HermitePolynomialApproximation; }
-declare module "cesium/Source/Core/HermiteSpline" { import { HermiteSpline } from 'mars3d-cesium'; export default HermiteSpline; }
-declare module "cesium/Source/Core/HilbertOrder" { import { HilbertOrder } from 'mars3d-cesium'; export default HilbertOrder; }
-declare module "cesium/Source/Core/InterpolationAlgorithm" { import { InterpolationAlgorithm } from 'mars3d-cesium'; export default InterpolationAlgorithm; }
-declare module "cesium/Source/Core/Intersections2D" { import { Intersections2D } from 'mars3d-cesium'; export default Intersections2D; }
-declare module "cesium/Source/Core/IntersectionTests" { import { IntersectionTests } from 'mars3d-cesium'; export default IntersectionTests; }
-declare module "cesium/Source/Core/Interval" { import { Interval } from 'mars3d-cesium'; export default Interval; }
-declare module "cesium/Source/Core/Ion" { import { Ion } from 'mars3d-cesium'; export default Ion; }
-declare module "cesium/Source/Core/IonGeocoderService" { import { IonGeocoderService } from 'mars3d-cesium'; export default IonGeocoderService; }
-declare module "cesium/Source/Core/IonResource" { import { IonResource } from 'mars3d-cesium'; export default IonResource; }
-declare module "cesium/Source/Core/isLeapYear" { import { isLeapYear } from 'mars3d-cesium'; export default isLeapYear; }
-declare module "cesium/Source/Core/Iso8601" { import { Iso8601 } from 'mars3d-cesium'; export default Iso8601; }
-declare module "cesium/Source/Core/JulianDate" { import { JulianDate } from 'mars3d-cesium'; export default JulianDate; }
-declare module "cesium/Source/Core/LagrangePolynomialApproximation" { import { LagrangePolynomialApproximation } from 'mars3d-cesium'; export default LagrangePolynomialApproximation; }
-declare module "cesium/Source/Core/LeapSecond" { import { LeapSecond } from 'mars3d-cesium'; export default LeapSecond; }
-declare module "cesium/Source/Core/LinearApproximation" { import { LinearApproximation } from 'mars3d-cesium'; export default LinearApproximation; }
-declare module "cesium/Source/Core/LinearSpline" { import { LinearSpline } from 'mars3d-cesium'; export default LinearSpline; }
-declare module "cesium/Source/Core/MapProjection" { import { MapProjection } from 'mars3d-cesium'; export default MapProjection; }
-declare module "cesium/Source/Core/Math" { import { Math } from 'mars3d-cesium'; export default Math; }
-declare module "cesium/Source/Core/Matrix2" { import { Matrix2 } from 'mars3d-cesium'; export default Matrix2; }
-declare module "cesium/Source/Core/Matrix3" { import { Matrix3 } from 'mars3d-cesium'; export default Matrix3; }
-declare module "cesium/Source/Core/Matrix4" { import { Matrix4 } from 'mars3d-cesium'; export default Matrix4; }
-declare module "cesium/Source/Core/mergeSort" { import { mergeSort } from 'mars3d-cesium'; export default mergeSort; }
-declare module "cesium/Source/Core/MorphWeightSpline" { import { MorphWeightSpline } from 'mars3d-cesium'; export default MorphWeightSpline; }
-declare module "cesium/Source/Core/NearFarScalar" { import { NearFarScalar } from 'mars3d-cesium'; export default NearFarScalar; }
-declare module "cesium/Source/Core/objectToQuery" { import { objectToQuery } from 'mars3d-cesium'; export default objectToQuery; }
-declare module "cesium/Source/Core/Occluder" { import { Occluder } from 'mars3d-cesium'; export default Occluder; }
-declare module "cesium/Source/Core/OpenCageGeocoderService" { import { OpenCageGeocoderService } from 'mars3d-cesium'; export default OpenCageGeocoderService; }
-declare module "cesium/Source/Core/OrientedBoundingBox" { import { OrientedBoundingBox } from 'mars3d-cesium'; export default OrientedBoundingBox; }
-declare module "cesium/Source/Core/OrthographicFrustum" { import { OrthographicFrustum } from 'mars3d-cesium'; export default OrthographicFrustum; }
-declare module "cesium/Source/Core/OrthographicOffCenterFrustum" { import { OrthographicOffCenterFrustum } from 'mars3d-cesium'; export default OrthographicOffCenterFrustum; }
-declare module "cesium/Source/Core/Packable" { import { Packable } from 'mars3d-cesium'; export default Packable; }
-declare module "cesium/Source/Core/PackableForInterpolation" { import { PackableForInterpolation } from 'mars3d-cesium'; export default PackableForInterpolation; }
-declare module "cesium/Source/Core/PeliasGeocoderService" { import { PeliasGeocoderService } from 'mars3d-cesium'; export default PeliasGeocoderService; }
-declare module "cesium/Source/Core/PerspectiveFrustum" { import { PerspectiveFrustum } from 'mars3d-cesium'; export default PerspectiveFrustum; }
-declare module "cesium/Source/Core/PerspectiveOffCenterFrustum" { import { PerspectiveOffCenterFrustum } from 'mars3d-cesium'; export default PerspectiveOffCenterFrustum; }
-declare module "cesium/Source/Core/PinBuilder" { import { PinBuilder } from 'mars3d-cesium'; export default PinBuilder; }
-declare module "cesium/Source/Core/Plane" { import { Plane } from 'mars3d-cesium'; export default Plane; }
-declare module "cesium/Source/Core/PlaneGeometry" { import { PlaneGeometry } from 'mars3d-cesium'; export default PlaneGeometry; }
-declare module "cesium/Source/Core/PlaneOutlineGeometry" { import { PlaneOutlineGeometry } from 'mars3d-cesium'; export default PlaneOutlineGeometry; }
-declare module "cesium/Source/Core/pointInsideTriangle" { import { pointInsideTriangle } from 'mars3d-cesium'; export default pointInsideTriangle; }
-declare module "cesium/Source/Core/PolygonGeometry" { import { PolygonGeometry } from 'mars3d-cesium'; export default PolygonGeometry; }
-declare module "cesium/Source/Core/PolygonHierarchy" { import { PolygonHierarchy } from 'mars3d-cesium'; export default PolygonHierarchy; }
-declare module "cesium/Source/Core/PolygonOutlineGeometry" { import { PolygonOutlineGeometry } from 'mars3d-cesium'; export default PolygonOutlineGeometry; }
-declare module "cesium/Source/Core/PolylineGeometry" { import { PolylineGeometry } from 'mars3d-cesium'; export default PolylineGeometry; }
-declare module "cesium/Source/Core/PolylineVolumeGeometry" { import { PolylineVolumeGeometry } from 'mars3d-cesium'; export default PolylineVolumeGeometry; }
-declare module "cesium/Source/Core/PolylineVolumeOutlineGeometry" { import { PolylineVolumeOutlineGeometry } from 'mars3d-cesium'; export default PolylineVolumeOutlineGeometry; }
-declare module "cesium/Source/Core/Proxy" { import { Proxy } from 'mars3d-cesium'; export default Proxy; }
-declare module "cesium/Source/Core/QuadraticRealPolynomial" { import { QuadraticRealPolynomial } from 'mars3d-cesium'; export default QuadraticRealPolynomial; }
-declare module "cesium/Source/Core/QuantizedMeshTerrainData" { import { QuantizedMeshTerrainData } from 'mars3d-cesium'; export default QuantizedMeshTerrainData; }
-declare module "cesium/Source/Core/QuarticRealPolynomial" { import { QuarticRealPolynomial } from 'mars3d-cesium'; export default QuarticRealPolynomial; }
-declare module "cesium/Source/Core/Quaternion" { import { Quaternion } from 'mars3d-cesium'; export default Quaternion; }
-declare module "cesium/Source/Core/QuaternionSpline" { import { QuaternionSpline } from 'mars3d-cesium'; export default QuaternionSpline; }
-declare module "cesium/Source/Core/queryToObject" { import { queryToObject } from 'mars3d-cesium'; export default queryToObject; }
-declare module "cesium/Source/Core/Queue" { import { Queue } from 'mars3d-cesium'; export default Queue; }
-declare module "cesium/Source/Core/Ray" { import { Ray } from 'mars3d-cesium'; export default Ray; }
-declare module "cesium/Source/Core/Rectangle" { import { Rectangle } from 'mars3d-cesium'; export default Rectangle; }
-declare module "cesium/Source/Core/RectangleGeometry" { import { RectangleGeometry } from 'mars3d-cesium'; export default RectangleGeometry; }
-declare module "cesium/Source/Core/RectangleOutlineGeometry" { import { RectangleOutlineGeometry } from 'mars3d-cesium'; export default RectangleOutlineGeometry; }
-declare module "cesium/Source/Core/Request" { import { Request } from 'mars3d-cesium'; export default Request; }
-declare module "cesium/Source/Core/requestAnimationFrame" { import { requestAnimationFrame } from 'mars3d-cesium'; export default requestAnimationFrame; }
-declare module "cesium/Source/Core/RequestErrorEvent" { import { RequestErrorEvent } from 'mars3d-cesium'; export default RequestErrorEvent; }
-declare module "cesium/Source/Core/RequestScheduler" { import { RequestScheduler } from 'mars3d-cesium'; export default RequestScheduler; }
-declare module "cesium/Source/Core/Resource" { import { Resource } from 'mars3d-cesium'; export default Resource; }
-declare module "cesium/Source/Core/RuntimeError" { import { RuntimeError } from 'mars3d-cesium'; export default RuntimeError; }
-declare module "cesium/Source/Core/sampleTerrain" { import { sampleTerrain } from 'mars3d-cesium'; export default sampleTerrain; }
-declare module "cesium/Source/Core/sampleTerrainMostDetailed" { import { sampleTerrainMostDetailed } from 'mars3d-cesium'; export default sampleTerrainMostDetailed; }
-declare module "cesium/Source/Core/ScreenSpaceEventHandler" { import { ScreenSpaceEventHandler } from 'mars3d-cesium'; export default ScreenSpaceEventHandler; }
-declare module "cesium/Source/Core/ShowGeometryInstanceAttribute" { import { ShowGeometryInstanceAttribute } from 'mars3d-cesium'; export default ShowGeometryInstanceAttribute; }
-declare module "cesium/Source/Core/Simon1994PlanetaryPositions" { import { Simon1994PlanetaryPositions } from 'mars3d-cesium'; export default Simon1994PlanetaryPositions; }
-declare module "cesium/Source/Core/SimplePolylineGeometry" { import { SimplePolylineGeometry } from 'mars3d-cesium'; export default SimplePolylineGeometry; }
-declare module "cesium/Source/Core/SphereGeometry" { import { SphereGeometry } from 'mars3d-cesium'; export default SphereGeometry; }
-declare module "cesium/Source/Core/SphereOutlineGeometry" { import { SphereOutlineGeometry } from 'mars3d-cesium'; export default SphereOutlineGeometry; }
-declare module "cesium/Source/Core/Spherical" { import { Spherical } from 'mars3d-cesium'; export default Spherical; }
-declare module "cesium/Source/Core/Spline" { import { Spline } from 'mars3d-cesium'; export default Spline; }
-declare module "cesium/Source/Core/SteppedSpline" { import { SteppedSpline } from 'mars3d-cesium'; export default SteppedSpline; }
-declare module "cesium/Source/Core/subdivideArray" { import { subdivideArray } from 'mars3d-cesium'; export default subdivideArray; }
-declare module "cesium/Source/Core/TaskProcessor" { import { TaskProcessor } from 'mars3d-cesium'; export default TaskProcessor; }
-declare module "cesium/Source/Core/TerrainData" { import { TerrainData } from 'mars3d-cesium'; export default TerrainData; }
-declare module "cesium/Source/Core/TerrainProvider" { import { TerrainProvider } from 'mars3d-cesium'; export default TerrainProvider; }
-declare module "cesium/Source/Core/TileAvailability" { import { TileAvailability } from 'mars3d-cesium'; export default TileAvailability; }
-declare module "cesium/Source/Core/TileProviderError" { import { TileProviderError } from 'mars3d-cesium'; export default TileProviderError; }
-declare module "cesium/Source/Core/TilingScheme" { import { TilingScheme } from 'mars3d-cesium'; export default TilingScheme; }
-declare module "cesium/Source/Core/TimeInterval" { import { TimeInterval } from 'mars3d-cesium'; export default TimeInterval; }
-declare module "cesium/Source/Core/TimeIntervalCollection" { import { TimeIntervalCollection } from 'mars3d-cesium'; export default TimeIntervalCollection; }
-declare module "cesium/Source/Core/Transforms" { import { Transforms } from 'mars3d-cesium'; export default Transforms; }
-declare module "cesium/Source/Core/TranslationRotationScale" { import { TranslationRotationScale } from 'mars3d-cesium'; export default TranslationRotationScale; }
-declare module "cesium/Source/Core/TridiagonalSystemSolver" { import { TridiagonalSystemSolver } from 'mars3d-cesium'; export default TridiagonalSystemSolver; }
-declare module "cesium/Source/Core/TrustedServers" { import { TrustedServers } from 'mars3d-cesium'; export default TrustedServers; }
-declare module "cesium/Source/Core/VertexFormat" { import { VertexFormat } from 'mars3d-cesium'; export default VertexFormat; }
-declare module "cesium/Source/Core/VideoSynchronizer" { import { VideoSynchronizer } from 'mars3d-cesium'; export default VideoSynchronizer; }
-declare module "cesium/Source/Core/VRTheWorldTerrainProvider" { import { VRTheWorldTerrainProvider } from 'mars3d-cesium'; export default VRTheWorldTerrainProvider; }
-declare module "cesium/Source/Core/WallGeometry" { import { WallGeometry } from 'mars3d-cesium'; export default WallGeometry; }
-declare module "cesium/Source/Core/WallOutlineGeometry" { import { WallOutlineGeometry } from 'mars3d-cesium'; export default WallOutlineGeometry; }
-declare module "cesium/Source/Core/WebMercatorProjection" { import { WebMercatorProjection } from 'mars3d-cesium'; export default WebMercatorProjection; }
-declare module "cesium/Source/Core/WebMercatorTilingScheme" { import { WebMercatorTilingScheme } from 'mars3d-cesium'; export default WebMercatorTilingScheme; }
-declare module "cesium/Source/Core/writeTextToCanvas" { import { writeTextToCanvas } from 'mars3d-cesium'; export default writeTextToCanvas; }
-declare module "cesium/Source/DataSources/BillboardGraphics" { import { BillboardGraphics } from 'mars3d-cesium'; export default BillboardGraphics; }
-declare module "cesium/Source/DataSources/BillboardVisualizer" { import { BillboardVisualizer } from 'mars3d-cesium'; export default BillboardVisualizer; }
-declare module "cesium/Source/DataSources/BoxGeometryUpdater" { import { BoxGeometryUpdater } from 'mars3d-cesium'; export default BoxGeometryUpdater; }
-declare module "cesium/Source/DataSources/BoxGraphics" { import { BoxGraphics } from 'mars3d-cesium'; export default BoxGraphics; }
-declare module "cesium/Source/DataSources/CallbackProperty" { import { CallbackProperty } from 'mars3d-cesium'; export default CallbackProperty; }
-declare module "cesium/Source/DataSources/Cesium3DTilesetGraphics" { import { Cesium3DTilesetGraphics } from 'mars3d-cesium'; export default Cesium3DTilesetGraphics; }
-declare module "cesium/Source/DataSources/Cesium3DTilesetVisualizer" { import { Cesium3DTilesetVisualizer } from 'mars3d-cesium'; export default Cesium3DTilesetVisualizer; }
-declare module "cesium/Source/DataSources/CheckerboardMaterialProperty" { import { CheckerboardMaterialProperty } from 'mars3d-cesium'; export default CheckerboardMaterialProperty; }
-declare module "cesium/Source/DataSources/ColorMaterialProperty" { import { ColorMaterialProperty } from 'mars3d-cesium'; export default ColorMaterialProperty; }
-declare module "cesium/Source/DataSources/CompositeEntityCollection" { import { CompositeEntityCollection } from 'mars3d-cesium'; export default CompositeEntityCollection; }
-declare module "cesium/Source/DataSources/CompositeMaterialProperty" { import { CompositeMaterialProperty } from 'mars3d-cesium'; export default CompositeMaterialProperty; }
-declare module "cesium/Source/DataSources/CompositePositionProperty" { import { CompositePositionProperty } from 'mars3d-cesium'; export default CompositePositionProperty; }
-declare module "cesium/Source/DataSources/CompositeProperty" { import { CompositeProperty } from 'mars3d-cesium'; export default CompositeProperty; }
-declare module "cesium/Source/DataSources/ConstantPositionProperty" { import { ConstantPositionProperty } from 'mars3d-cesium'; export default ConstantPositionProperty; }
-declare module "cesium/Source/DataSources/ConstantProperty" { import { ConstantProperty } from 'mars3d-cesium'; export default ConstantProperty; }
-declare module "cesium/Source/DataSources/CorridorGeometryUpdater" { import { CorridorGeometryUpdater } from 'mars3d-cesium'; export default CorridorGeometryUpdater; }
-declare module "cesium/Source/DataSources/CorridorGraphics" { import { CorridorGraphics } from 'mars3d-cesium'; export default CorridorGraphics; }
-declare module "cesium/Source/DataSources/CustomDataSource" { import { CustomDataSource } from 'mars3d-cesium'; export default CustomDataSource; }
-declare module "cesium/Source/DataSources/CylinderGeometryUpdater" { import { CylinderGeometryUpdater } from 'mars3d-cesium'; export default CylinderGeometryUpdater; }
-declare module "cesium/Source/DataSources/CylinderGraphics" { import { CylinderGraphics } from 'mars3d-cesium'; export default CylinderGraphics; }
-declare module "cesium/Source/DataSources/CzmlDataSource" { import { CzmlDataSource } from 'mars3d-cesium'; export default CzmlDataSource; }
-declare module "cesium/Source/DataSources/DataSource" { import { DataSource } from 'mars3d-cesium'; export default DataSource; }
-declare module "cesium/Source/DataSources/DataSourceClock" { import { DataSourceClock } from 'mars3d-cesium'; export default DataSourceClock; }
-declare module "cesium/Source/DataSources/DataSourceCollection" { import { DataSourceCollection } from 'mars3d-cesium'; export default DataSourceCollection; }
-declare module "cesium/Source/DataSources/DataSourceDisplay" { import { DataSourceDisplay } from 'mars3d-cesium'; export default DataSourceDisplay; }
-declare module "cesium/Source/DataSources/EllipseGeometryUpdater" { import { EllipseGeometryUpdater } from 'mars3d-cesium'; export default EllipseGeometryUpdater; }
-declare module "cesium/Source/DataSources/EllipseGraphics" { import { EllipseGraphics } from 'mars3d-cesium'; export default EllipseGraphics; }
-declare module "cesium/Source/DataSources/EllipsoidGeometryUpdater" { import { EllipsoidGeometryUpdater } from 'mars3d-cesium'; export default EllipsoidGeometryUpdater; }
-declare module "cesium/Source/DataSources/EllipsoidGraphics" { import { EllipsoidGraphics } from 'mars3d-cesium'; export default EllipsoidGraphics; }
-declare module "cesium/Source/DataSources/Entity" { import { Entity } from 'mars3d-cesium'; export default Entity; }
-declare module "cesium/Source/DataSources/EntityCluster" { import { EntityCluster } from 'mars3d-cesium'; export default EntityCluster; }
-declare module "cesium/Source/DataSources/EntityCollection" { import { EntityCollection } from 'mars3d-cesium'; export default EntityCollection; }
-declare module "cesium/Source/DataSources/EntityView" { import { EntityView } from 'mars3d-cesium'; export default EntityView; }
-declare module "cesium/Source/DataSources/exportKml" { import { exportKml } from 'mars3d-cesium'; export default exportKml; }
-declare module "cesium/Source/DataSources/GeoJsonDataSource" { import { GeoJsonDataSource } from 'mars3d-cesium'; export default GeoJsonDataSource; }
-declare module "cesium/Source/DataSources/GeometryUpdater" { import { GeometryUpdater } from 'mars3d-cesium'; export default GeometryUpdater; }
-declare module "cesium/Source/DataSources/GeometryVisualizer" { import { GeometryVisualizer } from 'mars3d-cesium'; export default GeometryVisualizer; }
-declare module "cesium/Source/DataSources/GpxDataSource" { import { GpxDataSource } from 'mars3d-cesium'; export default GpxDataSource; }
-declare module "cesium/Source/DataSources/GridMaterialProperty" { import { GridMaterialProperty } from 'mars3d-cesium'; export default GridMaterialProperty; }
-declare module "cesium/Source/DataSources/GroundGeometryUpdater" { import { GroundGeometryUpdater } from 'mars3d-cesium'; export default GroundGeometryUpdater; }
-declare module "cesium/Source/DataSources/ImageMaterialProperty" { import { ImageMaterialProperty } from 'mars3d-cesium'; export default ImageMaterialProperty; }
-declare module "cesium/Source/DataSources/KmlCamera" { import { KmlCamera } from 'mars3d-cesium'; export default KmlCamera; }
-declare module "cesium/Source/DataSources/KmlDataSource" { import { KmlDataSource } from 'mars3d-cesium'; export default KmlDataSource; }
-declare module "cesium/Source/DataSources/KmlLookAt" { import { KmlLookAt } from 'mars3d-cesium'; export default KmlLookAt; }
-declare module "cesium/Source/DataSources/KmlTour" { import { KmlTour } from 'mars3d-cesium'; export default KmlTour; }
-declare module "cesium/Source/DataSources/KmlTourFlyTo" { import { KmlTourFlyTo } from 'mars3d-cesium'; export default KmlTourFlyTo; }
-declare module "cesium/Source/DataSources/KmlTourWait" { import { KmlTourWait } from 'mars3d-cesium'; export default KmlTourWait; }
-declare module "cesium/Source/DataSources/LabelGraphics" { import { LabelGraphics } from 'mars3d-cesium'; export default LabelGraphics; }
-declare module "cesium/Source/DataSources/LabelVisualizer" { import { LabelVisualizer } from 'mars3d-cesium'; export default LabelVisualizer; }
-declare module "cesium/Source/DataSources/MaterialProperty" { import { MaterialProperty } from 'mars3d-cesium'; export default MaterialProperty; }
-declare module "cesium/Source/DataSources/ModelGraphics" { import { ModelGraphics } from 'mars3d-cesium'; export default ModelGraphics; }
-declare module "cesium/Source/DataSources/ModelVisualizer" { import { ModelVisualizer } from 'mars3d-cesium'; export default ModelVisualizer; }
-declare module "cesium/Source/DataSources/NodeTransformationProperty" { import { NodeTransformationProperty } from 'mars3d-cesium'; export default NodeTransformationProperty; }
-declare module "cesium/Source/DataSources/PathGraphics" { import { PathGraphics } from 'mars3d-cesium'; export default PathGraphics; }
-declare module "cesium/Source/DataSources/PathVisualizer" { import { PathVisualizer } from 'mars3d-cesium'; export default PathVisualizer; }
-declare module "cesium/Source/DataSources/PlaneGeometryUpdater" { import { PlaneGeometryUpdater } from 'mars3d-cesium'; export default PlaneGeometryUpdater; }
-declare module "cesium/Source/DataSources/PlaneGraphics" { import { PlaneGraphics } from 'mars3d-cesium'; export default PlaneGraphics; }
-declare module "cesium/Source/DataSources/PointGraphics" { import { PointGraphics } from 'mars3d-cesium'; export default PointGraphics; }
-declare module "cesium/Source/DataSources/PointVisualizer" { import { PointVisualizer } from 'mars3d-cesium'; export default PointVisualizer; }
-declare module "cesium/Source/DataSources/PolygonGeometryUpdater" { import { PolygonGeometryUpdater } from 'mars3d-cesium'; export default PolygonGeometryUpdater; }
-declare module "cesium/Source/DataSources/PolygonGraphics" { import { PolygonGraphics } from 'mars3d-cesium'; export default PolygonGraphics; }
-declare module "cesium/Source/DataSources/PolylineArrowMaterialProperty" { import { PolylineArrowMaterialProperty } from 'mars3d-cesium'; export default PolylineArrowMaterialProperty; }
-declare module "cesium/Source/DataSources/PolylineDashMaterialProperty" { import { PolylineDashMaterialProperty } from 'mars3d-cesium'; export default PolylineDashMaterialProperty; }
-declare module "cesium/Source/DataSources/PolylineGeometryUpdater" { import { PolylineGeometryUpdater } from 'mars3d-cesium'; export default PolylineGeometryUpdater; }
-declare module "cesium/Source/DataSources/PolylineGlowMaterialProperty" { import { PolylineGlowMaterialProperty } from 'mars3d-cesium'; export default PolylineGlowMaterialProperty; }
-declare module "cesium/Source/DataSources/PolylineGraphics" { import { PolylineGraphics } from 'mars3d-cesium'; export default PolylineGraphics; }
-declare module "cesium/Source/DataSources/PolylineOutlineMaterialProperty" { import { PolylineOutlineMaterialProperty } from 'mars3d-cesium'; export default PolylineOutlineMaterialProperty; }
-declare module "cesium/Source/DataSources/PolylineVisualizer" { import { PolylineVisualizer } from 'mars3d-cesium'; export default PolylineVisualizer; }
-declare module "cesium/Source/DataSources/PolylineVolumeGeometryUpdater" { import { PolylineVolumeGeometryUpdater } from 'mars3d-cesium'; export default PolylineVolumeGeometryUpdater; }
-declare module "cesium/Source/DataSources/PolylineVolumeGraphics" { import { PolylineVolumeGraphics } from 'mars3d-cesium'; export default PolylineVolumeGraphics; }
-declare module "cesium/Source/DataSources/PositionProperty" { import { PositionProperty } from 'mars3d-cesium'; export default PositionProperty; }
-declare module "cesium/Source/DataSources/PositionPropertyArray" { import { PositionPropertyArray } from 'mars3d-cesium'; export default PositionPropertyArray; }
-declare module "cesium/Source/DataSources/Property" { import { Property } from 'mars3d-cesium'; export default Property; }
-declare module "cesium/Source/DataSources/PropertyArray" { import { PropertyArray } from 'mars3d-cesium'; export default PropertyArray; }
-declare module "cesium/Source/DataSources/PropertyBag" { import { PropertyBag } from 'mars3d-cesium'; export default PropertyBag; }
-declare module "cesium/Source/DataSources/RectangleGeometryUpdater" { import { RectangleGeometryUpdater } from 'mars3d-cesium'; export default RectangleGeometryUpdater; }
-declare module "cesium/Source/DataSources/RectangleGraphics" { import { RectangleGraphics } from 'mars3d-cesium'; export default RectangleGraphics; }
-declare module "cesium/Source/DataSources/ReferenceProperty" { import { ReferenceProperty } from 'mars3d-cesium'; export default ReferenceProperty; }
-declare module "cesium/Source/DataSources/Rotation" { import { Rotation } from 'mars3d-cesium'; export default Rotation; }
-declare module "cesium/Source/DataSources/SampledPositionProperty" { import { SampledPositionProperty } from 'mars3d-cesium'; export default SampledPositionProperty; }
-declare module "cesium/Source/DataSources/SampledProperty" { import { SampledProperty } from 'mars3d-cesium'; export default SampledProperty; }
-declare module "cesium/Source/DataSources/StripeMaterialProperty" { import { StripeMaterialProperty } from 'mars3d-cesium'; export default StripeMaterialProperty; }
-declare module "cesium/Source/DataSources/TimeIntervalCollectionPositionProperty" { import { TimeIntervalCollectionPositionProperty } from 'mars3d-cesium'; export default TimeIntervalCollectionPositionProperty; }
-declare module "cesium/Source/DataSources/TimeIntervalCollectionProperty" { import { TimeIntervalCollectionProperty } from 'mars3d-cesium'; export default TimeIntervalCollectionProperty; }
-declare module "cesium/Source/DataSources/VelocityOrientationProperty" { import { VelocityOrientationProperty } from 'mars3d-cesium'; export default VelocityOrientationProperty; }
-declare module "cesium/Source/DataSources/VelocityVectorProperty" { import { VelocityVectorProperty } from 'mars3d-cesium'; export default VelocityVectorProperty; }
-declare module "cesium/Source/DataSources/Visualizer" { import { Visualizer } from 'mars3d-cesium'; export default Visualizer; }
-declare module "cesium/Source/DataSources/WallGeometryUpdater" { import { WallGeometryUpdater } from 'mars3d-cesium'; export default WallGeometryUpdater; }
-declare module "cesium/Source/DataSources/WallGraphics" { import { WallGraphics } from 'mars3d-cesium'; export default WallGraphics; }
-declare module "cesium/Source/Scene/Appearance" { import { Appearance } from 'mars3d-cesium'; export default Appearance; }
-declare module "cesium/Source/Scene/ArcGisMapServerImageryProvider" { import { ArcGisMapServerImageryProvider } from 'mars3d-cesium'; export default ArcGisMapServerImageryProvider; }
-declare module "cesium/Source/Scene/Billboard" { import { Billboard } from 'mars3d-cesium'; export default Billboard; }
-declare module "cesium/Source/Scene/BillboardCollection" { import { BillboardCollection } from 'mars3d-cesium'; export default BillboardCollection; }
-declare module "cesium/Source/Scene/BingMapsImageryProvider" { import { BingMapsImageryProvider } from 'mars3d-cesium'; export default BingMapsImageryProvider; }
-declare module "cesium/Source/Scene/BlendingState" { import { BlendingState } from 'mars3d-cesium'; export default BlendingState; }
-declare module "cesium/Source/Scene/BoxEmitter" { import { BoxEmitter } from 'mars3d-cesium'; export default BoxEmitter; }
-declare module "cesium/Source/Scene/Camera" { import { Camera } from 'mars3d-cesium'; export default Camera; }
-declare module "cesium/Source/Scene/CameraEventAggregator" { import { CameraEventAggregator } from 'mars3d-cesium'; export default CameraEventAggregator; }
-declare module "cesium/Source/Scene/Cesium3DTile" { import { Cesium3DTile } from 'mars3d-cesium'; export default Cesium3DTile; }
-declare module "cesium/Source/Scene/Cesium3DTileContent" { import { Cesium3DTileContent } from 'mars3d-cesium'; export default Cesium3DTileContent; }
-declare module "cesium/Source/Scene/Cesium3DTileFeature" { import { Cesium3DTileFeature } from 'mars3d-cesium'; export default Cesium3DTileFeature; }
-declare module "cesium/Source/Scene/Cesium3DTilePointFeature" { import { Cesium3DTilePointFeature } from 'mars3d-cesium'; export default Cesium3DTilePointFeature; }
-declare module "cesium/Source/Scene/Cesium3DTileset" { import { Cesium3DTileset } from 'mars3d-cesium'; export default Cesium3DTileset; }
-declare module "cesium/Source/Scene/Cesium3DTileStyle" { import { Cesium3DTileStyle } from 'mars3d-cesium'; export default Cesium3DTileStyle; }
-declare module "cesium/Source/Scene/CircleEmitter" { import { CircleEmitter } from 'mars3d-cesium'; export default CircleEmitter; }
-declare module "cesium/Source/Scene/ClassificationPrimitive" { import { ClassificationPrimitive } from 'mars3d-cesium'; export default ClassificationPrimitive; }
-declare module "cesium/Source/Scene/ClippingPlane" { import { ClippingPlane } from 'mars3d-cesium'; export default ClippingPlane; }
-declare module "cesium/Source/Scene/ClippingPlaneCollection" { import { ClippingPlaneCollection } from 'mars3d-cesium'; export default ClippingPlaneCollection; }
-declare module "cesium/Source/Scene/CloudCollection" { import { CloudCollection } from 'mars3d-cesium'; export default CloudCollection; }
-declare module "cesium/Source/Scene/ConditionsExpression" { import { ConditionsExpression } from 'mars3d-cesium'; export default ConditionsExpression; }
-declare module "cesium/Source/Scene/ConeEmitter" { import { ConeEmitter } from 'mars3d-cesium'; export default ConeEmitter; }
-declare module "cesium/Source/Scene/createElevationBandMaterial" { import { createElevationBandMaterial } from 'mars3d-cesium'; export default createElevationBandMaterial; }
-declare module "cesium/Source/Scene/createOsmBuildings" { import { createOsmBuildings } from 'mars3d-cesium'; export default createOsmBuildings; }
-declare module "cesium/Source/Scene/createTangentSpaceDebugPrimitive" { import { createTangentSpaceDebugPrimitive } from 'mars3d-cesium'; export default createTangentSpaceDebugPrimitive; }
-declare module "cesium/Source/Scene/createWorldImagery" { import { createWorldImagery } from 'mars3d-cesium'; export default createWorldImagery; }
-declare module "cesium/Source/Scene/CreditDisplay" { import { CreditDisplay } from 'mars3d-cesium'; export default CreditDisplay; }
-declare module "cesium/Source/Scene/CumulusCloud" { import { CumulusCloud } from 'mars3d-cesium'; export default CumulusCloud; }
-declare module "cesium/Source/Scene/DebugAppearance" { import { DebugAppearance } from 'mars3d-cesium'; export default DebugAppearance; }
-declare module "cesium/Source/Scene/DebugCameraPrimitive" { import { DebugCameraPrimitive } from 'mars3d-cesium'; export default DebugCameraPrimitive; }
-declare module "cesium/Source/Scene/DebugModelMatrixPrimitive" { import { DebugModelMatrixPrimitive } from 'mars3d-cesium'; export default DebugModelMatrixPrimitive; }
-declare module "cesium/Source/Scene/DirectionalLight" { import { DirectionalLight } from 'mars3d-cesium'; export default DirectionalLight; }
-declare module "cesium/Source/Scene/DiscardEmptyTileImagePolicy" { import { DiscardEmptyTileImagePolicy } from 'mars3d-cesium'; export default DiscardEmptyTileImagePolicy; }
-declare module "cesium/Source/Scene/DiscardMissingTileImagePolicy" { import { DiscardMissingTileImagePolicy } from 'mars3d-cesium'; export default DiscardMissingTileImagePolicy; }
-declare module "cesium/Source/Scene/EllipsoidSurfaceAppearance" { import { EllipsoidSurfaceAppearance } from 'mars3d-cesium'; export default EllipsoidSurfaceAppearance; }
-declare module "cesium/Source/Scene/Expression" { import { Expression } from 'mars3d-cesium'; export default Expression; }
-declare module "cesium/Source/Scene/Fog" { import { Fog } from 'mars3d-cesium'; export default Fog; }
-declare module "cesium/Source/Scene/FrameRateMonitor" { import { FrameRateMonitor } from 'mars3d-cesium'; export default FrameRateMonitor; }
-declare module "cesium/Source/Scene/GetFeatureInfoFormat" { import { GetFeatureInfoFormat } from 'mars3d-cesium'; export default GetFeatureInfoFormat; }
-declare module "cesium/Source/Scene/Globe" { import { Globe } from 'mars3d-cesium'; export default Globe; }
-declare module "cesium/Source/Scene/GlobeTranslucency" { import { GlobeTranslucency } from 'mars3d-cesium'; export default GlobeTranslucency; }
-declare module "cesium/Source/Scene/GoogleEarthEnterpriseImageryProvider" { import { GoogleEarthEnterpriseImageryProvider } from 'mars3d-cesium'; export default GoogleEarthEnterpriseImageryProvider; }
-declare module "cesium/Source/Scene/GoogleEarthEnterpriseMapsProvider" { import { GoogleEarthEnterpriseMapsProvider } from 'mars3d-cesium'; export default GoogleEarthEnterpriseMapsProvider; }
-declare module "cesium/Source/Scene/GridImageryProvider" { import { GridImageryProvider } from 'mars3d-cesium'; export default GridImageryProvider; }
-declare module "cesium/Source/Scene/GroundPolylinePrimitive" { import { GroundPolylinePrimitive } from 'mars3d-cesium'; export default GroundPolylinePrimitive; }
-declare module "cesium/Source/Scene/GroundPrimitive" { import { GroundPrimitive } from 'mars3d-cesium'; export default GroundPrimitive; }
-declare module "cesium/Source/Scene/I3SDataProvider" { import { I3SDataProvider } from 'mars3d-cesium'; export default I3SDataProvider; }
-declare module "cesium/Source/Scene/I3SFeature" { import { I3SFeature } from 'mars3d-cesium'; export default I3SFeature; }
-declare module "cesium/Source/Scene/I3SField" { import { I3SField } from 'mars3d-cesium'; export default I3SField; }
-declare module "cesium/Source/Scene/I3SGeometry" { import { I3SGeometry } from 'mars3d-cesium'; export default I3SGeometry; }
-declare module "cesium/Source/Scene/I3SLayer" { import { I3SLayer } from 'mars3d-cesium'; export default I3SLayer; }
-declare module "cesium/Source/Scene/I3SNode" { import { I3SNode } from 'mars3d-cesium'; export default I3SNode; }
-declare module "cesium/Source/Scene/ImageBasedLighting" { import { ImageBasedLighting } from 'mars3d-cesium'; export default ImageBasedLighting; }
-declare module "cesium/Source/Scene/ImageryLayer" { import { ImageryLayer } from 'mars3d-cesium'; export default ImageryLayer; }
-declare module "cesium/Source/Scene/ImageryLayerCollection" { import { ImageryLayerCollection } from 'mars3d-cesium'; export default ImageryLayerCollection; }
-declare module "cesium/Source/Scene/ImageryLayerFeatureInfo" { import { ImageryLayerFeatureInfo } from 'mars3d-cesium'; export default ImageryLayerFeatureInfo; }
-declare module "cesium/Source/Scene/ImageryProvider" { import { ImageryProvider } from 'mars3d-cesium'; export default ImageryProvider; }
-declare module "cesium/Source/Scene/IonImageryProvider" { import { IonImageryProvider } from 'mars3d-cesium'; export default IonImageryProvider; }
-declare module "cesium/Source/Scene/Label" { import { Label } from 'mars3d-cesium'; export default Label; }
-declare module "cesium/Source/Scene/LabelCollection" { import { LabelCollection } from 'mars3d-cesium'; export default LabelCollection; }
-declare module "cesium/Source/Scene/Light" { import { Light } from 'mars3d-cesium'; export default Light; }
-declare module "cesium/Source/Scene/MapboxImageryProvider" { import { MapboxImageryProvider } from 'mars3d-cesium'; export default MapboxImageryProvider; }
-declare module "cesium/Source/Scene/MapboxStyleImageryProvider" { import { MapboxStyleImageryProvider } from 'mars3d-cesium'; export default MapboxStyleImageryProvider; }
-declare module "cesium/Source/Scene/Material" { import { Material } from 'mars3d-cesium'; export default Material; }
-declare module "cesium/Source/Scene/MaterialAppearance" { import { MaterialAppearance } from 'mars3d-cesium'; export default MaterialAppearance; }
-declare module "cesium/Source/Scene/Moon" { import { Moon } from 'mars3d-cesium'; export default Moon; }
-declare module "cesium/Source/Scene/NeverTileDiscardPolicy" { import { NeverTileDiscardPolicy } from 'mars3d-cesium'; export default NeverTileDiscardPolicy; }
-declare module "cesium/Source/Scene/OpenStreetMapImageryProvider" { import { OpenStreetMapImageryProvider } from 'mars3d-cesium'; export default OpenStreetMapImageryProvider; }
-declare module "cesium/Source/Scene/Particle" { import { Particle } from 'mars3d-cesium'; export default Particle; }
-declare module "cesium/Source/Scene/ParticleBurst" { import { ParticleBurst } from 'mars3d-cesium'; export default ParticleBurst; }
-declare module "cesium/Source/Scene/ParticleEmitter" { import { ParticleEmitter } from 'mars3d-cesium'; export default ParticleEmitter; }
-declare module "cesium/Source/Scene/ParticleSystem" { import { ParticleSystem } from 'mars3d-cesium'; export default ParticleSystem; }
-declare module "cesium/Source/Scene/PerInstanceColorAppearance" { import { PerInstanceColorAppearance } from 'mars3d-cesium'; export default PerInstanceColorAppearance; }
-declare module "cesium/Source/Scene/PointCloudShading" { import { PointCloudShading } from 'mars3d-cesium'; export default PointCloudShading; }
-declare module "cesium/Source/Scene/PointPrimitive" { import { PointPrimitive } from 'mars3d-cesium'; export default PointPrimitive; }
-declare module "cesium/Source/Scene/PointPrimitiveCollection" { import { PointPrimitiveCollection } from 'mars3d-cesium'; export default PointPrimitiveCollection; }
-declare module "cesium/Source/Scene/Polyline" { import { Polyline } from 'mars3d-cesium'; export default Polyline; }
-declare module "cesium/Source/Scene/PolylineCollection" { import { PolylineCollection } from 'mars3d-cesium'; export default PolylineCollection; }
-declare module "cesium/Source/Scene/PolylineColorAppearance" { import { PolylineColorAppearance } from 'mars3d-cesium'; export default PolylineColorAppearance; }
-declare module "cesium/Source/Scene/PolylineMaterialAppearance" { import { PolylineMaterialAppearance } from 'mars3d-cesium'; export default PolylineMaterialAppearance; }
-declare module "cesium/Source/Scene/PostProcessStage" { import { PostProcessStage } from 'mars3d-cesium'; export default PostProcessStage; }
-declare module "cesium/Source/Scene/PostProcessStageCollection" { import { PostProcessStageCollection } from 'mars3d-cesium'; export default PostProcessStageCollection; }
-declare module "cesium/Source/Scene/PostProcessStageComposite" { import { PostProcessStageComposite } from 'mars3d-cesium'; export default PostProcessStageComposite; }
-declare module "cesium/Source/Scene/PostProcessStageLibrary" { import { PostProcessStageLibrary } from 'mars3d-cesium'; export default PostProcessStageLibrary; }
-declare module "cesium/Source/Scene/Primitive" { import { Primitive } from 'mars3d-cesium'; export default Primitive; }
-declare module "cesium/Source/Scene/PrimitiveCollection" { import { PrimitiveCollection } from 'mars3d-cesium'; export default PrimitiveCollection; }
-declare module "cesium/Source/Scene/Scene" { import { Scene } from 'mars3d-cesium'; export default Scene; }
-declare module "cesium/Source/Scene/SceneTransforms" { import { SceneTransforms } from 'mars3d-cesium'; export default SceneTransforms; }
-declare module "cesium/Source/Scene/ScreenSpaceCameraController" { import { ScreenSpaceCameraController } from 'mars3d-cesium'; export default ScreenSpaceCameraController; }
-declare module "cesium/Source/Scene/ShadowMap" { import { ShadowMap } from 'mars3d-cesium'; export default ShadowMap; }
-declare module "cesium/Source/Scene/SingleTileImageryProvider" { import { SingleTileImageryProvider } from 'mars3d-cesium'; export default SingleTileImageryProvider; }
-declare module "cesium/Source/Scene/SkyAtmosphere" { import { SkyAtmosphere } from 'mars3d-cesium'; export default SkyAtmosphere; }
-declare module "cesium/Source/Scene/SkyBox" { import { SkyBox } from 'mars3d-cesium'; export default SkyBox; }
-declare module "cesium/Source/Scene/SphereEmitter" { import { SphereEmitter } from 'mars3d-cesium'; export default SphereEmitter; }
-declare module "cesium/Source/Scene/StyleExpression" { import { StyleExpression } from 'mars3d-cesium'; export default StyleExpression; }
-declare module "cesium/Source/Scene/Sun" { import { Sun } from 'mars3d-cesium'; export default Sun; }
-declare module "cesium/Source/Scene/SunLight" { import { SunLight } from 'mars3d-cesium'; export default SunLight; }
-declare module "cesium/Source/Scene/TileCoordinatesImageryProvider" { import { TileCoordinatesImageryProvider } from 'mars3d-cesium'; export default TileCoordinatesImageryProvider; }
-declare module "cesium/Source/Scene/TileDiscardPolicy" { import { TileDiscardPolicy } from 'mars3d-cesium'; export default TileDiscardPolicy; }
-declare module "cesium/Source/Scene/TileMapServiceImageryProvider" { import { TileMapServiceImageryProvider } from 'mars3d-cesium'; export default TileMapServiceImageryProvider; }
-declare module "cesium/Source/Scene/TimeDynamicImagery" { import { TimeDynamicImagery } from 'mars3d-cesium'; export default TimeDynamicImagery; }
-declare module "cesium/Source/Scene/TimeDynamicPointCloud" { import { TimeDynamicPointCloud } from 'mars3d-cesium'; export default TimeDynamicPointCloud; }
-declare module "cesium/Source/Scene/UrlTemplateImageryProvider" { import { UrlTemplateImageryProvider } from 'mars3d-cesium'; export default UrlTemplateImageryProvider; }
-declare module "cesium/Source/Scene/ViewportQuad" { import { ViewportQuad } from 'mars3d-cesium'; export default ViewportQuad; }
-declare module "cesium/Source/Scene/WebMapServiceImageryProvider" { import { WebMapServiceImageryProvider } from 'mars3d-cesium'; export default WebMapServiceImageryProvider; }
-declare module "cesium/Source/Scene/WebMapTileServiceImageryProvider" { import { WebMapTileServiceImageryProvider } from 'mars3d-cesium'; export default WebMapTileServiceImageryProvider; }
-declare module "cesium/Source/Widgets/ClockViewModel" { import { ClockViewModel } from 'mars3d-cesium'; export default ClockViewModel; }
-declare module "cesium/Source/Widgets/Command" { import { Command } from 'mars3d-cesium'; export default Command; }
-declare module "cesium/Source/Widgets/createCommand" { import { createCommand } from 'mars3d-cesium'; export default createCommand; }
-declare module "cesium/Source/Widgets/SvgPathBindingHandler" { import { SvgPathBindingHandler } from 'mars3d-cesium'; export default SvgPathBindingHandler; }
-declare module "cesium/Source/Widgets/ToggleButtonViewModel" { import { ToggleButtonViewModel } from 'mars3d-cesium'; export default ToggleButtonViewModel; }
-declare module "cesium/Source/Scene/GltfPipeline/removeExtension" { import { removeExtension } from 'mars3d-cesium'; export default removeExtension; }
-declare module "cesium/Source/Scene/Model/CustomShader" { import { CustomShader } from 'mars3d-cesium'; export default CustomShader; }
-declare module "cesium/Source/Scene/Model/Model" { import { Model } from 'mars3d-cesium'; export default Model; }
-declare module "cesium/Source/Scene/Model/ModelAnimation" { import { ModelAnimation } from 'mars3d-cesium'; export default ModelAnimation; }
-declare module "cesium/Source/Scene/Model/ModelAnimationCollection" { import { ModelAnimationCollection } from 'mars3d-cesium'; export default ModelAnimationCollection; }
-declare module "cesium/Source/Scene/Model/ModelFeature" { import { ModelFeature } from 'mars3d-cesium'; export default ModelFeature; }
-declare module "cesium/Source/Scene/Model/ModelNode" { import { ModelNode } from 'mars3d-cesium'; export default ModelNode; }
-declare module "cesium/Source/Scene/Model/TextureUniform" { import { TextureUniform } from 'mars3d-cesium'; export default TextureUniform; }
-declare module "cesium/Source/Widgets/Animation/Animation" { import { Animation } from 'mars3d-cesium'; export default Animation; }
-declare module "cesium/Source/Widgets/Animation/AnimationViewModel" { import { AnimationViewModel } from 'mars3d-cesium'; export default AnimationViewModel; }
-declare module "cesium/Source/Widgets/BaseLayerPicker/BaseLayerPicker" { import { BaseLayerPicker } from 'mars3d-cesium'; export default BaseLayerPicker; }
-declare module "cesium/Source/Widgets/BaseLayerPicker/BaseLayerPickerViewModel" { import { BaseLayerPickerViewModel } from 'mars3d-cesium'; export default BaseLayerPickerViewModel; }
-declare module "cesium/Source/Widgets/BaseLayerPicker/ProviderViewModel" { import { ProviderViewModel } from 'mars3d-cesium'; export default ProviderViewModel; }
-declare module "cesium/Source/Widgets/Cesium3DTilesInspector/Cesium3DTilesInspector" { import { Cesium3DTilesInspector } from 'mars3d-cesium'; export default Cesium3DTilesInspector; }
-declare module "cesium/Source/Widgets/Cesium3DTilesInspector/Cesium3DTilesInspectorViewModel" { import { Cesium3DTilesInspectorViewModel } from 'mars3d-cesium'; export default Cesium3DTilesInspectorViewModel; }
-declare module "cesium/Source/Widgets/CesiumInspector/CesiumInspector" { import { CesiumInspector } from 'mars3d-cesium'; export default CesiumInspector; }
-declare module "cesium/Source/Widgets/CesiumInspector/CesiumInspectorViewModel" { import { CesiumInspectorViewModel } from 'mars3d-cesium'; export default CesiumInspectorViewModel; }
-declare module "cesium/Source/Widgets/CesiumWidget/CesiumWidget" { import { CesiumWidget } from 'mars3d-cesium'; export default CesiumWidget; }
-declare module "cesium/Source/Widgets/FullscreenButton/FullscreenButton" { import { FullscreenButton } from 'mars3d-cesium'; export default FullscreenButton; }
-declare module "cesium/Source/Widgets/FullscreenButton/FullscreenButtonViewModel" { import { FullscreenButtonViewModel } from 'mars3d-cesium'; export default FullscreenButtonViewModel; }
-declare module "cesium/Source/Widgets/Geocoder/Geocoder" { import { Geocoder } from 'mars3d-cesium'; export default Geocoder; }
-declare module "cesium/Source/Widgets/Geocoder/GeocoderViewModel" { import { GeocoderViewModel } from 'mars3d-cesium'; export default GeocoderViewModel; }
-declare module "cesium/Source/Widgets/HomeButton/HomeButton" { import { HomeButton } from 'mars3d-cesium'; export default HomeButton; }
-declare module "cesium/Source/Widgets/HomeButton/HomeButtonViewModel" { import { HomeButtonViewModel } from 'mars3d-cesium'; export default HomeButtonViewModel; }
-declare module "cesium/Source/Widgets/InfoBox/InfoBox" { import { InfoBox } from 'mars3d-cesium'; export default InfoBox; }
-declare module "cesium/Source/Widgets/InfoBox/InfoBoxViewModel" { import { InfoBoxViewModel } from 'mars3d-cesium'; export default InfoBoxViewModel; }
-declare module "cesium/Source/Widgets/NavigationHelpButton/NavigationHelpButton" { import { NavigationHelpButton } from 'mars3d-cesium'; export default NavigationHelpButton; }
-declare module "cesium/Source/Widgets/NavigationHelpButton/NavigationHelpButtonViewModel" { import { NavigationHelpButtonViewModel } from 'mars3d-cesium'; export default NavigationHelpButtonViewModel; }
-declare module "cesium/Source/Widgets/PerformanceWatchdog/PerformanceWatchdog" { import { PerformanceWatchdog } from 'mars3d-cesium'; export default PerformanceWatchdog; }
-declare module "cesium/Source/Widgets/PerformanceWatchdog/PerformanceWatchdogViewModel" { import { PerformanceWatchdogViewModel } from 'mars3d-cesium'; export default PerformanceWatchdogViewModel; }
-declare module "cesium/Source/Widgets/ProjectionPicker/ProjectionPicker" { import { ProjectionPicker } from 'mars3d-cesium'; export default ProjectionPicker; }
-declare module "cesium/Source/Widgets/ProjectionPicker/ProjectionPickerViewModel" { import { ProjectionPickerViewModel } from 'mars3d-cesium'; export default ProjectionPickerViewModel; }
-declare module "cesium/Source/Widgets/SceneModePicker/SceneModePicker" { import { SceneModePicker } from 'mars3d-cesium'; export default SceneModePicker; }
-declare module "cesium/Source/Widgets/SceneModePicker/SceneModePickerViewModel" { import { SceneModePickerViewModel } from 'mars3d-cesium'; export default SceneModePickerViewModel; }
-declare module "cesium/Source/Widgets/SelectionIndicator/SelectionIndicator" { import { SelectionIndicator } from 'mars3d-cesium'; export default SelectionIndicator; }
-declare module "cesium/Source/Widgets/SelectionIndicator/SelectionIndicatorViewModel" { import { SelectionIndicatorViewModel } from 'mars3d-cesium'; export default SelectionIndicatorViewModel; }
-declare module "cesium/Source/Widgets/Timeline/Timeline" { import { Timeline } from 'mars3d-cesium'; export default Timeline; }
-declare module "cesium/Source/Widgets/Viewer/Viewer" { import { Viewer } from 'mars3d-cesium'; export default Viewer; }
-declare module "cesium/Source/Widgets/Viewer/viewerCesium3DTilesInspectorMixin" { import { viewerCesium3DTilesInspectorMixin } from 'mars3d-cesium'; export default viewerCesium3DTilesInspectorMixin; }
-declare module "cesium/Source/Widgets/Viewer/viewerCesiumInspectorMixin" { import { viewerCesiumInspectorMixin } from 'mars3d-cesium'; export default viewerCesiumInspectorMixin; }
-declare module "cesium/Source/Widgets/Viewer/viewerDragDropMixin" { import { viewerDragDropMixin } from 'mars3d-cesium'; export default viewerDragDropMixin; }
-declare module "cesium/Source/Widgets/Viewer/viewerPerformanceWatchdogMixin" { import { viewerPerformanceWatchdogMixin } from 'mars3d-cesium'; export default viewerPerformanceWatchdogMixin; }
-declare module "cesium/Source/Widgets/VRButton/VRButton" { import { VRButton } from 'mars3d-cesium'; export default VRButton; }
-declare module "cesium/Source/Widgets/VRButton/VRButtonViewModel" { import { VRButtonViewModel } from 'mars3d-cesium'; export default VRButtonViewModel; }