beginor
10/4/2017 - 1:37 AM

Updated typings file for Cesium v1.37.0

Updated typings file for Cesium v1.37.0

/**
 * Cesium type definitions
 * For use with Cesium v1.37.0
 * Created by Aigars Zeiza <https://github.com/Zuzon>
 * Modified by Harry Nicholls <harry@northstar-robotics.com>
 * Updated for v1.37.0 by James Bromwell <https://github.com/Thw0rted>
 */
declare module "cesium"{

    type RenderState = any;

    interface Proxy {
        getURL(resource: string): string;
    }

    class ArcGisImageServerTerrainProvider {
        errorEvent: Event;
        credit: Credit;
        tilingScheme: GeographicTilingScheme;
        ready: boolean;
        hasWaterMask: boolean;
        hasVertexNormals: boolean;
        constructor(options: { url: string; token?: string; proxy?: any; tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid; credit?: Credit | string });
        requestTileGeometry(x: number, y: number, level: number): Promise<TerrainData>;
        getLevelMaximumGeometricError(level: number): number;
        getTileDataAvailable(x: number, y: number, level: number): boolean;
    }

    class AssociativeArray {
        length: number;
        values: any[];
        contains(key: string | number): boolean;
        set(key: string | number, value: any): void;
        get(key: string | number): any;
        remove(key: string | number): boolean;
        removeAll(): void;
    }

    class AxisAlignedBoundingBox {
        minimum: Cartesian3;
        maximum: Cartesian3;
        center: Cartesian3;
        constructor(minimum?: Cartesian3, maximum?: Cartesian3, center?: Cartesian3);
        clone(result?: AxisAlignedBoundingBox): AxisAlignedBoundingBox;
        intersect(plane: Cartesian4): Intersect;
        equals(right?: AxisAlignedBoundingBox): boolean;
        static fromPoints(positions: Cartesian3[], result?: AxisAlignedBoundingBox): AxisAlignedBoundingBox;
        static clone(box: AxisAlignedBoundingBox, result?: AxisAlignedBoundingBox): AxisAlignedBoundingBox;
        static equals(left?: AxisAlignedBoundingBox, right?: AxisAlignedBoundingBox): boolean;
        static intersect(box: AxisAlignedBoundingBox, plane: Cartesian4): Intersect;
    }

    class BoundingRectangle {
        x: number;
        y: number;
        width: number;
        height: number;
        constructor(x?: number, y?: number, width?: number, height?: number);
        clone(result?: BoundingRectangle): BoundingRectangle;
        intersect(right: BoundingRectangle): Intersect;
        equals(right?: BoundingRectangle): boolean;
        static fromPoints(positions: Cartesian2[], result?: BoundingRectangle): BoundingRectangle;
        static fromRectangle(rectangle: Rectangle, projection?: any, result?: BoundingRectangle): BoundingRectangle;
        static clone(rectangle: BoundingRectangle, result?: BoundingRectangle): BoundingRectangle;
        static union(left: BoundingRectangle, right: BoundingRectangle, result?: BoundingRectangle): BoundingRectangle;
        static expand(rectangle: BoundingRectangle, point: Cartesian2, result?: BoundingRectangle): BoundingRectangle;
        static intersect(left: BoundingRectangle, right: BoundingRectangle): Intersect;
        static equals(left?: BoundingRectangle, right?: BoundingRectangle): boolean;
    }

    class BoundingSphere {
        center: Cartesian3;
        radius: number;
        static packedLength: number;
        constructor(center?: Cartesian3, radius?: number);
        intersect(plane: Cartesian4): Intersect;
        equals(right?: BoundingSphere): boolean;
        clone(result?: BoundingSphere): BoundingSphere;
        static fromPoints(positions: Cartesian3[], result?: BoundingSphere): BoundingSphere;
        static fromRectangle2D(rectangle: Rectangle, projection?: any, result?: BoundingSphere): BoundingSphere;
        static fromRectangleWithHeights2D(rectangle: Rectangle, projection?: any, minimumHeight?: number, maximumHeight?: number, result?: BoundingSphere): BoundingSphere;
        static fromRectangle3D(rectangle: Rectangle, ellipsoid?: Ellipsoid, surfaceHeight?: number, result?: BoundingSphere): BoundingSphere;
        static fromVertices(positions: Cartesian3[], center?: Cartesian3, stride?: number, result?: BoundingSphere): BoundingSphere;
        static fromCornerPoints(corner?: number, oppositeCorner?: number, result?: BoundingSphere): BoundingSphere;
        static fromEllipsoid(ellipsoid: Ellipsoid, result?: BoundingSphere): BoundingSphere;
        static fromBoundingSpheres(boundingSpheres: BoundingSphere[], result?: BoundingSphere): BoundingSphere;
        static clone(sphere: BoundingSphere, result?: BoundingSphere): BoundingSphere;
        static pack(value: BoundingSphere, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: BoundingSphere): BoundingSphere;
        static union(left: BoundingSphere, right: BoundingSphere, result?: BoundingSphere): BoundingSphere;
        static expand(sphere: BoundingSphere, point: Cartesian3, result?: BoundingSphere): BoundingSphere;
        static intersect(sphere: BoundingSphere, plane: Cartesian4): Intersect;
        static transform(sphere: BoundingSphere, transform: Matrix4, result?: BoundingSphere): BoundingSphere;
        static distanceSquaredTo(sphere: BoundingSphere, cartesian: Cartesian3): number;
        static transformWithoutScale(sphere: BoundingSphere, transform: Matrix4, result?: BoundingSphere): BoundingSphere;
        static computePlaneDistances(sphere: BoundingSphere, position: Cartesian3, direction: Cartesian3, result?: Cartesian2): Interval;
        static projectTo2D(sphere: BoundingSphere, projection?: any, result?: BoundingSphere): BoundingSphere;
        static equals(left?: BoundingSphere, right?: BoundingSphere): boolean;
    }

    class BoxGeometry {
        static packedLength: number;
        constructor(options: { minimumCorner: Cartesian3; maximumCorner: Cartesian3; vertexFormat?: VertexFormat });
        static fromDimensions(): BoxGeometry;
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: BoxGeometry): BoxGeometry;
        static createGeometry(boxGeometry: BoxGeometry): Geometry;
    }

    class BoxOutlineGeometry {
        static packedLength: number;
        constructor();
        static fromDimensions(): BoxOutlineGeometry;
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: BoxOutlineGeometry): BoxOutlineGeometry;
        static createGeometry(boxGeometry: BoxOutlineGeometry): Geometry;
    }

    class Cartesian2 {
        x: number;
        y: number;
        static packedLength: number;
        static ZERO: Cartesian2;
        static UNIT_X: Cartesian2;
        static UNIT_Y: Cartesian2;
        constructor(x?: number, y?: number);
        clone(result?: Cartesian2): Cartesian2;
        equals(right?: Cartesian2): boolean;
        equalsEpsilon(right: Cartesian2, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
        toString(): string;
        static fromElements(x: number, y: number, result?: Cartesian2): Cartesian2;
        static clone(cartesian: Cartesian2, result?: Cartesian2): Cartesian2;
        static fromCartesian3(cartesian: Cartesian3, result?: Cartesian2): Cartesian2;
        static fromCartesian4(cartesian: Cartesian4, result?: Cartesian2): Cartesian2;
        static pack(value: Cartesian2, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: Cartesian2): Cartesian2;
        static fromArray(array: number[], startingIndex?: number, result?: Cartesian2): Cartesian2;
        static maximumComponent(cartesian: Cartesian2): number;
        static minimumComponent(cartesian: Cartesian2): number;
        static minimumByComponent(first: Cartesian2, second: Cartesian2, result: Cartesian2): Cartesian2;
        static maximumByComponent(first: Cartesian2, second: Cartesian2, result: Cartesian2): Cartesian2;
        static magnitudeSquared(cartesian: Cartesian2): number;
        static magnitude(cartesian: Cartesian2): number;
        static distance(left: Cartesian2, right: Cartesian2): number;
        static distanceSquared(left: Cartesian2, right: Cartesian2): number;
        static normalize(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
        static dot(left: Cartesian2, right: Cartesian2): number;
        static multiplyComponents(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
        static add(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
        static subtract(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
        static multiplyByScalar(cartesian: Cartesian2, scalar: number, result: Cartesian2): Cartesian2;
        static divideByScalar(cartesian: Cartesian2, scalar: number, result: Cartesian2): Cartesian2;
        static negate(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
        static abs(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
        static lerp(start: Cartesian2, end: Cartesian2, t: number, result: Cartesian2): Cartesian2;
        static angleBetween(left: Cartesian2, right: Cartesian2): number;
        static mostOrthogonalAxis(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
        static equals(left?: Cartesian2, right?: Cartesian2): boolean;
        static equalsEpsilon(left: Cartesian2, right: Cartesian2, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
    }

    class Cartesian3 implements PositionProperty {
        x: number;
        y: number;
        z: number;
        static packedLength: number;
        static ZERO: Cartesian3;
        static UNIT_X: Cartesian3;
        static UNIT_Y: Cartesian3;
        static UNIT_Z: Cartesian3;
        constructor(x?: number, y?: number, z?: number);
        clone(result?: Cartesian3): Cartesian3;
        equals(right?: Cartesian3): boolean;
        equalsEpsilon(right: Cartesian3, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
        toString(): string;
        static fromSpherical(spherical: Spherical, result?: Cartesian3): Cartesian3;
        static fromElements(x: number, y: number, z: number, result?: Cartesian3): Cartesian3;
        static clone(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
        static fromCartesian4(cartesian: Cartesian4, result?: Cartesian3): Cartesian3;
        static pack(value: Cartesian3, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: Cartesian3): Cartesian3;
        static fromArray(array: number[], startingIndex?: number, result?: Cartesian3): Cartesian3;
        static maximumComponent(cartesian: Cartesian3): number;
        static minimumComponent(cartesian: Cartesian3): number;
        static minimumByComponent(first: Cartesian3, second: Cartesian3, result: Cartesian3): Cartesian3;
        static maximumByComponent(first: Cartesian3, second: Cartesian3, result: Cartesian3): Cartesian3;
        static magnitudeSquared(cartesian: Cartesian3): number;
        static magnitude(cartesian: Cartesian3): number;
        static distance(left: Cartesian3, right: Cartesian3): number;
        static distanceSquared(left: Cartesian3, right: Cartesian3): number;
        static normalize(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
        static dot(left: Cartesian3, right: Cartesian3): number;
        static multiplyComponents(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
        static add(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
        static subtract(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
        static multiplyByScalar(cartesian: Cartesian3, scalar: number, result: Cartesian3): Cartesian3;
        static divideByScalar(cartesian: Cartesian3, scalar: number, result: Cartesian3): Cartesian3;
        static negate(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
        static abs(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
        static lerp(start: Cartesian3, end: Cartesian3, t: number, result: Cartesian3): Cartesian3;
        static angleBetween(left: Cartesian3, right: Cartesian3): number;
        static mostOrthogonalAxis(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
        static equals(left?: Cartesian3, right?: Cartesian3): boolean;
        static equalsEpsilon(left: Cartesian3, right: Cartesian3, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
        static cross(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
        static fromDegrees(longitude: number, latitude: number, height?: number, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3;
        static fromRadians(longitude: number, latitude: number, height?: number, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3;
        static fromDegreesArray(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
        static fromRadiansArray(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
        static fromDegreesArrayHeights(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
        static fromRadiansArrayHeights(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
        isConstant: boolean;
        definitionChanged: Event;
        referenceFrame: ReferenceFrame;
        getValue(time: JulianDate, result?: Cartesian3): Cartesian3;
        getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
    }

    class Cartesian4 {
        x: number;
        y: number;
        z: number;
        w: number;
        static packedLength: number;
        static ZERO: Cartesian4;
        static UNIT_X: Cartesian4;
        static UNIT_Y: Cartesian4;
        static UNIT_Z: Cartesian4;
        static UNIT_W: Cartesian4;
        constructor(x?: number, y?: number, z?: number, w?: number);
        clone(result?: Cartesian4): Cartesian4;
        equals(right?: Cartesian4): boolean;
        equalsEpsilon(right: Cartesian4, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
        toString(): string;
        static fromElements(x: number, y: number, z: number, w: number, result?: Cartesian4): Cartesian4;
        static fromColor(color: Color, result?: Cartesian4): Cartesian4;
        static clone(cartesian: Cartesian4, result?: Cartesian4): Cartesian4;
        static pack(value: Cartesian4, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: Cartesian4): Cartesian4;
        static fromArray(array: number[], startingIndex?: number, result?: Cartesian4): Cartesian4;
        static maximumComponent(cartesian: Cartesian4): number;
        static minimumComponent(cartesian: Cartesian4): number;
        static minimumByComponent(first: Cartesian4, second: Cartesian4, result: Cartesian4): Cartesian4;
        static maximumByComponent(first: Cartesian4, second: Cartesian4, result: Cartesian4): Cartesian4;
        static magnitudeSquared(cartesian: Cartesian4): number;
        static magnitude(cartesian: Cartesian4): number;
        static distance(left: Cartesian4, right: Cartesian4): number;
        static distanceSquared(left: Cartesian4, right: Cartesian4): number;
        static normalize(cartesian: Cartesian4, result: Cartesian4): Cartesian4;
        static dot(left: Cartesian4, right: Cartesian4): number;
        static multiplyComponents(left: Cartesian4, right: Cartesian4, result: Cartesian4): Cartesian4;
        static add(left: Cartesian4, right: Cartesian4, result: Cartesian4): Cartesian4;
        static subtract(left: Cartesian4, right: Cartesian4, result: Cartesian4): Cartesian4;
        static multiplyByScalar(cartesian: Cartesian4, scalar: number, result: Cartesian4): Cartesian4;
        static divideByScalar(cartesian: Cartesian4, scalar: number, result: Cartesian4): Cartesian4;
        static negate(cartesian: Cartesian4, result: Cartesian4): Cartesian4;
        static abs(cartesian: Cartesian4, result: Cartesian4): Cartesian4;
        static lerp(start: Cartesian4, end: Cartesian4, t: number, result: Cartesian4): Cartesian4;
        static mostOrthogonalAxis(cartesian: Cartesian4, result: Cartesian4): Cartesian4;
        static equals(left?: Cartesian4, right?: Cartesian4): boolean;
        static equalsEpsilon(left: Cartesian4, right: Cartesian4, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
    }

    class Cartographic {
        longitude: number;
        latitude: number;
        height: number;
        static ZERO: Cartographic;
        constructor(longitude?: number, latitude?: number, height?: number);
        clone(result?: Cartographic): Cartographic;
        equals(right?: Cartographic): boolean;
        equalsEpsilon(right: Cartographic, epsilon: number): boolean;
        toString(): string;
        static fromRadians(longitude: number, latitude: number, height?: number, result?: Cartographic): Cartographic;
        static fromCartesian(cartesian: Cartesian3, ellipsoid?: Ellipsoid, result?: Cartographic): Cartographic;
        static fromDegrees(longitude: number, latitude: number, height?: number, result?: Cartographic): Cartographic;
        static clone(cartographic: Cartographic, result?: Cartographic): Cartographic;
        static equals(left?: Cartographic, right?: Cartographic): boolean;
        static equalsEpsilon(left: Cartographic, right: Cartographic, epsilon: number): boolean;
    }

    class CartographicGeocoderService implements GeocoderService{
        geocode(query: string): Promise<Array<GeocoderResult>>
    }

    class CatmullRomSpline {
        times: number[];
        points: Cartesian3[];
        firstTangent: Cartesian3;
        lastTangent: Cartesian3;
        constructor(options: { times: number[]; points: Cartesian3[]; firstTangent?: Cartesian3; lastTangent?: Cartesian3 });
        findTimeInterval(time: number): number;
        evaluate(time: number, result?: Cartesian3): Cartesian3;
    }

    class CesiumTerrainProvider {
        errorEvent: Event;
        credit: Credit;
        tilingScheme: GeographicTilingScheme;
        ready: boolean;
        hasWaterMask: boolean;
        hasVertexNormals: boolean;
        requestVertexNormals: boolean;
        requestWaterMask: boolean;
        constructor(options: { url: string; proxy?: Proxy; requestVertexNormals?: boolean; requestWaterMask?: boolean; ellipsoid?: Ellipsoid; credit?: Credit | string });
        requestTileGeometry(x: number, y: number, level: number, throttleRequests?: boolean): Promise<TerrainData>;
        getLevelMaximumGeometricError(level: number): number;
        getTileDataAvailable(x: number, y: number, level: number): boolean;
    }

    class CircleGeometry {
        static packedLength: number;
        constructor(options: { center: Cartesian3; radius: number; ellipsoid?: Ellipsoid; height?: number; granularity?: number; vertexFormat?: VertexFormat; extrudedHeight?: number; stRotation?: number });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: CircleGeometry): CircleGeometry;
        static createGeometry(circleGeometry: CircleGeometry): Geometry;
    }

    class CircleOutlineGeometry {
        static packedLength: number;
        constructor(options: { center: Cartesian3; radius: number; ellipsoid?: Ellipsoid; height?: number; granularity?: number; extrudedHeight?: number; numberOfVerticalLines?: number });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: CircleOutlineGeometry): CircleOutlineGeometry;
        static createGeometry(circleGeometry: CircleOutlineGeometry): Geometry;
    }

    class Clock {
        startTime: JulianDate;
        stopTime: JulianDate;
        currentTime: JulianDate;
        multiplier: number;
        clockStep: ClockStep;
        clockRange: ClockRange;
        canAnimate: boolean;
        shouldAnimate: boolean;
        onTick: Event;
        constructor(options: { startTime?: JulianDate; stopTime?: JulianDate; currentTime?: JulianDate; multiplier?: number; clockStep?: ClockStep; clockRange?: ClockRange; canAnimate?: boolean; shouldAnimate?: boolean });
        tick(): JulianDate;
    }

    class Color extends MaterialProperty {
        red: number;
        green: number;
        blue: number;
        alpha: number;
        static packedLength: number;
        static ALICEBLUE: Color;
        static ANTIQUEWHITE: Color;
        static AQUA: Color;
        static AQUAMARINE: Color;
        static AZURE: Color;
        static BEIGE: Color;
        static BISQUE: Color;
        static BLACK: Color;
        static BLANCHEDALMOND: Color;
        static BLUE: Color;
        static BLUEVIOLET: Color;
        static BROWN: Color;
        static BURLYWOOD: Color;
        static CADETBLUE: Color;
        static CHARTREUSE: Color;
        static CHOCOLATE: Color;
        static CORAL: Color;
        static CORNFLOWERBLUE: Color;
        static CORNSILK: Color;
        static CRIMSON: Color;
        static CYAN: Color;
        static DARKBLUE: Color;
        static DARKCYAN: Color;
        static DARKGOLDENROD: Color;
        static DARKGRAY: Color;
        static DARKGREEN: Color;
        static DARKGREY: Color;
        static DARKKHAKI: Color;
        static DARKMAGENTA: Color;
        static DARKOLIVEGREEN: Color;
        static DARKORANGE: Color;
        static DARKORCHID: Color;
        static DARKRED: Color;
        static DARKSALMON: Color;
        static DARKSEAGREEN: Color;
        static DARKSLATEBLUE: Color;
        static DARKSLATEGRAY: Color;
        static DARKSLATEGREY: Color;
        static DARKTURQUOISE: Color;
        static DARKVIOLET: Color;
        static DEEPPINK: Color;
        static DEEPSKYBLUE: Color;
        static DIMGRAY: Color;
        static DIMGREY: Color;
        static DODGERBLUE: Color;
        static FIREBRICK: Color;
        static FLORALWHITE: Color;
        static FORESTGREEN: Color;
        static FUSCHIA: Color;
        static GAINSBORO: Color;
        static GHOSTWHITE: Color;
        static GOLD: Color;
        static GOLDENROD: Color;
        static GRAY: Color;
        static GREEN: Color;
        static GREENYELLOW: Color;
        static GREY: Color;
        static HONEYDEW: Color;
        static HOTPINK: Color;
        static INDIANRED: Color;
        static INDIGO: Color;
        static IVORY: Color;
        static KHAKI: Color;
        static LAVENDER: Color;
        static LAVENDAR_BLUSH: Color;
        static LAWNGREEN: Color;
        static LEMONCHIFFON: Color;
        static LIGHTBLUE: Color;
        static LIGHTCORAL: Color;
        static LIGHTCYAN: Color;
        static LIGHTGOLDENRODYELLOW: Color;
        static LIGHTGRAY: Color;
        static LIGHTGREEN: Color;
        static LIGHTGREY: Color;
        static LIGHTPINK: Color;
        static LIGHTSEAGREEN: Color;
        static LIGHTSKYBLUE: Color;
        static LIGHTSLATEGRAY: Color;
        static LIGHTSLATEGREY: Color;
        static LIGHTSTEELBLUE: Color;
        static LIGHTYELLOW: Color;
        static LIME: Color;
        static LIMEGREEN: Color;
        static LINEN: Color;
        static MAGENTA: Color;
        static MAROON: Color;
        static MEDIUMAQUAMARINE: Color;
        static MEDIUMBLUE: Color;
        static MEDIUMORCHID: Color;
        static MEDIUMPURPLE: Color;
        static MEDIUMSEAGREEN: Color;
        static MEDIUMSLATEBLUE: Color;
        static MEDIUMSPRINGGREEN: Color;
        static MEDIUMTURQUOISE: Color;
        static MEDIUMVIOLETRED: Color;
        static MIDNIGHTBLUE: Color;
        static MINTCREAM: Color;
        static MISTYROSE: Color;
        static MOCCASIN: Color;
        static NAVAJOWHITE: Color;
        static NAVY: Color;
        static OLDLACE: Color;
        static OLIVE: Color;
        static OLIVEDRAB: Color;
        static ORANGE: Color;
        static ORANGERED: Color;
        static ORCHID: Color;
        static PALEGOLDENROD: Color;
        static PALEGREEN: Color;
        static PALETURQUOISE: Color;
        static PALEVIOLETRED: Color;
        static PAPAYAWHIP: Color;
        static PEACHPUFF: Color;
        static PERU: Color;
        static PINK: Color;
        static PLUM: Color;
        static POWDERBLUE: Color;
        static PURPLE: Color;
        static RED: Color;
        static ROSYBROWN: Color;
        static ROYALBLUE: Color;
        static SADDLEBROWN: Color;
        static SALMON: Color;
        static SANDYBROWN: Color;
        static SEAGREEN: Color;
        static SEASHELL: Color;
        static SIENNA: Color;
        static SILVER: Color;
        static SKYBLUE: Color;
        static SLATEBLUE: Color;
        static SLATEGRAY: Color;
        static SLATEGREY: Color;
        static SNOW: Color;
        static SPRINGGREEN: Color;
        static STEELBLUE: Color;
        static TAN: Color;
        static TEAL: Color;
        static THISTLE: Color;
        static TOMATO: Color;
        static TURQUOISE: Color;
        static VIOLET: Color;
        static WHEAT: Color;
        static WHITE: Color;
        static WHITESMOKE: Color;
        static YELLOW: Color;
        static YELLOWGREEN: Color;
        static TRANSPARENT: Color;
        constructor(red?: number, green?: number, blue?: number, alpha?: number);
        clone(result?: Color): Color;
        equals(other: Color): boolean;
        equalsEpsilon(other: Color, epsilon?: number): boolean;
        toString(): string;
        toCssColorString(): string;
        toBytes(result?: number[]): number[];
        toRgba(): number;
        brighten(magnitude: number, result: Color): Color;
        darken(magnitude: number, result: Color): Color;
        withAlpha(alpha: number, result?: Color): Color;
        static fromCartesian4(cartesian: Cartesian4, result?: Color): Color;
        static fromBytes(red?: number, green?: number, blue?: number, alpha?: number, result?: Color): Color;
        static fromAlpha(color: Color, alpha: number, result?: Color): Color;
        static fromRgba(rgba: number): Color;
        static fromHsl(hue?: number, saturation?: number, lightness?: number, alpha?: number): Color;
        static fromRandom(options?: { red?: number; minimumRed?: number; maximumRed?: number; green?: number; minimumGreen?: number; maximumGreen?: number; blue?: number; minimumBlue?: number; maximumBlue?: number; alpha?: number; minimumAlpha?: number; maximumAlpha?: number }, result?: Color): Color;
        static fromCssColorString(color: string): Color;
        static pack(value: Color, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: Color): Color;
        static byteToFloat(number: number): number;
        static floatToByte(number: number): number;
        static clone(color: Color, result?: Color): Color;
        static equals(left: Color, right: Color): boolean;
    }

    class ColorGeometryInstanceAttribute {
        value: Uint8Array;
        componentDatatype: ComponentDatatype;
        componentsPerAttribute: number;
        normalize: boolean;
        constructor(red?: number, green?: number, blue?: number, alpha?: number);
        static fromColor(color: Color): ColorGeometryInstanceAttribute;
        static toValue(color: Color, result?: Uint8Array): Uint8Array;
    }

    class CorridorGeometry {
        packedLength: number;
        constructor(options: { positions: Cartesian3[]; width: number; ellipsoid?: Ellipsoid; granularity?: number; height?: number; extrudedHeight?: number; vertexFormat?: VertexFormat; cornerType?: CornerType });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: CorridorGeometry): CorridorGeometry;
        static createGeometry(corridorGeometry: CorridorGeometry): Geometry;
    }

    class CorridorOutlineGeometry {
        packedLength: number;
        constructor(options: { positions: Cartesian3[]; width: number; ellipsoid?: Ellipsoid; granularity?: number; height?: number; extrudedHeight?: number; cornerType?: CornerType });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: CorridorOutlineGeometry): CorridorOutlineGeometry;
        static createGeometry(corridorOutlineGeometry: CorridorOutlineGeometry): Geometry;
    }

    class Credit {
        text: string;
        imageUrl: string;
        link: string;
        constructor(text?: string, imageUrl?: string, link?: string);
        hasImage(): boolean;
        hasLink(): boolean;
        equals(credits: Credit): boolean;
        static equals(left: Credit, right: Credit): boolean;
    }

    class CylinderGeometry {
        static packedLength: number;
        constructor(options: { length: number; topRadius: number; bottomRadius: number; slices?: number; vertexFormat?: VertexFormat });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: CylinderGeometry): CylinderGeometry;
        static createGeometry(cylinderGeometry: CylinderGeometry): Geometry;
    }

    class CylinderOutlineGeometry {
        static packedLength: number;
        constructor(options: { length: number; topRadius: number; bottomRadius: number; slices?: number; numberOfVerticalLines?: number });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: CylinderOutlineGeometry): CylinderOutlineGeometry;
        static createGeometry(cylinderGeometry: CylinderOutlineGeometry): Geometry;
    }

    class DefaultProxy {
        constructor(proxy: string);
        getURL(resource: string): string;
    }

    class DeveloperError {
        name: string;
        message: string;
        stack: string;
        constructor(message?: string);
    }

    class EllipseGeometry {
        static packedLength: number;
        constructor(options: { center: Cartesian3; semiMajorAxis: number; semiMinorAxis: number; ellipsoid?: Ellipsoid; height?: number; extrudedHeight?: number; rotation?: number; stRotation?: number; granularity?: number; vertexFormat?: VertexFormat });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: EllipseGeometry): EllipseGeometry;
        static createGeometry(ellipseGeometry: EllipseGeometry): Geometry;
    }

    class EllipseOutlineGeometry {
        static packedLength: number;
        constructor(options: { center: Cartesian3; semiMajorAxis: number; semiMinorAxis: number; ellipsoid?: Ellipsoid; height?: number; extrudedHeight?: number; rotation?: number; granularity?: number; numberOfVerticalLines?: number });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: EllipseOutlineGeometry): EllipseOutlineGeometry;
        static createGeometry(ellipseGeometry: EllipseOutlineGeometry): Geometry;
    }

    class Ellipsoid {
        radii: Cartesian3;
        radiiSquared: Cartesian3;
        radiiToTheFourth: Cartesian3;
        oneOverRadii: Cartesian3;
        oneOverRadiiSquared: Cartesian3;
        minimumRadius: number;
        maximumRadius: number;
        static WGS84: Ellipsoid;
        static UNIT_SPHERE: Ellipsoid;
        static MOON: Ellipsoid;
        static packedLength: number;
        constructor(x?: number, y?: number, z?: number);
        clone(result?: Ellipsoid): Ellipsoid;
        geocentricSurfaceNormal(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
        geodeticSurfaceNormalCartographic(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
        geodeticSurfaceNormal(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
        cartographicToCartesian(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
        cartographicArrayToCartesianArray(cartographics: Cartographic[], result?: Cartesian3[]): Cartesian3[];
        cartesianToCartographic(cartesian: Cartesian3, result?: Cartographic): Cartographic;
        cartesianArrayToCartographicArray(cartesians: Cartesian3[], result?: Cartographic[]): Cartographic[];
        scaleToGeodeticSurface(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
        scaleToGeocentricSurface(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
        transformPositionToScaledSpace(position: Cartesian3, result?: Cartesian3): Cartesian3;
        transformPositionFromScaledSpace(position: Cartesian3, result?: Cartesian3): Cartesian3;
        equals(right?: Ellipsoid): boolean;
        toString(): string;
        static clone(ellipsoid: Ellipsoid, result?: Ellipsoid): Ellipsoid;
        static fromCartesian3(radii?: Cartesian3): Ellipsoid;
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: Ellipsoid): Ellipsoid;
    }

    class EllipsoidGeodesic {
        surfaceDistance: number;
        start: Cartographic;
        end: Cartographic;
        startHeading: number;
        endHeading: number;
        constructor(start?: Cartographic, end?: Cartographic, ellipsoid?: Ellipsoid);
        setEndPoints(start: Cartographic, end: Cartographic): void;
        interpolateUsingFraction(fraction: number): Cartographic;
        interpolateUsingSurfaceDistance(distance: number): Cartographic;
    }

    class EllipsoidGeometry {
        static packedLength: number;
        constructor(options?: { radii?: Cartesian3; stackPartitions?: number; slicePartitions?: number; vertexFormat?: VertexFormat });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: EllipsoidGeometry): EllipsoidGeometry;
        static createGeometry(ellipsoidGeometry: EllipsoidGeometry): Geometry;
    }

    class EllipsoidOutlineGeometry {
        static packedLength: number;
        constructor(options?: { radii?: Cartesian3; stackPartitions?: number; slicePartitions?: number; subdivisions?: number });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: EllipsoidOutlineGeometry): EllipsoidOutlineGeometry;
        static createGeometry(ellipsoidGeometry: EllipsoidOutlineGeometry): Geometry;
    }

    class EllipsoidTangentPlane {
        ellipsoid: Ellipsoid;
        origin: Cartesian3;
        constructor(ellipsoid: Ellipsoid, origin: Cartesian3);
        projectPointOntoPlane(cartesian: Cartesian3, result?: Cartesian2): Cartesian2;
        projectPointsOntoPlane(cartesians: Cartesian3[], result?: Cartesian2[]): Cartesian2[];
        projectPointsOntoEllipsoid(cartesians: Cartesian2[], result?: Cartesian3[]): Cartesian3[];
        static fromPoints(ellipsoid: Ellipsoid, cartesians: Cartesian3): EllipsoidTangentPlane;
    }

    class EllipsoidTerrainProvider {
        errorEvent: Event;
        credit: Credit;
        tilingScheme: GeographicTilingScheme;
        ready: boolean;
        hasWaterMask: boolean;
        hasVertexNormals: boolean;
        constructor(options?: { tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid });
        requestTileGeometry(x: number, y: number, level: number, throttleRequests?: boolean): Promise<TerrainData>;
        getLevelMaximumGeometricError(level: number): number;
        getTileDataAvailable(x: number, y: number, level: number): boolean;
    }

    class Event {
        numberOfListeners: number;
        addEventListener(listener: Function, scope?: any): Event.RemoveCallback;
        removeEventListener(listener: Function, scope?: any): boolean;
        raiseEvent(...args: any[]): void;
    }

    module Event {
        type RemoveCallback = () => void;
    }

    class EventHelper {
        add(event: Event, listener: Function, scope?: any): EventHelper.RemoveCallback;
        removeAll(): void;
    }

    module EventHelper {
        type RemoveCallback = () => void;
    }

    class GeographicProjection {
        ellipsoid: Ellipsoid;
        constructor(ellipsoid?: Ellipsoid);
        project(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
        unproject(cartesian: Cartesian3, result?: Cartographic): Cartographic;
    }

    class GeographicTilingScheme {
        ellipsoid: Ellipsoid;
        rectangle: Rectangle;
        projection: MapProjection;
        constructor(options?: { ellipsoid?: Ellipsoid; rectangle?: Rectangle; numberOfLevelZeroTilesX?: number; numberOfLevelZeroTilesY?: number });
        getNumberOfXTilesAtLevel(level: number): number;
        getNumberOfYTilesAtLevel(level: number): number;
        rectangleToNativeRectangle(rectangle: Rectangle, result?: Rectangle): Rectangle;
        tileXYToNativeRectangle(x: number, y: number, level: number, result?: any): Rectangle;
        tileXYToRectangle(x: number, y: number, level: number, result?: any): Rectangle;
        positionToTileXY(position: Cartographic, level: number, result?: Cartesian2): Cartesian2;
    }

    class Geometry {
        attributes: GeometryAttributes;
        indices: any[];
        primitiveType: PrimitiveType;
        boundingSphere: BoundingSphere;
        constructor(options: { attributes: GeometryAttributes; primitiveType?: PrimitiveType; indices?: Uint16Array | Uint32Array; boundingSphere?: BoundingSphere });
        static computeNumberOfVertices(geometry: Cartesian3): number;
    }

    class GeometryAttribute {
        componentDatatype: ComponentDatatype;
        componentsPerAttribute: number;
        normalize: boolean;
        values: any[];
        constructor(options?: { componentDatatype?: ComponentDatatype; componentsPerAttribute?: number; normalize?: boolean; values?: number[] });
    }

    class GeometryAttributes {
        position: GeometryAttribute;
        normal: GeometryAttribute;
        st: GeometryAttribute;
        binormal: GeometryAttribute;
        tangent: GeometryAttribute;
        color: GeometryAttribute;
    }

    class GeometryInstance {
        geometry: Geometry;
        modelMatrix: Matrix4;
        id: any;
        attributes: any;
        constructor(options: { geometry: Geometry; modelMatrix?: Matrix4; id?: any; attributes?: any });
    }

    class GeometryInstanceAttribute {
        componentDatatype: ComponentDatatype;
        componentsPerAttribute: number;
        normalize: boolean;
        value: number[];
        constructor(options: { componentDatatype?: ComponentDatatype; componentsPerAttribute?: number; normalize?: boolean; value?: number[] });
    }

    class GregorianDate {
        year: number;
        month: number;
        day: number;
        hour: number;
        minute: number;
        second: number;
        millisecond: number;
        isLeapSecond: boolean;
    }

    class HeightmapTerrainData {
        waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement;
        constructor(options: { buffer: Int8Array | Uint8Array | Int16Array | Uint16Array | Float32Array | Float64Array; width: number; height: number; childTileMask?: number; structure?: any; structureheightScale?: number; structureheightOffset?: number; structureelementsPerHeight?: number; structurestride?: number; structureelementMultiplier?: number; structureisBigEndian?: boolean; createdByUpsampling?: boolean });
        createMesh(tilingScheme: TilingScheme, x: number, y: number, level: number): Promise<TerrainMesh>;
        interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number;
        upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<HeightmapTerrainData>;
        isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean;
        wasCreatedByUpsampling(): boolean;
    }

    class HermiteSpline {
        times: number[];
        points: Cartesian3[];
        inTangents: Cartesian3[];
        outTangents: Cartesian3[];
        constructor(options: { times: number[]; points: Cartesian3[]; inTangents: Cartesian3[]; outTangents: Cartesian3[] });
        findTimeInterval(time: number): number;
        evaluate(time: number, result?: Cartesian3): Cartesian3;
        static createC1(): HermiteSpline;
        static createNaturalCubic(): HermiteSpline | LinearSpline;
        static createClampedCubic(): HermiteSpline | LinearSpline;
    }

    class Interval {
        start: number;
        stop: number;
        constructor(start?: number, stop?: number);
    }

    class JulianDate {
        dayNumber: number;
        secondsOfDay: number;
        static leapSeconds: LeapSecond[];
        constructor(julianDayNumber: number, secondsOfDay: number, timeStandard?: TimeStandard);
        clone(result?: JulianDate): JulianDate;
        equals(right?: JulianDate): boolean;
        equalsEpsilon(right: JulianDate, epsilon: number): boolean;
        toString(): string;
        static fromDate(date: Date, result?: JulianDate): JulianDate;
        static fromIso8601(iso8601String: string, result?: JulianDate): JulianDate;
        static now(result?: JulianDate): JulianDate;
        static toGregorianDate(julianDate: JulianDate, result?: GregorianDate): GregorianDate;
        static toDate(julianDate: JulianDate): Date;
        static toIso8601(julianDate: JulianDate, precision?: number): string;
        static clone(julianDate: JulianDate, result?: JulianDate): JulianDate;
        static compare(left: JulianDate, right: JulianDate): number;
        static equals(left?: JulianDate, right?: JulianDate): boolean;
        static equalsEpsilon(left: JulianDate, right: JulianDate, epsilon: number): boolean;
        static totalDays(julianDate: JulianDate): number;
        static secondsDifference(left: JulianDate, right: JulianDate): number;
        static daysDifference(left: JulianDate, right: JulianDate): number;
        static computeTaiMinusUtc(julianDate: JulianDate): number;
        static addSeconds(julianDate: JulianDate, seconds: number, result: JulianDate): JulianDate;
        static addMinutes(julianDate: JulianDate, minutes: number, result: JulianDate): JulianDate;
        static addHours(julianDate: JulianDate, hours: number, result: JulianDate): JulianDate;
        static addDays(julianDate: JulianDate, days: number, result: JulianDate): JulianDate;
        static lessThan(left: JulianDate, right: JulianDate): boolean;
        static lessThanOrEquals(left: JulianDate, right: JulianDate): boolean;
        static greaterThan(left: JulianDate, right: JulianDate): boolean;
        static greaterThanOrEquals(left: JulianDate, right: JulianDate): boolean;
    }

    class LeapSecond {
        julianDate: JulianDate;
        offset: number;
        constructor(date?: JulianDate, offset?: number);
    }

    class LinearSpline {
        times: number[];
        points: Cartesian3[];
        constructor();
        findTimeInterval(time: number): number;
        evaluate(time: number, result?: Cartesian3): Cartesian3;
    }

    class MapProjection {
        ellipsoid: Ellipsoid;
        project(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
        unproject(cartesian: Cartesian3, result?: Cartographic): Cartographic;
    }

    class Matrix2 {
        static packedLength: number;
        static IDENTITY: Matrix2;
        static COLUMN0ROW0: number;
        static COLUMN0ROW1: number;
        static COLUMN1ROW0: number;
        static COLUMN1ROW1: number;
        constructor(column0Row0?: number, column1Row0?: number, column0Row1?: number, column1Row1?: number);
        clone(result?: Matrix2): Matrix2;
        equals(right?: Matrix2): boolean;
        equalsEpsilon(right: Matrix2, epsilon: number): boolean;
        toString(): string;
        static pack(value: Matrix2, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: Matrix2): Matrix2;
        static clone(matrix: Matrix2, result?: Matrix2): Matrix2;
        static fromArray(array: number[], startingIndex?: number, result?: Matrix2): Matrix2;
        static fromColumnMajorArray(values: number[], result?: Matrix2): Matrix2;
        static fromRowMajorArray(values: number[], result?: Matrix2): Matrix2;
        static fromScale(scale: Cartesian2, result?: Matrix2): Matrix2;
        static fromUniformScale(scale: number, result?: Matrix2): Matrix2;
        static fromRotation(angle: number, result?: Matrix2): Matrix2;
        static toArray(matrix: Matrix2, result?: number[]): number[];
        static getElementIndex(row: number, column: number): number;
        static getColumn(matrix: Matrix2, index: number, result: Cartesian2): Cartesian2;
        static setColumn(matrix: Matrix2, index: number, cartesian: Cartesian2, result: Cartesian2): Matrix2;
        static getRow(matrix: Matrix2, index: number, result: Cartesian2): Cartesian2;
        static setRow(matrix: Matrix2, index: number, cartesian: Cartesian2, result: Matrix2): Matrix2;
        static getScale(matrix: Matrix2, result: Cartesian2): Cartesian2;
        static getMaximumScale(matrix: Matrix2): number;
        static multiply(left: Matrix2, right: Matrix2, result: Matrix2): Matrix2;
        static add(left: Matrix2, right: Matrix2, result: Matrix2): Matrix2;
        static subtract(left: Matrix2, right: Matrix2, result: Matrix2): Matrix2;
        static multiplyByVector(matrix: Matrix2, cartesian: Cartesian2, result: Cartesian2): Cartesian2;
        static multiplyByScalar(matrix: Matrix2, scalar: number, result: Matrix2): Matrix2;
        static negate(matrix: Matrix2, result: Matrix2): Matrix2;
        static transpose(matrix: Matrix2, result: Matrix2): Matrix2;
        static abs(matrix: Matrix2, result: Matrix2): Matrix2;
        static equals(left?: Matrix2, right?: Matrix2): boolean;
        static equalsEpsilon(left: Matrix2, right: Matrix2, epsilon: number): boolean;
    }

    class Matrix3 {
        static packedLength: number;
        static IDENTITY: Matrix3;
        static COLUMN0ROW0: number;
        static COLUMN0ROW1: number;
        static COLUMN0ROW2: number;
        static COLUMN1ROW0: number;
        static COLUMN1ROW1: number;
        static COLUMN1ROW2: number;
        static COLUMN2ROW0: number;
        static COLUMN2ROW1: number;
        static COLUMN2ROW2: number;
        constructor(column0Row0?: number, column1Row0?: number, column2Row0?: number, column0Row1?: number, column1Row1?: number, column2Row1?: number, column0Row2?: number, column1Row2?: number, column2Row2?: number);
        clone(result?: Matrix3): Matrix3;
        equals(right?: Matrix3): boolean;
        equalsEpsilon(right: Matrix3, epsilon: number): boolean;
        toString(): string;
        static pack(value: Matrix3, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: Matrix3): Matrix3;
        static clone(matrix: Matrix3, result?: Matrix3): Matrix3;
        static fromArray(array: number[], startingIndex?: number, result?: Matrix3): Matrix3;
        static fromColumnMajorArray(values: number[], result?: Matrix3): Matrix3;
        static fromRowMajorArray(values: number[], result?: Matrix3): Matrix3;
        static fromQuaternion(quaternion: Quaternion): Matrix3;
        static fromScale(scale: Cartesian3, result?: Matrix3): Matrix3;
        static fromUniformScale(scale: number, result?: Matrix3): Matrix3;
        static fromCrossProduct(the: Cartesian3, result?: Matrix3): Matrix3;
        static fromRotationX(angle: number, result?: Matrix3): Matrix3;
        static fromRotationY(angle: number, result?: Matrix3): Matrix3;
        static fromRotationZ(angle: number, result?: Matrix3): Matrix3;
        static toArray(matrix: Matrix3, result?: number[]): number[];
        static getElementIndex(row: number, column: number): number;
        static getColumn(matrix: Matrix3, index: number, result: Cartesian3): Cartesian3;
        static setColumn(matrix: Matrix3, index: number, cartesian: Cartesian3, result: Cartesian3): Matrix3;
        static getRow(matrix: Matrix3, index: number, result: Cartesian3): Cartesian3;
        static setRow(matrix: Matrix3, index: number, cartesian: Cartesian3, result: Cartesian3): Matrix3;
        static getScale(matrix: Matrix3, result: Cartesian3): Cartesian3;
        static getMaximumScale(matrix: Matrix3): number;
        static multiply(left: Matrix3, right: Matrix3, result: Matrix3): Matrix3;
        static add(left: Matrix3, right: Matrix3, result: Matrix3): Matrix3;
        static subtract(left: Matrix3, right: Matrix3, result: Matrix3): Matrix3;
        static multiplyByVector(matrix: Matrix3, cartesian: Cartesian3, result: Cartesian3): Cartesian3;
        static multiplyByScalar(matrix: Matrix3, scalar: number, result: Matrix3): Matrix3;
        static negate(matrix: Matrix3, result: Matrix3): Matrix3;
        static transpose(matrix: Matrix3, result: Matrix3): Matrix3;
        static computeEigenDecomposition(matrix: Matrix3, result?: any): any;
        static abs(matrix: Matrix3, result: Matrix3): Matrix3;
        static determinant(matrix: Matrix3): number;
        static inverse(matrix: Matrix3, result: Matrix3): Matrix3;
        static equals(left?: Matrix3, right?: Matrix3): boolean;
        static equalsEpsilon(left: Matrix3, right: Matrix3, epsilon: number): boolean;
    }

    class Matrix4 {
        static packedLength: number;
        static IDENTITY: Matrix4;
        static COLUMN0ROW0: number;
        static COLUMN0ROW1: number;
        static COLUMN0ROW2: number;
        static COLUMN0ROW3: number;
        static COLUMN1ROW0: number;
        static COLUMN1ROW1: number;
        static COLUMN1ROW2: number;
        static COLUMN1ROW3: number;
        static COLUMN2ROW0: number;
        static COLUMN2ROW1: number;
        static COLUMN2ROW2: number;
        static COLUMN2ROW3: number;
        static COLUMN3ROW0: number;
        static COLUMN3ROW1: number;
        static COLUMN3ROW2: number;
        static COLUMN3ROW3: number;
        constructor(column0Row0?: number, column1Row0?: number, column2Row0?: number, column3Row0?: number, column0Row1?: number, column1Row1?: number, column2Row1?: number, column3Row1?: number, column0Row2?: number, column1Row2?: number, column2Row2?: number, column3Row2?: number, column0Row3?: number, column1Row3?: number, column2Row3?: number, column3Row3?: number);
        clone(result?: Matrix4): Matrix4;
        equals(right?: Matrix4): boolean;
        equalsEpsilon(right: Matrix4, epsilon: number): boolean;
        toString(): string;
        static pack(value: Matrix4, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: Matrix4): Matrix4;
        static clone(matrix: Matrix4, result?: Matrix4): Matrix4;
        static fromArray(array: number[], startingIndex?: number, result?: Matrix4): Matrix4;
        static fromColumnMajorArray(values: number[], result?: Matrix4): Matrix4;
        static fromRowMajorArray(values: number[], result?: Matrix4): Matrix4;
        static fromRotationTranslation(rotation: Matrix3, translation?: Cartesian3, result?: Matrix4): Matrix4;
        static fromTranslationQuaternionRotationScale(translation: Cartesian3, rotation: Quaternion, scale: Cartesian3, result?: Matrix4): Matrix4;
        static fromTranslation(translation: Cartesian3, result?: Matrix4): Matrix4;
        static fromScale(scale: Cartesian3, result?: Matrix4): Matrix4;
        static fromUniformScale(scale: number, result?: Matrix4): Matrix4;
        static fromCamera(camera: Camera, result?: Matrix4): Matrix4;
        static computePerspectiveFieldOfView(fovY: number, aspectRatio: number, near: number, far: number, result: Matrix4): Matrix4;
        static computeOrthographicOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4): Matrix4;
        static computePerspectiveOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4): Matrix4;
        static computeInfinitePerspectiveOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4): Matrix4;
        static computeViewportTransformation(viewport: any, nearDepthRange: number, farDepthRange: number, result: Matrix4): Matrix4;
        static toArray(matrix: Matrix4, result?: number[]): number[];
        static getElementIndex(row: number, column: number): number;
        static getColumn(matrix: Matrix4, index: number, result: Cartesian4): Cartesian4;
        static setColumn(matrix: Matrix4, index: number, cartesian: Cartesian4, result: Cartesian4): Matrix4;
        static getRow(matrix: Matrix4, index: number, result: Cartesian4): Cartesian4;
        static setRow(matrix: Matrix4, index: number, cartesian: Cartesian4, result: Cartesian4): Matrix4;
        static getScale(matrix: Matrix4, result: Cartesian3): Cartesian3;
        static getMaximumScale(matrix: Matrix4): number;
        static multiply(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
        static add(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
        static subtract(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
        static multiplyTransformation(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
        static multiplyByMatrix3(matrix: Matrix4, rotation: Matrix3, result: Matrix4): Matrix4;
        static multiplyByTranslation(matrix: Matrix4, translation: Cartesian3, result: Matrix4): Matrix4;
        static multiplyByUniformScale(matrix: Matrix4, scale: number, result: Matrix4): Matrix4;
        static multiplyByScale(matrix: Matrix4, scale: Cartesian3, result: Matrix4): Matrix4;
        static multiplyByVector(matrix: Matrix4, cartesian: Cartesian4, result: Cartesian4): Cartesian4;
        static multiplyByPointAsVector(matrix: Matrix4, cartesian: Cartesian3, result: Cartesian3): Cartesian3;
        static multiplyByPoint(matrix: Matrix4, cartesian: Cartesian3, result: Cartesian3): Cartesian3;
        static multiplyByScalar(matrix: Matrix4, scalar: number, result: Matrix4): Matrix4;
        static negate(matrix: Matrix4, result: Matrix4): Matrix4;
        static transpose(matrix: Matrix4, result: Matrix4): Matrix4;
        static abs(matrix: Matrix4, result: Matrix4): Matrix4;
        static equals(left?: Matrix4, right?: Matrix4): boolean;
        static equalsEpsilon(left: Matrix4, right: Matrix4, epsilon: number): boolean;
        static getTranslation(matrix: Matrix4, result: Cartesian3): Cartesian3;
        static getRotation(matrix: Matrix4, result: Matrix3): Matrix3;
        static inverse(matrix: Matrix4, result: Matrix4): Matrix4;
        static inverseTransformation(matrix: Matrix4, result: Matrix4): Matrix4;
    }

    class NearFarScalar {
        near: number;
        nearValue: number;
        far: number;
        farValue: number;
        static packedLength: number;
        constructor(near?: number, nearValue?: number, far?: number, farValue?: number);
        clone(result?: NearFarScalar): NearFarScalar;
        equals(right?: NearFarScalar): boolean;
        static clone(nearFarScalar: NearFarScalar, result?: NearFarScalar): NearFarScalar;
        static pack(value: NearFarScalar, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: NearFarScalar): NearFarScalar;
        static equals(left?: NearFarScalar, right?: NearFarScalar): boolean;
    }

    class ObjectOrientedBoundingBox {
        rotation: Matrix3;
        translation: Cartesian3;
        scale: Cartesian3;
        constructor(rotation?: Matrix3, translation?: Cartesian3, scale?: Cartesian3);
        clone(result?: ObjectOrientedBoundingBox): ObjectOrientedBoundingBox;
        equals(right?: ObjectOrientedBoundingBox): boolean;
        static fromPoints(positions: Cartesian3[], result?: ObjectOrientedBoundingBox): ObjectOrientedBoundingBox;
        static fromBoundingRectangle(boundingRectangle: BoundingRectangle, rotation?: number): ObjectOrientedBoundingBox;
        static clone(box: ObjectOrientedBoundingBox, result?: ObjectOrientedBoundingBox): ObjectOrientedBoundingBox;
        static intersect(left: ObjectOrientedBoundingBox, right: ObjectOrientedBoundingBox): boolean;
        static equals(left: ObjectOrientedBoundingBox, right: ObjectOrientedBoundingBox): boolean;
    }

    class Occluder {
        position: Cartesian3;
        radius: number;
        cameraPosition: Cartesian3;
        constructor(occluderBoundingSphere: BoundingSphere, cameraPosition: Cartesian3);
        isPointVisible(occludee: Cartesian3): boolean;
        isBoundingSphereVisible(occludee: BoundingSphere): boolean;
        computeVisibility(occludeeBS: BoundingSphere): number;
        static fromBoundingSphere(occluderBoundingSphere: BoundingSphere, cameraPosition: Cartesian3, result?: Occluder): Occluder;
        static computeOccludeePoint(occluderBoundingSphere: BoundingSphere, occludeePosition: Cartesian3, positions: Cartesian3[]): any;
        static computeOccludeePointFromRectangle(rectangle: Rectangle, ellipsoid?: Ellipsoid): any;
    }

    class PinBuilder {
        fromColor(color: Color, size: number): HTMLCanvasElement;
        fromUrl(url: string, color: Color, size: number): HTMLCanvasElement | Promise<HTMLCanvasElement>;
        fromMakiIconId(id: string, color: Color, size: number): HTMLCanvasElement | Promise<HTMLCanvasElement>;
        fromText(text: string, color: Color, size: number): HTMLCanvasElement;
    }

    class Plane {
        normal: Cartesian3;
        distance: number;
        constructor(normal: Cartesian3, distance: number);
        static fromPointNormal(point: Cartesian3, normal: Cartesian3, result?: Plane): Plane;
        static getPointDistance(plane: Plane, point: Cartesian3): number;
    }

    class PolygonGeometry {
        constructor(options: { polygonHierarchy: PolygonHierarchy; height?: number; extrudedHeight?: number; vertexFormat?: VertexFormat; stRotation?: number; ellipsoid?: Ellipsoid; granularity?: number; perPositionHeight?: boolean });
        packedLength: number;
        static createGeometry(polygonGeometry: PolygonGeometry): Geometry;
        static fromPositions(options: PolygonGeometryOptions): PolygonGeometry;
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: PolygonGeometry): PolygonGeometry;
    }

    type PolygonGeometryOptions = PolygonOutlineGeometryOptions & {
        closeBottom?: boolean;
        closeTop?: boolean;
        stRotation?: number;
    };

    class PolygonHierarchy extends Property {
        positions: Cartesian3[];
        holes: PolygonHierarchy[];
        constructor(positions?: Cartesian3[], holes?: PolygonHierarchy[]);
    }

    class PolygonOutlineGeometry {
        constructor(options: { polygonHierarchy: any; height?: number; extrudedHeight?: number; vertexFormat?: VertexFormat; ellipsoid?: Ellipsoid; granularity?: number; perPositionHeight?: boolean });
        packedLength: number;
        static createGeometry(polygonGeometry: PolygonOutlineGeometry): Geometry;
        static fromPositions(options: PolygonOutlineGeometryOptions): PolygonOutlineGeometry;
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: PolygonOutlineGeometry): PolygonOutlineGeometry;
    }

    type PolygonOutlineGeometryOptions = {
        polygonHierarchy: PolygonHierarchy;
        ellipsoid?: Ellipsoid;
        extrudedHeight?: number;
        granularity?: number;
        height?: number;
        perPositionHeight?: boolean;
        vertexFormat?: VertexFormat;
    };

    class PolylineGeometry {
        packedLength: number;
        constructor(options: { positions: Cartesian3[]; width?: number; colors?: Color[]; colorsPerVertex?: boolean; followSurface?: boolean; granularity?: number; ellipsoid?: Ellipsoid });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: PolylineGeometry): PolylineGeometry;
        static createGeometry(polylineGeometry: PolylineGeometry): Geometry;
    }

    class PolylineVolumeGeometry {
        packedLength: number;
        constructor(options: { polylinePositions: Cartesian3[]; shapePositions: Cartesian2[]; ellipsoid?: Ellipsoid; granularity?: number; vertexFormat?: VertexFormat; cornerType?: CornerType });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: PolylineVolumeGeometry): PolylineVolumeGeometry;
        static createGeometry(polylineVolumeGeometry: PolylineVolumeGeometry): Geometry;
    }

    class PolylineVolumeOutlineGeometry {
        packedLength: number;
        constructor(options: { polylinePositions: Cartesian3[]; shapePositions: number; ellipsoid?: Ellipsoid; granularity?: number; cornerType?: CornerType });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: PolylineVolumeOutlineGeometry): PolylineVolumeOutlineGeometry;
        static createGeometry(polylineVolumeOutlineGeometry: PolylineVolumeOutlineGeometry): Geometry;
    }

    class QuantizedMeshTerrainData {
        waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement;
        constructor(options: { quantizedVertices: Uint16Array; indices: Uint16Array | Uint32Array; minimumHeight: number; maximumHeight: number; boundingSphere: BoundingSphere; horizonOcclusionPoint: Cartesian3; westIndices: number[]; southIndices: number[]; eastIndices: number[]; northIndices: number[]; westSkirtHeight: number; southSkirtHeight: number; eastSkirtHeight: number; northSkirtHeight: number; childTileMask?: number; createdByUpsampling?: boolean; encodedNormals?: Uint8Array; waterMask?: Uint8Array });
        createMesh(tilingScheme: TilingScheme, x: number, y: number, level: number): Promise<TerrainMesh>;
        upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<QuantizedMeshTerrainData>;
        interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number;
        isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean;
        wasCreatedByUpsampling(): boolean;
    }

    class Quaternion {
        x: number;
        y: number;
        z: number;
        w: number;
        static packedLength: number;
        static packedInterpolationLength: number;
        static ZERO: Quaternion;
        static IDENTITY: Quaternion;
        constructor(x?: number, y?: number, z?: number, w?: number);
        clone(result?: Quaternion): Quaternion;
        equals(right?: Quaternion): boolean;
        equalsEpsilon(right: Quaternion, epsilon: number): boolean;
        toString(): string;
        static fromAxisAngle(axis: Cartesian3, angle: number, result?: Quaternion): Quaternion;
        static fromRotationMatrix(matrix: Matrix3, result?: Quaternion): Quaternion;
        static fromHeadingPitchRoll(heading: number, pitch: number, roll: number, result: Quaternion): Quaternion;
        static pack(value: Quaternion, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: Quaternion): Quaternion;
        static convertPackedArrayForInterpolation(packedArray: number[], startingIndex?: number, lastIndex?: number, result?: number[]): void;
        static unpackInterpolationResult(array: number[], sourceArray: number[], startingIndex?: number, lastIndex?: number, result?: Quaternion): Quaternion;
        static clone(quaternion: Quaternion, result?: Quaternion): Quaternion;
        static conjugate(quaternion: Quaternion, result: Quaternion): Quaternion;
        static magnitudeSquared(quaternion: Quaternion): number;
        static magnitude(quaternion: Quaternion): number;
        static normalize(quaternion: Quaternion, result: Quaternion): Quaternion;
        static inverse(quaternion: Quaternion, result: Quaternion): Quaternion;
        static add(left: Quaternion, right: Quaternion, result: Quaternion): Quaternion;
        static subtract(left: Quaternion, right: Quaternion, result: Quaternion): Quaternion;
        static negate(quaternion: Quaternion, result: Quaternion): Quaternion;
        static dot(left: Quaternion, right: Quaternion): number;
        static multiply(left: Quaternion, right: Quaternion, result: Quaternion): Quaternion;
        static multiplyByScalar(quaternion: Quaternion, scalar: number, result: Quaternion): Quaternion;
        static divideByScalar(quaternion: Quaternion, scalar: number, result: Quaternion): Quaternion;
        static computeAxis(quaternion: Quaternion, result: Cartesian3): Cartesian3;
        static computeAngle(quaternion: Quaternion): number;
        static lerp(start: Quaternion, end: Quaternion, t: number, result: Quaternion): Quaternion;
        static slerp(start: Quaternion, end: Quaternion, t: number, result: Quaternion): Quaternion;
        static log(quaternion: Quaternion, result: Cartesian3): Cartesian3;
        static exp(cartesian: Cartesian3, result: Quaternion): Quaternion;
        static computeInnerQuadrangle(q0: Quaternion, q1: Quaternion, q2: Quaternion, result: Quaternion): Quaternion;
        static squad(q0: Quaternion, q1: Quaternion, s0: Quaternion, s1: Quaternion, t: number, result: Quaternion): Quaternion;
        static fastSlerp(start: Quaternion, end: Quaternion, t: number, result: Quaternion): Quaternion;
        static fastSquad(q0: Quaternion, q1: Quaternion, s0: Quaternion, s1: Quaternion, t: number, result?: Quaternion): Quaternion;
        static equals(left?: Quaternion, right?: Quaternion): boolean;
        static equalsEpsilon(left: Quaternion, right: Quaternion, epsilon: number): boolean;
    }

    class QuaternionSpline {
        times: number[];
        points: Quaternion[];
        innerQuadrangles: Quaternion[];
        constructor(options: { times: number[]; points: Quaternion[]; firstInnerQuadrangle?: Quaternion; lastInnerQuadrangle?: Quaternion });
        findTimeInterval(time: number): number;
        evaluate(time: number, result?: Quaternion): Quaternion;
    }

    module Queue {
        type Comparator = (a: any, b: any) => number;
    }

    class Ray {
        origin: Cartesian3;
        direction: Cartesian3;
        constructor(origin?: Cartesian3, direction?: Cartesian3);
        static getPoint(t: number, result?: Cartesian3): Cartesian3;
    }

    class Rectangle {
        west: number;
        south: number;
        east: number;
        north: number;
        width: number;
        height: number;
        static packedLength: number;
        static MAX_VALUE: Rectangle;
        constructor(west?: number, south?: number, east?: number, north?: number);
        clone(result?: Rectangle): Rectangle;
        equals(other?: Rectangle): boolean;
        equalsEpsilon(other: Rectangle, epsilon: number): boolean;
        static pack(value: Rectangle, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: Rectangle): Rectangle;
        static computeWidth(rectangle: Rectangle): number;
        static computeHeight(rectangle: Rectangle): number;
        static fromDegrees(west?: number, south?: number, east?: number, north?: number, result?: Rectangle): Rectangle;
        static fromCartographicArray(cartographics: Cartographic[], result?: Rectangle): Rectangle;
        static clone(rectangle: Rectangle, result?: Rectangle): Rectangle;
        static equals(left?: Rectangle, right?: Rectangle): boolean;
        /**
         *
         * @param rectangle
         * @throws {DeveloperError}
         */
        static validate(rectangle: Rectangle): void;
        static southwest(rectangle: Rectangle, result?: Cartographic): Cartographic;
        static northwest(rectangle: Rectangle, result?: Cartographic): Cartographic;
        static northeast(rectangle: Rectangle, result?: Cartographic): Cartographic;
        static southeast(rectangle: Rectangle, result?: Cartographic): Cartographic;
        static center(rectangle: Rectangle, result?: Cartographic): Cartographic;
        static intersection(rectangle: Rectangle, otherRectangle: Rectangle, result?: Rectangle): Rectangle;
        static contains(rectangle: Rectangle, cartographic: Cartographic): boolean;
        static subsample(rectangle: Rectangle, ellipsoid?: Ellipsoid, surfaceHeight?: number, result?: Cartesian3[]): Cartesian3[];
    }

    class RectangleGeometry {
        static packedLength: number;
        constructor(options: { rectangle: Rectangle; vertexFormat?: VertexFormat; ellipsoid?: Ellipsoid; granularity?: number; height?: number; rotation?: number; stRotation?: number; extrudedHeight?: number });
        static pack(value: BoundingSphere, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: RectangleGeometry): RectangleGeometry;
        static createGeometry(rectangleGeometry: RectangleGeometry): Geometry;
    }

    class RectangleOutlineGeometry {
        static packedLength: number;
        constructor(options: { rectangle: Rectangle; ellipsoid?: Ellipsoid; granularity?: number; height?: number; rotation?: number; extrudedHeight?: number });
        static pack(value: BoundingSphere, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: RectangleGeometry): RectangleGeometry;
        static createGeometry(rectangleGeometry: RectangleOutlineGeometry): Geometry;
    }

    class RequestErrorEvent {
        statusCode: number;
        response: any;
        responseHeaders: any;
        constructor(statusCode?: number, response?: any, responseHeaders?: string | any);
        toString(): string;
    }

    class RuntimeError {
        name: string;
        message: string;
        stack: string;
        constructor(message?: string);
    }

    class ScreenSpaceEventHandler {
        constructor(element?: HTMLCanvasElement);
        setInputAction(action: ScreenSpaceEventAction, type: number, modifier?: number): void;
        getInputAction(type: number, modifier?: number): ScreenSpaceEventAction;
        removeInputAction(type: number, modifier?: number): void;
        isDestroyed(): boolean;
        destroy(): void;
    }
    type ScreenSpaceEventAction = (evt: PositionedEvent | MoveEvent | Touch2Event) => void;

    class ShowGeometryInstanceAttribute {
        value: Uint8Array;
        componentDatatype: ComponentDatatype;
        componentsPerAttribute: number;
        normalize: boolean;
        constructor(show?: boolean);
        static toValue(show: boolean, result?: Uint8Array): Uint8Array;
    }

    class SimplePolylineGeometry {
        packedLength: number;
        constructor(options: { positions: Cartesian3[]; colors?: Color[]; colorsPerVertex?: boolean; followSurface?: boolean; granularity?: number; ellipsoid?: Ellipsoid });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: SimplePolylineGeometry): SimplePolylineGeometry;
        static createGeometry(simplePolylineGeometry: SimplePolylineGeometry): Geometry;
    }

    class SphereGeometry {
        static packedLength: number;
        constructor(options?: { radius?: number; stackPartitions?: number; slicePartitions?: number; vertexFormat?: VertexFormat });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: SphereGeometry): SphereGeometry;
        static createGeometry(sphereGeometry: SphereGeometry): Geometry;
    }

    class SphereOutlineGeometry {
        static packedLength: number;
        constructor(options?: { radius?: number; stackPartitions?: number; slicePartitions?: number; subdivisions?: number });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: SphereOutlineGeometry): SphereOutlineGeometry;
        static createGeometry(sphereGeometry: SphereOutlineGeometry): Geometry;
    }

    class Spherical {
        constructor(clock?: number, cone?: number, magnitude?: number);
        equals(other: Spherical): boolean;
        clone(result?: Spherical): Spherical;
        equalsEpsilon(other: Spherical, epsilon: number): boolean;
        toString(): string;
        static fromCartesian3(cartesian3: Cartesian3, spherical?: Spherical): Spherical;
        static clone(spherical: Spherical, result?: Spherical): Spherical;
        static normalize(spherical: Spherical, result?: Spherical): Spherical;
        static equals(left: Spherical, right: Spherical): boolean;
        static equalsEpsilon(left: Spherical, right: Spherical, epsilon?: number): boolean;
    }

    class Spline {
        times: number[];
        points: Cartesian3[] | Quaternion[];
        evaluate(time: number, result?: Cartesian3 | Quaternion): Cartesian3 | Quaternion;
        findTimeInterval(time: number, startIndex: number): number;
    }

    class TaskProcessor {
        constructor(workerName: string, maximumActiveTasks?: number);
        scheduleTask(parameters: any, transferableObjects?: any[]): Promise<any>;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class TerrainData {
        waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement;
        interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number;
        isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean;
        createMesh(tilingScheme: TilingScheme, x: number, y: number, level: number): Promise<TerrainMesh>;
        upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<TerrainData>;
        wasCreatedByUpsampling(): boolean;
    }

    class TerrainMesh {
        center: Cartesian3;
        vertices: Float32Array;
        stride: number;
        indices: Uint16Array | Uint32Array;
        minimumHeight: number;
        maximumHeight: number;
        boundingSphere3D: BoundingSphere;
        occludeePointInScaledSpace: Cartesian3;
        constructor(center: Cartesian3, vertices: Float32Array, indices: Uint16Array | Uint32Array, minimumHeight: number, maximumHeight: number, boundingSphere3D: BoundingSphere, occludeePointInScaledSpace: Cartesian3, vertexStride?: number);
    }

    class TerrainProvider {
        credit: Credit;
        errorEvent: Event;
        hasVertexNormals: boolean;
        hasWaterMask: boolean;
        ready: boolean;
        static heightmapTerrainQuality: number;
        tilingScheme: TilingScheme;
        getLevelMaximumGeometricError(level: number): number;
        getTileDataAvailable(x: number, y: number, level: number): boolean;
        requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
        static getEstimatedLevelZeroGeometricErrorForAHeightmap(ellipsoid: Ellipsoid, tileImageWidth: number, numberOfTilesAtLevelZero: number): number;
        static getRegularGridIndices(width: number, height: number): Uint16Array;
    }

    class TileProviderError {
        provider: ImageryProvider | TerrainProvider;
        message: string;
        x: number;
        y: number;
        level: number;
        timesRetried: number;
        retry: boolean;
        error: Error;
        constructor(provider: ImageryProvider | TerrainProvider, message: string, x?: number, y?: number, level?: number, timesRetried?: number, error?: Error);
        static handleError(previousError: TileProviderError, provider: ImageryProvider | TerrainProvider, event: Event, message: string, x: number, y: number, level: number, retryFunction: TileProviderError.RetryFunction, errorDetails?: Error): TileProviderError;
        static handleSuccess(previousError: TileProviderError): void;
    }

    module TileProviderError {
        type RetryFunction = () => void;
    }

    class TilingScheme {
        ellipsoid: Ellipsoid;
        rectangle: Rectangle;
        projection: MapProjection;
        getNumberOfXTilesAtLevel(level: number): number;
        getNumberOfYTilesAtLevel(level: number): number;
        rectangleToNativeRectangle(rectangle: Rectangle, result?: Rectangle): Rectangle;
        tileXYToNativeRectangle(x: number, y: number, level: number, result?: any): Rectangle;
        tileXYToRectangle(x: number, y: number, level: number, result?: any): Rectangle;
        positionToTileXY(position: Cartographic, level: number, result?: Cartesian2): Cartesian2;
    }

    class TimeInterval {
        start: JulianDate;
        stop: JulianDate;
        data: any;
        isStartIncluded: boolean;
        isStopIncluded: boolean;
        isEmpty: boolean;
        static EMPTY: TimeInterval;
        constructor(options?: { start?: JulianDate; stop?: JulianDate; isStartIncluded?: boolean; isStopIncluded?: boolean; data?: any });
        clone(result?: TimeInterval): TimeInterval;
        equals(right?: TimeInterval, dataComparer?: TimeInterval.DataComparer): boolean;
        equalsEpsilon(right: TimeInterval, epsilon: number, dataComparer?: TimeInterval.DataComparer): boolean;
        toString(): string;
        static fromIso8601(options: { iso8601: string; isStartIncluded?: boolean; isStopIncluded?: boolean; data?: any }, result?: TimeInterval): TimeInterval;
        static toIso8601(timeInterval: TimeInterval, precision?: number): string;
        static clone(timeInterval?: TimeInterval, result?: TimeInterval): TimeInterval;
        static equals(left?: TimeInterval, right?: TimeInterval, dataComparer?: TimeInterval.DataComparer): boolean;
        static equalsEpsilon(left: TimeInterval, right: TimeInterval, epsilon: number, dataComparer?: TimeInterval.DataComparer): boolean;
        static intersect(left: TimeInterval, right: TimeInterval, result: TimeInterval, mergeCallback?: TimeInterval.MergeCallback): TimeInterval;
        static contains(timeInterval: TimeInterval, julianDate: JulianDate): boolean;
    }

    module TimeInterval {
        type MergeCallback = (leftData: any, rightData: any) => any;
        type DataComparer = (leftData: any, rightData: any) => boolean;
    }

    class TimeIntervalCollection {
        changedEvent: Event;
        start: JulianDate;
        isStartIncluded: boolean;
        stop: JulianDate;
        isStopIncluded: boolean;
        length: number;
        isEmpty: boolean;
        constructor(intervals?: TimeInterval[]);
        equals(right?: TimeIntervalCollection, dataComparer?: TimeInterval.DataComparer): boolean;
        get(index: number): TimeInterval;
        removeAll(): void;
        findIntervalContainingDate(date: JulianDate): TimeInterval;
        findDataForIntervalContainingDate(date: JulianDate): Object;
        contains(julianDate: JulianDate): boolean;
        indexOf(date: JulianDate): number;
        findInterval(options?: { start?: JulianDate; stop?: JulianDate; isStartIncluded?: boolean; isStopIncluded?: boolean }): TimeInterval;
        addInterval(interval: TimeInterval, dataComparer?: TimeInterval.DataComparer): void;
        removeInterval(interval: TimeInterval): void;
        intersect(other: TimeIntervalCollection, dataComparer?: TimeInterval.DataComparer, mergeCallback?: TimeInterval.MergeCallback): TimeIntervalCollection;
    }

    class VRTheWorldTerrainProvider {
        errorEvent: Event;
        credit: Credit;
        tilingScheme: GeographicTilingScheme;
        ready: boolean;
        hasWaterMask: boolean;
        hasVertexNormals: boolean;
        constructor(options: { url: string; proxy?: any; ellipsoid?: Ellipsoid; credit?: Credit | string });
        requestTileGeometry(x: number, y: number, level: number, throttleRequests?: boolean): Promise<TerrainData>;
        getLevelMaximumGeometricError(level: number): number;
        getTileDataAvailable(x: number, y: number, level: number): boolean;
    }

    class VertexFormat {
        position: boolean;
        normal: boolean;
        st: boolean;
        binormal: boolean;
        tangent: boolean;
        color: boolean;
        static POSITION_ONLY: VertexFormat;
        static POSITION_AND_NORMAL: VertexFormat;
        static POSITION_NORMAL_AND_ST: VertexFormat;
        static POSITION_AND_ST: VertexFormat;
        static POSITION_AND_COLOR: VertexFormat;
        static ALL: VertexFormat;
        static DEFAULT: VertexFormat;
        static packedLength: number;
        constructor(options?: any);
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: VertexFormat): VertexFormat;
        static clone(cartesian: VertexFormat, result?: VertexFormat): VertexFormat;
    }

    class WallGeometry {
        packedLength: number;
        constructor(options: { positions: Cartesian3[]; granularity?: number; maximumHeights?: number[]; minimumHeights?: number[]; ellipsoid?: Ellipsoid; vertexFormat?: VertexFormat });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: WallGeometry): WallGeometry;
        static fromConstantHeights(positions: Cartesian3[], maximumHeight?: number, minimumHeight?: number, ellipsoid?: Ellipsoid): WallGeometry;
        static createGeometry(wallGeometry: WallGeometry): Geometry;
    }

    class WallOutlineGeometry {
        packedLength: number;
        constructor(options: { positions: Cartesian3[]; granularity?: number; maximumHeights?: number[]; minimumHeights?: number[]; ellipsoid?: Ellipsoid });
        static pack(value: any, array: number[], startingIndex?: number): number[];
        static unpack(array: number[], startingIndex?: number, result?: WallOutlineGeometry): WallOutlineGeometry;
        static fromConstantHeights(positions: Cartesian3[], maximumHeight?: number, minimumHeight?: number, ellipsoid?: Ellipsoid): WallOutlineGeometry;
        static createGeometry(wallGeometry: WallOutlineGeometry): Geometry;
    }

    class WebMercatorProjection {
        ellipsoid: Ellipsoid;
        static MaximumLatitude: number;
        constructor(ellipsoid?: Ellipsoid);
        project(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
        unproject(cartesian: Cartesian3, result?: Cartographic): Cartographic;
        static mercatorAngleToGeodeticLatitude(mercatorAngle: number): number;
        static geodeticLatitudeToMercatorAngle(latitude: number): number;
    }

    class WebMercatorTilingScheme {
        ellipsoid: Ellipsoid;
        rectangle: Rectangle;
        projection: MapProjection;
        constructor(options?: { ellipsoid?: Ellipsoid; numberOfLevelZeroTilesX?: number; numberOfLevelZeroTilesY?: number; rectangleSouthwestInMeters?: Cartesian2; rectangleNortheastInMeters?: Cartesian2 });
        getNumberOfXTilesAtLevel(level: number): number;
        getNumberOfYTilesAtLevel(level: number): number;
        rectangleToNativeRectangle(rectangle: Rectangle, result?: Rectangle): Rectangle;
        tileXYToNativeRectangle(x: number, y: number, level: number, result?: any): Rectangle;
        tileXYToRectangle(x: number, y: number, level: number, result?: any): Rectangle;
        positionToTileXY(position: Cartographic, level: number, result?: Cartesian2): Cartesian2;
    }

    type BillboardGraphicsOptions = {
        image?: Property | String | HTMLCanvasElement;
        show?: Property | boolean;
        scale?: Property | number;
        horizontalOrigin?: Property | HorizontalOrigin;
        verticalOrigin?: Property | VerticalOrigin;
        eyeOffset?: Property;
        pixelOffset?: Property | Cartesian2;
        rotation?: Property;
        alignedAxis?: Property;
        width?: Property | number;
        height?: Property | number;
        color?: Property;
        scaleByDistance?: Property | NearFarScalar;
        translucencyByDistance?: Property | NearFarScalar;
        pixelOffsetScaleByDistance?: Property | NearFarScalar;
        imageSubRegion?: Property
    }

    class BillboardGraphics {
        definitionChanged: Event;
        image: Property;
        imageSubRegion: Property;
        scale: Property;
        rotation: Property;
        alignedAxis: Property;
        horizontalOrigin: Property;
        verticalOrigin: Property;
        color: Property;
        eyeOffset: Property;
        pixelOffset: Property;
        show: Property;
        width: Property;
        height: Property;
        scaleByDistance: Property;
        translucencyByDistance: Property;
        pixelOffsetScaleByDistance: Property;
        constructor(options?: BillboardGraphicsOptions);
        clone(result?: BillboardGraphics): BillboardGraphics;
        merge(source: BillboardGraphics): void;
    }

    class BillboardVisualizer {
        constructor(scene: Scene, entityCollection: EntityCollection);
        update(time: JulianDate): boolean;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class BoxGeometryUpdater {
        entity: Entity;
        fillEnabled: boolean;
        hasConstantFill: boolean;
        fillMaterialProperty: MaterialProperty;
        outlineEnabled: boolean;
        hasConstantOutline: boolean;
        outlineColorProperty: Property;
        outlineWidth: number;
        isDynamic: boolean;
        isClosed: boolean;
        geometryChanged: boolean;
        static perInstanceColorAppearanceType: Appearance;
        static materialAppearanceType: Appearance;
        constructor(entity: Entity, scene: Scene);
        isOutlineVisible(time: JulianDate): boolean;
        isFilled(time: JulianDate): boolean;
        createFillGeometryInstance(time: JulianDate): GeometryInstance;
        createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
        isDestroyed(): boolean;
        destroy(): void;
        createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
    }

    class BoxGraphics {
        definitionChanged: Event;
        show: Property;
        dimensions: Property;
        material: MaterialProperty;
        fill: Property;
        outline: Property;
        outlineColor: Property;
        outlineWidth: Property;
        constructor(options?: { dimensions?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property });
        clone(result?: BoxGraphics): BoxGraphics;
        merge(source: BoxGraphics): void;
    }

    class CallbackProperty {
        isConstant: boolean;
        definitionChanged: Event;
        constructor(callback: CallbackProperty.Callback, isConstant: boolean);
        getValue(time?: JulianDate, result?: any): any;
        setCallback(callback: CallbackProperty.Callback, isConstant: boolean): void;
        equals(other?: Property): boolean;
    }

    module CallbackProperty {
        type Callback = (time?: JulianDate, result?: any) => any;
    }

    class CheckerboardMaterialProperty {
        isConstant: boolean;
        definitionChanged: Event;
        evenColor: Property;
        oddColor: Property;
        repeat: Property;
        constructor(options?: { evenColor?: Property; oddColor?: Property; repeat?: Property });
        getType(time: JulianDate): string;
        getValue(time: JulianDate, result?: any): any;
        equals(other?: Property): boolean;
    }

    class ColorMaterialProperty {
        isConstant: boolean;
        definitionChanged: Event;
        color: Property;
        constructor(color?: Property);
        getType(time: JulianDate): string;
        getValue(time: JulianDate, result?: any): any;
        equals(other?: Property): boolean;
    }

    class CompositeEntityCollection {
        collectionChanged: Event;
        id: string;
        values: Entity[];
        constructor(collections?: EntityCollection[]);
        addCollection(collection: EntityCollection, index?: number): void;
        removeCollection(collection: EntityCollection): boolean;
        removeAllCollections(): void;
        containsCollection(collection: EntityCollection): boolean;
        contains(entity: Entity): boolean;
        indexOfCollection(collection: EntityCollection): number;
        getCollection(index: number): EntityCollection;
        getCollectionsLength(): number;
        raiseCollection(collection: EntityCollection): void;
        lowerCollection(collection: EntityCollection): void;
        raiseCollectionToTop(collection: EntityCollection): void;
        lowerCollectionToBottom(collection: EntityCollection): void;
        suspendEvents(): void;
        resumeEvents(): void;
        computeAvailability(): TimeInterval;
        getById(id: any): Entity;
    }

    class CompositeMaterialProperty {
        isConstant: boolean;
        definitionChanged: Event;
        intervals: TimeIntervalCollection;
        getType(time: JulianDate): string;
        getValue(time: JulianDate, result?: any): any;
        equals(other?: Property): boolean;
    }

    class CompositePositionProperty {
        isConstant: boolean;
        definitionChanged: Event;
        intervals: TimeIntervalCollection;
        referenceFrame: ReferenceFrame;
        getValue(time: JulianDate, result?: any): any;
        getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
        equals(other?: Property): boolean;
    }

    class CompositeProperty {
        isConstant: boolean;
        definitionChanged: Event;
        intervals: TimeIntervalCollection;
        getValue(time: JulianDate, result?: any): any;
        equals(other?: Property): boolean;
    }

    class ConstantPositionProperty {
        isConstant: boolean;
        definitionChanged: Event;
        referenceFrame: ReferenceFrame;
        constructor(value?: Cartesian3, referenceFrame?: ReferenceFrame);
        getValue(time: JulianDate, result?: any): any;
        setValue(value: Cartesian3, referenceFrame?: ReferenceFrame): void;
        getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
        equals(other?: Property): boolean;
    }

    class ConstantProperty {
        isConstant: boolean;
        definitionChanged: Event;
        constructor(value?: any);
        getValue(time?: JulianDate, result?: any): any;
        setValue(value: any): void;
        equals(other?: Property): boolean;
    }

    class CorridorGeometryUpdater {
        entity: Entity;
        fillEnabled: boolean;
        hasConstantFill: boolean;
        fillMaterialProperty: MaterialProperty;
        outlineEnabled: boolean;
        hasConstantOutline: boolean;
        outlineColorProperty: Property;
        outlineWidth: number;
        isDynamic: boolean;
        isClosed: boolean;
        geometryChanged: boolean;
        static perInstanceColorAppearanceType: Appearance;
        static materialAppearanceType: Appearance;
        constructor(entity: Entity, scene: Scene);
        isOutlineVisible(time: JulianDate): boolean;
        isFilled(time: JulianDate): boolean;
        createFillGeometryInstance(time: JulianDate): GeometryInstance;
        createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
        isDestroyed(): boolean;
        destroy(): void;
        createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
    }

    class CorridorGraphics {
        definitionChanged: Event;
        show: Property;
        material: MaterialProperty;
        positions: Property;
        height: Property;
        extrudedHeight: Property;
        granularity: Property;
        width: Property;
        fill: Property;
        outline: Property;
        outlineColor: Property;
        outlineWidth: Property;
        cornerType: Property;
        constructor(options?: { positions?: Property; width?: Property; cornerType?: Property; height?: Property; extrudedHeight?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; granularity?: Property });
        clone(result?: CorridorGraphics): CorridorGraphics;
        merge(source: CorridorGraphics): void;
    }

    class CustomDataSource extends DataSource {
        name: string;
        clock: DataSourceClock;
        entities: EntityCollection;
        isLoading: boolean;
        changedEvent: Event;
        errorEvent: Event;
        loadingEvent: Event;
        constructor(name?: string);
    }

    class CylinderGeometryUpdater {
        entity: Entity;
        fillEnabled: boolean;
        hasConstantFill: boolean;
        fillMaterialProperty: MaterialProperty;
        outlineEnabled: boolean;
        hasConstantOutline: boolean;
        outlineColorProperty: Property;
        outlineWidth: number;
        isDynamic: boolean;
        isClosed: boolean;
        geometryChanged: boolean;
        static perInstanceColorAppearanceType: Appearance;
        static materialAppearanceType: Appearance;
        constructor(entity: Entity, scene: Scene);
        isOutlineVisible(time: JulianDate): boolean;
        isFilled(time: JulianDate): boolean;
        createFillGeometryInstance(time: JulianDate): GeometryInstance;
        createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
        isDestroyed(): boolean;
        destroy(): void;
        createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
    }

    class CylinderGraphics {
        definitionChanged: Event;
        length: Property;
        topRadius: Property;
        bottomRadius: Property;
        numberOfVerticalLines: Property;
        slices: Property;
        show: Property;
        material: MaterialProperty;
        fill: Property;
        outline: Property;
        outlineColor: Property;
        outlineWidth: Property;
        constructor(options?: { length?: Property; topRadius?: Property; bottomRadius?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; numberOfVerticalLines?: Property; slices?: Property });
        clone(result?: CylinderGraphics): CylinderGraphics;
        merge(source: CylinderGraphics): void;
    }

    class CzmlDataSource {
        name: string;
        clock: DataSourceClock;
        entities: EntityCollection;
        isLoading: boolean;
        changedEvent: Event;
        errorEvent: Event;
        loadingEvent: Event;
        static updaters: any[];
        constructor(name?: string);
        process(data: string | any, options?: { sourceUri?: string }): Promise<CzmlDataSource>;
        load(data: string | any, options?: { sourceUri?: string }): Promise<CzmlDataSource>;
        static load(data: string | any, options?: { sourceUri?: string }): Promise<CzmlDataSource>;
        static processPacketData(type: Function, object: any, propertyName: string, packetData: any, interval: TimeInterval, sourceUri: string, entityCollection: EntityCollection): void;
        static processPositionPacketData(object: any, propertyName: string, packetData: any, interval: TimeInterval, sourceUri: string, entityCollection: EntityCollection): void;
        static processMaterialPacketData(object: any, propertyName: string, packetData: any, interval: TimeInterval, sourceUri: string, entityCollection: EntityCollection): void;
    }

    class DataSource {
        changedEvent: Event;
        clock: DataSourceClock;
        clustering: EntityCluster;
        entities: EntityCollection;
        errorEvent: Event;
        isLoading: boolean;
        loadingEvent: Event;
        name: string;
        show: boolean;
        update(time: JulianDate): boolean;
    }

    class DataSourceClock {
        definitionChanged: Event;
        startTime: JulianDate;
        stopTime: JulianDate;
        currentTime: JulianDate;
        clockRange: ClockRange;
        clockStep: ClockStep;
        multiplier: number;
        clone(result?: DataSourceClock): DataSourceClock;
        equals(other: DataSourceClock): boolean;
        merge(source: DataSourceClock): void;
        getValue(): Clock;
    }

    class DataSourceCollection {
        length: number;
        dataSourceAdded: Event;
        dataSourceRemoved: Event;
        add(dataSource: DataSource | Promise<DataSource>): Promise<DataSource>;
        remove(dataSource: DataSource, destroy?: boolean): boolean;
        removeAll(destroy?: boolean): void;
        contains(dataSource: DataSource): boolean;
        indexOf(dataSource: DataSource): number;
        get(index: number): DataSource;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class DataSourceDisplay {
        scene: Scene;
        dataSources: DataSourceCollection;
        defaultDataSource: CustomDataSource;
        static defaultVisualizersCallback: DataSourceDisplay.VisualizersCallback;
        constructor(options: { scene: Scene; dataSourceCollection: DataSourceCollection; visualizersCallback?: DataSourceDisplay.VisualizersCallback });
        isDestroyed(): boolean;
        destroy(): void;
        update(time: JulianDate): boolean;
    }

    module DataSourceDisplay {
        type VisualizersCallback = (scene: Scene, dataSource: DataSource) => Visualizer[];
    }

    class DynamicGeometryUpdater {
        update(time: JulianDate): void;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class EllipseGeometryUpdater {
        entity: Entity;
        fillEnabled: boolean;
        hasConstantFill: boolean;
        fillMaterialProperty: MaterialProperty;
        outlineEnabled: boolean;
        hasConstantOutline: boolean;
        outlineColorProperty: Property;
        outlineWidth: number;
        isDynamic: boolean;
        isClosed: boolean;
        geometryChanged: boolean;
        static perInstanceColorAppearanceType: Appearance;
        static materialAppearanceType: Appearance;
        constructor(entity: Entity, scene: Scene);
        isOutlineVisible(time: JulianDate): boolean;
        isFilled(time: JulianDate): boolean;
        createFillGeometryInstance(time: JulianDate): GeometryInstance;
        createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
        isDestroyed(): boolean;
        destroy(): void;
        createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
    }

    class EllipseGraphics {
        definitionChanged: Event;
        semiMajorAxis: Property;
        semiMinorAxis: Property;
        rotation: Property;
        show: Property;
        material: MaterialProperty;
        height: Property;
        extrudedHeight: Property;
        granularity: Property;
        stRotation: Property;
        fill: Property;
        outline: Property;
        outlineColor: Property;
        outlineWidth: Property;
        numberOfVerticalLines: Property;
        constructor(options?: { semiMajorAxis?: number; semiMinorAxis?: number; height?: Property; extrudedHeight?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; numberOfVerticalLines?: Property; rotation?: Property; stRotation?: Property; granularity?: Property });
        clone(result?: EllipseGraphics): EllipseGraphics;
        merge(source: EllipseGraphics): void;
    }

    class EllipsoidGeometryUpdater {
        entity: Entity;
        fillEnabled: boolean;
        hasConstantFill: boolean;
        fillMaterialProperty: MaterialProperty;
        outlineEnabled: boolean;
        hasConstantOutline: boolean;
        outlineColorProperty: Property;
        outlineWidth: number;
        isDynamic: boolean;
        isClosed: boolean;
        geometryChanged: boolean;
        static perInstanceColorAppearanceType: Appearance;
        static materialAppearanceType: Appearance;
        constructor(entity: Entity, scene: Scene);
        isOutlineVisible(time: JulianDate): boolean;
        isFilled(time: JulianDate): boolean;
        createFillGeometryInstance(time: JulianDate): GeometryInstance;
        createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
        isDestroyed(): boolean;
        destroy(): void;
        createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
    }

    class EllipsoidGraphics {
        definitionChanged: Event;
        show: Property;
        radii: Property;
        material: MaterialProperty;
        fill: Property;
        outline: Property;
        outlineColor: Property;
        outlineWidth: Property;
        stackPartitions: Property;
        slicePartitions: Property;
        subdivisions: Property;
        constructor(options?: { radii?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; subdivisions?: Property; stackPartitions?: Property; slicePartitions?: Property });
        clone(result?: EllipsoidGraphics): EllipsoidGraphics;
        merge(source: EllipsoidGraphics): void;
    }

    class Entity {
        availability: TimeIntervalCollection;
        id: string;
        definitionChanged: Event;
        name: string;
        show: boolean;
        isShowing: boolean;
        parent: Entity;
        propertyNames: Event;
        billboard: BillboardGraphics;
        box: BoxGraphics;
        corridor: CorridorGraphics;
        cylinder: CylinderGraphics;
        description: Property;
        ellipse: EllipseGraphics;
        ellipsoid: EllipsoidGraphics;
        entityCollection: EntityCollection;
        label: LabelGraphics;
        model: ModelGraphics;
        orientation: Property;
        path: PathGraphics;
        point: PointGraphics;
        polygon: PolygonGraphics;
        polyline: PolylineGraphics;
        polylineVolume: PolylineVolumeGraphics;
        position: PositionProperty;
        properties: PropertyBag;
        rectangle: RectangleGraphics;
        viewFrom: Property;
        wall: WallGraphics;
        constructor(options?: EntityOptions);
        isAvailable(time: JulianDate): boolean;
        addProperty(propertyName: string): void;
        removeProperty(propertyName: string): void;
        merge(source: Entity): void;
    }

    class EntityOptions {
        id?: string;
        name?: string;
        show?: boolean;
        description?: Property | string;
        position?: Property | Cartesian3;
        orientation?: Property | any;
        viewFrom?: Property | any;
        parent?: Entity;
        billboard?: BillboardGraphics | BillboardGraphicsOptions;
        box?: BoxGraphics;
        corridor?: CorridorGraphics;
        cylinder?: CylinderGraphics;
        ellipse?: EllipseGraphics;
        ellipsoid?: EllipsoidGraphics;
        label?: LabelGraphics | LabelGraphicsOptions;
        model?: ModelGraphics;
        path?: PathGraphics;
        point?: PointGraphics;
        polygon?: PolygonGraphics | PolygonGraphicsOptions;
        polyline?: PolylineGraphics;
        polylineVolume?: PolylineVolumeGraphics;
        properties?: {[key:string]: string|number|boolean};
        rectangle?: RectangleGraphics;
        wall?: WallGraphics
    }

    class EntityCluster {
        constructor(options: EntityClusterOptions);
        clusterBillboards: boolean;
        clusterEvent: Event;
        clusterLabels: boolean;
        clusterPoints: boolean;
        enabled: boolean;
        minimumClusterSize: number;
        pixelRange: number;
    }

    type EntityClusterOptions = {
        clusterBillboards?: boolean;
        clusterLabels?: boolean;
        clusterPoints?: boolean;
        enabled?: boolean;
        minimumClusterSize?: number;
        pixelRange?: number;
    }

    module EntityCluster {
        type newClustterCallback = (clusteredEntities: Entity[], cluster: {billboard: BillboardGraphics, label: LabelGraphics, point: PointGraphics}) => void;
    }

    class EntityCollection {
        collectionChanged: Event;
        id: string;
        owner: DataSource | CompositeEntityCollection;
        show: boolean;
        values: Entity[];
        suspendEvents(): void;
        resumeEvents(): void;
        computeAvailability(): TimeInterval;
        add(entity: Entity | EntityOptions): Entity;
        remove(entity: Entity): boolean;
        contains(entity: Entity): boolean;
        removeById(id: any): boolean;
        removeAll(): void;
        getById(id: any): Entity;
        getOrCreateEntity(id: any): Entity;
    }

    module EntityCollection {
        type collectionChangedEventCallback = (collection: EntityCollection, added: Entity[], removed: Entity[], changed: Entity[]) => void;
    }

    class EntityView {
        entity: Entity;
        scene: Scene;
        ellipsoid: Ellipsoid;
        boundingSphere: Entity;
        static defaultOffset3D: Cartesian3;
        constructor(entity: Entity, scene: Scene, ellipsoid?: Ellipsoid, boundingSphere?: BoundingSphere);
        update(time: JulianDate): void;
    }

    class GeoJsonDataSource extends DataSource {
        name: string;
        clock: DataSourceClock;
        entities: EntityCollection;
        isLoading: boolean;
        changedEvent: Event;
        errorEvent: Event;
        loadingEvent: Event;
        static markerSize: number;
        static markerSymbol: string;
        static markerColor: Color;
        static stroke: Color;
        static strokeWidth: number;
        static fill: Color;
        static crsNames: any;
        static crsLinkHrefs: any;
        static crsLinkTypes: any;
        constructor(name?: string);
        load(data: string | any, options?: { sourceUri?: string; markerSize?: number; markerSymbol?: string; markerColor?: Color; stroke?: Color; strokeWidth?: number; fill?: Color }): Promise<GeoJsonDataSource>;
        static load(data: string | any, options?: { sourceUri?: string; markerSize?: number; markerSymbol?: string; markerColor?: Color; stroke?: Color; strokeWidth?: number; fill?: Color }): Promise<GeoJsonDataSource>;
    }

    class GeometryUpdater {
        entity: Entity;
        fillEnabled: boolean;
        hasConstantFill: boolean;
        fillMaterialProperty: MaterialProperty;
        outlineEnabled: boolean;
        hasConstantOutline: boolean;
        outlineColorProperty: Property;
        outlineWidth: number;
        isDynamic: boolean;
        isClosed: boolean;
        geometryChanged: boolean;
        static perInstanceColorAppearanceType: Appearance;
        static materialAppearanceType: Appearance;
        constructor(entity: Entity, scene: Scene);
        isOutlineVisible(time: JulianDate): boolean;
        isFilled(time: JulianDate): boolean;
        createFillGeometryInstance(time: JulianDate): GeometryInstance;
        createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
        isDestroyed(): boolean;
        destroy(): void;
        createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
    }

    class GeometryVisualizer {
        constructor(type: GeometryUpdater, scene: Scene, entityCollection: EntityCollection);
        update(time: JulianDate): boolean;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class GridMaterialProperty {
        isConstant: boolean;
        definitionChanged: Event;
        color: Color;
        cellAlpha: Property;
        lineCount: Property;
        lineThickness: Property;
        lineOffset: Property;
        constructor(options?: { color?: Property; cellAlpha?: Property; lineCount?: Property; lineThickness?: Property; lineOffset?: Property });
        getType(time: JulianDate): string;
        getValue(time: JulianDate, result?: any): any;
        equals(other?: Property): boolean;
    }

    class ImageMaterialProperty {
        isConstant: boolean;
        definitionChanged: Event;
        image: Property;
        repeat: Property;
        constructor(options?: { image?: Property; repeat?: Property });
        getType(time: JulianDate): string;
        getValue(time: JulianDate, result?: any): any;
        equals(other?: Property): boolean;
    }

    class KmlDataSource extends DataSource {
        name: string;
        clock: DataSourceClock;
        entities: EntityCollection;
        isLoading: boolean;
        changedEvent: Event;
        errorEvent: Event;
        loadingEvent: Event;
        constructor(options: KmlConstructorOptions);
        load(data: string | Document | Blob, options?: KmlLoadOptions): Promise<KmlDataSource>;
        static load(data: string | Document | Blob, options?: KmlConstructorOptions & KmlLoadOptions): Promise<KmlDataSource>;
    }

    class KmlConstructorOptions {
        camera: Camera;
        canvas: HTMLCanvasElement;
        proxy?: DefaultProxy;
    }

    class KmlLoadOptions {
        sourceUri?: string;
        clampToGround?: boolean;
        query?: Object;
    }

    class KmlFeatureData {
        author: { name: string; uri: string; email: string };
        link: { href: string; hreflang: string; rel: string; type: string; title: string; length: string };
        address: string;
        phoneNumber: string;
        snippet: string;
        extendedData: string;
    }

    class LabelGraphics {
        definitionChanged: Event;
        text: Property;
        font: Property;
        style: Property;
        fillColor: Property;
        outlineColor: Property;
        outlineWidth: Property;
        horizontalOrigin: Property;
        verticalOrigin: Property;
        eyeOffset: Property;
        pixelOffset: Property;
        scale: Property;
        show: Property;
        translucencyByDistance: Property;
        pixelOffsetScaleByDistance: Property;
        constructor(options?: LabelGraphicsOptions);
        clone(result?: LabelGraphics): LabelGraphics;
        merge(source: LabelGraphics): void;
    }

    class LabelGraphicsOptions {
        text?: Property | string;
        font?: Property | string;
        style?: Property;
        fillColor?: Property | Color;
        backgroundColor?: Property | Color;
        outlineColor?: Property | Color;
        outlineWidth?: Property | number;
        show?: Property | boolean;
        showBackground?: Property | boolean;
        scale?: Property | NearFarScalar;
        scaleByDistance?: Property | NearFarScalar;
        horizontalOrigin?: Property | HorizontalOrigin;
        verticalOrigin?: Property | VerticalOrigin;
        eyeOffset?: Property | Cartesian2;
        pixelOffset?: Property | Cartesian2;
        translucencyByDistance?: Property | NearFarScalar;
        pixelOffsetScaleByDistance?: Property | NearFarScalar;
    }

    class LabelVisualizer {
        constructor(scene: Scene, entityCollection: EntityCollection);
        update(time: JulianDate): boolean;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class MaterialProperty {
        isConstant: boolean;
        definitionChanged: Event;
        equals(left: MaterialProperty, right: MaterialProperty): boolean;
        getType(time: JulianDate): string;
        getValue(time: JulianDate, result?: any): any;
    }

    class ModelGraphics {
        definitionChanged: Event;
        show: Property;
        scale: Property;
        minimumPixelSize: Property;
        uri: Property;
        constructor(options?: { uri?: Property; show?: Property; scale?: Property; minimumPixelSize?: Property });
        clone(result?: ModelGraphics): ModelGraphics;
        merge(source: ModelGraphics): void;
    }

    class ModelVisualizer {
        constructor(scene: Scene, entityCollection: EntityCollection);
        update(time: JulianDate): boolean;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class PathGraphics {
        definitionChanged: Event;
        show: Property;
        material: MaterialProperty;
        width: Property;
        resolution: Property;
        leadTime: Property;
        trailTime: Property;
        constructor(options?: { leadTime?: Property; trailTime?: Property; show?: Property; width?: Property; material?: MaterialProperty; resolution?: Property });
        clone(result?: PathGraphics): PathGraphics;
        merge(source: PathGraphics): void;
    }

    class PathVisualizer {
        constructor(scene: Scene, entityCollection: EntityCollection);
        update(time: JulianDate): boolean;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class PointGraphics {
        color: Property;
        pixelSize: Property;
        outlineColor: Property;
        outlineWidth: Property;
        show: Property | boolean;
        scaleByDistance: Property;
        translucencyByDistance: Property;
        heightReference: Property;
        distanceDisplayCondition: Property;
        constructor(options?: PointGraphicsOptions);
        clone(result?: PointGraphics): PointGraphics;
        merge(source: PointGraphics): void;
    }

    class PointGraphicsOptions {
        color?: Color;
        pixelSize?: number;
        outlineColor?: Color;
        outlineWidth?: number;
        show?: Property | boolean;
        scaleByDistance?: Property | NearFarScalar;
        translucencyByDistance?: Property | NearFarScalar;
        heightReference?: HeightReference;
        distanceDisplayCondition?: Property | number;
    }

    class PointVisualizer {
        constructor(scene: Scene, entityCollection: EntityCollection);
        update(time: JulianDate): boolean;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class PolygonGeometryUpdater {
        entity: Entity;
        fillEnabled: boolean;
        hasConstantFill: boolean;
        fillMaterialProperty: MaterialProperty;
        outlineEnabled: boolean;
        hasConstantOutline: boolean;
        outlineColorProperty: Property;
        outlineWidth: number;
        isDynamic: boolean;
        isClosed: boolean;
        geometryChanged: boolean;
        static perInstanceColorAppearanceType: Appearance;
        static materialAppearanceType: Appearance;
        constructor(entity: Entity, scene: Scene);
        isOutlineVisible(time: JulianDate): boolean;
        isFilled(time: JulianDate): boolean;
        createFillGeometryInstance(time: JulianDate): GeometryInstance;
        createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
        isDestroyed(): boolean;
        destroy(): void;
        createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
    }

    class PolygonGraphics {
        definitionChanged: Event;
        show: Property | boolean;
        material: MaterialProperty;
        positions: Property;
        hierarchy: Property;
        height: Property;
        extrudedHeight: Property;
        granularity: Property;
        stRotation: Property;
        fill: Property;
        outline: Property;
        outlineColor: Property;
        outlineWidth: Property;
        perPositionHeight: Property;
        constructor(options?: PolygonGraphicsOptions);
        clone(result?: PolygonGraphics): PolygonGraphics;
        merge(source: PolygonGraphics): void;
    }

    class PolygonGraphicsOptions {
        hierarchy?: Property | PolygonHierarchy;
        height?: number;
        extrudedHeight?: Property | number;
        show?: Property | boolean;
        fill?: Property | boolean;
        material?: MaterialProperty | Color;
        outline?: boolean;
        outlineColor?: Property | Color;
        outlineWidth?: number;
        stRotation?: Property | number;
        granularity?: Property | number;
        perPositionHeight?: Property | boolean;
    }

    class PolylineArrowMaterialProperty {
        isConstant: boolean;
        definitionChanged: Event;
        color: Property;
        constructor(color?: Property);
        getType(time: JulianDate): string;
        getValue(time: JulianDate, result?: any): any;
        equals(other?: Property): boolean;
    }

    class PolylineGeometryUpdater {
        entity: Entity;
        fillEnabled: boolean;
        hasConstantFill: boolean;
        fillMaterialProperty: MaterialProperty;
        outlineEnabled: boolean;
        hasConstantOutline: boolean;
        outlineColorProperty: Property;
        isDynamic: boolean;
        isClosed: boolean;
        geometryChanged: boolean;
        static perInstanceColorAppearanceType: Appearance;
        static materialAppearanceType: Appearance;
        constructor(entity: Entity, scene: Scene);
        isOutlineVisible(time: JulianDate): boolean;
        isFilled(time: JulianDate): boolean;
        createFillGeometryInstance(time: JulianDate): GeometryInstance;
        createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
        isDestroyed(): boolean;
        destroy(): void;
        createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
    }

    class PolylineGlowMaterialProperty {
        isConstant: boolean;
        definitionChanged: Event;
        color: Property;
        glowPower: Property;
        constructor(options?: { color?: Property; glowPower?: Property });
        getType(time: JulianDate): string;
        getValue(time: JulianDate, result?: any): any;
        equals(other?: Property): boolean;
    }

    class PolylineGraphics {
        definitionChanged: Event;
        show: Property;
        material: MaterialProperty;
        positions: Property;
        width: number;
        followSurface: Property;
        granularity: Property;
        constructor(options?: { positions?: Array<Cartesian3>; followSurface?: Property; width?: number; show?: Property; material?: MaterialProperty; granularity?: Property });
        clone(result?: PolylineGraphics): PolylineGraphics;
        merge(source: PolylineGraphics): void;
    }

    class PolylineOutlineMaterialProperty {
        isConstant: boolean;
        definitionChanged: Event;
        color: Property;
        outlineColor: Property;
        outlineWidth: Property;
        constructor(options?: { color?: Property; outlineColor?: Property; outlineWidth?: Property });
        getType(time: JulianDate): string;
        getValue(time: JulianDate, result?: any): any;
        equals(other?: Property): boolean;
    }

    class PolylineVolumeGeometryUpdater {
        entity: Entity;
        fillEnabled: boolean;
        hasConstantFill: boolean;
        fillMaterialProperty: MaterialProperty;
        outlineEnabled: boolean;
        hasConstantOutline: boolean;
        outlineColorProperty: Property;
        outlineWidth: number;
        isDynamic: boolean;
        isClosed: boolean;
        geometryChanged: boolean;
        static perInstanceColorAppearanceType: Appearance;
        static materialAppearanceType: Appearance;
        constructor(entity: Entity, scene: Scene);
        isOutlineVisible(time: JulianDate): boolean;
        isFilled(time: JulianDate): boolean;
        createFillGeometryInstance(time: JulianDate): GeometryInstance;
        createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
        isDestroyed(): boolean;
        destroy(): void;
        createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
    }

    class PolylineVolumeGraphics {
        definitionChanged: Event;
        show: Property;
        material: MaterialProperty;
        positions: Property;
        shape: Property;
        granularity: Property;
        fill: Property;
        outline: Property;
        outlineColor: Property;
        outlineWidth: Property;
        cornerType: Property;
        constructor(options?: { positions?: Property; shape?: Property; cornerType?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; granularity?: Property });
        clone(result?: PolylineVolumeGraphics): PolylineVolumeGraphics;
        merge(source: PolylineVolumeGraphics): void;
    }

    interface PositionProperty {
        isConstant: boolean;
        definitionChanged: Event;
        referenceFrame: ReferenceFrame;
        equals(other: any): boolean;
        getValue(time: JulianDate, result?: Cartesian3): Cartesian3;
        getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
    }

    class PositionPropertyArray {
        isConstant: boolean;
        definitionChanged: Event;
        referenceFrame: ReferenceFrame;
        constructor(value?: Property[]);
        getValue(time?: JulianDate, result?: Cartesian3[]): Cartesian3[];
        getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
        setValue(value: Property[]): void;
        equals(other?: Property): boolean;
    }

    class Property {
        isConstant: boolean;
        definitionChanged: Event;
        getValue(time: JulianDate, result?: any): any;
        equals(other?: Property): boolean;
    }

    class PropertyArray {
        isConstant: boolean;
        definitionChanged: Event;
        constructor(value?: Property[]);
        getValue(time?: JulianDate, result?: any[]): any[];
        setValue(value: Property[]): void;
        equals(other?: Property): boolean;
    }

    interface ObjectLike {
        [key: string]: Property;
    }
    type PropertyBag = ObjectLike & {
        constructor(value?: object, createPropertyCallback?: Function): PropertyBag;
        definitionChanged: Event;
        isConstant: boolean;
        propertyNames: string[];
        addProperty(propertyName: string, value?: any, createPropertyCallback?: Function): void;
        getValue(time: JulianDate, result?: Object): Object;
        hasProperty(propertyName: string): boolean;
        merge(source: Object, createPropertyCallback?: Function): void;
        removeProperty(propertyName: string): void;
    }

    class RectangleGeometryUpdater {
        entity: Entity;
        fillEnabled: boolean;
        hasConstantFill: boolean;
        fillMaterialProperty: MaterialProperty;
        outlineEnabled: boolean;
        hasConstantOutline: boolean;
        outlineColorProperty: Property;
        outlineWidth: number;
        isDynamic: boolean;
        isClosed: boolean;
        geometryChanged: boolean;
        static perInstanceColorAppearanceType: Appearance;
        static materialAppearanceType: Appearance;
        constructor(entity: Entity, scene: Scene);
        isOutlineVisible(time: JulianDate): boolean;
        isFilled(time: JulianDate): boolean;
        createFillGeometryInstance(time: JulianDate): GeometryInstance;
        createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
        isDestroyed(): boolean;
        destroy(): void;
        createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
    }

    class RectangleGraphics {
        definitionChanged: Event;
        show: Property;
        coordinates: Property;
        material: MaterialProperty;
        height: Property;
        extrudedHeight: Property;
        granularity: Property;
        stRotation: Property;
        rotation: Property;
        fill: Property;
        outline: Property;
        outlineColor: Property;
        outlineWidth: Property;
        closeTop: Property;
        closeBottom: Property;
        constructor(options?: { coordinates?: Property; height?: Property; extrudedHeight?: Property; closeTop?: Property; closeBottom?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; rotation?: Property; stRotation?: Property; granularity?: Property });
        clone(result?: RectangleGraphics): RectangleGraphics;
        merge(source: RectangleGraphics): void;
    }

    class ReferenceProperty {
        isConstant: boolean;
        definitionChanged: Event;
        referenceFrame: ReferenceFrame;
        targetId: string;
        targetCollection: EntityCollection;
        targetPropertyNames: string[];
        resolvedProperty: Property;
        constructor(targetCollection: EntityCollection, targetId: string, targetPropertyNames: string);
        getValue(time: JulianDate, result?: any): any;
        getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
        getType(time: JulianDate): string;
        equals(other?: Property): boolean;
        static fromString(targetCollection: Entity, referenceString: string): ReferenceProperty;
    }

    class SampledPositionProperty {
        isConstant: boolean;
        definitionChanged: Event;
        referenceFrame: ReferenceFrame;
        interpolationDegree: number;
        interpolationAlgorithm: InterpolationAlgorithm;
        numberOfDerivatives: boolean;
        forwardExtrapolationType: ExtrapolationType;
        forwardExtrapolationDuration: number;
        backwardExtrapolationType: ExtrapolationType;
        backwardExtrapolationDuration: number;
        constructor(referenceFrame?: ReferenceFrame, numberOfDerivatives?: number);
        getValue(time: JulianDate, result?: Cartesian3): Cartesian3;
        getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
        setInterpolationOptions(options?: { interpolationAlgorithm?: InterpolationAlgorithm; interpolationDegree?: number }): void;
        addSample(time: JulianDate, position: Cartesian3, derivatives?: Cartesian3[]): void;
        addSamples(times: JulianDate[], positions: Cartesian3[], derivatives?: any[][]): void;
        addSamplesPackedArray(packedSamples: number[], epoch?: JulianDate): void;
        equals(other?: Property): boolean;
    }

    class SampledProperty {
        isConstant: boolean;
        definitionChanged: Event;
        type: any;
        derivativeTypes: Packable[];
        interpolationDegree: number;
        interpolationAlgorithm: InterpolationAlgorithm;
        forwardExtrapolationType: ExtrapolationType;
        forwardExtrapolationDuration: number;
        backwardExtrapolationType: ExtrapolationType;
        backwardExtrapolationDuration: number;
        constructor(type: number | Packable, derivativeTypes?: Packable[]);
        getValue(time: JulianDate, result?: any): any;
        setInterpolationOptions(options?: { interpolationAlgorithm?: InterpolationAlgorithm; interpolationDegree?: number }): void;
        addSample(time: JulianDate, value: Packable, derivatives?: Packable[]): void;
        addSamples(times: JulianDate[], values: Packable[], derivativeValues?: any[][]): void;
        addSamplesPackedArray(packedSamples: number[], epoch?: JulianDate): void;
        equals(other?: Property): boolean;
    }

    class StripeMaterialProperty {
        isConstant: boolean;
        definitionChanged: Event;
        orientation: Property;
        evenColor: Color;
        oddColor: Color;
        offset: Property;
        repeat: number;
        constructor(options?: { evenColor?: Property; oddColor?: Property; repeat?: Property; offset?: Property; orientation?: Property });
        getType(time: JulianDate): string;
        getValue(time: JulianDate, result?: any): any;
        equals(other?: Property): boolean;
    }

    class TimeIntervalCollectionPositionProperty {
        isConstant: boolean;
        definitionChanged: Event;
        intervals: TimeIntervalCollection;
        referenceFrame: ReferenceFrame;
        constructor(referenceFrame?: ReferenceFrame);
        getValue(time: JulianDate, result?: any): any;
        getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
        equals(other?: Property): boolean;
    }

    class TimeIntervalCollectionProperty {
        isConstant: boolean;
        definitionChanged: Event;
        intervals: TimeIntervalCollection;
        getValue(time: JulianDate, result?: any): any;
        equals(other?: Property): boolean;
    }

    class VelocityOrientationProperty {
        isConstant: boolean;
        definitionChanged: Event;
        position: Property;
        ellipsoid: Property;
        constructor(position?: Property, ellipsoid?: Ellipsoid);
        getValue(time?: JulianDate, result?: Quaternion): Quaternion;
        equals(other?: Property): boolean;
    }

    class Visualizer {
        update(time: JulianDate): boolean;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class WallGeometryUpdater {
        entity: Entity;
        fillEnabled: boolean;
        hasConstantFill: boolean;
        fillMaterialProperty: MaterialProperty;
        outlineEnabled: boolean;
        hasConstantOutline: boolean;
        outlineColorProperty: Property;
        outlineWidth: number;
        isDynamic: boolean;
        isClosed: boolean;
        geometryChanged: boolean;
        static perInstanceColorAppearanceType: Appearance;
        static materialAppearanceType: Appearance;
        constructor(entity: Entity, scene: Scene);
        isOutlineVisible(time: JulianDate): boolean;
        isFilled(time: JulianDate): boolean;
        createFillGeometryInstance(time: JulianDate): GeometryInstance;
        createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
        isDestroyed(): boolean;
        destroy(): void;
        createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
    }

    class WallGraphics {
        definitionChanged: Event;
        show: Property;
        material: MaterialProperty;
        positions: Property;
        minimumHeights: Property;
        maximumHeights: Property;
        granularity: Property;
        fill: Property;
        outline: Property;
        outlineColor: Property;
        outlineWidth: Property;
        constructor(options?: { positions?: Property; maximumHeights?: Property; minimumHeights?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; granularity?: Property });
        clone(result?: WallGraphics): WallGraphics;
        merge(source: WallGraphics): void;
    }

    class Appearance {
        material: Material;
        translucent: boolean;
        vertexShaderSource: string;
        fragmentShaderSource: string;
        renderState: any;
        closed: boolean;
        constructor(options?: { translucent?: boolean; closed?: boolean; material?: Material; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
        getFragmentShaderSource(): string;
        isTranslucent(): boolean;
        getRenderState(): any;
    }

    class ArcGisMapServerImageryProvider extends ImageryProvider {
        url: string;
        proxy: Proxy;
        tileWidth: number;
        tileHeight: number;
        maximumLevel: number;
        minimumLevel: number;
        tilingScheme: TilingScheme;
        rectangle: Rectangle;
        tileDiscardPolicy: TileDiscardPolicy;
        errorEvent: Event;
        ready: boolean;
        credit: Credit;
        usingPrecachedTiles: boolean;
        hasAlphaChannel: boolean;
        constructor(options: { url: string; tileDiscardPolicy?: TileDiscardPolicy; proxy?: Proxy; usePreCachedTilesIfAvailable?: boolean; enablePickFeatures?: boolean; rectangle?: Rectangle; tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid; tileWidth?: number; tileHeight?: number; maximumLevel?: number }, layers?: string);
        getTileCredits(x: number, y: number, level: number): Credit[];
        requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
        pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
    }

    class Billboard {
        show: boolean;
        position: Cartesian3;
        pixelOffset: Cartesian2;
        scaleByDistance: NearFarScalar;
        translucencyByDistance: NearFarScalar;
        pixelOffsetScaleByDistance: NearFarScalar;
        eyeOffset: Cartesian3;
        horizontalOrigin: HorizontalOrigin;
        verticalOrigin: VerticalOrigin;
        scale: number;
        color: Color;
        rotation: number;
        alignedAxis: Cartesian3;
        width: number;
        height: number;
        id: any;
        image: string;
        ready: boolean;
        setImage(id: string, image: HTMLImageElement | HTMLCanvasElement | string | Billboard.CreateImageCallback): void;
        setImageSubRegion(id: string, subRegion: BoundingRectangle): void;
        computeScreenSpacePosition(scene: Scene, result?: Cartesian2): Cartesian2;
        equals(other: Billboard): boolean;
    }

    module Billboard {
        type CreateImageCallback = (id: string) => HTMLImageElement | HTMLCanvasElement | Promise<HTMLImageElement | HTMLCanvasElement>;
    }

    class BillboardCollection {
        modelMatrix: Matrix4;
        debugShowBoundingVolume: boolean;
        length: number;
        constructor(options?: { modelMatrix?: Matrix4; debugShowBoundingVolume?: boolean });
        add(billboard?: any): Billboard;
        remove(billboard: Billboard): boolean;
        removeAll(): void;
        contains(billboard?: Billboard): boolean;
        get(index: number): Billboard;
        update(): void;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class BingMapsImageryProvider extends ImageryProvider{
        defaultGamma: number;
        url: string;
        proxy: Proxy;
        key: string;
        mapStyle: BingMapsStyle;
        culture: string;
        tileWidth: number;
        tileHeight: number;
        maximumLevel: number;
        minimumLevel: number;
        tilingScheme: TilingScheme;
        rectangle: Rectangle;
        tileDiscardPolicy: TileDiscardPolicy;
        errorEvent: Event;
        ready: boolean;
        credit: Credit;
        hasAlphaChannel: boolean;
        constructor(options: { url: string; key?: string; tileProtocol?: string; mapStyle?: string; culture?: string; ellipsoid?: Ellipsoid; tileDiscardPolicy?: TileDiscardPolicy; proxy?: Proxy });
        getTileCredits(x: number, y: number, level: number): Credit[];
        requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
        pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
        static tileXYToQuadKey(x: number, y: number, level: number): string;
        static quadKeyToTileXY(quadkey: string): {x: number, y: number, level: number};
    }

    class Camera {
        position: Cartesian3;
        direction: Cartesian3;
        up: Cartesian3;
        right: Cartesian3;
        frustum: OrthographicFrustum;
        defaultMoveAmount: number;
        defaultLookAmount: number;
        defaultRotateAmount: number;
        defaultZoomAmount: number;
        constrainedAxis: Cartesian3;
        maximumTranslateFactor: number;
        maximumZoomFactor: number;
        transform: Matrix4;
        inverseTransform: Matrix4;
        viewMatrix: Matrix4;
        inverseViewMatrix: Matrix4;
        positionCartographic: Cartographic;
        positionWC: Cartesian3;
        directionWC: Cartesian3;
        upWC: Cartesian3;
        rightWC: Cartesian3;
        heading: number;
        pitch: number;
        roll: number;
        moveStart: Event;
        moveEnd: Event;
        static DEFAULT_VIEW_RECTANGLE: Rectangle;
        static DEFAULT_VIEW_FACTOR: number;
        setView(): void;
        worldToCameraCoordinates(cartesian: Cartesian4, result?: Cartesian4): Cartesian4;
        worldToCameraCoordinatesPoint(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
        worldToCameraCoordinatesVector(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
        cameraToWorldCoordinates(cartesian: Cartesian4, result?: Cartesian4): Cartesian4;
        cameraToWorldCoordinatesPoint(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
        cameraToWorldCoordinatesVector(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
        move(direction: Cartesian3, amount?: number): void;
        moveForward(amount?: number): void;
        moveBackward(amount?: number): void;
        moveUp(amount?: number): void;
        moveDown(amount?: number): void;
        moveRight(amount?: number): void;
        moveLeft(amount?: number): void;
        lookLeft(amount?: number): void;
        lookRight(amount?: number): void;
        lookUp(amount?: number): void;
        lookDown(amount?: number): void;
        look(axis: Cartesian3, angle?: number): void;
        twistLeft(amount?: number): void;
        twistRight(amount?: number): void;
        rotate(axis: Cartesian3, angle?: number): void;
        rotateDown(angle?: number): void;
        rotateUp(angle?: number): void;
        rotateRight(angle?: number): void;
        rotateLeft(angle?: number): void;
        zoomIn(amount?: number): void;
        zoomOut(amount?: number): void;
        getMagnitude(): number;
        lookAt(target: Cartesian3, offset: Cartesian3 | HeadingPitchRange): void;
        lookAtTransform(transform: Matrix4, offset: Cartesian3 | HeadingPitchRange): void;
        getRectangleCameraCoordinates(rectangle: Rectangle, result?: Cartesian3): Cartesian3;
        computeViewRectangle(ellipsoid?: Ellipsoid, result?: Rectangle): Rectangle;
        pickEllipsoid(windowPosition: Cartesian2, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3;
        getPickRay(windowPosition: Cartesian2, result?: Ray): any;
        flyTo(options: { destination: Cartesian3 | Rectangle; orientation?: any; duration?: number; complete?: () => void; cancel?: () => void; endTransform?: Matrix4; convert?: boolean }): void;
        viewBoundingSphere(boundingSphere: BoundingSphere, offset?: HeadingPitchRange): void;
        flyToBoundingSphere(boundingSphere: BoundingSphere, options?: { duration?: number; offset?: HeadingPitchRange; complete?: () => void; cancel?: () => void; endTransform?: Matrix4 }): void;
        clone(): Camera;
    }

    class CameraEventAggregator {
        currentMousePosition: Cartesian2;
        anyButtonDown: boolean;
        constructor(element?: HTMLCanvasElement);
        isMoving(type: CameraEventType, modifier?: KeyboardEventModifier): boolean;
        getMovement(type: CameraEventType, modifier?: KeyboardEventModifier): any;
        getLastMovement(type: CameraEventType, modifier?: KeyboardEventModifier): any;
        isButtonDown(type: CameraEventType, modifier?: KeyboardEventModifier): boolean;
        getStartMousePosition(type: CameraEventType, modifier?: KeyboardEventModifier): Cartesian2;
        getButtonPressTime(type: CameraEventType, modifier?: KeyboardEventModifier): Date;
        getButtonReleaseTime(type: CameraEventType, modifier?: KeyboardEventModifier): Date;
        reset(): void;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class CreditDisplay {
        constructor(container: HTMLElement, delimiter?: string);
        addCredit(credit: Credit): void;
        addDefaultCredit(credit: Credit): void;
        removeDefaultCredit(credit: Credit): void;
        beginFrame(credit: Credit): void;
        endFrame(credit: Credit): void;
        destroy(): void;
        isDestroyed(): boolean;
    }

    class CullingVolume {
        planes: Cartesian4[];
        constructor(planes: Cartesian4[]);
        computeVisibility(boundingVolume: any): Intersect;
    }

    class DebugAppearance {
        material: Material;
        translucent: boolean;
        vertexShaderSource: string;
        fragmentShaderSource: string;
        renderState: any;
        closed: boolean;
        attributeName: string;
        glslDatatype: string;
        constructor(options: { attributeName: string; glslDatatype?: string; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
        getFragmentShaderSource(): string;
        isTranslucent(): boolean;
        getRenderState(): any;
    }

    class DebugModelMatrixPrimitive {
        length: number;
        width: number;
        show: boolean;
        modelMatrix: Matrix4;
        id: any;
        constructor(options?: { length?: number; width?: number; modelMatrix?: Matrix4; show?: boolean; id?: any });
        isDestroyed(): boolean;
        destroy(): void;
    }

    class DiscardMissingTileImagePolicy {
        constructor(options: { missingImageUrl: string; pixelsToCheck: Cartesian2[]; disableCheckIfAllPixelsAreTransparent?: boolean });
        isReady(): boolean;
        shouldDiscardImage(image: HTMLImageElement): boolean;
    }

    class EllipsoidPrimitive {
        center: Cartesian3;
        radii: Cartesian3;
        modelMatrix: Matrix4;
        show: boolean;
        material: Material;
        id: any;
        debugShowBoundingVolume: boolean;
        constructor(options?: { center?: Cartesian3; radii?: Cartesian3; modelMatrix?: Matrix4; show?: boolean; material?: Material; id?: any; debugShowBoundingVolume?: boolean });
        update(): void;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class EllipsoidSurfaceAppearance {
        material: Material;
        translucent: boolean;
        vertexShaderSource: string;
        fragmentShaderSource: string;
        renderState: any;
        closed: boolean;
        vertexFormat: VertexFormat;
        flat: boolean;
        faceForward: boolean;
        aboveGround: boolean;
        static VERTEX_FORMAT: VertexFormat;
        constructor(options?: { flat?: boolean; faceForward?: boolean; translucent?: boolean; aboveGround?: boolean; material?: Material; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
        getFragmentShaderSource(): void;
        isTranslucent(): boolean;
        getRenderState(): any;
    }

    class FrameRateMonitor {
        samplingWindow: number;
        quietPeriod: number;
        warmupPeriod: number;
        minimumFrameRateDuringWarmup: number;
        minimumFrameRateAfterWarmup: number;
        scene: Scene;
        lowFrameRate: Event;
        nominalFrameRate: Event;
        lastFramesPerSecond: number;
        static defaultSettings: Object;
        constructor(options?: { scene: Scene; samplingWindow?: number; quietPeriod?: number; warmupPeriod?: number; minimumFrameRateDuringWarmup?: number; minimumFrameRateAfterWarmup?: number });
        pause(): void;
        unpause(): void;
        isDestroyed(): boolean;
        destroy(): void;
        static fromScene(scene: Scene): FrameRateMonitor;
    }

    class GetFeatureInfoFormat {
        constructor(type: string, format?: string);
    }

    class Globe {
        terrainProvider: TerrainProvider;
        terrainProviderChanged: Event;
        northPoleColor: Cartesian3;
        southPoleColor: Cartesian3;
        show: boolean;
        oceanNormalMapUrl: string;
        depthTestAgainstTerrain: boolean;
        maximumScreenSpaceError: number;
        tileCacheSize: number;
        enableLighting: boolean;
        lightingFadeOutDistance: number;
        lightingFadeInDistance: number;
        showWaterEffect: boolean;
        ellipsoid: Ellipsoid;
        imageryLayers: ImageryLayerCollection;
        baseColor: Color;
        constructor(ellipsoid?: Ellipsoid);
        pick(ray: Ray, scene: Scene, result?: Cartesian3): Cartesian3;
        getHeight(cartographic: Cartographic): number;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class GoogleEarthEnterpriseMapsProvider {
        constructor(options: { url: string; channel: number; path?: string; maximumLevel?: number; tileDiscardPolicy?: TileDiscardPolicy; ellipsoid?: Ellipsoid; proxy?: Proxy });
        readonly channel: number;
        readonly credit: Credit;
        defaultGamma: number;
        readonly errorEvent: Event;
        readonly hasAlphaChannel: boolean;
        readonly maximumLevel: number;
        readonly minimumLevel: number;
        readonly path: string;
        readonly proxy: Proxy;
        readonly ready: boolean;
        readonly readyPromise: Promise<boolean>;
        readonly rectangle: Rectangle;
        readonly requestType: string;
        readonly tileDiscardPolicy: TileDiscardPolicy;
        readonly tileHeight: number;
        readonly tileWidth: number;
        readonly tilingScheme: TilingScheme;
        readonly url: string;
        readonly version: number;
        getTileCredits(x: number, y: number, level: number): Credit[];
        pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
        requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
    }

    class GoogleEarthEnterpriseImageryProvider extends ImageryProvider {
        defaultGamma: number;
        url: string;
        path: string;
        proxy: Proxy;
        channel: number;
        tileWidth: number;
        tileHeight: number;
        maximumLevel: number;
        minimumLevel: number;
        tilingScheme: TilingScheme;
        version: number;
        requestType: string;
        rectangle: Rectangle;
        tileDiscardPolicy: TileDiscardPolicy;
        errorEvent: Event;
        ready: boolean;
        credit: Credit;
        hasAlphaChannel: boolean;
        constructor(options: { url: string; proxy?: Proxy; ellipsoid?: Ellipsoid; tileDiscardPolicy?: TileDiscardPolicy; credit?: Credit | string;});
        getTileCredits(x: number, y: number, level: number): Credit[];
        requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
        pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
    }

    class GridImageryProvider extends ImageryProvider{
        proxy: Proxy;
        tileWidth: number;
        tileHeight: number;
        maximumLevel: number;
        minimumLevel: number;
        tilingScheme: TilingScheme;
        rectangle: Rectangle;
        tileDiscardPolicy: TileDiscardPolicy;
        errorEvent: Event;
        ready: boolean;
        credit: Credit;
        hasAlphaChannel: boolean;
        constructor(options?: {
            tilingScheme?: TilingScheme;
            ellipsoid?: Ellipsoid;
            cells?: number;
            color?: Color;
            glowColor?: Color;
            glowWidth?: number;
            tileWidth?: number;
            tileHeight?: number;
            canvasSize?: number;
            backgroundColor?: Color;
        });
        getTileCredits(x: number, y: number, level: number): Credit[];
        requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
        pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
    }

    class HeadingPitchRange {
        heading: number;
        pitch: number;
        range: number;
        constructor(heading?: number, pitch?: number, range?: number);
        static clone(hpr: HeadingPitchRange, result?: HeadingPitchRange): HeadingPitchRange;
    }

    class ImageryLayer {
        alpha: number;
        brightness: number;
        contrast: number;
        hue: number;
        saturation: number;
        gamma: number;
        show: boolean;
        imageryProvider: ImageryProvider;
        rectangle: Rectangle;
        static DEFAULT_BRIGHTNESS: number;
        static DEFAULT_CONTRAST: number;
        static DEFAULT_HUE: number;
        static DEFAULT_SATURATION: number;
        static DEFAULT_GAMMA: number;
        constructor(imageryProvider: ImageryProvider, options?: { rectangle?: Rectangle; alpha?: number | Function; brightness?: number | Function; contrast?: number | Function; hue?: number | Function; saturation?: number | Function; gamma?: number | Function; show?: boolean; maximumAnisotropy?: number; minimumTerrainLevel?: number; maximumTerrainLevel?: number });
        isBaseLayer(): boolean;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class ImageryLayerCollection {
        layerAdded: Event;
        layerRemoved: Event;
        layerMoved: Event;
        layerShownOrHidden: Event;
        length: number;
        add(layer: ImageryLayer, index?: number): void;
        addImageryProvider(imageryProvider: ImageryProvider, index?: number): ImageryLayer;
        remove(layer: ImageryLayer, destroy?: boolean): boolean;
        removeAll(destroy?: boolean): void;
        contains(layer: ImageryLayer): boolean;
        indexOf(layer: ImageryLayer): number;
        get(index: number): ImageryLayer;
        raise(layer: ImageryLayer): void;
        lower(layer: ImageryLayer): void;
        raiseToTop(layer: ImageryLayer): void;
        lowerToBottom(layer: ImageryLayer): void;
        pickImageryLayerFeatures(ray: Ray, scene: Scene): Promise<ImageryLayerFeatureInfo[]>;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class ImageryLayerFeatureInfo {
        name: string;
        description: string;
        position: Cartographic;
        data: any;
        configureNameFromProperties(properties: any): void;
        configureDescriptionFromProperties(properties: any): void;
    }

    class ImageryProvider {
        defaultAlpha: number;
        defaultBrightness: number;
        defaultContrast: number;
        defaultHue: number;
        defaultSaturation: number;
        defaultGamma: number;
        ready: boolean;
        rectangle: Rectangle;
        tileWidth: number;
        tileHeight: number;
        maximumLevel: number;
        minimumLevel: number;
        tilingScheme: TilingScheme;
        tileDiscardPolicy: TileDiscardPolicy;
        errorEvent: Event;
        credit: Credit;
        proxy: Proxy;
        hasAlphaChannel: boolean;
        getTileCredits(x: number, y: number, level: number): Credit[];
        requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
        pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
        static loadImage(url: string): Promise<HTMLImageElement | HTMLCanvasElement>;
    }

    class Label {
        show: boolean;
        position: Cartesian3;
        text: string;
        font: string;
        fillColor: Color;
        outlineColor: Color;
        outlineWidth: number;
        style: LabelStyle;
        pixelOffset: Cartesian2;
        translucencyByDistance: NearFarScalar;
        pixelOffsetScaleByDistance: NearFarScalar;
        eyeOffset: Cartesian3;
        horizontalOrigin: HorizontalOrigin;
        verticalOrigin: VerticalOrigin;
        scale: number;
        id: any;
        computeScreenSpacePosition(scene: Scene, result?: Cartesian2): Cartesian2;
        equals(other: Label): boolean;
        isDestroyed(): boolean;
    }

    class LabelCollection {
        modelMatrix: Matrix4;
        debugShowBoundingVolume: boolean;
        length: number;
        constructor(options?: { modelMatrix?: Matrix4; debugShowBoundingVolume?: boolean });
        add(options?: any): Label;
        remove(label: Label): boolean;
        removeAll(): void;
        contains(label: Label): boolean;
        get(index: number): Label;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class Material {
        type: string;
        shaderSource: string;
        materials: any;
        uniforms: any;
        translucent: boolean | Function;
        static DefaultImageId: string;
        static DefaultCubeMapId: string;
        static ColorType: string;
        static ImageType: string;
        static DiffuseMapType: string;
        static AlphaMapType: string;
        static SpecularMapType: string;
        static EmissionMapType: string;
        static BumpMapType: string;
        static NormalMapType: string;
        static GridType: string;
        static StripeType: string;
        static CheckerboardType: string;
        static DotType: string;
        static WaterType: string;
        static RimLightingType: string;
        static FadeType: string;
        static PolylineArrowType: string;
        static PolylineGlowType: string;
        static PolylineOutlineType: string;
        constructor(options?: { strict?: boolean; translucent?: boolean | Function; fabric: any });
        isTranslucent(): boolean;
        isDestroyed(): boolean;
        destroy(): void;
        static fromType(type: string, uniforms?: any): Material;
    }

    class MaterialAppearance {
        material: Material;
        translucent: boolean;
        vertexShaderSource: string;
        fragmentShaderSource: string;
        renderState: any;
        closed: boolean;
        materialSupport: MaterialAppearance.MaterialSupport;
        vertexFormat: VertexFormat;
        flat: boolean;
        faceForward: boolean;
        constructor(options?: { flat?: boolean; faceForward?: boolean; translucent?: boolean; closed?: boolean; materialSupport?: MaterialAppearance.MaterialSupport; material?: Material; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
        getFragmentShaderSource(): string;
        isTranslucent(): boolean;
        getRenderState(): any;
    }

    module MaterialAppearance {
        enum MaterialSupport {
            BASIC,
            TEXTURED,
            ALL
        }
    }

    class Model {
        show: boolean;
        modelMatrix: Matrix4;
        scale: number;
        minimumPixelSize: number;
        id: any;
        activeAnimations: ModelAnimationCollection;
        debugShowBoundingVolume: boolean;
        debugWireframe: boolean;
        gltf: any;
        basePath: string;
        boundingSphere: BoundingSphere;
        ready: boolean;
        readyPromise: Promise<Model>;
        asynchronous: boolean;
        allowPicking: boolean;
        constructor(options?: { gltf?: any; basePath?: string; show?: boolean; modelMatrix?: Matrix4; scale?: number; minimumPixelSize?: number; id?: any; allowPicking?: boolean; asynchronous?: boolean; debugShowBoundingVolume?: boolean; debugWireframe?: boolean });
        getNode(name: string): ModelNode;
        getMesh(name: string): ModelMesh;
        getMaterial(name: string): ModelMaterial;
        update(): void;
        isDestroyed(): boolean;
        destroy(): void;
        static fromGltf(options: { url: string; headers?: any; show?: boolean; modelMatrix?: Matrix4; scale?: number; minimumPixelSize?: number; allowPicking?: boolean; asynchronous?: boolean; debugShowBoundingVolume?: boolean; debugWireframe?: boolean }): Model;
    }

    class ModelAnimation {
        removeOnStop: boolean;
        start: Event;
        update: Event;
        stop: Event;
        name: string;
        startTime: JulianDate;
        delay: number;
        stopTime: JulianDate;
        speedup: number;
        reverse: boolean;
        loop: ModelAnimationLoop;
    }

    class ModelAnimationCollection {
        animationAdded: Event;
        animationRemoved: Event;
        length: number;
        add(options: { name: string; startTime?: JulianDate; delay?: number; stopTime?: JulianDate; removeOnStop?: boolean; speedup?: number; reverse?: boolean; loop?: ModelAnimationLoop }): ModelAnimation;
        addAll(options?: { startTime?: JulianDate; delay?: number; stopTime?: JulianDate; removeOnStop?: boolean; speedup?: number; reverse?: boolean; loop?: ModelAnimationLoop }): ModelAnimation[];
        remove(animation: ModelAnimation): boolean;
        removeAll(): void;
        contains(animation: ModelAnimation): boolean;
        get(index: number): ModelAnimation;
    }

    class ModelMaterial {
        name: string;
        id: string;
        setValue(name: string, value?: any): void;
        getValue(name: string): any;
    }

    class ModelMesh {
        name: string;
        id: string;
        materials: ModelMaterial[];
    }

    class ModelNode {
        name: string;
        id: string;
        show: boolean;
        matrix: Matrix4;
    }

    class Moon {
        show: boolean;
        textureUrl: string;
        onlySunLighting: boolean;
        ellipsoid: Ellipsoid;
        constructor(options?: { show?: boolean; textureUrl?: string; ellipsoid?: Ellipsoid; onlySunLighting?: boolean });
        isDestroyed(): boolean;
        destroy(): void;
    }

    class NeverTileDiscardPolicy {
        isReady(): boolean;
        shouldDiscardImage(image: HTMLImageElement | Promise<HTMLImageElement>): Promise<boolean>;
    }

    class OpenStreetMapImageryProvider {
        url: string;
        proxy: Proxy;
        tileWidth: number;
        tileHeight: number;
        maximumLevel: number;
        minimumLevel: number;
        tilingScheme: TilingScheme;
        rectangle: Rectangle;
        tileDiscardPolicy: TileDiscardPolicy;
        errorEvent: Event;
        ready: boolean;
        credit: Credit;
        hasAlphaChannel: boolean;
        constructor(options?: { url?: string; fileExtension?: string; proxy?: any; rectangle?: Rectangle; minimumLevel?: number; maximumLevel?: number; ellipsoid?: Ellipsoid; credit?: Credit | string });
        getTileCredits(x: number, y: number, level: number): Credit[];
        requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
        pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
    }

    class OrthographicFrustum {
        left: number;
        right: number;
        top: number;
        bottom: number;
        near: number;
        far: number;
        projectionMatrix: Matrix4;
        computeCullingVolume(position: Cartesian3, direction: Cartesian3, up: Cartesian3): CullingVolume;
        getPixelSize(drawingBufferDimensions: Cartesian2, distance?: number, result?: Cartesian2): Cartesian2;
        clone(result?: OrthographicFrustum): OrthographicFrustum;
        equals(other?: OrthographicFrustum): boolean;
    }

    class PerInstanceColorAppearance {
        material: Material;
        translucent: boolean;
        vertexShaderSource: string;
        fragmentShaderSource: string;
        renderState: any;
        closed: boolean;
        vertexFormat: VertexFormat;
        flat: boolean;
        faceForward: boolean;
        static VERTEX_FORMAT: VertexFormat;
        static FLAT_VERTEX_FORMAT: VertexFormat;
        constructor(options?: { flat?: boolean; faceForward?: boolean; translucent?: boolean; closed?: boolean; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
        getFragmentShaderSource(): void;
        isTranslucent(): boolean;
        getRenderState(): any;
    }

    class PerspectiveFrustum {
        fov: number;
        aspectRatio: number;
        near: number;
        far: number;
        projectionMatrix: Matrix4;
        infiniteProjectionMatrix: Matrix4;
        fovy: number;
        computeCullingVolume(position: Cartesian3, direction: Cartesian3, up: Cartesian3): CullingVolume;
        getPixelSize(drawingBufferDimensions: Cartesian2, distance?: number, result?: Cartesian2): Cartesian2;
        clone(result?: PerspectiveFrustum): PerspectiveFrustum;
        equals(other?: PerspectiveFrustum): boolean;
    }

    class PerspectiveOffCenterFrustum {
        left: number;
        right: number;
        top: number;
        bottom: number;
        near: number;
        far: number;
        projectionMatrix: Matrix4;
        infiniteProjectionMatrix: Matrix4;
        computeCullingVolume(position: Cartesian3, direction: Cartesian3, up: Cartesian3): CullingVolume;
        getPixelSize(drawingBufferDimensions: Cartesian2, distance?: number, result?: Cartesian2): Cartesian2;
        clone(result?: PerspectiveOffCenterFrustum): PerspectiveOffCenterFrustum;
        equals(other?: PerspectiveOffCenterFrustum): boolean;
    }

    class PointPrimitive {
        show: boolean;
        position: Cartesian3;
        scaleByDistance: NearFarScalar;
        translucencyByDistance: NearFarScalar;
        pixelSize: number;
        color: Color;
        outlineColor: Color;
        outlineWidth: number;
        id: any;
        computeScreenSpacePosition(scene: Scene, result?: Cartesian2): Cartesian2;
        equals(other: PointPrimitive): boolean;
    }

    class PointPrimitiveCollection {
        modelMatrix: Matrix4;
        debugShowBoundingVolume: boolean;
        length: number;
        constructor(options?: {
            modelMatrix?: Matrix4;
            debugShowBoundingVolume?: boolean;
            blendOption?: BlendOption;
        });
        add(pointPrimitive?: any): PointPrimitive;
        remove(pointPrimitive: PointPrimitive): boolean;
        removeAll(): void;
        contains(pointPrimitive?: PointPrimitive): boolean;
        get(index: number): PointPrimitive;
        isDestroyed(): boolean;
        destroy(): void;
    }

    enum BlendOption {
        OPAQUE, OPAQUE_AND_TRANSLUCENT, TRANSLUCENT
    }

    class Polygon {
        ellipsoid: Ellipsoid;
        granularity: number;
        height: number;
        textureRotationAngle: number;
        show: boolean;
        material: Material;
        id: any;
        asynchronous: boolean;
        debugShowBoundingVolume: boolean;
        positions: Cartesian3[];
        constructor(options?: { ellipsoid?: Ellipsoid; positions?: Cartesian3[]; polygonHierarchy?: any; granularity?: number; height?: number; textureRotationAngle?: number; show?: boolean; material?: Material; id?: any; asynchronous?: boolean; debugShowBoundingVolume?: boolean });
        configureFromPolygonHierarchy(hierarchy: any): void;
        update(): void;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class Polyline {
        show: boolean;
        positions: Cartesian3[];
        material: Material;
        width: number;
        loop: boolean;
        id: any;
        constructor(options?: { show?: boolean; width?: number; loop?: boolean; material?: Material; positions?: Cartesian3[]; id?: any });
    }

    class PolylineCollection {
        modelMatrix: Matrix4;
        debugShowBoundingVolume: boolean;
        length: number;
        constructor(options?: { modelMatrix?: Matrix4; debugShowBoundingVolume?: boolean });
        add(polyline?: any): Polyline;
        remove(polyline: Polyline): boolean;
        removeAll(): void;
        contains(polyline: Polyline): boolean;
        get(index: number): Polyline;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class PolylineColorAppearance {
        material: Material;
        translucent: boolean;
        vertexShaderSource: string;
        fragmentShaderSource: string;
        renderState: any;
        closed: boolean;
        vertexFormat: VertexFormat;
        static VERTEX_FORMAT: VertexFormat;
        constructor(options?: { translucent?: boolean; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
        getFragmentShaderSource(): void;
        isTranslucent(): boolean;
        getRenderState(): any;
    }

    class PolylineMaterialAppearance {
        material: Material;
        translucent: boolean;
        vertexShaderSource: string;
        fragmentShaderSource: string;
        renderState: any;
        closed: boolean;
        vertexFormat: VertexFormat;
        static VERTEX_FORMAT: VertexFormat;
        constructor(options?: { translucent?: boolean; material?: Material; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
        getFragmentShaderSource(): void;
        isTranslucent(): boolean;
        getRenderState(): any;
    }

    class Primitive {
        geometryInstances: any[];
        appearance: Appearance;
        modelMatrix: Matrix4;
        show: boolean;
        cull: boolean;
        debugShowBoundingVolume: boolean;
        vertexCacheOptimize: boolean;
        interleave: boolean;
        releaseGeometryInstances: boolean;
        allowPicking: boolean;
        asynchronous: boolean;
        compressVertices: boolean;
        ready: boolean;
        readyPromise: Promise<Primitive>;
        constructor(options?: { geometryInstances?: any[] | GeometryInstance; appearance?: Appearance; show?: boolean; modelMatrix?: Matrix4; vertexCacheOptimize?: boolean; interleave?: boolean; compressVertices?: boolean; releaseGeometryInstances?: boolean; allowPicking?: boolean; cull?: boolean; asynchronous?: boolean; debugShowBoundingVolume?: boolean });
        update(): void;
        getGeometryInstanceAttributes(id: any): any;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class PrimitiveCollection {
        show: boolean;
        destroyPrimitives: boolean;
        length: number;
        constructor(options?: { show?: boolean; destroyPrimitives?: boolean });
        add(primitive: any): any;
        remove(primitive?: any): boolean;
        removeAll(): void;
        contains(primitive?: any): boolean;
        raise(primitive?: any): void;
        raiseToTop(primitive?: any): void;
        lower(primitive?: any): void;
        lowerToBottom(primitive?: any): void;
        get(index: number): any;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class RectanglePrimitive {
        ellipsoid: Ellipsoid;
        rectangle: Rectangle;
        granularity: number;
        height: number;
        rotation: number;
        textureRotationAngle: number;
        show: boolean;
        material: Material;
        id: any;
        asynchronous: boolean;
        debugShowBoundingVolume: boolean;
        constructor(options?: { ellipsoid?: Ellipsoid; rectangle?: Rectangle; granularity?: number; height?: number; rotation?: number; textureRotationAngle?: number; show?: boolean; material?: Material; id?: any; asynchronous?: boolean; debugShowBoundingVolume?: boolean });
        update(): void;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class Fog {
        density: number;
        enabled: boolean;
        screenSpaceErrorFactor: number;
    }

    class Scene {
        backgroundColor: Color;
        readonly camera: Camera;
        readonly canvas: HTMLCanvasElement;
        completeMorphOnUserInput: boolean;
        debugCommandFilter: Function;
        readonly debugFrustumStatistics: any;
        debugShowCommands: boolean;
        debugShowFramesPerSecond: boolean;
        debugShowFrustums: boolean;
        readonly drawingBufferHeight: number;
        readonly drawingBufferWidth: number;
        farToNearRatio: number;
        fog: Fog;
        fxaa: boolean;
        fxaaOrderIndependentTranslucency: boolean;
        globe: Globe;
        readonly groundPrimitives: PrimitiveCollection;
        readonly id: string;
        readonly imageryLayers: ImageryLayerCollection;
        imagerySplitPosition: number;
        mapMode2D: boolean;
        readonly mapProjection: MapProjection;
        readonly maximumAliasedLineWidth: number;
        readonly maximumCubeMapSize: number;
        minimumDisableDepthTestDistance: number;
        mode: SceneMode;
        moon: Moon;
        morphComplete: Event;
        morphStart: Event;
        morphTime: number;
        nearToFarDistance2D: number;
        readonly orderIndependentTranslucency: boolean;
        readonly pickPositionSupported: boolean;
        pickTranslucentDepth: boolean;
        readonly postRender: Event;
        readonly preRender: Event;
        readonly primitives: PrimitiveCollection;
        readonly renderError: Event;
        rethrowRenderErrors: boolean;
        readonly scene3DOnly: boolean;
        readonly screenSpaceCameraController: ScreenSpaceCameraController;
        shadowMap: ShadowMap;
        skyAtmosphere: SkyAtmosphere;
        skyBox: SkyBox;
        sun: Sun;
        sunBloom: boolean;
        terrainProvider: TerrainProvider;
        readonly terrainProviderChanged: Event;
        useDepthPicking: boolean;
        useWebVR: boolean;
        constructor(options?: { canvas: HTMLCanvasElement; contextOptions?: any; creditContainer?: Element; mapProjection?: MapProjection; orderIndependentTranslucency?: boolean; scene3DOnly?: boolean });
        cartesianToCanvasCoordinates(position: Cartesian3, result?: Cartesian2): Cartesian2;
        completeMorph(): void;
        destroy(): void;
        drillPick(windowPosition: Cartesian2, limit?: number): any[];
        getCompressedTextureFormatSupported(format: string): boolean;
        isDestroyed(): boolean;
        morphTo2D(duration?: number): void;
        morphTo3D(duration?: number): void;
        morphToColumbusView(duration?: number): void;
        pick(windowPosition: Cartesian2, width?: number, height?: number): any;
        pickPosition(windowPosition: Cartesian2, result?: Cartesian3): Cartesian3;
    }

    class ScreenSpaceCameraController {
        enableInputs: boolean;
        enableTranslate: boolean;
        enableZoom: boolean;
        enableRotate: boolean;
        enableTilt: boolean;
        enableLook: boolean;
        inertiaSpin: number;
        inertiaTranslate: number;
        inertiaZoom: number;
        maximumMovementRatio: number;
        bounceAnimationTime: number;
        minimumZoomDistance: number;
        maximumZoomDistance: number;
        translateEventTypes: CameraEventType | any[];
        zoomEventTypes: CameraEventType | any[];
        rotateEventTypes: CameraEventType | any[];
        tiltEventTypes: CameraEventType | any[];
        lookEventTypes: CameraEventType | any[];
        minimumPickingTerrainHeight: number;
        minimumCollisionTerrainHeight: number;
        minimumTrackBallHeight: number;
        enableCollisionDetection: boolean;
        constructor(scene: Scene);
        isDestroyed(): boolean;
        destroy(): void;
    }

    class ShadowMap {
        darkness: number;
        enabled: boolean;
        maximumDistance: number;
        normalOffset: boolean;
        size: number;
        softShadows: boolean;
        constructor(options: ShadowMapOptions);
    }

    type ShadowMapOptions = {
        lightCamera: Camera;
        cascadesEnabled?: boolean;
        darkness?: number;
        enabled?: boolean;
        isPointLight?: boolean;
        maximumDistance?: number;
        normalOffset?: boolean;
        numberOfCascades?: number;
        pointLightRadius?: number;
        size?: number;
        softShadows?: boolean;
    }

    class SingleTileImageryProvider {
        url: string;
        proxy: Proxy;
        tileWidth: number;
        tileHeight: number;
        maximumLevel: number;
        minimumLevel: number;
        tilingScheme: TilingScheme;
        rectangle: Rectangle;
        tileDiscardPolicy: TileDiscardPolicy;
        errorEvent: Event;
        ready: boolean;
        credit: Credit;
        hasAlphaChannel: boolean;
        constructor(options: { url: string; rectangle?: Rectangle; credit?: Credit | string; ellipsoid?: Ellipsoid; proxy?: any });
        getTileCredits(x: number, y: number, level: number): Credit[];
        requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
        pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
    }

    class SkyAtmosphere {
        show: boolean;
        ellipsoid: Ellipsoid;
        constructor(ellipsoid?: Ellipsoid);
        isDestroyed(): boolean;
        destroy(): void;
    }

    class SkyBox {
        sources: any;
        show: boolean;
        constructor(options: { sources?: any; show?: boolean });
        update(): void;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class Sun {
        show: boolean;
        glowFactor: number;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class TileCoordinatesImageryProvider {
        proxy: Proxy;
        tileWidth: number;
        tileHeight: number;
        maximumLevel: number;
        minimumLevel: number;
        tilingScheme: TilingScheme;
        rectangle: Rectangle;
        tileDiscardPolicy: TileDiscardPolicy;
        errorEvent: Event;
        ready: boolean;
        credit: Credit;
        hasAlphaChannel: boolean;
        constructor(options?: { tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid; color?: Color; tileWidth?: number; tileHeight?: number });
        getTileCredits(x: number, y: number, level: number): Credit[];
        requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
        pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
    }

    class TileDiscardPolicy {
        isReady(): boolean;
        shouldDiscardImage(image: HTMLImageElement | Promise<HTMLImageElement>): Promise<boolean>;
    }

    class TileMapServiceImageryProvider extends ImageryProvider {
        url: string;
        proxy: Proxy;
        tileWidth: number;
        tileHeight: number;
        maximumLevel: number;
        minimumLevel: number;
        tilingScheme: TilingScheme;
        rectangle: Rectangle;
        tileDiscardPolicy: TileDiscardPolicy;
        errorEvent: Event;
        ready: boolean;
        credit: Credit;
        hasAlphaChannel: boolean;
        constructor(options?: { url?: string; fileExtension?: string; proxy?: any; credit?: Credit | string; minimumLevel?: number; maximumLevel?: number; rectangle?: Rectangle; tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid; tileWidth?: number; tileHeight?: number });
        getTileCredits(x: number, y: number, level: number): Credit[];
        requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
        pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
    }

    class ViewportQuad {
        show: boolean;
        rectangle: BoundingRectangle;
        material: Material;
        constructor(rectangle?: BoundingRectangle, material?: Material);
        update(): void;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class WebMapServiceImageryProvider extends ImageryProvider {
        url: string;
        proxy: Proxy;
        layers: string;
        tileWidth: number;
        tileHeight: number;
        maximumLevel: number;
        minimumLevel: number;
        tilingScheme: TilingScheme;
        rectangle: Rectangle;
        tileDiscardPolicy: TileDiscardPolicy;
        errorEvent: Event;
        ready: boolean;
        credit: Credit;
        hasAlphaChannel: boolean;
        static DefaultParameters: Object;
        static GetFeatureInfoDefaultParameters: Object;
        constructor(options: { url: string; layers: string; parameters?: any; getFeatureInfoParameters?: any; enablePickFeatures?: boolean; getFeatureInfoFormats?: GetFeatureInfoFormat[]; rectangle?: Rectangle; tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid; tileWidth?: number; tileHeight?: number; minimumLevel?: number; maximumLevel?: number; credit?: Credit | string; proxy?: any });
        getTileCredits(x: number, y: number, level: number): Credit[];
        requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
        pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
    }

    class WebMapTileServiceImageryProvider extends ImageryProvider {
        url: string;
        proxy: Proxy;
        tileWidth: number;
        tileHeight: number;
        maximumLevel: number;
        minimumLevel: number;
        tilingScheme: TilingScheme;
        rectangle: Rectangle;
        tileDiscardPolicy: TileDiscardPolicy;
        errorEvent: Event;
        format: string;
        ready: boolean;
        credit: Credit;
        hasAlphaChannel: boolean;
        constructor(options: { url: string; format?: string; layer: string; style: string; tileMatrixSetID: string; tileMatrixLabels?: any[]; tileWidth?: number; tileHeight?: number; tilingScheme?: TilingScheme; proxy?: any; rectangle?: Rectangle; minimumLevel?: number; maximumLevel?: number; ellipsoid?: Ellipsoid; credit?: Credit | string });
        getTileCredits(x: number, y: number, level: number): Credit[];
        requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
        pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
    }

    class Animation {
        container: Element;
        viewModel: AnimationViewModel;
        constructor(container: Element | string, viewModel: AnimationViewModel);
        isDestroyed(): boolean;
        destroy(): void;
        resize(): void;
        applyThemeChanges(): void;
    }

    class AnimationViewModel {
        shuttleRingDragging: boolean;
        snapToTicks: boolean;
        timeLabel: string;
        dateLabel: string;
        multiplierLabel: string;
        shuttleRingAngle: number;
        slower: Command;
        faster: Command;
        clockViewModel: ClockViewModel;
        pauseViewModel: ToggleButtonViewModel;
        playReverseViewModel: ToggleButtonViewModel;
        playForwardViewModel: ToggleButtonViewModel;
        playRealtimeViewModel: ToggleButtonViewModel;
        dateFormatter: AnimationViewModel.DateFormatter;
        timeFormatter: AnimationViewModel.TimeFormatter;
        static defaultDateFormatter: AnimationViewModel.DateFormatter;
        static defaultTicks: number[];
        static defaultTimeFormatter: AnimationViewModel.TimeFormatter;
        constructor(clockViewModel: ClockViewModel);
        getShuttleRingTicks(): number[];
        setShuttleRingTicks(positiveTicks: number[]): void;
    }

    module AnimationViewModel {
        type DateFormatter = (date: JulianDate, viewModel: AnimationViewModel) => string;
        type TimeFormatter = (date: JulianDate, viewModel: AnimationViewModel) => string;
    }

    class BaseLayerPicker {
        container: Element;
        viewModel: BaseLayerPickerViewModel;
        constructor(container: Element, options: { globe: Globe; imageryProviderViewModels?: ProviderViewModel[]; selectedImageryProviderViewModel?: ProviderViewModel; terrainProviderViewModels?: ProviderViewModel[]; selectedTerrainProviderViewModel?: ProviderViewModel });
        isDestroyed(): boolean;
        destroy(): void;
    }

    class BaseLayerPickerViewModel {
        imageryProviderViewModels: ProviderViewModel[];
        terrainProviderViewModels: ProviderViewModel[];
        dropDownVisible: boolean;
        buttonTooltip: string;
        buttonImageUrl: string;
        selectedImagery: ProviderViewModel;
        selectedTerrain: ProviderViewModel;
        toggleDropDown: Command;
        globe: Globe;
        constructor(options: { globe: Globe; imageryProviderViewModels?: ProviderViewModel[]; selectedImageryProviderViewModel?: ProviderViewModel; terrainProviderViewModels?: ProviderViewModel[]; selectedTerrainProviderViewModel?: ProviderViewModel });
    }

    class ProviderViewModel {
        name: string;
        tooltip: string;
        iconUrl: string;
        creationCommand: Command;
        constructor(options: {
            name: string;
            tooltip: string;
            iconUrl: string;
            creationFunction: ProviderViewModel.CreationFunction | Command
        });
    }

    module ProviderViewModel {
        type CreationFunction = () => ImageryProvider | TerrainProvider | ImageryProvider[] | TerrainProvider[];
    }

    class CesiumInspector {
        container: Element;
        viewModel: CesiumInspectorViewModel;
        constructor(container: Element | string, scene: Scene);
        isDestroyed(): boolean;
        destroy(): void;
    }

    class CesiumInspectorViewModel {
        frustums: boolean;
        performance: boolean;
        shaderCacheText: string;
        primitiveBoundingSphere: boolean;
        primitiveReferenceFrame: boolean;
        filterPrimitive: boolean;
        tileBoundingSphere: boolean;
        filterTile: boolean;
        wireframe: boolean;
        suspendUpdates: boolean;
        tileCoordinates: boolean;
        frustumStatisticText: string;
        tileText: string;
        hasPickedPrimitive: boolean;
        hasPickedTile: boolean;
        pickPimitiveActive: boolean;
        pickTileActive: boolean;
        dropDownVisible: boolean;
        generalVisible: boolean;
        primitivesVisible: boolean;
        terrainVisible: boolean;
        generalSwitchText: string;
        primitivesSwitchText: string;
        terrainSwitchText: string;
        scene: Scene;
        performanceContainer: Element;
        toggleDropDown: Command;
        showFrustums: Command;
        showPerformance: Command;
        showPrimitiveBoundingSphere: Command;
        showPrimitiveReferenceFrame: Command;
        doFilterPrimitive: Command;
        showWireframe: Command;
        doSuspendUpdates: Command;
        showTileCoordinates: Command;
        showTileBoundingSphere: Command;
        doFilterTile: Command;
        toggleGeneral: Command;
        togglePrimitives: Command;
        toggleTerrain: Command;
        pickPrimitive: Command;
        pickTile: Command;
        selectParent: Command;
        selectNW: Command;
        selectNE: Command;
        selectSW: Command;
        selectSE: Command;
        primitive: Command;
        tile: Command;
        constructor(scene: Scene);
        isDestroyed(): boolean;
        destroy(): void;
    }

    class CesiumWidget {
        container: Element;
        canvas: HTMLCanvasElement;
        creditContainer: Element;
        scene: Scene;
        imageryLayers: ImageryLayerCollection;
        terrainProvider: TerrainProvider;
        camera: Camera;
        clock: Clock;
        screenSpaceEventHandler: ScreenSpaceEventHandler;
        targetFrameRate: number;
        useDefaultRenderLoop: boolean;
        resolutionScale: number;
        constructor(container: Element | string, options?: CesiumWidgetOptions);
        showErrorPanel(title: string, message: string, error?: string): void;
        isDestroyed(): boolean;
        destroy(): void;
        resize(): void;
        render(): void;
    }

    class CesiumWidgetOptions {
        clock?: Clock;
        imageryProvider?: ImageryProvider;
        terrainProvider?: TerrainProvider;
        skyBox?: SkyBox | boolean;
        skyAtmosphere?: SkyAtmosphere;
        sceneMode?: SceneMode;
        scene3DOnly?: boolean;
        orderIndependentTranslucency?: boolean;
        mapProjection?: MapProjection;
        globe?: Globe;
        useDefaultRenderLoop?: boolean;
        targetFrameRate?: number;
        showRenderLoopErrors?: boolean;
        contextOptions?: any;
        creditContainer?: Element | string;
    }

    class ClockViewModel {
        systemTime: JulianDate;
        startTime: JulianDate;
        stopTime: JulianDate;
        currentTime: JulianDate;
        multiplier: number;
        clockStep: ClockStep;
        clockRange: ClockRange;
        canAnimate: boolean;
        shouldAnimate: boolean;
        clock: Clock;
        constructor(clock?: Clock);
        synchronize(): void;
        isDestroyed(): boolean;
        destroy(): void;
    }

    class Command {
        canExecute: boolean;
        beforeExecute: Event;
        afterExecute: Event;
    }

    class FullscreenButton {
        container: Element;
        viewModel: FullscreenButtonViewModel;
        constructor(container: Element | string, fullscreenElement?: Element | string);
        isDestroyed(): boolean;
        destroy(): void;
    }

    class FullscreenButtonViewModel {
        isFullscreen: boolean;
        isFullscreenEnabled: boolean;
        tooltip: string;
        fullscreenElement: Element;
        command: Command;
        constructor(fullscreenElement?: Element | string);
        isDestroyed(): boolean;
        destroy(): void;
    }

    class GeocoderOptions {
        container?: Element | string
        scene?: Scene
        url?: string
        key?: string
        flightDuration?: number;
    }

    class Geocoder {
        container: Element;
        viewModel: GeocoderViewModel;
        constructor(options: GeocoderOptions);
        isDestroyed(): boolean;
        destroy(): void;
    }

    class GeocoderViewModel {
        isSearchInProgress: boolean;
        searchText: string;
        flightDuration: number;
        url: string;
        key: string;
        complete: Event;
        scene: Scene;
        search: Command;
        constructor(options: { scene: Scene; url?: string; key?: string; flightDuration?: number });
    }

    class GeocoderResult {
        displayName: string;
        destination: Rectangle | Cartesian3;
    }

    interface GeocoderService {
        geocode(query: string): Promise<Array<GeocoderResult>>
    }

    class HomeButton {
        container: Element;
        viewModel: HomeButtonViewModel;
        constructor(container: Element | string, scene: Scene, duration?: number);
        isDestroyed(): boolean;
        destroy(): void;
    }

    class HomeButtonViewModel {
        tooltip: string;
        scene: Scene;
        command: Command;
        duration: number;
        constructor(scene: Scene, duration?: number);
    }

    class InfoBox {
        container: Element;
        viewModel: InfoBoxViewModel;
        frame: HTMLIFrameElement;
        constructor(container: Element | string);
        isDestroyed(): boolean;
        destroy(): void;
    }

    class InfoBoxViewModel {
        maxHeight: number;
        enableCamera: boolean;
        isCameraTracking: boolean;
        showInfo: boolean;
        titleText: string;
        description: string;
        cameraIconPath: string;
        cameraClicked: Event;
        closeClicked: Event;
        maxHeightOffset(offset: number): string;
    }

    class NavigationHelpButton {
        container: Element;
        viewModel: NavigationHelpButtonViewModel;
        constructor(options: { container: Element | string; instructionsInitiallyVisible?: boolean });
        isDestroyed(): boolean;
        destroy(): void;
    }

    class NavigationHelpButtonViewModel {
        showInstructions: boolean;
        tooltip: string;
        command: Command;
        showClick: Command;
        showTouch: Command;
    }

    class PerformanceWatchdog {
        container: Element;
        viewModel: PerformanceWatchdogViewModel;
        constructor(options?: { container: Element | string; scene: Scene; lowFrameRateMessage?: string });
        isDestroyed(): boolean;
        destroy(): void;
    }

    class PerformanceWatchdogViewModel {
        lowFrameRateMessage: string;
        lowFrameRateMessageDismissed: boolean;
        showingLowFrameRateMessage: boolean;
        scene: Scene;
        dismissMessage: Command;
        constructor(options?: { scene: Scene; lowFrameRateMessage?: string });
    }

    class SceneModePicker {
        container: Element;
        viewModel: SceneModePickerViewModel;
        constructor(container: Element | string, scene: Scene, duration?: number);
        isDestroyed(): boolean;
        destroy(): void;
    }

    class SceneModePickerViewModel {
        sceneMode: SceneMode;
        dropDownVisible: boolean;
        tooltip2D: string;
        tooltip3D: string;
        tooltipColumbusView: string;
        selectedTooltip: string;
        scene: Scene;
        duration: number;
        toggleDropDown: Command;
        morphTo2D: Command;
        morphTo3D: Command;
        morphToColumbusView: Command;
        constructor(scene: Scene, duration?: number);
        isDestroyed(): boolean;
        destroy(): void;
    }

    class SelectionIndicator {
        container: Element;
        viewModel: SelectionIndicatorViewModel;
        constructor(container: Element | string, scene: Scene);
        isDestroyed(): boolean;
        destroy(): void;
    }

    class SelectionIndicatorViewModel {
        position: Cartesian3;
        showSelection: boolean;
        isVisible: boolean;
        computeScreenSpacePosition: SelectionIndicatorViewModel.ComputeScreenSpacePosition;
        container: Element;
        selectionIndicatorElement: Element;
        scene: Scene;
        constructor(scene: Scene, selectionIndicatorElement: Element, container: Element);
        update(): void;
        animateAppear(): void;
        animateDepart(): void;
    }

    module SelectionIndicatorViewModel {
        type ComputeScreenSpacePosition = (position: Cartesian3, result: Cartesian2) => Cartesian2;
    }

    class Timeline {
        container: Element;
        constructor(container: Element, clock: Clock);
        isDestroyed(): boolean;
        destroy(): void;
        zoomTo(startTime: JulianDate, stopTime: JulianDate): void;
        resize(): void;
    }

    class ToggleButtonViewModel {
        toggled: boolean;
        tooltip: string;
        command: Command;
        constructor(command: Command, options?: { toggled?: boolean; tooltip?: string });
    }

    class Viewer {
        constructor(container: Element | string, options?: ViewerOptions);
        allowDataSourcesToSuspendAnimation: boolean;
        readonly animation: Animation;
        readonly baseLayerPicker: BaseLayerPicker;
        readonly bottomContainer: Element;
        readonly camera: Camera;
        readonly canvas: HTMLCanvasElement;
        readonly cesiumLogo: Element;
        readonly cesiumWidget: CesiumWidget;
        readonly clock: Clock;
        clockTrackedDataSource: DataSource;
        readonly clockViewModel: ClockViewModel;
        readonly container: Element;
        readonly dataSourceDisplay: DataSourceDisplay;
        readonly dataSources: DataSourceCollection;
        readonly entities: EntityCollection;
        readonly fullscreenButton: FullscreenButton;
        readonly geocoder: Geocoder;
        readonly homeButton: HomeButton;
        readonly imageryLayers: ImageryLayerCollection;
        readonly infoBox: InfoBox;
        readonly navigationHelpButton: NavigationHelpButton;
        resolutionScale: number;
        readonly scene: Scene;
        readonly sceneModePicker: SceneModePicker;
        readonly screenSpaceEventHandler: ScreenSpaceEventHandler;
        selectedEntity: Entity;
        readonly selectedEntityChanged: Event;
        readonly selectionIndicator: SelectionIndicator;
        readonly shadowMap: ShadowMap;
        shadows: boolean;
        targetFrameRate: number;
        terrainProvider: TerrainProvider;
        terrainShadows: boolean;
        readonly timeline: Timeline;
        trackedEntity: Entity;
        readonly trackedEntityChanged: Event;
        useDefaultRenderLoop: boolean;
        readonly vrButton: VRButton;
        destroy(): void;
        extend(mixin: Viewer.ViewerMixin, options: any): void;
        flyTo(target: Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Promise<Entity | Entity[] | EntityCollection | DataSource | ImageryLayer>,
            options?: { duration?: number; offset?: HeadingPitchRange }): Promise<boolean>;
        forceResize(): void;
        isDestroyed(): boolean;
        render(): void;
        resize(): void;
        zoomTo(target: Entity | Entity[] | EntityCollection | DataSource | Promise<Entity | Entity[] | EntityCollection | DataSource>, offset?: HeadingPitchRange): Promise<boolean>;
    }

    module Viewer {
        type ViewerMixin = (viewer: Viewer, options: any) => void;
    }

    class ViewerOptions {
        animation?: boolean;
        automaticallyTrackDataSourceClocks?: boolean;
        baseLayerPicker?: boolean;
        clockViewModel?: ClockViewModel;
        contextOptions?: any;
        creditContainer?: Element | string;
        dataSources?: DataSourceCollection;
        fullscreenButton?: boolean;
        fullscreenElement?: Element | string;
        geocoder?: boolean | GeocoderService[];
        globe?: Globe;
        homeButton?: boolean;
        imageryProvider?: ImageryProvider;
        imageryProviderViewModels?: ProviderViewModel[];
        infoBox?: boolean;
        mapProjection?: MapProjection;
        navigationHelpButton?: boolean;
        navigationInstructionsInitiallyVisible?: boolean;
        orderIndependentTranslucency?: boolean;
        scene3DOnly?: boolean;
        sceneMode?: SceneMode;
        sceneModePicker?: boolean;
        selectedImageryProviderViewModel?: ProviderViewModel;
        selectedTerrainProviderViewModel?: ProviderViewModel;
        selectionIndicator?: boolean;
        showRenderLoopErrors?: boolean;
        skyAtmosphere?: SkyAtmosphere;
        skyBox?: SkyBox;
        targetFrameRate?: number;
        terrainProvider?: TerrainProvider;
        terrainProviderViewModels?: ProviderViewModel[];
        timeline?: boolean;
        useDefaultRenderLoop?: boolean;
    }

    class VRButton {
        constructor(container: Element|string, scene: Scene, vrElement: Element|string);
        readonly container: Element;
        readonly viewModel: VRButtonViewModel;
        destroy(): void;
        isDestroyed(): boolean;
    }

    class VRButtonViewModel {
        constructor(scene: Scene, vrElement: Element | string);
        readonly command: Command;
        isVREnabled: boolean;
        readonly isVRMode: boolean;
        readonly tooltip: string;
        vrElement: Element;
        destroy(): void;
        isDestroyed(): boolean;
    }

    function barycentricCoordinates(point: Cartesian2 | Cartesian3, p0: Cartesian2 | Cartesian3, p1: Cartesian2 | Cartesian3, p2: Cartesian2 | Cartesian3, result?: Cartesian3): Cartesian3;

    function binarySearch(array: any[], itemToFind: any, comparator: binarySearch.Comparator): number;

    module binarySearch {
        type Comparator = (a: any, b: any) => number;
    }

    function cancelAnimationFrame(requestID: number): void;

    function clone(object: Object, deep?: boolean): Object;

    function combine(object1?: Object, object2?: Object, deep?: boolean): Object;

    function destroyObject(object: any, message?: string): void;

    function formatError(object: any): string;

    function getFilenameFromUri(uri: string): string;

    function getImagePixels(image: HTMLImageElement): number[];

    function isArray(value: any): boolean;

    function isLeapYear(year: number): boolean;

    function jsonp(url: string, options?: { parameters?: any; callbackParameterName?: string; proxy?: any }): Promise<any>;

    function loadArrayBuffer(url: string, headers?: any): Promise<ArrayBuffer>;

    function loadBlob(url: string, headers?: any): Promise<Blob>;

    function loadImage(url: string, allowCrossOrigin?: boolean): Promise<HTMLImageElement>;

    function loadImageViaBlob(url: string): Promise<HTMLImageElement>;

    function loadJson(url: string, headers?: any): Promise<any>;

    function loadText(url: string, headers?: any): Promise<string>;

    function loadWithXhr(options: {
        url: string;
        responseType?: string;
        method?: string;
        data?: string | FormData;
        headers?: any;
        overrideMimeType?: string;
    }): Promise<any>;

    function loadXML(url: string, headers?: any): Promise<XMLDocument>;

    function mergeSort(array: any[], comparator: mergeSort.Comparator, userDefinedObject?: any): void;

    module mergeSort {
        type Comparator = (a: any, b: any, userDefinedObject?: any) => number;
    }

    function objectToQuery(obj: any): string;

    function pointInsideTriangle(point: Cartesian2 | Cartesian3, p0: Cartesian2 | Cartesian3, p1: Cartesian2 | Cartesian3, p2: Cartesian2 | Cartesian3): boolean;

    function queryToObject(queryString: string): any;

    function requestAnimationFrame(callback: requestAnimationFrame.Callback): number;

    module requestAnimationFrame {
        type Callback = (timestamp: number) => void;
    }

    function sampleTerrain(terrainProvider: TerrainProvider, level: number, positions: Cartographic[]): Promise<Cartographic[]>;

    function subdivideArray<T>(array: T[], numberOfArrays: number): T[][];

    function throttleRequestByServer(url: string, requestFunction: throttleRequestByServer.RequestFunction): Promise<any>;

    module throttleRequestByServer {
        type RequestFunction = (url: string) => Promise<any>;
    }

    function createTangentSpaceDebugPrimitive(options: { geometry: Geometry; length?: number; modelMatrix?: Matrix4 }): Primitive;

    function viewerCesiumInspectorMixin(viewer: Viewer): void;

    function viewerDragDropMixin(viewer: Viewer, options?: { dropTarget?: Element | string; clearOnDrop?: boolean; proxy?: DefaultProxy }): void;

    function viewerPerformanceWatchdogMixin(viewer: Viewer): void;

    function createCommand(func: Function, canExecute?: boolean): Function;

    function createTaskProcessorWorker(workerFunction: createTaskProcessorWorker.WorkerFunction): createTaskProcessorWorker.TaskProcessorWorkerFunction;

    module createTaskProcessorWorker {
        type WorkerFunction = (parameters: any, transferableObjects: any[]) => any;
        type TaskProcessorWorkerFunction = (event: any) => void;
    }

    enum ClockRange {
        UNBOUNDED,
        CLAMPED,
        LOOP_STOP,
    }

    enum ClockStep {
        TICK_DEPENDENT,
        SYSTEM_CLOCK_MULTIPLIER,
        SYSTEM_CLOCK,
    }

    enum ComponentDatatype {
        BYTE,
        UNSIGNED_BYTE,
        SHORT,
        UNSIGNED_SHORT,
        FLOAT,
        DOUBLE,
    }

    module ComponentDatatype {
        function getSizeInBytes(componentDatatype: ComponentDatatype): number;
        function fromTypedArray(array: Int8Array | Uint8Array | Int16Array | Uint16Array | Float32Array | Float64Array): ComponentDatatype;
        function validate(componentDatatype: ComponentDatatype): boolean;
        function createTypedArray(componentDatatype: ComponentDatatype, valuesOrLength: number | any[]): Int8Array | Uint8Array | Int16Array | Uint16Array | Float32Array | Float64Array;
        function createArrayBufferView(componentDatatype: ComponentDatatype, buffer: ArrayBuffer, byteOffset?: number, length?: number): Int8Array | Uint8Array | Int16Array | Uint16Array | Float32Array | Float64Array;
    }

    enum CornerType {
        ROUNDED,
        MITERED,
        BEVELED,
    }

    module CubicRealPolynomial {
        function computeDiscriminant(a: number, b: number, c: number, d: number): number;
        function computeRealRoots(a: number, b: number, c: number, d: number): number[];
    }

    enum ExtrapolationType {
        NONE,
        HOLD,
        EXTRAPOLATE,
    }

    module FeatureDetection {
        function supportsFullscreen(): boolean;
        function supportsTypedArrays(): boolean;
        function supportsWebWorkers(): boolean;
    }

    enum Fullscreen {
        element,
        changeEventName,
        errorEventName,
        enabled,
        fullscreen,
    }

    module Fullscreen {
        function supportsFullscreen(): boolean;
        function requestFullscreen(element: any): boolean;
        function exitFullscreen(): boolean;
    }

    module GeometryPipeline {
        function toWireframe(geometry: Geometry): Geometry;
        function createLineSegmentsForVectors(geometry: Geometry, attributeName?: string, length?: number): Geometry;
        function createAttributeLocations(geometry: Geometry): any;
        function reorderForPreVertexCache(geometry: Geometry): Geometry;
        function reorderForPostVertexCache(geometry: Geometry, cacheCapacity?: number): Geometry;
        function fitToUnsignedShortIndices(geometry: Geometry): Geometry[];
        function projectTo2D(geometry: Geometry, attributeName: string, attributeName3D: string, attributeName2D: string, projection?: any): Geometry;
        function encodeAttribute(geometry: Geometry, attributeName: string, attributeHighName: string, attributeLowName: string): Geometry;
        function transformToWorldCoordinates(instance: GeometryInstance): GeometryInstance;
        function computeNormal(geometry: Geometry): Geometry;
        function computeBinormalAndTangent(geometry: Geometry): Geometry;
        function compressVertices(geometry: Geometry): Geometry;
    }

    // enum HeightmapTessellator {
    //     DEFAULT_STRUCTURE,
    // }

    // module HeightmapTessellator {
    //     function computeVertices(options: { vertices: any[] | Float32Array; heightmap: Int8Array | Uint8Array | Int16Array | Uint16Array | Float32Array | Float64Array; width: number; height: number; skirtHeight: number; nativeRectangle: Rectangle; rectangle?: Rectangle; isGeographic?: boolean; relativetoCenter?: Cartesian3; ellipsoid?: Ellipsoid; structure?: any; structureheightScale?: number; structureheightOffset?: number; structureelementsPerHeight?: number; structurestride?: number; structureelementMultiplier?: number; structureisBigEndian?: boolean });
    // }

    enum HeightReference {
        CLAMP_TO_GROUND,
        NONE,
        RELATIVE_TO_GROUND
    }

    module HermitePolynomialApproximation {
        function getRequiredDataPoints(degree: number, inputOrder?: number): number;
        function interpolateOrderZero(x: number, xTable: number[], yTable: number[], yStride: number, result?: number[]): number[];
        function interpolate(x: number, xTable: number[], yTable: number[], yStride: number, inputOrder: number, outputOrder: number, result?: number[]): number[];
    }

    enum IndexDatatype {
        UNSIGNED_BYTE,
        UNSIGNED_SHORT,
        UNSIGNED_INT,
    }

    module IndexDatatype {
        function getSizeInBytes(indexDatatype: IndexDatatype): number;
        function validate(indexDatatype: IndexDatatype): boolean;
        function createTypedArray(numberOfVertices: number, indicesLengthOrArray: any): Uint16Array | Uint32Array;
        function createTypedArrayFromArrayBuffer(numberOfVertices: number, sourceArray: ArrayBuffer, byteOffset: number, length: number): Uint16Array | Uint32Array;
    }

    enum InterpolationAlgorithm {
        type,
    }

    module InterpolationAlgorithm {
        function getRequiredDataPoints(degree: number): number;
        function interpolateOrderZero(x: number, xTable: number[], yTable: number[], yStride: number, result?: number[]): number[];
        function interpolate(x: number, xTable: number[], yTable: number[], yStride: number, inputOrder: number, outputOrder: number, result?: number[]): number[];
    }

    enum Intersect {
        OUTSIDE,
        INTERSECTING,
        INSIDE,
    }

    module IntersectionTests {
        function rayPlane(ray: Ray, plane: Plane, result?: Cartesian3): Cartesian3;
        function rayTriangle(ray: Ray, p0: Cartesian3, p1: Cartesian3, p2: Cartesian3, cullBackFaces?: boolean, result?: Cartesian3): Cartesian3;
        function lineSegmentTriangle(v0: Cartesian3, v1: Cartesian3, p0: Cartesian3, p1: Cartesian3, p2: Cartesian3, cullBackFaces?: boolean, result?: Cartesian3): Cartesian3;
        function raySphere(ray: Ray, sphere: BoundingSphere, result?: any): any;
        function lineSegmentSphere(p0: Cartesian3, p1: Cartesian3, sphere: BoundingSphere, result?: any): any;
        function rayEllipsoid(ray: Ray, ellipsoid: Ellipsoid): any;
        function grazingAltitudeLocation(ray: Ray, ellipsoid: Ellipsoid): Cartesian3;
        function lineSegmentPlane(endPoint0: Cartesian3, endPoint1: Cartesian3, plane: Plane, result?: Cartesian3): Cartesian3;
        function trianglePlaneIntersection(p0: Cartesian3, p1: Cartesian3, p2: Cartesian3, plane: Plane): any;
    }

    module Intersections2D {
        function clipTriangleAtAxisAlignedThreshold(threshold: number, keepAbove: boolean, u0: number, u1: number, u2: number, result?: number[]): number[];
        function computeBarycentricCoordinates(x: number, y: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, result?: Cartesian3): Cartesian3;
    }

    enum Iso8601 {
        MINIMUM_VALUE,
        MAXIMUM_VALUE,
        MAXIMUM_INTERVAL,
    }

    enum KeyboardEventModifier {
        SHIFT,
        CTRL,
        ALT,
    }

    module LagrangePolynomialApproximation {
        function getRequiredDataPoints(degree: number): number;
        function interpolateOrderZero(x: number, xTable: number[], yTable: number[], yStride: number, result?: number[]): number[];
    }

    module LinearApproximation {
        function getRequiredDataPoints(degree: number): number;
        function interpolateOrderZero(x: number, xTable: number[], yTable: number[], yStride: number, result?: number[]): number[];
    }

    enum Math {
        EPSILON1,
        EPSILON2,
        EPSILON3,
        EPSILON4,
        EPSILON5,
        EPSILON6,
        EPSILON7,
        EPSILON8,
        EPSILON9,
        EPSILON10,
        EPSILON11,
        EPSILON12,
        EPSILON13,
        EPSILON14,
        EPSILON15,
        EPSILON16,
        EPSILON17,
        EPSILON18,
        EPSILON19,
        EPSILON20,
        GRAVITATIONALPARAMETER,
        SOLAR_RADIUS,
        LUNAR_RADIUS,
        SIXTY_FOUR_KILOBYTES,
        PI,
        ONE_OVER_PI,
        PI_OVER_TWO,
        PI_OVER_THREE,
        PI_OVER_FOUR,
        PI_OVER_SIX,
        THREE_PI_OVER_TWO,
        TWO_PI,
        ONE_OVER_TWO_PI,
        RADIANS_PER_DEGREE,
        DEGREES_PER_RADIAN,
        RADIANS_PER_ARCSECOND,
    }

    module Math {
        function sign(value: number): number;
        function signNotZero(value: number): number;
        function toSNorm(value: number): number;
        function fromSNorm(value: number): number;
        function sinh(value: number): number;
        function cosh(value: number): number;
        function lerp(p: number, q: number, time: number): number;
        function toRadians(degrees: number): number;
        function toDegrees(radians: number): number;
        function convertLongitudeRange(angle: number): number;
        function negativePiToPi(angle: number): number;
        function zeroToTwoPi(angle: number): number;
        function mod(m: number, n: number): number;
        function equalsEpsilon(left: number, right: number, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
        function factorial(n: number): number;
        function incrementWrap(n?: number, maximumValue?: number, minimumValue?: number): number;
        function isPowerOfTwo(n: number): boolean;
        function nextPowerOfTwo(n: number): number;
        function clamp(value: number, min: number, max: number): number;
        function setRandomNumberSeed(seed: number): void;
        function nextRandomNumber(): number;
        function acosClamped(value: number): number;
        function asinClamped(value: number): number;
        function chordLength(angle: number, radius: number): number;
    }

    enum Packable {
        packedLength,
    }

    module Packable {
        function pack(value: any, array: number[], startingIndex?: number): number[];
        function unpack(array: number[], startingIndex?: number, result?: any): any;
    }

    enum PackableForInterpolation {
        packedInterpolationLength,
    }

    module PackableForInterpolation {
        function convertPackedArrayForInterpolation(packedArray: number[], startingIndex?: number, lastIndex?: number, result?: number[]): void;
        function unpackInterpolationResult(array: number[], sourceArray: number[], startingIndex?: number, lastIndex?: number, result?: any): any;
    }

    enum PixelFormat {
        DEPTH_COMPONENT,
        DEPTH_STENCIL,
        ALPHA,
        RGB,
        RGBA,
        LUMINANCE,
        LUMINANCE_ALPHA,
    }

    enum PrimitiveType {
        POINTS,
        LINES,
        LINE_LOOP,
        LINE_STRIP,
        TRIANGLES,
        TRIANGLE_STRIP,
        TRIANGLE_FAN,
    }

    module QuadraticRealPolynomial {
        function computeDiscriminant(a: number, b: number, c: number): number;
        function computeRealRoots(a: number, b: number, c: number): number[];
    }

    module QuarticRealPolynomial {
        function computeDiscriminant(a: number, b: number, c: number, d: number, e: number): number;
        function computeRealRoots(a: number, b: number, c: number, d: number, e: number): number[];
    }

    enum ReferenceFrame {
        FIXED,
        INERTIAL,
    }

    enum ScreenSpaceEventType {
        LEFT_DOWN,
        LEFT_UP,
        LEFT_CLICK,
        LEFT_DOUBLE_CLICK,
        RIGHT_DOWN,
        RIGHT_UP,
        RIGHT_CLICK,
        RIGHT_DOUBLE_CLICK,
        MIDDLE_DOWN,
        MIDDLE_UP,
        MIDDLE_CLICK,
        MIDDLE_DOUBLE_CLICK,
        MOUSE_MOVE,
        WHEEL,
        PINCH_START,
        PINCH_END,
        PINCH_MOVE,
    }

    interface PositionedEvent {
        position: Cartesian2;
    }

    interface MoveEvent {
        startPosition: Cartesian2;
        endPosition: Cartesian2;
    }

    interface Touch2Event {
        position1: Cartesian2;
        position2: Cartesian2;
    }



    module Simon1994PlanetaryPositions {
        function computeSunPositionInEarthInertialFrame(julianDate?: JulianDate, result?: Cartesian3): Cartesian3;
        function computeMoonPositionInEarthInertialFrame(julianDate?: JulianDate, result?: Cartesian3): Cartesian3;
    }

    enum TimeStandard {
        UTC,
        TAI,
    }

    module Transforms {
        function eastNorthUpToFixedFrame(origin: Cartesian3, ellipsoid?: Ellipsoid, result?: Matrix4): Matrix4;
        function northEastDownToFixedFrame(origin: Cartesian3, ellipsoid?: Ellipsoid, result?: Matrix4): Matrix4;
        function northUpEastToFixedFrame(origin: Cartesian3, ellipsoid?: Ellipsoid, result?: Matrix4): Matrix4;
        function headingPitchRollToFixedFrame(origin: Cartesian3, heading: number, pitch: number, roll: number, ellipsoid?: Ellipsoid, result?: Matrix4): Matrix4;
        function headingPitchRollQuaternion(origin: Cartesian3, heading: number, pitch: number, roll: number, ellipsoid?: Ellipsoid, result?: Quaternion): Quaternion;
        function computeTemeToPseudoFixedMatrix(date: JulianDate, result?: Matrix3): Matrix3;
        function preloadIcrfFixed(timeInterval: TimeInterval): Promise<void>;
        function computeIcrfToFixedMatrix(date: JulianDate, result?: Matrix3): Matrix3;
        function computeFixedToIcrfMatrix(date: JulianDate, result?: Matrix3): Matrix3;
        function pointToWindowCoordinates(modelViewProjectionMatrix: Matrix4, viewportTransformation: Matrix4, point: Cartesian3, result?: Cartesian2): Cartesian2;
    }

    module TridiagonalSystemSolver {
        function solve(diagonal: number[], lower: number[], upper: number[], right: Cartesian3[]): Cartesian3[];
    }

    enum Visibility {
        NONE,
        PARTIAL,
        FULL,
    }

    enum WindingOrder {
        CLOCKWISE,
        COUNTER_CLOCKWISE,
    }

    enum StripeOrientation {
        HORIZONTAL,
        VERTICAL,
    }

    enum BingMapsStyle {
        AERIAL,
        AERIAL_WITH_LABELS,
        ROAD,
        ORDNANCE_SURVEY,
        COLLINS_BART,
    }

    enum BlendEquation {
        ADD,
        SUBTRACT,
        REVERSE_SUBTRACT,
    }

    enum BlendFunction {
        ZERO,
        ONE,
        SOURCE_COLOR,
        ONE_MINUS_SOURCE_COLOR,
        DESTINATION_COLOR,
        ONE_MINUS_DESTINATION_COLOR,
        SOURCE_ALPHA,
        ONE_MINUS_SOURCE_ALPHA,
        DESTINATION_ALPHA,
        ONE_MINUS_DESTINATION_ALPHA,
        CONSTANT_COLOR,
        ONE_MINUS_CONSTANT_COLOR,
        CONSTANT_ALPHA,
        ONE_MINUS_CONSTANT_ALPHA,
        SOURCE_ALPHA_SATURATE,
    }

    enum BlendingState {
        DISABLED,
        ALPHA_BLEND,
        PRE_MULTIPLIED_ALPHA_BLEND,
        ADDITIVE_BLEND,
    }

    enum CameraEventType {
        LEFT_DRAG,
        RIGHT_DRAG,
        MIDDLE_DRAG,
        WHEEL,
        PINCH,
    }

    enum CullFace {
        FRONT,
        BACK,
        FRONT_AND_BACK,
    }

    enum DepthFunction {
        NEVER,
        LESS,
        EQUAL,
        LESS_OR_EQUAL,
        GREATER,
        NOT_EQUAL,
        GREATER_OR_EQUAL,
        ALWAYS,
    }

    enum HorizontalOrigin {
        CENTER,
        LEFT,
        RIGHT,
    }

    enum LabelStyle {
        FILL,
        OUTLINE,
        FILL_AND_OUTLINE,
    }

    enum ModelAnimationLoop {
        NONE,
        REPEAT,
        MIRRORED_REPEAT,
    }

    enum SceneMode {
        MORPHING,
        COLUMBUS_VIEW,
        SCENE2D,
        SCENE3D,
    }

    module SceneMode {
        function getMorphTime(value: SceneMode): number;
    }

    module SceneTransforms {
        function wgs84ToWindowCoordinates(scene: Scene, position: Cartesian3, result?: Cartesian2): Cartesian2;
        function wgs84ToDrawingBufferCoordinates(scene: Scene, position: Cartesian3, result?: Cartesian2): Cartesian2;
    }

    enum StencilFunction {
        NEVER,
        LESS,
        EQUAL,
        LESS_OR_EQUAL,
        GREATER,
        NOT_EQUAL,
        GREATER_OR_EQUAL,
        ALWAYS,
    }

    enum StencilOperation {
        ZERO,
        KEEP,
        REPLACE,
        INCREMENT,
        DECREMENT,
        INVERT,
        INCREMENT_WRAP,
        DECREMENT_WRAP,
    }

    enum VerticalOrigin {
        CENTER,
        BOTTOM,
        TOP,
    }

    function createTileMapServiceImageryProvider(options: {
        url?: string,
        fileExtension?: string,
        proxy?: {},
        credit?: Credit | string,
        minimumLevel?: number,
        maximumLevel?: number,
        rectangle?: Rectangle,
        tilingScheme?: TilingScheme,
        ellipsoid?: Ellipsoid,
        tileWidth?: number,
        tileHeight?: number,
        flipXY?: boolean
    }): TileMapServiceImageryProvider;

    class UrlTemplateImageryProvider {
        url: string;
        pickFeaturesUrl: string;
        urlSchemeZeroPadding: {};
        subdomains: string | Array<string>
        proxy: {};
        credit: Credit | string;
        minimumLevel: number;
        maximumLevel: number;
        rectangle: Rectangle;
        tilingScheme: TilingScheme;
        ellipsoid: Ellipsoid;
        tileWidth: number;
        tileHeight: number;
        hasAlphaChannel: boolean;
        getFeatureInfoFormats: Array<GetFeatureInfoFormat>;
        enablePickFeatures: boolean;
        errorEvent: Event;
        ready: boolean;
        readyPromise: Promise<boolean>;
        tileDiscardPolicy: TileDiscardPolicy;
        constructor(options: {
            url: string,
            pickFeaturesUrl?: string,
            urlSchemeZeroPadding?: {},
            subdomains?: string | Array<string>
            proxy?: {},
            credit?: Credit | string,
            minimumLevel?: number,
            maximumLevel?: number,
            rectangle?: Rectangle,
            tilingScheme?: TilingScheme,
            ellipsoid?: Ellipsoid,
            tileWidth?: number,
            tileHeight?: number,
            hasAlphaChannel?: boolean,
            getFeatureInfoFormats?: Array<GetFeatureInfoFormat>,
            enablePickFeatures?: boolean
        });
        getTileCredits(x: number, y: number, level: number): Array<Credit>;
        pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<Array<ImageryLayerFeatureInfo>> | undefined;
        reinitialize(options: Promise<Object> | Object): void;
    }

    function defined(value: Object): boolean;

    function buildModuleUrl(url: string): string;

    namespace when {
        function all<T>(promises: Promise<T>[]): Promise<T[]>;
        function resolve<T>(val: T): Promise<T>;
    }
    function when(arg:any) : Promise<any>;

    // TODO
    var knockout: any;
}