ts/public/GV/cesium.d.ts

/**
 * 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<TerrainData>

    getLevelMaximumGeometricError(level: number): number

    getTileDataAvailable(x: number, y: number, level: number): boolean
  }

  class AssociativeArray {
    length: number
    values: any[]

    contains(key: string | number): boolean

    set(key: string | number, value: any): void

    get(key: string | number): any

    remove(key: string | number): boolean

    removeAll(): void
  }

  class AxisAlignedBoundingBox {
    minimum: Cartesian3
    maximum: Cartesian3
    center: Cartesian3

    constructor(minimum?: Cartesian3, maximum?: Cartesian3, center?: Cartesian3)

    clone(result?: AxisAlignedBoundingBox): AxisAlignedBoundingBox

    intersect(plane: Cartesian4): Intersect

    equals(right?: AxisAlignedBoundingBox): boolean

    static fromPoints(
      positions: Cartesian3[],
      result?: AxisAlignedBoundingBox
    ): AxisAlignedBoundingBox

    static clone(
      box: AxisAlignedBoundingBox,
      result?: AxisAlignedBoundingBox
    ): AxisAlignedBoundingBox

    static equals(left?: AxisAlignedBoundingBox, right?: AxisAlignedBoundingBox): boolean

    static intersect(box: AxisAlignedBoundingBox, plane: Cartesian4): Intersect
  }

  class BoundingRectangle {
    x: number
    y: number
    width: number
    height: number

    constructor(x?: number, y?: number, width?: number, height?: number)

    clone(result?: BoundingRectangle): BoundingRectangle

    intersect(right: BoundingRectangle): Intersect

    equals(right?: BoundingRectangle): boolean

    static fromPoints(positions: Cartesian2[], result?: BoundingRectangle): BoundingRectangle

    static fromRectangle(
      rectangle: Rectangle,
      projection?: any,
      result?: BoundingRectangle
    ): BoundingRectangle

    static clone(rectangle: BoundingRectangle, result?: BoundingRectangle): BoundingRectangle

    static union(
      left: BoundingRectangle,
      right: BoundingRectangle,
      result?: BoundingRectangle
    ): BoundingRectangle

    static expand(
      rectangle: BoundingRectangle,
      point: Cartesian2,
      result?: BoundingRectangle
    ): BoundingRectangle

    static intersect(left: BoundingRectangle, right: BoundingRectangle): Intersect

    static equals(left?: BoundingRectangle, right?: BoundingRectangle): boolean
  }

  class BoundingSphere {
    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<Array<GeocoderResult>>
  }

  class CatmullRomSpline {
    times: number[]
    points: Cartesian3[]
    firstTangent: Cartesian3
    lastTangent: Cartesian3

    constructor(options: {
      times: number[]
      points: Cartesian3[]
      firstTangent?: Cartesian3
      lastTangent?: Cartesian3
    })

    findTimeInterval(time: number): number

    evaluate(time: number, result?: Cartesian3): Cartesian3
  }

  class CesiumTerrainProvider 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<TerrainData>

    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<boolean>

    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<boolean>
    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<TerrainData>
  }

  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<TerrainMesh>

    interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number

    upsample(
      tilingScheme: TilingScheme,
      thisX: number,
      thisY: number,
      thisLevel: number,
      descendantX: number,
      descendantY: number,
      descendantLevel: number
    ): Promise<HeightmapTerrainData>

    isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean

    wasCreatedByUpsampling(): boolean
  }

  class HermiteSpline {
    times: number[]
    points: Cartesian3[]
    inTangents: Cartesian3[]
    outTangents: Cartesian3[]

    constructor(options: {
      times: number[]
      points: Cartesian3[]
      inTangents: Cartesian3[]
      outTangents: Cartesian3[]
    })

    findTimeInterval(time: number): number

    evaluate(time: number, result?: Cartesian3): Cartesian3

    static createC1(): HermiteSpline

    static createNaturalCubic(): HermiteSpline | LinearSpline

    static createClampedCubic(): HermiteSpline | LinearSpline
  }

  class Interval {
    start: number
    stop: number

    constructor(start?: number, stop?: number)
  }

  class JulianDate {
    dayNumber: number
    secondsOfDay: number
    static leapSeconds: LeapSecond[]

    constructor(julianDayNumber?: number, secondsOfDay?: number, timeStandard?: TimeStandard)

    clone(result?: JulianDate): JulianDate

    equals(right?: JulianDate): boolean

    equalsEpsilon(right: JulianDate, epsilon: number): boolean

    toString(): string

    static fromDate(date: Date, result?: JulianDate): JulianDate

    static fromIso8601(iso8601String: string, result?: JulianDate): JulianDate

    static now(result?: JulianDate): JulianDate

    static toGregorianDate(julianDate: JulianDate, result?: GregorianDate): GregorianDate

    static toDate(julianDate: JulianDate): Date

    static toIso8601(julianDate: JulianDate, precision?: number): string

    static clone(julianDate: JulianDate, result?: JulianDate): JulianDate

    static compare(left: JulianDate, right: JulianDate): number

    static equals(left?: JulianDate, right?: JulianDate): boolean

    static equalsEpsilon(left: JulianDate, right: JulianDate, epsilon: number): boolean

    static totalDays(julianDate: JulianDate): number

    static secondsDifference(left: JulianDate, right: JulianDate): number

    static daysDifference(left: JulianDate, right: JulianDate): number

    static computeTaiMinusUtc(julianDate: JulianDate): number

    static addSeconds(julianDate: JulianDate, seconds: number, result: JulianDate): JulianDate

    static addMinutes(julianDate: JulianDate, minutes: number, result: JulianDate): JulianDate

    static addHours(julianDate: JulianDate, hours: number, result: JulianDate): JulianDate

    static addDays(julianDate: JulianDate, days: number, result: JulianDate): JulianDate

    static lessThan(left: JulianDate, right: JulianDate): boolean

    static lessThanOrEquals(left: JulianDate, right: JulianDate): boolean

    static greaterThan(left: JulianDate, right: JulianDate): boolean

    static greaterThanOrEquals(left: JulianDate, right: JulianDate): boolean
  }

  class LeapSecond {
    julianDate: JulianDate
    offset: number

    constructor(date?: JulianDate, offset?: number)
  }

  class LinearSpline {
    times: number[]
    points: Cartesian3[]

    constructor(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<HTMLCanvasElement>

    fromMakiIconId(
      id: string,
      color: Color,
      size: number
    ): HTMLCanvasElement | Promise<HTMLCanvasElement>

    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<TerrainMesh>

    upsample(
      tilingScheme: TilingScheme,
      thisX: number,
      thisY: number,
      thisLevel: number,
      descendantX: number,
      descendantY: number,
      descendantLevel: number
    ): Promise<QuantizedMeshTerrainData>

    interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number

    isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean

    wasCreatedByUpsampling(): boolean
  }

  class Quaternion {
    x: number
    y: number
    z: number
    w: number
    static packedLength: number
    static packedInterpolationLength: number
    static ZERO: Quaternion
    static IDENTITY: Quaternion

    constructor(x?: number, y?: number, z?: number, w?: number)

    clone(result?: Quaternion): Quaternion

    equals(right?: Quaternion): boolean

    equalsEpsilon(right: Quaternion, epsilon: number): boolean

    toString(): string

    static fromAxisAngle(axis: Cartesian3, angle: number, result?: Quaternion): Quaternion

    static fromRotationMatrix(matrix: Matrix3, result?: Quaternion): Quaternion

    static fromHeadingPitchRoll(
      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<boolean>

  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<any>

    isDestroyed(): boolean

    destroy(): void
  }

  class TerrainData {
    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement

    interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number

    isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean

    createMesh(
      tilingScheme: TilingScheme,
      x: number,
      y: number,
      level: number
    ): Promise<TerrainMesh>

    upsample(
      tilingScheme: TilingScheme,
      thisX: number,
      thisY: number,
      thisLevel: number,
      descendantX: number,
      descendantY: number,
      descendantLevel: number
    ): Promise<TerrainData>

    wasCreatedByUpsampling(): boolean
  }

  class TerrainMesh {
    center: Cartesian3
    vertices: Float32Array
    stride: number
    indices: Uint16Array | Uint32Array
    minimumHeight: number
    maximumHeight: number
    boundingSphere3D: BoundingSphere
    occludeePointInScaledSpace: Cartesian3

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

  class TerrainProvider {
    static heightmapTerrainQuality: number
    credit: Credit
    errorEvent: Event
    hasVertexNormals: boolean
    hasWaterMask: boolean
    ready: boolean
    readonly readyPromise: Promise<boolean>
    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<TerrainData>
  }

  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<boolean>
    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<TerrainData>
  }

  class GoogleEarthEnterpriseMetadata {
    constructor(resourceOrUrl: Resource | string)
  }

  class VRTheWorldTerrainProvider extends TerrainProvider {
    credit: Credit
    errorEvent: Event
    hasVertexNormals: boolean
    hasWaterMask: boolean
    ready: boolean
    readonly readyPromise: Promise<boolean>
    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<TerrainData>
  }

  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<CzmlDataSource>

    load(data: string | any, options?: { sourceUri?: string }): Promise<CzmlDataSource>
    static load(data: string | any, options?: { sourceUri?: string }): Promise<CzmlDataSource>

    static processPacketData(
      type: Function,
      object: any,
      propertyName: string,
      packetData: any,
      interval: TimeInterval,
      sourceUri: string,
      entityCollection: EntityCollection
    ): void

    static processPositionPacketData(
      object: any,
      propertyName: string,
      packetData: any,
      interval: TimeInterval,
      sourceUri: string,
      entityCollection: EntityCollection
    ): void

    static processMaterialPacketData(
      object: any,
      propertyName: string,
      packetData: any,
      interval: TimeInterval,
      sourceUri: string,
      entityCollection: EntityCollection
    ): void
  }

  class DataSource {
    changedEvent: Event
    clock: DataSourceClock
    clustering: EntityCluster
    entities: EntityCollection
    errorEvent: Event
    isLoading: boolean
    loadingEvent: Event
    name: string
    show: boolean

    update(time: JulianDate): boolean
  }

  class DataSourceClock {
    definitionChanged: Event
    startTime: JulianDate
    stopTime: JulianDate
    currentTime: JulianDate
    clockRange: ClockRange
    clockStep: ClockStep
    multiplier: number

    clone(result?: DataSourceClock): DataSourceClock

    equals(other: DataSourceClock): boolean

    merge(source: DataSourceClock): void

    getValue(): Clock
  }

  class DataSourceCollection {
    length: number
    dataSourceAdded: Event
    dataSourceRemoved: Event

    add(dataSource: DataSource | Promise<DataSource>): Promise<DataSource>

    remove(dataSource: DataSource, destroy?: boolean): boolean

    removeAll(destroy?: boolean): void

    contains(dataSource: DataSource): boolean

    indexOf(dataSource: DataSource): number

    get(index: number): DataSource

    isDestroyed(): boolean

    destroy(): void
  }

  class DataSourceDisplay {
    scene: Scene
    dataSources: DataSourceCollection
    defaultDataSource: CustomDataSource
    static defaultVisualizersCallback: DataSourceDisplay.VisualizersCallback

    constructor(options: {
      scene: Scene
      dataSourceCollection: DataSourceCollection
      visualizersCallback?: DataSourceDisplay.VisualizersCallback
    })

    isDestroyed(): boolean

    destroy(): void

    update(time: JulianDate): boolean
  }

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

  class DynamicGeometryUpdater {
    update(time: JulianDate): void

    isDestroyed(): boolean

    destroy(): void
  }

  class EllipseGeometryUpdater {
    entity: Entity
    fillEnabled: boolean
    hasConstantFill: boolean
    fillMaterialProperty: MaterialProperty
    outlineEnabled: boolean
    hasConstantOutline: boolean
    outlineColorProperty: 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<GeoJsonDataSource>
    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<GeoJsonDataSource>
  }

  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<KmlDataSource>
    static load(
      data: string | Document | Blob,
      options?: KmlConstructorOptions & KmlLoadOptions
    ): Promise<KmlDataSource>
  }

  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<HTMLImageElement | HTMLCanvasElement>

    pickFeatures(
      x: number,
      y: number,
      level: number,
      longitude: number,
      latitude: number
    ): Promise<ImageryLayerFeatureInfo[]>
  }

  class Billboard {
    show: boolean
    position: Cartesian3
    pixelOffset: Cartesian2
    scaleByDistance: NearFarScalar
    translucencyByDistance: NearFarScalar
    pixelOffsetScaleByDistance: NearFarScalar
    eyeOffset: Cartesian3
    horizontalOrigin: HorizontalOrigin
    verticalOrigin: VerticalOrigin
    scale: number
    color: Color
    rotation: number
    alignedAxis: Cartesian3
    width: number
    height: number
    id: any
    image: string
    ready: boolean

    setImage(
      id: string,
      image: HTMLImageElement | HTMLCanvasElement | string | Billboard.CreateImageCallback
    ): void

    setImageSubRegion(id: string, subRegion: BoundingRectangle): void

    computeScreenSpacePosition(scene: Scene, result?: Cartesian2): Cartesian2

    equals(other: Billboard): boolean
  }

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

  class BillboardCollection {
    modelMatrix: Matrix4
    debugShowBoundingVolume: boolean
    length: number

    constructor(options?: { modelMatrix?: Matrix4; debugShowBoundingVolume?: boolean })

    add(billboard?: any): Billboard

    remove(billboard: Billboard): boolean

    removeAll(): void

    contains(billboard?: Billboard): boolean

    get(index: number): Billboard

    update(): void

    isDestroyed(): boolean

    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<HTMLImageElement | HTMLCanvasElement>

    pickFeatures(
      x: number,
      y: number,
      level: number,
      longitude: number,
      latitude: number
    ): Promise<ImageryLayerFeatureInfo[]>

    static tileXYToQuadKey(x: number, y: number, level: number): string

    static quadKeyToTileXY(quadkey: string): { x: number; y: number; level: number }
  }

  class 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<boolean>
    readonly rectangle: Rectangle
    readonly requestType: string
    readonly tileDiscardPolicy: TileDiscardPolicy
    readonly tileHeight: number
    readonly tileWidth: number
    readonly tilingScheme: TilingScheme
    readonly url: string
    readonly version: number

    getTileCredits(x: number, y: number, level: number): Credit[]

    pickFeatures(
      x: number,
      y: number,
      level: number,
      longitude: number,
      latitude: number
    ): Promise<ImageryLayerFeatureInfo[]>

    requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>
  }

  class GoogleEarthEnterpriseImageryProvider extends ImageryProvider {
    defaultGamma: number
    url: string
    path: string
    proxy: Proxy
    channel: number
    tileWidth: number
    tileHeight: number
    maximumLevel: number
    minimumLevel: number
    tilingScheme: TilingScheme
    version: number
    requestType: string
    rectangle: Rectangle
    tileDiscardPolicy: TileDiscardPolicy
    errorEvent: Event
    ready: boolean
    credit: Credit
    hasAlphaChannel: boolean

    constructor(options: {
      url: string
      proxy?: Proxy
      ellipsoid?: Ellipsoid
      tileDiscardPolicy?: TileDiscardPolicy
      credit?: Credit | string
    })

    getTileCredits(x: number, y: number, level: number): Credit[]

    requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>

    pickFeatures(
      x: number,
      y: number,
      level: number,
      longitude: number,
      latitude: number
    ): Promise<ImageryLayerFeatureInfo[]>
  }

  class GridImageryProvider extends ImageryProvider {
    proxy: Proxy
    tileWidth: number
    tileHeight: number
    maximumLevel: number
    minimumLevel: number
    tilingScheme: TilingScheme
    rectangle: Rectangle
    tileDiscardPolicy: TileDiscardPolicy
    errorEvent: Event
    ready: boolean
    credit: Credit
    hasAlphaChannel: boolean

    constructor(options?: {
      tilingScheme?: TilingScheme
      ellipsoid?: Ellipsoid
      cells?: number
      color?: Color
      glowColor?: Color
      glowWidth?: number
      tileWidth?: number
      tileHeight?: number
      canvasSize?: number
      backgroundColor?: Color
    })

    getTileCredits(x: number, y: number, level: number): Credit[]

    requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>

    pickFeatures(
      x: number,
      y: number,
      level: number,
      longitude: number,
      latitude: number
    ): Promise<ImageryLayerFeatureInfo[]>
  }

  class HeadingPitchRange {
    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<Rectangle>

    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<ImageryLayerFeatureInfo[]>

    isDestroyed(): boolean

    destroy(): void
  }

  class ImageryLayerFeatureInfo {
    name: string
    description: string
    position: Cartographic
    data: any

    configureNameFromProperties(properties: any): void

    configureDescriptionFromProperties(properties: any): void
  }

  class ImageryProvider {
    defaultAlpha: number
    defaultBrightness: number
    defaultContrast: number
    defaultHue: number
    defaultSaturation: number
    defaultGamma: number
    ready: boolean
    rectangle: Rectangle
    tileWidth: number
    tileHeight: number
    maximumLevel: number
    minimumLevel: number
    tilingScheme: TilingScheme
    tileDiscardPolicy: TileDiscardPolicy
    errorEvent: Event
    credit: Credit
    proxy: Proxy
    hasAlphaChannel: boolean

    getTileCredits(x: number, y: number, level: number): Credit[]

    requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>

    pickFeatures(
      x: number,
      y: number,
      level: number,
      longitude: number,
      latitude: number
    ): Promise<ImageryLayerFeatureInfo[]>

    static loadImage(url: string): Promise<HTMLImageElement | HTMLCanvasElement>
  }

  class Label {
    show: boolean
    position: Cartesian3
    text: string
    font: string
    fillColor: Color
    outlineColor: Color
    outlineWidth: number
    style: LabelStyle
    pixelOffset: Cartesian2
    translucencyByDistance: NearFarScalar
    pixelOffsetScaleByDistance: NearFarScalar
    eyeOffset: Cartesian3
    horizontalOrigin: HorizontalOrigin
    verticalOrigin: VerticalOrigin
    scale: number
    id: any

    computeScreenSpacePosition(scene: Scene, result?: Cartesian2): Cartesian2

    equals(other: Label): boolean

    isDestroyed(): boolean
  }

  class LabelCollection {
    modelMatrix: Matrix4
    debugShowBoundingVolume: boolean
    length: number

    constructor(options?: { modelMatrix?: Matrix4; debugShowBoundingVolume?: boolean })

    add(options?: any): Label

    remove(label: Label): boolean

    removeAll(): void

    contains(label: Label): boolean

    get(index: number): Label

    isDestroyed(): boolean

    destroy(): void
  }

  class Material {
    type: string
    shaderSource: string
    materials: any
    uniforms: any
    translucent: boolean | Function
    static DefaultImageId: string
    static DefaultCubeMapId: string
    static ColorType: string
    static ImageType: string
    static DiffuseMapType: string
    static AlphaMapType: string
    static SpecularMapType: string
    static EmissionMapType: string
    static BumpMapType: string
    static NormalMapType: string
    static GridType: string
    static StripeType: string
    static CheckerboardType: string
    static DotType: string
    static WaterType: string
    static RimLightingType: string
    static FadeType: string
    static PolylineArrowType: string
    static PolylineGlowType: string
    static PolylineOutlineType: string

    constructor(options?: { strict?: boolean; translucent?: boolean | Function; fabric: any })

    isTranslucent(): boolean

    isDestroyed(): boolean

    destroy(): void

    static fromType(type: string, uniforms?: any): Material
  }

  class MaterialAppearance {
    material: Material
    translucent: boolean
    vertexShaderSource: string
    fragmentShaderSource: string
    renderState: any
    closed: boolean
    materialSupport: MaterialAppearance.MaterialSupport
    vertexFormat: VertexFormat
    flat: boolean
    faceForward: boolean

    constructor(options?: {
      flat?: boolean
      faceForward?: boolean
      translucent?: boolean
      closed?: boolean
      materialSupport?: MaterialAppearance.MaterialSupport
      material?: Material
      vertexShaderSource?: string
      fragmentShaderSource?: string
      renderState?: RenderState
    })

    getFragmentShaderSource(): string

    isTranslucent(): boolean

    getRenderState(): any
  }

  module MaterialAppearance {
    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<Model>
    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<HTMLImageElement>): Promise<boolean>
  }

  class OpenStreetMapImageryProvider {
    url: string
    proxy: Proxy
    tileWidth: number
    tileHeight: number
    maximumLevel: number
    minimumLevel: number
    tilingScheme: TilingScheme
    rectangle: Rectangle
    tileDiscardPolicy: TileDiscardPolicy
    errorEvent: Event
    ready: boolean
    credit: Credit
    hasAlphaChannel: boolean

    constructor(options?: {
      url?: string
      fileExtension?: string
      proxy?: any
      rectangle?: Rectangle
      minimumLevel?: number
      maximumLevel?: number
      ellipsoid?: Ellipsoid
      credit?: Credit | string
    })

    getTileCredits(x: number, y: number, level: number): Credit[]

    requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>

    pickFeatures(
      x: number,
      y: number,
      level: number,
      longitude: number,
      latitude: number
    ): Promise<ImageryLayerFeatureInfo[]>
  }

  class OrthographicFrustum {
    left: number
    right: number
    top: number
    bottom: number
    near: number
    far: number
    projectionMatrix: Matrix4

    computeCullingVolume(position: Cartesian3, direction: Cartesian3, up: Cartesian3): CullingVolume

    getPixelSize(
      drawingBufferDimensions: Cartesian2,
      distance?: number,
      result?: Cartesian2
    ): Cartesian2

    clone(result?: OrthographicFrustum): OrthographicFrustum

    equals(other?: OrthographicFrustum): boolean
  }

  class PerInstanceColorAppearance {
    material: Material
    translucent: boolean
    vertexShaderSource: string
    fragmentShaderSource: string
    renderState: any
    closed: boolean
    vertexFormat: VertexFormat
    flat: boolean
    faceForward: boolean
    static VERTEX_FORMAT: VertexFormat
    static FLAT_VERTEX_FORMAT: VertexFormat

    constructor(options?: {
      flat?: boolean
      faceForward?: boolean
      translucent?: boolean
      closed?: boolean
      vertexShaderSource?: string
      fragmentShaderSource?: string
      renderState?: RenderState
    })

    getFragmentShaderSource(): void

    isTranslucent(): boolean

    getRenderState(): any
  }

  class PerspectiveFrustum {
    fov: number
    aspectRatio: number
    near: number
    far: number
    projectionMatrix: Matrix4
    infiniteProjectionMatrix: Matrix4
    fovy: number

    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<Primitive>
    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<Primitive>
    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<any>

    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<HTMLImageElement | HTMLCanvasElement>

    pickFeatures(
      x: number,
      y: number,
      level: number,
      longitude: number,
      latitude: number
    ): Promise<ImageryLayerFeatureInfo[]>
  }

  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<HTMLImageElement | HTMLCanvasElement>

    pickFeatures(
      x: number,
      y: number,
      level: number,
      longitude: number,
      latitude: number
    ): Promise<ImageryLayerFeatureInfo[]>
  }

  class TileDiscardPolicy {
    isReady(): boolean

    shouldDiscardImage(image: HTMLImageElement | Promise<HTMLImageElement>): Promise<boolean>
  }

  class TileMapServiceImageryProvider extends ImageryProvider {
    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<boolean>
    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<HTMLImageElement | HTMLCanvasElement>

    pickFeatures(
      x: number,
      y: number,
      level: number,
      longitude: number,
      latitude: number
    ): Promise<ImageryLayerFeatureInfo[]>
  }

  class ViewportQuad {
    show: boolean
    rectangle: BoundingRectangle
    material: Material

    constructor(rectangle?: BoundingRectangle, material?: Material)

    update(): void

    isDestroyed(): boolean

    destroy(): void
  }

  class WebMapServiceImageryProvider extends ImageryProvider {
    url: string
    proxy: Proxy
    layers: string
    tileWidth: number
    tileHeight: number
    maximumLevel: number
    minimumLevel: number
    tilingScheme: TilingScheme
    rectangle: Rectangle
    tileDiscardPolicy: TileDiscardPolicy
    errorEvent: Event
    ready: boolean
    credit: Credit
    hasAlphaChannel: boolean
    static DefaultParameters: Object
    static GetFeatureInfoDefaultParameters: Object

    constructor(options: {
      url: string
      layers: string
      parameters?: any
      getFeatureInfoParameters?: any
      enablePickFeatures?: boolean
      getFeatureInfoFormats?: GetFeatureInfoFormat[]
      rectangle?: Rectangle
      tilingScheme?: TilingScheme
      ellipsoid?: Ellipsoid
      tileWidth?: number
      tileHeight?: number
      minimumLevel?: number
      maximumLevel?: number
      credit?: Credit | string
      proxy?: any
    })

    getTileCredits(x: number, y: number, level: number): Credit[]

    requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>

    pickFeatures(
      x: number,
      y: number,
      level: number,
      longitude: number,
      latitude: number
    ): Promise<ImageryLayerFeatureInfo[]>
  }

  class WebMapTileServiceImageryProvider extends ImageryProvider {
    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<boolean>
    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<ImageryLayerFeatureInfo[]>

    requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>
  }

  class Animation {
    container: Element
    viewModel: AnimationViewModel

    constructor(container: Element | string, viewModel: AnimationViewModel)

    isDestroyed(): boolean

    destroy(): void

    resize(): void

    applyThemeChanges(): void
  }

  class AnimationViewModel {
    shuttleRingDragging: boolean
    snapToTicks: boolean
    timeLabel: string
    dateLabel: string
    multiplierLabel: string
    shuttleRingAngle: number
    slower: Command
    faster: Command
    clockViewModel: ClockViewModel
    pauseViewModel: ToggleButtonViewModel
    playReverseViewModel: ToggleButtonViewModel
    playForwardViewModel: ToggleButtonViewModel
    playRealtimeViewModel: ToggleButtonViewModel
    dateFormatter: AnimationViewModel.DateFormatter
    timeFormatter: AnimationViewModel.TimeFormatter
    static defaultDateFormatter: AnimationViewModel.DateFormatter
    static defaultTicks: number[]
    static defaultTimeFormatter: AnimationViewModel.TimeFormatter

    constructor(clockViewModel: ClockViewModel)

    getShuttleRingTicks(): number[]

    setShuttleRingTicks(positiveTicks: number[]): void
  }

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

  class BaseLayerPicker {
    container: Element
    viewModel: BaseLayerPickerViewModel

    constructor(
      container: Element,
      options: {
        globe: Globe
        imageryProviderViewModels?: ProviderViewModel[]
        selectedImageryProviderViewModel?: ProviderViewModel
        terrainProviderViewModels?: ProviderViewModel[]
        selectedTerrainProviderViewModel?: ProviderViewModel
      }
    )

    isDestroyed(): boolean

    destroy(): void
  }

  class BaseLayerPickerViewModel {
    imageryProviderViewModels: ProviderViewModel[]
    terrainProviderViewModels: ProviderViewModel[]
    dropDownVisible: boolean
    buttonTooltip: string
    buttonImageUrl: string
    selectedImagery: ProviderViewModel
    selectedTerrain: ProviderViewModel
    toggleDropDown: Command
    globe: Globe

    constructor(options: {
      globe: Globe
      imageryProviderViewModels?: ProviderViewModel[]
      selectedImageryProviderViewModel?: ProviderViewModel
      terrainProviderViewModels?: ProviderViewModel[]
      selectedTerrainProviderViewModel?: ProviderViewModel
    })
  }

  class ProviderViewModel {
    name: string
    tooltip: string
    iconUrl: string
    creationCommand: Command

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

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

  class CesiumInspector {
    container: Element
    viewModel: CesiumInspectorViewModel

    constructor(container: Element | string, scene: Scene)

    isDestroyed(): boolean

    destroy(): void
  }

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

    constructor(scene: Scene)

    isDestroyed(): boolean

    destroy(): void
  }

  class CesiumWidget {
    container: Element
    canvas: HTMLCanvasElement
    creditContainer: Element
    scene: Scene
    imageryLayers: ImageryLayerCollection
    terrainProvider: TerrainProvider
    camera: Camera
    clock: Clock
    screenSpaceEventHandler: ScreenSpaceEventHandler
    targetFrameRate: number
    useDefaultRenderLoop: boolean
    resolutionScale: number

    constructor(container: Element | string, options?: CesiumWidgetOptions)

    showErrorPanel(title: string, message: string, error?: string): void

    isDestroyed(): boolean

    destroy(): void

    resize(): void

    render(): void
  }

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

  class ClockViewModel {
    systemTime: JulianDate
    startTime: JulianDate
    stopTime: JulianDate
    currentTime: JulianDate
    multiplier: number
    clockStep: ClockStep
    clockRange: ClockRange
    canAnimate: boolean
    shouldAnimate: boolean
    clock: Clock

    constructor(clock?: Clock)

    synchronize(): void

    isDestroyed(): boolean

    destroy(): void
  }

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

  class FullscreenButton {
    container: Element
    viewModel: FullscreenButtonViewModel

    constructor(container: Element | string, fullscreenElement?: Element | string)

    isDestroyed(): boolean

    destroy(): void
  }

  class FullscreenButtonViewModel {
    isFullscreen: boolean
    isFullscreenEnabled: boolean
    tooltip: string
    fullscreenElement: Element
    command: Command

    constructor(fullscreenElement?: Element | string)

    isDestroyed(): boolean

    destroy(): void
  }

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

  class Geocoder {
    container: Element
    viewModel: GeocoderViewModel

    constructor(options: GeocoderOptions)

    isDestroyed(): boolean

    destroy(): void
  }

  class GeocoderViewModel {
    isSearchInProgress: boolean
    searchText: string
    flightDuration: number
    url: string
    key: string
    complete: Event
    scene: Scene
    search: Command

    constructor(options: { scene: Scene; url?: string; key?: string; flightDuration?: number })
  }

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

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

  class HomeButton {
    container: Element
    viewModel: HomeButtonViewModel

    constructor(container: Element | string, scene: Scene, duration?: number)

    isDestroyed(): boolean

    destroy(): void
  }

  class HomeButtonViewModel {
    tooltip: string
    scene: Scene
    command: Command
    duration: number

    constructor(scene: Scene, duration?: number)
  }

  class InfoBox {
    container: Element
    viewModel: InfoBoxViewModel
    frame: HTMLIFrameElement

    constructor(container: Element | string)

    isDestroyed(): boolean

    destroy(): void
  }

  class InfoBoxViewModel {
    maxHeight: number
    enableCamera: boolean
    isCameraTracking: boolean
    showInfo: boolean
    titleText: string
    description: string
    cameraIconPath: string
    cameraClicked: Event
    closeClicked: Event

    maxHeightOffset(offset: number): string
  }

  class NavigationHelpButton {
    container: Element
    viewModel: NavigationHelpButtonViewModel

    constructor(options: { container: Element | string; instructionsInitiallyVisible?: boolean })

    isDestroyed(): boolean

    destroy(): void
  }

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

  class PerformanceWatchdog {
    container: Element
    viewModel: PerformanceWatchdogViewModel

    constructor(options?: {
      container: Element | string
      scene: Scene
      lowFrameRateMessage?: string
    })

    isDestroyed(): boolean

    destroy(): void
  }

  class PerformanceWatchdogViewModel {
    lowFrameRateMessage: string
    lowFrameRateMessageDismissed: boolean
    showingLowFrameRateMessage: boolean
    scene: Scene
    dismissMessage: Command

    constructor(options?: { scene: Scene; lowFrameRateMessage?: string })
  }

  class SceneModePicker {
    container: Element
    viewModel: SceneModePickerViewModel

    constructor(container: Element | string, scene: Scene, duration?: number)

    isDestroyed(): boolean

    destroy(): void
  }

  class SceneModePickerViewModel {
    sceneMode: SceneMode
    dropDownVisible: boolean
    tooltip2D: string
    tooltip3D: string
    tooltipColumbusView: string
    selectedTooltip: string
    scene: Scene
    duration: number
    toggleDropDown: Command
    morphTo2D: Command
    morphTo3D: Command
    morphToColumbusView: Command

    constructor(scene: Scene, duration?: number)

    isDestroyed(): boolean

    destroy(): void
  }

  class SelectionIndicator {
    container: Element
    viewModel: SelectionIndicatorViewModel

    constructor(container: Element | string, scene: Scene)

    isDestroyed(): boolean

    destroy(): void
  }

  class SelectionIndicatorViewModel {
    position: Cartesian3
    showSelection: boolean
    isVisible: boolean
    computeScreenSpacePosition: SelectionIndicatorViewModel.ComputeScreenSpacePosition
    container: Element
    selectionIndicatorElement: Element
    scene: Scene

    constructor(scene: Scene, selectionIndicatorElement: Element, container: Element)

    update(): void

    animateAppear(): void

    animateDepart(): void
  }

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

  class Timeline {
    container: Element

    constructor(container: Element, clock: Clock)

    isDestroyed(): boolean

    destroy(): void

    zoomTo(startTime: JulianDate, stopTime: JulianDate): void

    resize(): void
  }

  class ToggleButtonViewModel {
    toggled: boolean
    tooltip: string
    command: Command

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

  class 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<Entity | Entity[] | EntityCollection | DataSource | ImageryLayer>,
      options?: { duration?: number; maximumHeight?: number; offset?: HeadingPitchRange }
    ): Promise<boolean>

    forceResize(): void

    isDestroyed(): boolean

    render(): void

    resize(): void

    zoomTo(
      target:
        | Entity
        | Entity[]
        | EntityCollection
        | DataSource
        | Promise<Entity | Entity[] | EntityCollection | DataSource>,
      offset?: HeadingPitchRange
    ): Promise<boolean>
  }

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

  class ViewerOptions {
    animation?: boolean
    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<any>

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

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

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

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

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

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

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

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

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

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

  function objectToQuery(obj: any): string

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

  function queryToObject(queryString: string): any

  function requestAnimationFrame(callback: requestAnimationFrame.Callback): number

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

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

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

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

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

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

  function viewerCesiumInspectorMixin(viewer: Viewer): void

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

  function viewerPerformanceWatchdogMixin(viewer: Viewer): void

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

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

  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<void>

    function computeIcrfToFixedMatrix(date: JulianDate, result?: Matrix3): Matrix3

    function computeFixedToIcrfMatrix(date: JulianDate, result?: Matrix3): Matrix3

    function pointToWindowCoordinates(
      modelViewProjectionMatrix: Matrix4,
      viewportTransformation: Matrix4,
      point: Cartesian3,
      result?: Cartesian2
    ): Cartesian2
  }

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

  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<boolean>
    readonly tileDiscardPolicy: TileDiscardPolicy

    constructor(options: {
      url: string
      pickFeaturesUrl?: string
      urlSchemeZeroPadding?: {}
      subdomains?: string | Array<string>
      proxy?: {}
      credit?: Credit
      minimumLevel?: number
      maximumLevel?: number
      rectangle?: Rectangle
      tilingScheme?: TilingScheme
      ellipsoid?: Ellipsoid
      tileWidth?: number
      tileHeight?: number
      hasAlphaChannel?: boolean
      getFeatureInfoFormats?: Array<GetFeatureInfoFormat>
      enablePickFeatures?: boolean
      customTags?: any
    })

    getTileCredits(x: number, y: number, level: number): Array<Credit>

    pickFeatures(
      x: number,
      y: number,
      level: number,
      longitude: number,
      latitude: number
    ): Promise<Array<ImageryLayerFeatureInfo>> | undefined

    reinitialize(options: Promise<Object> | Object): void
  }

  function defined(value: Object): boolean

  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
}