/** * Created by laixiangran on 2018/10/08. * homepage：http://www.laixiangran.cn * Typescript definition for cesium 1.5x */ declare module GeoVis { class a { } } declare module Cesium { function defineProperties(a1, a2); function when(a1, a2); class Ion { static defaultAccessToken: string static defaultServer: string constructor() } 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 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 { static packedLength: number center: Cartesian3 radius: number constructor(center?: Cartesian3, radius?: number) 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 fromEncodedCartesianVertices( positionsHigh?: number[], positionsLow?: number[], result?: BoundingSphere ): BoundingSphere static fromOrientedBoundingBox( orientedBoundingBox: OrientedBoundingBox, 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 static intersectPlane(sphere: BoundingSphere, plane: Plane): Intersect static isOccluded(sphere: BoundingSphere, occluder: Occluder): boolean intersect(plane: Cartesian4): Intersect equals(right?: BoundingSphere): boolean clone(result?: BoundingSphere): BoundingSphere computePlaneDistances(position: Cartesian3, direction: Cartesian3, result?: Interval): Interval distanceSquaredTo(cartesian: Cartesian3): number intersectPlane(plane: Plane): Intersect isOccluded(occluder: Occluder): boolean } class OrientedBoundingBox { center: Cartesian3 halfAxes: Matrix3 constructor(center?: Cartesian3, halfAxes?: Matrix3) static clone(box: OrientedBoundingBox, result?: OrientedBoundingBox): OrientedBoundingBox static computePlaneDistances( box: OrientedBoundingBox, position: Cartesian3, direction: Cartesian3, result?: Interval ): Interval static distanceSquaredTo(box: OrientedBoundingBox, cartesian: Cartesian3): number static equals(left: OrientedBoundingBox, right: OrientedBoundingBox): boolean static fromPoints(positions: Cartesian3[], result?: OrientedBoundingBox): OrientedBoundingBox static fromRectangle( rectangle: Rectangle, minimumHeight?: number, maximumHeight?: number, ellipsoid?: Ellipsoid, result?: OrientedBoundingBox ): OrientedBoundingBox static intersectPlane(box: OrientedBoundingBox, plane: Plane): Intersect static isOccluded(box: OrientedBoundingBox, occluder: Occluder): boolean clone(result?: OrientedBoundingBox): OrientedBoundingBox computePlaneDistances(position: Cartesian3, direction: Cartesian3, result?: Interval): Interval distanceSquaredTo(cartesian: Cartesian3): number equals(right: OrientedBoundingBox): boolean intersectPlane(plane: Plane): Intersect isOccluded(occluder: Occluder): boolean } class BoxGeometry { static packedLength: number constructor(options: { minimumCorner: Cartesian3 maximumCorner: Cartesian3 vertexFormat?: VertexFormat }) static createGeometry(boxGeometry: BoxGeometry): Geometry | undefined static fromAxisAlignedBoundingBox(boundingBox: AxisAlignedBoundingBox): BoxGeometry static fromDimensions(options: { dimensions: Cartesian3 vertexFormat?: VertexFormat }): BoxGeometry static pack(value: any, array: number[], startingIndex?: number): number[] static unpack(array: number[], startingIndex?: number, result?: BoxGeometry): BoxGeometry } 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 | undefined } 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 midpoint(left, right, result): Cartesian3 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[] static unpackArray(array: number[]): Cartesian3[] isConstant: boolean definitionChanged: Event referenceFrame: ReferenceFrame getValue(time: JulianDate, result?: Cartesian3): Cartesian3 getValueInReferenceFrame( time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3 ): Cartesian3 setInterpolationOptions(options?: { interpolationAlgorithm?: InterpolationAlgorithm interpolationDegree?: number }): void } 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 x: any; y: any; z: any; 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 toCartesian( 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> } 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 extends TerrainProvider { 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, request: Request): Promise getLevelMaximumGeometricError(level: number): number getTileDataAvailable(x: number, y: number, level: number): boolean } class Cesium3DTileset { readonly url: string show: boolean modelMatrix: Matrix4 shadows: ShadowMode maximumScreenSpaceError: number maximumMemoryUsage: number cullWithChildrenBounds: boolean dynamicScreenSpaceError: boolean dynamicScreenSpaceErrorDensity: number dynamicScreenSpaceErrorFactor: number dynamicScreenSpaceErrorHeightFalloff: number skipLevelOfDetail: boolean baseScreenSpaceError: number skipScreenSpaceErrorFactor: number skipLevels: number immediatelyLoadDesiredLevelOfDetail: boolean loadSiblings: boolean debugFreezeFrame: boolean debugColorizeTiles: boolean debugWireframe: boolean debugShowBoundingVolume: boolean debugShowContentBoundingVolume: boolean debugShowViewerRequestVolume: boolean debugShowGeometricError: boolean debugShowRenderingStatistics: boolean debugShowMemoryUsage: boolean debugShowUrl: boolean pointCloudShading: PointCloudShading readonly ready: boolean readonly readyPromise: Promise constructor(options: { url: string | Resource show?: boolean modelMatrix?: Matrix4 shadows?: ShadowMode maximumScreenSpaceError?: number maximumMemoryUsage?: number cullWithChildrenBounds?: boolean dynamicScreenSpaceError?: boolean dynamicScreenSpaceErrorDensity?: number dynamicScreenSpaceErrorFactor?: number dynamicScreenSpaceErrorHeightFalloff?: number skipLevelOfDetail?: boolean baseScreenSpaceError?: number skipScreenSpaceErrorFactor?: number skipLevels?: number immediatelyLoadDesiredLevelOfDetail?: boolean loadSiblings?: boolean debugFreezeFrame?: boolean debugColorizeTiles?: boolean debugWireframe?: boolean debugShowBoundingVolume?: boolean debugShowContentBoundingVolume?: boolean debugShowViewerRequestVolume?: boolean debugShowGeometricError?: boolean debugShowRenderingStatistics?: boolean debugShowMemoryUsage?: boolean debugShowUrl?: boolean pointCloudShading?: PointCloudShadingOptions }) } class Cesium3DTileStyle { constructor(style?: string | Object) } class ShadowMode { static CAST_ONLY: number static DISABLED: number static ENABLED: number static RECEIVE_ONLY: number } class CircleGeometry { static packedLength: number constructor(options: { center: Cartesian3 radius: number ellipsoid?: Ellipsoid height?: number granularity?: number vertexFormat?: VertexFormat extrudedHeight?: number stRotation?: number }) static createGeometry(circleGeometry: CircleGeometry): Geometry | undefined static pack(value: any, array: number[], startingIndex?: number): number[] static unpack(array: number[], startingIndex?: number, result?: CircleGeometry): CircleGeometry } class CircleOutlineGeometry { static packedLength: number constructor(options: { center: Cartesian3 radius: number ellipsoid?: Ellipsoid height?: number granularity?: number extrudedHeight?: number numberOfVerticalLines?: number }) static createGeometry(circleGeometry: CircleOutlineGeometry): Geometry | undefined static pack(value: any, array: number[], startingIndex?: number): number[] static unpack( array: number[], startingIndex?: number, result?: CircleOutlineGeometry ): CircleOutlineGeometry } class ClassificationType { static BOTH: number static CESIUM_3D_TILE: number static TERRAIN: number } 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 | undefined } 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 | undefined } 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 | undefined } 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 | undefined } class DefaultProxy { constructor(proxy: string) getURL(resource: string): string } class DeveloperError { name: string message: string stack: string constructor(message?: string) } class DistanceDisplayCondition { near: number far: number constructor(near?: number, far?: number) clone(result?: DistanceDisplayCondition): DistanceDisplayCondition equals(other: DistanceDisplayCondition): boolean static clone( value?: DistanceDisplayCondition, result?: DistanceDisplayCondition ): DistanceDisplayCondition static equals(left: DistanceDisplayCondition, right: DistanceDisplayCondition): boolean } 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 createGeometry(ellipseGeometry: EllipseGeometry): Geometry | undefined static pack(value: any, array: number[], startingIndex?: number): number[] static unpack( array: number[], startingIndex?: number, result?: EllipseGeometry ): EllipseGeometry } 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 createGeometry(ellipseGeometry: EllipseOutlineGeometry): Geometry | undefined static pack(value: any, array: number[], startingIndex?: number): number[] static unpack( array: number[], startingIndex?: number, result?: EllipseOutlineGeometry ): EllipseOutlineGeometry } class Ellipsoid { static MOON: Ellipsoid static packedLength: number static UNIT_SPHERE: Ellipsoid static WGS84: Ellipsoid minimumRadius: number maximumRadius: number oneOverRadii: Cartesian3 oneOverRadiiSquared: Cartesian3 radii: Cartesian3 radiiSquared: Cartesian3 radiiToTheFourth: Cartesian3 constructor(x?: number, y?: number, z?: number) 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 cartesianArrayToCartographicArray( cartesians: Cartesian3[], result?: Cartographic[] ): Cartographic[] cartesianToCartographic(cartesian: Cartesian3, result?: Cartographic): Cartographic cartographicArrayToCartesianArray( cartographics: Cartographic[], result?: Cartesian3[] ): Cartesian3[] cartographicToCartesian(cartographic: Cartographic, result?: Cartesian3): Cartesian3 clone(result?: Ellipsoid): Ellipsoid equals(right?: Ellipsoid): boolean geocentricSurfaceNormal(cartesian: Cartesian3, result?: Cartesian3): Cartesian3 geodeticSurfaceNormalCartographic(cartographic: Cartographic, result?: Cartesian3): Cartesian3 geodeticSurfaceNormal(cartesian: Cartesian3, result?: Cartesian3): Cartesian3 scaleToGeodeticSurface(cartesian: Cartesian3, result?: Cartesian3): Cartesian3 scaleToGeocentricSurface(cartesian: Cartesian3, result?: Cartesian3): Cartesian3 transformPositionToScaledSpace(position: Cartesian3, result?: Cartesian3): Cartesian3 transformPositionFromScaledSpace(position: Cartesian3, result?: Cartesian3): Cartesian3 getSurfaceNormalIntersectionWithZAxis( position: Cartesian3, buffer: number, result: Cartesian3 ): Cartesian3 toString(): string } 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 createGeometry(ellipsoidGeometry: EllipsoidGeometry): Geometry | undefined static pack(value: any, array: number[], startingIndex?: number): number[] static unpack( array: number[], startingIndex?: number, result?: EllipsoidGeometry ): EllipsoidGeometry } class EllipsoidOutlineGeometry { static packedLength: number constructor(options?: { radii?: Cartesian3 stackPartitions?: number slicePartitions?: number subdivisions?: number }) static createGeometry(ellipsoidGeometry: EllipsoidOutlineGeometry): Geometry | undefined static pack(value: any, array: number[], startingIndex?: number): number[] static unpack( array: number[], startingIndex?: number, result?: EllipsoidOutlineGeometry ): EllipsoidOutlineGeometry } 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 extends TerrainProvider { credit: Credit errorEvent: Event hasWaterMask: boolean hasVertexNormals: boolean ready: boolean readonly readyPromise: Promise tilingScheme: GeographicTilingScheme constructor(options?: { tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid }) getLevelMaximumGeometricError(level: number): number getTileDataAvailable(x: number, y: number, level: number): boolean requestTileGeometry(x: number, y: number, level: number, request: Request): Promise } 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 boundingSphere: BoundingSphere indices: any[] primitiveType: PrimitiveType 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?: any[] }) } class GeometryAttributes { bitangent?: GeometryAttribute color?: GeometryAttribute normal?: GeometryAttribute position?: GeometryAttribute st?: GeometryAttribute tangent?: GeometryAttribute msize?: GeometryAttribute } class GeometryInstance { geometry: Geometry modelMatrix: Matrix4 id: any attributes: any constructor(options: { geometry: Geometry | any 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 interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number upsample( tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number ): Promise 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(any) 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, result?: Matrix3): 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: Matrix3 ): 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 TranslationRotationScale { translation: Cartesian3 rotation: Quaternion scale: Cartesian3 constructor( translation?: Cartesian3, rotation?: Quaternion, scale?: Cartesian3 ) } 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 fromTranslationRotationScale(translationRotationScale: TranslationRotationScale, result?: Matrix4): 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 { cameraPosition: Cartesian3 position: Cartesian3 radius: number constructor(occluderBoundingSphere: BoundingSphere, cameraPosition: Cartesian3) static computeOccludeePoint( occluderBoundingSphere: BoundingSphere, occludeePosition: Cartesian3, positions: Cartesian3[] ): any static computeOccludeePointFromRectangle(rectangle: Rectangle, ellipsoid?: Ellipsoid): any static fromBoundingSphere( occluderBoundingSphere: BoundingSphere, cameraPosition: Cartesian3, result?: Occluder ): Occluder computeVisibility(occludeeBS: BoundingSphere): number isBoundingSphereVisible(occludee: BoundingSphere): boolean isPointVisible(occludee: Cartesian3): boolean } class PinBuilder { fromColor(color: Color, size: number): HTMLCanvasElement fromUrl(url: string, color: Color, size: number): HTMLCanvasElement | Promise fromMakiIconId( id: string, color: Color, size: number ): HTMLCanvasElement | Promise fromText(text: string, color: Color, size: number): HTMLCanvasElement } class Plane { static ORIGIN_XY_PLANE: Plane static ORIGIN_YZ_PLANE: Plane static ORIGIN_ZX_PLANE: Plane distance: number normal: Cartesian3 constructor(normal: Cartesian3, distance: number) static fromCartesian4(coefficients: Cartesian4, result: Plane): Plane static fromPointNormal(point: Cartesian3, normal: Cartesian3, result?: Plane): Plane static getPointDistance(plane: Plane, point: Cartesian3): number } class ClippingPlane { distance: number normal: Cartesian3 constructor(normal: Cartesian3, distance: number) } class ClippingPlaneCollection { constructor(options) } type PointCloudShadingOptions = Partial<{ attenuation: boolean geometricErrorScale: number maximumAttenuation: number baseResolution: number eyeDomeLighting: boolean eyeDomeLightingStrength: number eyeDomeLightingRadius: number }> class PointCloudShading { attenuation: boolean baseResolution: number eyeDomeLighting: boolean eyeDomeLightingRadius: number eyeDomeLightingStrength: number geometricErrorScale: number maximumAttenuation: number constructor(options: PointCloudShadingOptions) static isSupported(scene: Scene): boolean } class PolygonGeometry { packedLength: number constructor(options: { polygonHierarchy: PolygonHierarchy height?: number extrudedHeight?: number vertexFormat?: VertexFormat stRotation?: number ellipsoid?: Ellipsoid granularity?: number perPositionHeight?: boolean closeTop?: boolean closeBottom?: boolean }) static createGeometry(polygonGeometry: PolygonGeometry): Geometry | undefined 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 | undefined 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 arcType?: any ellipsoid?: Ellipsoid vertexFormat?: any }) static pack(value: any, array: number[], startingIndex?: number): number[] static unpack( array: number[], startingIndex?: number, result?: PolylineGeometry ): PolylineGeometry static createGeometry(polylineGeometry: PolylineGeometry): Geometry | undefined } class ArcType { static NONE: 0 static GEODESIC: 1 static RHUMB: 2 } 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 | undefined } 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 | undefined } 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 upsample( tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number ): Promise 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( headingPitchRoll: HeadingPitchRoll, 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 { static fromCartesianArray(arg0: any) 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 closeTop?: boolean closeBottom?: boolean }) static createGeometry(rectangleGeometry: RectangleGeometry): Geometry | undefined static pack(value: BoundingSphere, array: number[], startingIndex?: number): number[] static unpack( array: number[], startingIndex?: number, result?: RectangleGeometry ): RectangleGeometry } 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 | undefined } class RequestErrorEvent { statusCode: number response: any responseHeaders: any constructor(statusCode?: number, response?: any, responseHeaders?: string | any) toString(): string } type ResourceCallback = (resource: Resource, error: Error) => boolean | Promise type ResourceOptions = { url: string queryParameters?: object templateValues?: object headers?: object proxy?: DefaultProxy retryCallback?: ResourceCallback retryAttempts?: number request?: any // Cesium.Request } class Resource { static fetchArrayBuffer: any; static fetchImage: any; constructor(options: string | ResourceOptions) } class RuntimeError { name: string message: string stack: string constructor(message?: string) } class ScreenSpaceEventHandler { lastPointTemporary: boolean; dragger: any; 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 createGeometry(simplePolylineGeometry: SimplePolylineGeometry): Geometry | undefined static pack(value: any, array: number[], startingIndex?: number): number[] static unpack( array: number[], startingIndex?: number, result?: SimplePolylineGeometry ): SimplePolylineGeometry } 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 | undefined } 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 | undefined } 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 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 upsample( tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number ): Promise 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 { static heightmapTerrainQuality: number credit: Credit errorEvent: Event hasVertexNormals: boolean hasWaterMask: boolean ready: boolean readonly readyPromise: Promise tilingScheme: TilingScheme static getEstimatedLevelZeroGeometricErrorForAHeightmap( ellipsoid: Ellipsoid, tileImageWidth: number, numberOfTilesAtLevelZero: number ): number static getRegularGridIndices(width: number, height: number): Uint16Array getLevelMaximumGeometricError(level: number): number getTileDataAvailable(x: number, y: number, level: number): boolean requestTileGeometry( x: number, y: number, level: number, request?: Request ): Promise } 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 GoogleEarthEnterpriseTerrainProvider extends TerrainProvider { readonly credit: Credit readonly errorEvent: Event hasVertexNormals: boolean hasWaterMask: boolean readonly proxy: Proxy readonly ready: boolean readonly readyPromise: Promise readonly tilingScheme: TilingScheme readonly url: string constructor(options: { url: Resource | string metadata: GoogleEarthEnterpriseMetadata ellipsoid?: Ellipsoid credit?: Credit | string }) getLevelMaximumGeometricError(level: number): number getTileDataAvailable(x: number, y: number, level: number): boolean requestTileGeometry( x: number, y: number, level: number, request?: Request ): Promise } class GoogleEarthEnterpriseMetadata { constructor(resourceOrUrl: Resource | string) } class VRTheWorldTerrainProvider extends TerrainProvider { credit: Credit errorEvent: Event hasVertexNormals: boolean hasWaterMask: boolean ready: boolean readonly readyPromise: Promise tilingScheme: GeographicTilingScheme constructor(options: { url: string proxy?: any ellipsoid?: Ellipsoid credit?: Credit | string }) getLevelMaximumGeometricError(level: number): number getTileDataAvailable(x: number, y: number, level: number): boolean requestTileGeometry( x: number, y: number, level: number, request?: Request ): Promise } 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 createGeometry(wallGeometry: WallGeometry): Geometry | undefined static fromConstantHeights( positions: Cartesian3[], maximumHeight?: number, minimumHeight?: number, ellipsoid?: Ellipsoid ): WallGeometry static pack(value: any, array: number[], startingIndex?: number): number[] static unpack(array: number[], startingIndex?: number, result?: WallGeometry): WallGeometry } 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 | undefined } 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?: any | String | HTMLCanvasElement show?: any | boolean scale?: any | number horizontalOrigin?: any | HorizontalOrigin verticalOrigin?: any | VerticalOrigin eyeOffset?: any pixelOffset?: any | Cartesian2 rotation?: any alignedAxis?: any width?: any | number height?: any | number color?: any scaleByDistance?: any | NearFarScalar translucencyByDistance?: any | NearFarScalar pixelOffsetScaleByDistance?: any | NearFarScalar imageSubRegion?: any } class BillboardGraphics { readonly definitionChanged: Event disableDepthTestDistance: any | any distanceDisplayCondition: any | any heightReference: any | any sizeInMeters: any | any image: any | any imageSubRegion: any | any scale: any | any rotation: any | any alignedAxis: any | any horizontalOrigin: any | any verticalOrigin: any | any color: any | any eyeOffset: any | any pixelOffset: any | any show: any | any width: any | any height: any | any scaleByDistance: any | any translucencyByDistance: any | any pixelOffsetScaleByDistance: any | any 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: any 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: any dimensions: any material: MaterialProperty fill: any outline: any outlineColor: any outlineWidth: any constructor(options?: { dimensions?: any show?: any fill?: any material?: MaterialProperty outline?: any outlineColor?: any outlineWidth?: any }) 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?: any): boolean } module CallbackProperty { type Callback = (time?: JulianDate, result?: any) => any } class CheckerboardMaterialProperty { isConstant: boolean definitionChanged: Event evenColor: any oddColor: any repeat: any constructor(options?: { evenColor?: any; oddColor?: any; repeat?: any }) getType(time: JulianDate): string getValue(time: JulianDate, result?: any): any equals(other?: any): boolean } class ColorMaterialProperty { isConstant: boolean definitionChanged: Event color: any constructor(color?: any) getType(time: JulianDate): string getValue(time: JulianDate, result?: any): any equals(other?: any): 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?: any): 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?: any): boolean } class CompositeProperty { isConstant: boolean definitionChanged: Event intervals: TimeIntervalCollection getValue(time: JulianDate, result?: any): any equals(other?: any): 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?: any): boolean } class ConstantProperty { isConstant: boolean definitionChanged: Event constructor(value?: any) getValue(time?: JulianDate, result?: any): any setValue(value: any): void equals(other?: any): boolean } class CorridorGeometryUpdater { entity: Entity fillEnabled: boolean hasConstantFill: boolean fillMaterialProperty: MaterialProperty outlineEnabled: boolean hasConstantOutline: boolean outlineColorProperty: any 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: any material: MaterialProperty positions: any height: any extrudedHeight: any granularity: any width: any fill: any outline: any outlineColor: any outlineWidth: any cornerType: any constructor(options?: { positions?: any width?: any cornerType?: any height?: any extrudedHeight?: any show?: any fill?: any material?: MaterialProperty outline?: any outlineColor?: any outlineWidth?: any granularity?: any }) 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: any 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: any topRadius: any bottomRadius: any numberOfVerticalLines: any slices: any show: any material: MaterialProperty fill: any outline: any outlineColor: any outlineWidth: any constructor(options?: { length?: any topRadius?: any bottomRadius?: any show?: any fill?: any material?: MaterialProperty outline?: any outlineColor?: any outlineWidth?: any numberOfVerticalLines?: any slices?: any }) clone(result?: CylinderGraphics): CylinderGraphics merge(source: CylinderGraphics): void } class CzmlDataSource extends DataSource { 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 load(data: string | any, options?: { sourceUri?: string }): Promise static load(data: string | any, options?: { sourceUri?: string }): Promise 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): Promise 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: any 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: any semiMajorAxis: any semiMinorAxis: any rotation: any show: any material: any height: any extrudedHeight: any granularity: any stRotation: any fill: any outline: any outlineColor: any outlineWidth: any numberOfVerticalLines: any constructor(options?: { semiMajorAxis?: number semiMinorAxis?: number height?: any extrudedHeight?: any show?: any fill?: any material?: any outline?: any outlineColor?: any outlineWidth?: any numberOfVerticalLines?: any rotation?: any stRotation?: any granularity?: any }) clone(result?: EllipseGraphics): EllipseGraphics merge(source: EllipseGraphics): void } class EllipsoidGeometryUpdater { entity: Entity fillEnabled: boolean hasConstantFill: boolean fillMaterialProperty: MaterialProperty outlineEnabled: boolean hasConstantOutline: boolean outlineColorProperty: any 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: any radii: any material: MaterialProperty fill: any outline: any outlineColor: any outlineWidth: any stackPartitions: any slicePartitions: any subdivisions: any constructor(options?: { radii?: any show?: any fill?: any material?: MaterialProperty outline?: any outlineColor?: any outlineWidth?: any subdivisions?: any stackPartitions?: any slicePartitions?: any }) clone(result?: EllipsoidGraphics): EllipsoidGraphics merge(source: EllipsoidGraphics): void } class RectangularSensorGraphics { options: any constructor(options?: any) } class Entity { conicSensor: any; rectangularSensor: any; inProgress(arg0: any, arg1: any) 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: any | any ellipse: EllipseGraphics ellipsoid: EllipsoidGraphics entityCollection: EntityCollection label: LabelGraphics model: ModelGraphics orientation: any path: PathGraphics plane: PlaneGraphics point: PointGraphics polygon: PolygonGraphics polyline: PolylineGraphics polylineVolume: PolylineVolumeGraphics position: PositionProperty properties: PropertyBag rectangle: RectangleGraphics viewFrom: any 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?: any | string position?: any | Cartesian3 orientation?: any | any viewFrom?: any | any parent?: Entity billboard?: BillboardGraphics | BillboardGraphicsOptions box?: BoxGraphics corridor?: CorridorGraphics cylinder?: CylinderGraphics ellipse?: EllipseGraphics ellipsoid?: EllipsoidGraphics label?: LabelGraphics | LabelGraphicsOptions model?: ModelGraphics path?: PathGraphics plane?: PlaneGraphics point?: PointGraphics polygon?: PolygonGraphics | PolygonGraphicsOptions polyline?: PolylineGraphics | PolylineGraphicsOptions 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 clampToGround?: boolean } ): Promise static load( data: string | any, options?: { sourceUri?: string describe?: (properties: Object, nameProperty: string) => void markerSize?: number markerSymbol?: string markerColor?: Color stroke?: Color strokeWidth?: number fill?: Color clampToGround?: boolean } ): Promise } class GeometryUpdater { entity: Entity fillEnabled: boolean hasConstantFill: boolean fillMaterialProperty: MaterialProperty outlineEnabled: boolean hasConstantOutline: boolean outlineColorProperty: any 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: any lineCount: any lineThickness: any lineOffset: any constructor(options?: { color?: any cellAlpha?: any lineCount?: any lineThickness?: any lineOffset?: any }) getType(time: JulianDate): string getValue(time: JulianDate, result?: any): any equals(other?: any): boolean } class ImageMaterialProperty { isConstant: boolean definitionChanged: Event image: any repeat: any constructor(options?: { image?: any; repeat?: any }) getType(time: JulianDate): string getValue(time: JulianDate, result?: any): any equals(other?: any): 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 static load( data: string | Document | Blob, options?: KmlConstructorOptions & KmlLoadOptions ): Promise } class KmlConstructorOptions { camera: Camera canvas: HTMLCanvasElement proxy?: DefaultProxy } class KmlLoadOptions { camera: Camera canvas: HTMLCanvasElement proxy?: DefaultProxy 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 { readonly definitionChanged: Event showBackground: any | boolean distanceDisplayCondition: any | any disableDepthTestDistance: any | any text: any font: any style: any fillColor: any outlineColor: any outlineWidth: any horizontalOrigin: any verticalOrigin: any eyeOffset: any pixelOffset: any scale: any show: any translucencyByDistance: any pixelOffsetScaleByDistance: any constructor(options?: LabelGraphicsOptions) clone(result?: LabelGraphics): LabelGraphics merge(source: LabelGraphics): void } class LabelGraphicsOptions { text?: any | string font?: any | string style?: any fillColor?: any | Color backgroundColor?: any | Color outlineColor?: any | Color outlineWidth?: any | number show?: any | boolean showBackground?: any | boolean scale?: any | NearFarScalar | any scaleByDistance?: any | NearFarScalar horizontalOrigin?: any | HorizontalOrigin verticalOrigin?: any | VerticalOrigin eyeOffset?: any | Cartesian2 pixelOffset?: any | Cartesian2 translucencyByDistance?: any | NearFarScalar pixelOffsetScaleByDistance?: any | NearFarScalar distanceDisplayCondition?: any | DistanceDisplayCondition disableDepthTestDistance?: any | number } 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 { readonly definitionChanged: Event show: any | boolean scale: any | number minimumPixelSize: any | number uri: any | string maximumScale: any | number constructor(options?: { uri?: any | string show?: any scale?: any | number minimumPixelSize?: any | number maximumScale: any | number }) 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: any material: MaterialProperty width: any resolution: any leadTime: any trailTime: any constructor(options?: { leadTime?: any trailTime?: any show?: any width?: any material?: MaterialProperty resolution?: any }) clone(result?: PathGraphics): PathGraphics merge(source: PathGraphics): void } class PathVisualizer { constructor(scene: Scene, entityCollection: EntityCollection) update(time: JulianDate): boolean isDestroyed(): boolean destroy(): void } class PlaneGraphics { readonly definitionChanged: Event plane: any dimensions: any show: any | boolean fill: any | boolean material?: MaterialProperty | Color outline: any | boolean outlineColor: any outlineWidth: any | number shadows: any distanceDisplayCondition: any constructor(options?: PlaneGraphicsOptions) clone(result?: PlaneGraphics): PlaneGraphics merge(source: PlaneGraphics): void } class PlaneGraphicsOptions { plane?: any dimensions?: any show?: any | boolean fill?: any | boolean material?: MaterialProperty | Color outline?: any | boolean outlineColor: any outlineWidth?: any | number shadows?: any distanceDisplayCondition?: any } class PointGraphics { color: any pixelSize: any outlineColor: any outlineWidth: any show: any | boolean scaleByDistance: any translucencyByDistance: any heightReference: any distanceDisplayCondition: any constructor(options?: PointGraphicsOptions) clone(result?: PointGraphics): PointGraphics merge(source: PointGraphics): void } class PointGraphicsOptions { color?: Color pixelSize?: number outlineColor?: Color outlineWidth?: number show?: any | boolean scaleByDistance?: any | NearFarScalar translucencyByDistance?: any | NearFarScalar heightReference?: HeightReference distanceDisplayCondition?: any | 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: any 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: any | boolean material: MaterialProperty positions: any hierarchy: any height: any extrudedHeight: any granularity: any stRotation: any fill: any outline: any outlineColor: any outlineWidth: any perPositionHeight: any constructor(options?: PolygonGraphicsOptions) clone(result?: PolygonGraphics): PolygonGraphics merge(source: PolygonGraphics): void } class PolygonGraphicsOptions { hierarchy?: any | PolygonHierarchy | Cartesian3[] height?: number extrudedHeight?: any | number show?: any | boolean fill?: any | boolean material?: MaterialProperty | Color outline?: boolean outlineColor?: any | Color outlineWidth?: number stRotation?: any | number granularity?: any | number perPositionHeight?: any | boolean } class PolylineArrowMaterialProperty { isConstant: boolean definitionChanged: Event color: any constructor(color?: any) getType(time: JulianDate): string getValue(time: JulianDate, result?: any): any equals(other?: any): boolean } class PolylineGeometryUpdater { entity: Entity fillEnabled: boolean hasConstantFill: boolean fillMaterialProperty: MaterialProperty outlineEnabled: boolean hasConstantOutline: boolean outlineColorProperty: any 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: any glowPower: any constructor(options?: { color?: any; glowPower?: any; taperPower?: any }) getType(time: JulianDate): string getValue(time: JulianDate, result?: any): any equals(other?: any): boolean } type PolylineGraphicsOptions = { positions?: any followSurface?: any width?: any show?: any material?: MaterialProperty granularity?: any } class PolylineGraphics { definitionChanged: Event show: any material: MaterialProperty positions: any width: number followSurface: any granularity: any constructor(options?: PolylineGraphicsOptions) clone(result?: PolylineGraphics): PolylineGraphics merge(source: PolylineGraphics): void } class PolylineOutlineMaterialProperty { isConstant: boolean definitionChanged: Event color: any outlineColor: any outlineWidth: any constructor(options?: { color?: any; outlineColor?: any; outlineWidth?: any }) getType(time: JulianDate): string getValue(time: JulianDate, result?: any): any equals(other?: any): boolean } class PolylineVolumeGeometryUpdater { entity: Entity fillEnabled: boolean hasConstantFill: boolean fillMaterialProperty: MaterialProperty outlineEnabled: boolean hasConstantOutline: boolean outlineColorProperty: any 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: any material: MaterialProperty positions: any shape: any granularity: any fill: any outline: any outlineColor: any outlineWidth: any cornerType: any constructor(options?: { positions?: any shape?: any cornerType?: any show?: any fill?: any material?: MaterialProperty outline?: any outlineColor?: any outlineWidth?: any granularity?: any }) clone(result?: PolylineVolumeGraphics): PolylineVolumeGraphics merge(source: PolylineVolumeGraphics): void } interface PositionProperty { readonly isConstant: boolean readonly definitionChanged: Event referenceFrame: ReferenceFrame equals(other: any): boolean getValue(time: JulianDate, result?: Cartesian3): Cartesian3 getValueInReferenceFrame( time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3 ): Cartesian3 setInterpolationOptions(options?: { interpolationAlgorithm?: InterpolationAlgorithm interpolationDegree?: number }): void } class PositionPropertyArray { isConstant: boolean definitionChanged: Event referenceFrame: ReferenceFrame constructor(value?: any[]) getValue(time?: JulianDate, result?: Cartesian3[]): Cartesian3[] getValueInReferenceFrame( time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3 ): Cartesian3 setValue(value: any[]): void equals(other?: any): boolean } class Property { isConstant: boolean definitionChanged: Event getValue(time: JulianDate, result?: any): any static getValueOrUndefined(property?: any, time?: JulianDate, result?: any): any equals(other?: any): boolean } class PropertyArray { isConstant: boolean definitionChanged: Event constructor(value?: any[]) getValue(time?: JulianDate, result?: any[]): any[] setValue(value: any[]): void equals(other?: any): boolean } interface ObjectLike { [key: string]: any } 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: any 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: any coordinates: any material: MaterialProperty height: any extrudedHeight: any granularity: any stRotation: any rotation: any fill: any outline: any outlineColor: any outlineWidth: any closeTop: any closeBottom: any constructor(options?: { coordinates?: any height?: any extrudedHeight?: any closeTop?: any closeBottom?: any show?: any fill?: any material?: MaterialProperty outline?: any outlineColor?: any outlineWidth?: any rotation?: any stRotation?: any granularity?: any }) clone(result?: RectangleGraphics): RectangleGraphics merge(source: RectangleGraphics): void } class ReferenceProperty { isConstant: boolean definitionChanged: Event referenceFrame: ReferenceFrame targetId: string targetCollection: EntityCollection targetPropertyNames: string[] resolvedProperty: any 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?: any): 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?: any): 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?: any): boolean } class StripeMaterialProperty { isConstant: boolean definitionChanged: Event orientation: any evenColor: Color oddColor: Color offset: any repeat: number constructor(options?: { evenColor?: any oddColor?: any repeat?: any offset?: any orientation?: any }) getType(time: JulianDate): string getValue(time: JulianDate, result?: any): any equals(other?: any): 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?: any): boolean } class TimeIntervalCollectionProperty { isConstant: boolean definitionChanged: Event intervals: TimeIntervalCollection getValue(time: JulianDate, result?: any): any equals(other?: any): boolean } class VelocityOrientationProperty { isConstant: boolean definitionChanged: Event position: any ellipsoid: any constructor(position?: any, ellipsoid?: Ellipsoid) getValue(time?: JulianDate, result?: Quaternion): Quaternion equals(other?: any): 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: any 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: any material: MaterialProperty positions: any minimumHeights: any maximumHeights: any granularity: any fill: any outline: any outlineColor: any outlineWidth: any constructor(options?: { positions?: any maximumHeights?: any minimumHeights?: any show?: any fill?: any material?: MaterialProperty outline?: any outlineColor?: any outlineWidth?: any granularity?: any }) 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 pickFeatures( x: number, y: number, level: number, longitude: number, latitude: number ): Promise } 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 } 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 refresh(): void 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 pickFeatures( x: number, y: number, level: number, longitude: number, latitude: number ): Promise static tileXYToQuadKey(x: number, y: number, level: number): string static quadKeyToTileXY(quadkey: string): { x: number; y: number; level: number } } class BingMapsApi { static defaultKey: string } class EasingFunction { static BACK_IN: Function static BACK_IN_OUT: Function static BACK_OUT: Function static BOUNCE_IN: Function static BOUNCE_IN_OUT: Function static BOUNCE_OUT: Function static CIRCULAR_IN: Function static CIRCULAR_IN_OUT: Function static CIRCULAR_OUT: Function static CUBIC_IN: Function static CUBIC_IN_OUT: Function static CUBIC_OUT: Function static ELASTIC_IN: Function static ELASTIC_IN_OUT: Function static ELASTIC_OUT: Function static EXPONENTIAL_IN: Function static EXPONENTIAL_IN_OUT: Function static EXPONENTIAL_OUT: Function static LINEAR_NONE: Function static QUADRACTIC_IN: Function static QUADRACTIC_IN_OUT: Function static QUADRACTIC_OUT: Function static QUARTIC_IN: Function static QUARTIC_IN_OUT: Function static QUARTIC_OUT: Function static QUINTIC_IN: Function static QUINTIC_IN_OUT: Function static QUINTIC_OUT: Function static SINUSOIDAL_IN: Function static SINUSOIDAL_IN_OUT: Function static SINUSOIDAL_OUT: Function } 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 readonly transform: Matrix4 readonly inverseTransform: Matrix4 readonly viewMatrix: Matrix4 readonly inverseViewMatrix: Matrix4 readonly positionCartographic: Cartographic readonly positionWC: Cartesian3 readonly directionWC: Cartesian3 readonly upWC: Cartesian3 readonly rightWC: Cartesian3 readonly heading: number readonly pitch: number readonly roll: number readonly moveStart: Event readonly moveEnd: Event readonly changed: Event percentageChanged: number static DEFAULT_OFFSET: HeadingPitchRange static DEFAULT_VIEW_RECTANGLE: Rectangle static DEFAULT_VIEW_FACTOR: number constructor(scene: Scene) setView(options: { destination?: Cartesian3 | Rectangle orientation?: Object endTransform?: Matrix4 }): 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 | undefined 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 easingFunction?: EasingFunction maximumHeight?: number pitchAdjustHeight?: number flyOverLongitude?: number flyOverLongitudeWeight?: number }): void viewBoundingSphere(boundingSphere: BoundingSphere, offset?: HeadingPitchRange): void flyToBoundingSphere( boundingSphere: BoundingSphere, options?: { duration?: number offset?: HeadingPitchRange complete?: () => void cancel?: () => void endTransform?: Matrix4 easingFunction?: EasingFunction maximumHeight?: number pitchAdjustHeight?: number flyOverLongitude?: number flyOverLongitudeWeight?: number } ): void clone(): Camera cancelFlight(): void distanceToBoundingSphere(boundingSphere: BoundingSphere): number flyHome(duration?: number): void switchToOrthographicFrustum(): void switchToPerspectiveFrustum(): void } 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 { baseColor: Color depthTestAgainstTerrain: boolean ellipsoid: Ellipsoid enableLighting: boolean imageryLayers: ImageryLayerCollection lightingFadeInDistance: number lightingFadeOutDistance: number maximumScreenSpaceError: number oceanNormalMapUrl: string shadows: ShadowMode show: boolean showWaterEffect: boolean terrainProvider: TerrainProvider readonly terrainProviderChanged: Event tileCacheSize: number tileLoadProgressEvent: Event 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 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 requestImage(x: number, y: number, level: number): Promise } 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 pickFeatures( x: number, y: number, level: number, longitude: number, latitude: number ): Promise } 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 pickFeatures( x: number, y: number, level: number, longitude: number, latitude: number ): Promise } class HeadingPitchRange { constructor(heading?: number, pitch?: number, roll?: number) static clone(hpr: HeadingPitchRange, result?: HeadingPitchRange): HeadingPitchRange } class HeadingPitchRoll { heading: number pitch: number roll: number constructor(heading?: number, pitch?: number, range?: number) toString(): string static clone(headingPitchRoll: HeadingPitchRoll, result?: HeadingPitchRoll): HeadingPitchRoll static equals(left?: HeadingPitchRoll, right?: HeadingPitchRoll): boolean static equalsEpsilon( left?: HeadingPitchRoll, right?: HeadingPitchRoll, relativeEpsilon?: number, absoluteEpsilon?: number ): boolean static fromDegrees( heading: number, pitch: number, roll: number, result?: HeadingPitchRoll ): HeadingPitchRoll static fromQuaternion(quaternion: Quaternion, result?: HeadingPitchRoll): HeadingPitchRoll clone(result?: HeadingPitchRoll): HeadingPitchRoll equals(right?: HeadingPitchRoll): boolean equalsEpsilon( right?: HeadingPitchRoll, relativeEpsilon?: number, absoluteEpsilon?: number ): boolean } class ImageryLayer { alpha: number brightness: number contrast: number gamma: number hue: number readonly imageryProvider: ImageryProvider magnificationFilter: number minificationFilter: number readonly rectangle: Rectangle saturation: number show: boolean splitDirection: number static DEFAULT_BRIGHTNESS: number static DEFAULT_CONTRAST: number static DEFAULT_GAMMA: number static DEFAULT_HUE: number static DEFAULT_MAGNIFICATION_FILTER: number static DEFAULT_MINIFICATION_FILTER: number static DEFAULT_SATURATION: number static DEFAULT_SPLIT: 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 splitDirection?: number | Function minificationFilter?: number magnificationFilter?: number show?: boolean maximumAnisotropy?: number minimumTerrainLevel?: number maximumTerrainLevel?: number } ) getViewableRectangle(): Promise isBaseLayer(): boolean isDestroyed(): boolean destroy(): void } class TextureMagnificationFilter { static LINEAR: number static NEAREST: number } class ImagerySplitDirection { static LEFT: number static NONE: number static RIGHT: number static UP: number static BOTTOM: number } 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 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 pickFeatures( x: number, y: number, level: number, longitude: number, latitude: number ): Promise static loadImage(url: string): Promise } 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 { class MaterialSupport { static BASIC: number static TEXTURED: number static ALL: number } } class Model { activeAnimations: ModelAnimationCollection readonly allowPicking: boolean readonly readonlyasynchronous: boolean readonly basePath: string readonly boundingSphere: BoundingSphere clampAnimations: boolean color: Color colorBlendAmount: number colorBlendMode: ColorBlendMode debugShowBoundingVolume: boolean debugWireframe: boolean readonly gltf: any id: any readonly incrementallyLoadTextures: boolean maximumScale: number minimumPixelSize: number modelMatrix: Matrix4 readonly pendingTextureLoads: number readonly ready: boolean readonly readyPromise: Promise scale: number shadows: ShadowMode show: boolean silhouetteColor: Color silhouetteSize: number constructor(options?: { gltf?: any basePath?: string show?: boolean modelMatrix?: Matrix4 scale?: number minimumPixelSize?: number maximumScale?: number id?: any allowPicking?: boolean incrementallyLoadTextures?: boolean asynchronous?: boolean clampAnimations?: boolean shadows?: ShadowMode debugShowBoundingVolume?: boolean debugWireframe?: boolean heightReference?: HeightReference scene?: Scene distanceDisplayCondition?: DistanceDisplayCondition color?: Color colorBlendMode?: ColorBlendMode colorBlendAmount?: number silhouetteColor?: Color silhouetteSize?: number }) static fromGltf(options?: { url?: string headers?: any basePath?: string show?: boolean modelMatrix?: Matrix4 scale?: number minimumPixelSize?: number maximumScale?: number id?: any allowPicking?: boolean incrementallyLoadTextures?: boolean asynchronous?: boolean clampAnimations?: boolean shadows?: ShadowMode debugShowBoundingVolume?: boolean debugWireframe?: boolean }): Model static silhouetteSupported(scene: Scene): boolean getMesh(name: string): ModelMesh getNode(name: string): ModelNode getMaterial(name: string): ModelMaterial update(): void isDestroyed(): boolean destroy(): void } class ColorBlendMode { } 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 readonly length: number add(options: { name: string index?: number 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[] contains(animation: ModelAnimation): boolean get(index: number): ModelAnimation remove(animation: ModelAnimation): boolean removeAll(): void } 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): Promise } 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 pickFeatures( x: number, y: number, level: number, longitude: number, latitude: number ): Promise } 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 constructor(options?: { 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 } class BlendOption { static OPAQUE: number static OPAQUE_AND_TRANSLUCENT: number static TRANSLUCENT: number } 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 { readonly allowPicking: boolean readonly asynchronous: boolean readonly compressVertices: boolean readonly geometryInstances: GeometryInstance[] | GeometryInstance readonly interleave: boolean readonly vertexCacheOptimize: boolean readonly releaseGeometryInstances: boolean readonly ready: boolean readonly readyPromise: Promise cull: boolean debugShowBoundingVolume: boolean depthFailAppearance: Appearance modelMatrix: Matrix4 shadows: ShadowMode show: boolean appearance: Appearance | any constructor(options?: { geometryInstances?: any[] | GeometryInstance appearance?: Appearance | any show?: boolean modelMatrix?: Matrix4 vertexCacheOptimize?: boolean interleave?: boolean compressVertices?: boolean releaseGeometryInstances?: boolean allowPicking?: boolean cull?: boolean asynchronous?: boolean debugShowBoundingVolume?: boolean shadows?: ShadowMode }) update(): void getGeometryInstanceAttributes(id: any): any isDestroyed(): boolean destroy(): void } class PrimitiveCollection { readonly length: number show: boolean destroyPrimitives: boolean 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 GroundPrimitive { static isSupported: any readonly allowPicking: boolean readonly asynchronous: boolean readonly compressVertices: boolean readonly geometryInstances: any[] | GeometryInstance readonly interleave: boolean readonly vertexCacheOptimize: boolean readonly releaseGeometryInstances: boolean readonly ready: boolean readonly readyPromise: Promise classificationType: any debugShowBoundingVolume: boolean debugShowShadowVolume: boolean show: boolean constructor(options?: { geometryInstances?: any[] | GeometryInstance appearance?: Appearance | any show?: boolean vertexCacheOptimize?: boolean interleave?: boolean compressVertices?: boolean releaseGeometryInstances?: boolean allowPicking?: boolean asynchronous?: boolean classificationType?: any debugShowBoundingVolume?: boolean debugShowShadowVolume?: boolean }) static initializeTerrainHeights(): Promise destroy(): void getGeometryInstanceAttributes(id: any): any destroy(): boolean update(): 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 MapMode2D { static INFINITE_SCROLL: number static ROTATE: number } class Scene { backgroundColor: Color readonly camera: Camera readonly canvas: HTMLCanvasElement completeMorphOnUserInput: boolean debugCommandFilter: Function readonly debugFrustumStatistics: any debugShowCommands: boolean debugShowFramesPerSecond: boolean debugShowFrustumPlanes: boolean debugShowFrustums: boolean debugShowGlobeDepth: boolean readonly drawingBufferHeight: number readonly drawingBufferWidth: number eyeSeparation: number farToNearRatio: number focalLength: number fog: Fog fxaa: boolean globe: Globe readonly groundPrimitives: PrimitiveCollection readonly id: string readonly imageryLayers: ImageryLayerCollection imagerySplitPosition: number invertClassification: boolean invertClassificationColor: Color 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 preUpdate: Event readonly postUpdate: 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 terrainExaggeration: number terrainProvider: TerrainProvider readonly terrainProviderChanged: Event useDepthPicking: boolean useWebVR: boolean constructor(options?: { canvas: HTMLCanvasElement contextOptions?: any creditContainer?: Element mapProjection?: MapProjection orderIndependentTranslucency?: boolean scene3DOnly?: boolean terrainExaggeration?: number shadows?: boolean mapMode2D?: MapMode2D }) cartesianToCanvasCoordinates(position: Cartesian3, result?: Cartesian2): Cartesian2 completeMorph(): void destroy(): void drillPick(windowPosition: Cartesian2, limit?: number, width?: number, height?: 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 requestRender(): void pickFromRay(ray: any, objectsToExclude: Object[], width: number): any } 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 context?: Scene softShadows?: boolean } class SingleTileImageryProvider 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 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 pickFeatures( x: number, y: number, level: number, longitude: number, latitude: number ): Promise } class SkyAtmosphere { brightnessShift: number hueShift: number saturationShift: number show: boolean readonly 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 pickFeatures( x: number, y: number, level: number, longitude: number, latitude: number ): Promise } class TileDiscardPolicy { isReady(): boolean shouldDiscardImage(image: HTMLImageElement | Promise): Promise } class TileMapServiceImageryProvider extends ImageryProvider { readonly url: string readonly proxy: Proxy readonly tileWidth: number readonly tileHeight: number readonly maximumLevel: number readonly minimumLevel: number readonly tilingScheme: TilingScheme readonly rectangle: Rectangle readonly tileDiscardPolicy: TileDiscardPolicy readonly errorEvent: Event readonly ready: boolean readonly readyPromise: Promise readonly credit: Credit readonly 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 pickFeatures( x: number, y: number, level: number, longitude: number, latitude: number ): Promise } 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 pickFeatures( x: number, y: number, level: number, longitude: number, latitude: number ): Promise } class WebMapTileServiceImageryProvider extends ImageryProvider { clock: Clock readonly credit: Credit dimensions: any readonly errorEvent: Event readonly format: string readonly hasAlphaChannel: boolean readonly maximumLevel: number readonly minimumLevel: number readonly proxy: Proxy readonly ready: boolean readonly readyPromise: Promise readonly rectangle: Rectangle readonly tileDiscardPolicy: TileDiscardPolicy readonly tileHeight: number readonly tileWidth: number readonly tilingScheme: TilingScheme times: TimeIntervalCollection readonly url: string constructor(options: { url: string format?: string layer: string style: string tileMatrixSetID: string tileMatrixLabels?: any[] clock?: Clock times?: TimeIntervalCollection dimensions?: any tileWidth?: number tileHeight?: number tilingScheme?: TilingScheme proxy?: any rectangle?: Rectangle minimumLevel?: number maximumLevel?: number ellipsoid?: Ellipsoid credit?: Credit | string subdomains?: string | string[] }) getTileCredits(x: number, y: number, level: number): Credit[] pickFeatures( x: number, y: number, level: number, longitude: number, latitude: number ): Promise requestImage(x: number, y: number, level: number): Promise } 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> } 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 ProjectionPicker { container: Element viewModel: ProjectionPickerViewModel constructor(container: Element | String, scene: Scene) destroy(): void isDestroyed(): boolean } class ProjectionPickerViewModel { dropDownVisible: boolean isOrthographicProjection: Command scene: Scene sceneMode: SceneMode selectedTooltip: String switchToOrthographic: Command switchToPerspective: Command toggleDropDown: Command tooltipOrthographic: String tooltipPerspective: String constructor(scene: Scene) destroy(): void isDestroyed(): boolean } class Viewer { 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 readonly projectionPicker: ProjectionPicker 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 constructor(container: Element | string, options?: ViewerOptions) destroy(): void extend(mixin: Viewer.ViewerMixin, options: any): void flyTo( target: | Entity | Entity[] | EntityCollection | DataSource | ImageryLayer | Promise, options?: { duration?: number; maximumHeight?: number; offset?: HeadingPitchRange } ): Promise forceResize(): void isDestroyed(): boolean render(): void resize(): void zoomTo( target: | Entity | Entity[] | EntityCollection | DataSource | Promise, offset?: HeadingPitchRange ): Promise } module Viewer { type ViewerMixin = (viewer: Viewer, options: any) => void } class ViewerOptions { animation?: boolean baseLayerPicker?: boolean fullscreenButton?: boolean vrButton?: boolean geocoder?: boolean | GeocoderService[] homeButton?: boolean infoBox?: boolean sceneModePicker?: boolean selectionIndicator?: boolean timeline?: boolean navigationHelpButton?: boolean navigationInstructionsInitiallyVisible?: boolean scene3DOnly?: boolean shouldAnimate?: boolean clockViewModel?: ClockViewModel selectedImageryProviderViewModel?: ProviderViewModel imageryProviderViewModels?: ProviderViewModel[] selectedTerrainProviderViewModel?: ProviderViewModel terrainProviderViewModels?: ProviderViewModel[] imageryProvider?: ImageryProvider | boolean terrainProvider?: TerrainProvider | boolean skyBox?: SkyBox | undefined skyAtmosphere?: SkyAtmosphere | boolean fullscreenElement?: Element | string useDefaultRenderLoop?: boolean targetFrameRate?: number showRenderLoopErrors?: boolean automaticallyTrackDataSourceClocks?: boolean contextOptions?: any sceneMode?: SceneMode mapProjection?: MapProjection globe?: Globe | boolean orderIndependentTranslucency?: boolean creditContainer?: Element | string dataSources?: DataSourceCollection terrainExaggeration?: number shadows?: boolean terrainShadows?: ShadowMode mapMode2D?: MapMode2D projectionPicker?: boolean requestRenderMode?: boolean maximumRenderTimeChange?: number } 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 function loadArrayBuffer(url: string, headers?: any): Promise function loadBlob(url: string, headers?: any): Promise function loadImage(url: string, allowCrossOrigin?: boolean): Promise function loadImageViaBlob(url: string): Promise function loadJson(url: string, headers?: any): Promise function loadText(url: string, headers?: any): Promise function loadWithXhr(options: { url: string responseType?: string method?: string data?: string | FormData headers?: any overrideMimeType?: string }): Promise function loadXML(url: string, headers?: any): Promise 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 function subdivideArray(array: T[], numberOfArrays: number): T[][] function throttleRequestByServer( url: string, requestFunction: throttleRequestByServer.RequestFunction ): Promise module throttleRequestByServer { type RequestFunction = (url: string) => Promise } 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 function createWorldTerrain(options?: { requestVertexNormals?: boolean requestWaterMask?: boolean }): CesiumTerrainProvider module createTaskProcessorWorker { type WorkerFunction = (parameters: any, transferableObjects: any[]) => any type TaskProcessorWorkerFunction = (event: any) => void } class ClockRange { static UNBOUNDED: number static CLAMPED: number static LOOP_STOP: number } class ClockStep { static TICK_DEPENDENT: number static SYSTEM_CLOCK_MULTIPLIER: number static SYSTEM_CLOCK: number } class ComponentDatatype { static BYTE: number static UNSIGNED_BYTE: number static SHORT: number static UNSIGNED_SHORT: number static FLOAT: number static DOUBLE: number static INT: number static UNSIGNED_INT: number } 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 } class CornerType { static ROUNDED: number static MITERED: number static BEVELED: number } module CubicRealPolynomial { function computeDiscriminant(a: number, b: number, c: number, d: number): number function computeRealRoots(a: number, b: number, c: number, d: number): number[] } class ExtrapolationType { static NONE: number static HOLD: number static EXTRAPOLATE: number } module FeatureDetection { function supportsFullscreen(): boolean function supportsTypedArrays(): boolean function supportsWebWorkers(): boolean } class Fullscreen { static element: any static changeEventName: string static errorEventName: string static enabled: boolean static fullscreen: boolean } 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 } class HeightReference { static CLAMP_TO_GROUND: number static NONE: number static RELATIVE_TO_GROUND: number } 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[] } class IndexDatatype { static UNSIGNED_BYTE: number static UNSIGNED_SHORT: number static UNSIGNED_INT: number } 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 } class InterpolationAlgorithm { static type: string } 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[] } class Intersect { static OUTSIDE: number static INTERSECTING: number static INSIDE: number } 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 } class Iso8601 { static MINIMUM_VALUE: JulianDate static MAXIMUM_VALUE: JulianDate static MAXIMUM_INTERVAL: JulianDate } class KeyboardEventModifier { static SHIFT: number static CTRL: number static ALT: number } 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[] } class Math { static EPSILON1: number static EPSILON2: number static EPSILON3: number static EPSILON4: number static EPSILON5: number static EPSILON6: number static EPSILON7: number static EPSILON8: number static EPSILON9: number static EPSILON10: number static EPSILON11: number static EPSILON12: number static EPSILON13: number static EPSILON14: number static EPSILON15: number static EPSILON16: number static EPSILON17: number static EPSILON18: number static EPSILON19: number static EPSILON20: number static GRAVITATIONALPARAMETER: number static SOLAR_RADIUS: number static LUNAR_RADIUS: number static SIXTY_FOUR_KILOBYTES: number static PI: number static ONE_OVER_PI: number static PI_OVER_TWO: number static PI_OVER_THREE: number static PI_OVER_FOUR: number static PI_OVER_SIX: number static THREE_PI_OVER_TWO: number static TWO_PI: number static ONE_OVER_TWO_PI: number static RADIANS_PER_DEGREE: number static DEGREES_PER_RADIAN: number static RADIANS_PER_ARCSECOND: number } module Math { function sign(value: number): number function signNotZero(value: number): number function toSNorm(value: number, rangeMax?: 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 logBase(number: number, base: number): number function nextPowerOfTwo(n: number): number function nextRandomNumber(): number function randomBetween(min: number, max: number): number function setRandomNumberSeed(seed: number): void function clamp(value: number, min: number, max: number): number function clampToLatitudeRange(angle: number): number function setRandomNumberSeed(seed: number): void function acosClamped(value: number): number function asinClamped(value: number): number function chordLength(angle: number, radius: number): number } class Packable { static packedLength: number } module Packable { function pack(value: any, array: number[], startingIndex?: number): number[] function unpack(array: number[], startingIndex?: number, result?: any): any } class PackableForInterpolation { static packedInterpolationLength: number } 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 } class PixelFormat { static DEPTH_COMPONENT: number static DEPTH_STENCIL: number static ALPHA: number static RGB: number static RGBA: number static RGB_DXT1: number static RGB_ETC1: number static RGB_PVRTC_2BPPV1: number static RGB_PVRTC_4BPPV1: number static RGBA_DXT1: number static RGBA_DXT3: number static RGBA_DXT5: number static RGBA_PVRTC_2BPPV1: number static RGBA_PVRTC_4BPPV1: number static LUMINANCE: number static LUMINANCE_ALPHA: number } class PrimitiveType { static LINE_LOOP: number static LINE_STRIP: number static LINES: number static POINTS: number static TRIANGLE_FAN: number static TRIANGLE_STRIP: number static TRIANGLES: number } 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[] } class ReferenceFrame { static FIXED: number static INERTIAL: number } class ScreenSpaceEventType { static MOUSE_DOWN static LEFT_DOWN: number static LEFT_UP: number static LEFT_CLICK: number static LEFT_DOUBLE_CLICK: number static RIGHT_DOWN: number static RIGHT_UP: number static RIGHT_CLICK: number static MIDDLE_DOWN: number static MIDDLE_UP: number static MIDDLE_CLICK: number static MOUSE_MOVE: number static WHEEL: number static PINCH_START: number static PINCH_END: number static PINCH_MOVE: number } 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 } class TimeStandard { static UTC: number static TAI: number } 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, hpr: HeadingPitchRoll, ellipsoid?: Ellipsoid, result?: Quaternion ): Quaternion function headingPitchRollQuaternion1( 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 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[] } class Visibility { static NONE: number static PARTIAL: number static FULL: number } class WindingOrder { static CLOCKWISE: number static COUNTER_CLOCKWISE: number } class StripeOrientation { static HORIZONTAL: number static VERTICAL: number } class BingMapsStyle { static AERIAL: string static AERIAL_WITH_LABELS: string static ROAD: string static ORDNANCE_SURVEY: string static COLLINS_BART: string } class BlendEquation { static ADD: number static MAX: number static MIN: number static SUBTRACT: number static REVERSE_SUBTRACT: number } class BlendFunction { static ZERO: number static ONE: number static SOURCE_COLOR: number static ONE_MINUS_SOURCE_COLOR: number static DESTINATION_COLOR: number static ONE_MINUS_DESTINATION_COLOR: number static SOURCE_ALPHA: number static ONE_MINUS_SOURCE_ALPHA: number static DESTINATION_ALPHA: number static ONE_MINUS_DESTINATION_ALPHA: number static CONSTANT_COLOR: number static ONE_MINUS_CONSTANT_COLOR: number static CONSTANT_ALPHA: number static ONE_MINUS_CONSTANT_ALPHA: number static SOURCE_ALPHA_SATURATE: number } class BlendingState { static DISABLED: any static ALPHA_BLEND: any static PRE_MULTIPLIED_ALPHA_BLEND: any static ADDITIVE_BLEND: any } class CameraEventType { static LEFT_DRAG: number static RIGHT_DRAG: number static MIDDLE_DRAG: number static WHEEL: number static PINCH: number } class CullFace { static FRONT: number static BACK: number static FRONT_AND_BACK: number } class DepthFunction { static NEVER: number static LESS: number static EQUAL: number static LESS_OR_EQUAL: number static GREATER: number static NOT_EQUAL: number static GREATER_OR_EQUAL: number static ALWAYS: number } class HorizontalOrigin { static CENTER: number static LEFT: number static RIGHT: number } class LabelStyle { static FILL: number static OUTLINE: number static FILL_AND_OUTLINE: number } class ModelAnimationLoop { static NONE: number static REPEAT: number static MIRRORED_REPEAT: number } class SceneMode { static MORPHING: number static COLUMBUS_VIEW: number static SCENE2D: number static SCENE3D: number } 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 } class StencilFunction { static NEVER: number static LESS: number static EQUAL: number static LESS_OR_EQUAL: number static GREATER: number static NOT_EQUAL: number static GREATER_OR_EQUAL: number static ALWAYS: number } class StencilOperation { static ZERO: number static KEEP: number static REPLACE: number static INCREMENT: number static DECREMENT: number static INVERT: number static INCREMENT_WRAP: number static DECREMENT_WRAP: number } class VerticalOrigin { static CENTER: number static BOTTOM: number static TOP: number } 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 extends ImageryProvider { readonly url: string readonly pickFeaturesUrl: string readonly urlSchemeZeroPadding: {} readonly proxy: Proxy readonly credit: Credit readonly minimumLevel: number readonly maximumLevel: number readonly rectangle: Rectangle readonly tilingScheme: TilingScheme readonly tileWidth: number readonly tileHeight: number readonly hasAlphaChannel: boolean enablePickFeatures: boolean readonly errorEvent: Event readonly ready: boolean readonly readyPromise: Promise readonly tileDiscardPolicy: TileDiscardPolicy constructor(options: { url: string pickFeaturesUrl?: string urlSchemeZeroPadding?: {} subdomains?: string | Array proxy?: {} credit?: Credit minimumLevel?: number maximumLevel?: number rectangle?: Rectangle tilingScheme?: TilingScheme ellipsoid?: Ellipsoid tileWidth?: number tileHeight?: number hasAlphaChannel?: boolean getFeatureInfoFormats?: Array enablePickFeatures?: boolean customTags?: any }) getTileCredits(x: number, y: number, level: number): Array pickFeatures( x: number, y: number, level: number, longitude: number, latitude: number ): Promise> | undefined reinitialize(options: Promise | Object): void } function defined(value: Object): boolean class ParticleSystem { options: any show: boolean constructor( options: any ) } class ParticleBurst { item: any constructor( item: any ) } class PostProcessStage { constructor(options: { fragmentShader: any uniforms: any }) } function createGuid(): string function defaultValue(a: Object, b: Object): Object class CircleEmitter { constructor(radius: number) } function buildModuleUrl(path: string): string } declare module 'cesium' { export = Cesium }