Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Updated typings file for Cesium v1.69 (I think?)
/**
* Cesium type definitions
* For use with Cesium v1.66
* Created by Aigars Zeiza <https://github.com/Zuzon>
* Modified by Harry Nicholls <harry@northstar-robotics.com>
* Updated for v1.66.0 by James Bromwell <https://github.com/Thw0rted>
*/
declare module "cesium"{
type RenderState = any;
interface Type<T> extends Function { new (...args: any[]): T; }
interface Proxy {
getURL(resource: string): string;
}
enum ArcType {
GEODESIC, NONE, RHUMB
}
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 implements BoundingVolume {
center: Cartesian3;
radius: number;
static packedLength: number;
constructor(center?: Cartesian3, radius?: number);
clone(result?: BoundingSphere): BoundingSphere;
computePlaneDistances(position: Cartesian3, direction: Cartesian3, result?: Interval): Interval;
distanceSquaredTo(cartesian: Cartesian3): number;
equals(right?: BoundingSphere): boolean;
intersectPlane(plane: Plane): Intersect;
isOccluded(occluder: Occluder): boolean;
volume(): number;
static clone(sphere: BoundingSphere, result?: BoundingSphere): BoundingSphere;
static computePlaneDistances(sphere: BoundingSphere, position: Cartesian3, direction: Cartesian3, result?: Interval): Interval;
static distanceSquaredTo(sphere: BoundingSphere, cartesian: Cartesian3): number;
static equals(left?: BoundingSphere, right?: BoundingSphere): boolean;
static expand(sphere: BoundingSphere, point: Cartesian3, result?: BoundingSphere): BoundingSphere;
static fromBoundingSpheres(boundingSpheres: BoundingSphere[], result?: BoundingSphere): BoundingSphere;
static fromCornerPoints(corner?: Cartesian3, oppositeCorner?: Cartesian3, result?: BoundingSphere): BoundingSphere;
static fromEllipsoid(ellipsoid: Ellipsoid, result?: BoundingSphere): BoundingSphere;
static fromEncodedCartesianVertices(positionsHigh?: number[], positionsLow?: number[], result?: BoundingSphere): BoundingSphere;
static fromPoints(positions: Cartesian3[], result?: BoundingSphere): BoundingSphere;
static fromRectangle2D(rectangle?: Rectangle, projection?: any, result?: BoundingSphere): BoundingSphere;
static fromRectangle3D(rectangle?: Rectangle, ellipsoid?: Ellipsoid, surfaceHeight?: number, result?: BoundingSphere): BoundingSphere;
static fromRectangleWithHeights2D(rectangle: Rectangle, projection?: any, minimumHeight?: number, maximumHeight?: number, result?: BoundingSphere): BoundingSphere;
static fromVertices(positions: Cartesian3[], center?: Cartesian3, stride?: number, result?: BoundingSphere): BoundingSphere;
static intersectPlane(sphere: BoundingSphere, plane: Plane): Intersect;
static isOccluded(sphere: BoundingSphere, occluder: Occluder): boolean;
static pack(value: BoundingSphere, array: number[], startingIndex?: number): number[];
static projectTo2D(sphere: BoundingSphere, projection?: any, result?: BoundingSphere): BoundingSphere;
static transform(sphere: BoundingSphere, transform: Matrix4, result?: BoundingSphere): BoundingSphere;
static transformWithoutScale(sphere: BoundingSphere, transform: Matrix4, result?: BoundingSphere): BoundingSphere;
static union(left: BoundingSphere, right: BoundingSphere, result?: BoundingSphere): BoundingSphere;
static unpack(array: number[], startingIndex?: number, result?: BoundingSphere): BoundingSphere;
}
class BoxGeometry {
static packedLength: number;
constructor(options: { minimumCorner: Cartesian3; maximumCorner: Cartesian3; vertexFormat?: VertexFormat });
static fromDimensions(): BoxGeometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: BoxGeometry): BoxGeometry;
static createGeometry(boxGeometry: BoxGeometry): Geometry;
}
class BoxOutlineGeometry {
static packedLength: number;
constructor();
static fromDimensions(): BoxOutlineGeometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: BoxOutlineGeometry): BoxOutlineGeometry;
static createGeometry(boxGeometry: BoxOutlineGeometry): Geometry;
}
class Cartesian2 {
x: number;
y: number;
static packedLength: number;
static ZERO: Cartesian2;
static UNIT_X: Cartesian2;
static UNIT_Y: Cartesian2;
constructor(x?: number, y?: number);
clone(result?: Cartesian2): Cartesian2;
equals(right?: Cartesian2): boolean;
equalsEpsilon(right: Cartesian2, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
toString(): string;
static abs(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static add(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
static angleBetween(left: Cartesian2, right: Cartesian2): number;
static clone(cartesian: Cartesian2, result?: Cartesian2): Cartesian2;
static distance(left: Cartesian2, right: Cartesian2): number;
static distanceSquared(left: Cartesian2, right: Cartesian2): number;
static divideByScalar(cartesian: Cartesian2, scalar: number, result: Cartesian2): Cartesian2;
static divideComponents(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
static dot(left: Cartesian2, right: Cartesian2): number;
static equals(left?: Cartesian2, right?: Cartesian2): boolean;
static equalsEpsilon(left: Cartesian2, right: Cartesian2, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
static fromArray(array: number[], startingIndex?: number, result?: Cartesian2): Cartesian2;
static fromCartesian3(cartesian: Cartesian3, result?: Cartesian2): Cartesian2;
static fromCartesian4(cartesian: Cartesian4, result?: Cartesian2): Cartesian2;
static fromElements(x: number, y: number, result?: Cartesian2): Cartesian2;
static lerp(start: Cartesian2, end: Cartesian2, t: number, result: Cartesian2): Cartesian2;
static magnitude(cartesian: Cartesian2): number;
static magnitudeSquared(cartesian: Cartesian2): number;
static maximumByComponent(first: Cartesian2, second: Cartesian2, result: Cartesian2): Cartesian2;
static maximumComponent(cartesian: Cartesian2): number;
static minimumByComponent(first: Cartesian2, second: Cartesian2, result: Cartesian2): Cartesian2;
static minimumComponent(cartesian: Cartesian2): number;
static mostOrthogonalAxis(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static multiplyByScalar(cartesian: Cartesian2, scalar: number, result: Cartesian2): Cartesian2;
static multiplyComponents(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
static negate(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static normalize(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static pack(value: Cartesian2, array: number[], startingIndex?: number): number[];
static packArray(values: Cartesian2[], array: number[]): number[];
static subtract(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
static unpack(array: number[], startingIndex?: number, result?: Cartesian2): Cartesian2;
static unpackArray(array: number[], result: Cartesian2): Cartesian2;
}
class Cartesian3 {
x: number;
y: number;
z: number;
static UNIT_X: Cartesian3;
static UNIT_Y: Cartesian3;
static UNIT_Z: Cartesian3;
static ZERO: Cartesian3;
static packedLength: number;
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 abs(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static add(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static angleBetween(left: Cartesian3, right: Cartesian3): number;
static clone(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
static cross(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static distance(left: Cartesian3, right: Cartesian3): number;
static distanceSquared(left: Cartesian3, right: Cartesian3): number;
static divideByScalar(cartesian: Cartesian3, scalar: number, result: Cartesian3): Cartesian3;
static dot(left: Cartesian3, right: Cartesian3): number;
static equals(left?: Cartesian3, right?: Cartesian3): boolean;
static equalsEpsilon(left: Cartesian3, right: Cartesian3, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
static fromArray(array: number[], startingIndex?: number, result?: Cartesian3): Cartesian3;
static fromCartesian4(cartesian: Cartesian4, result?: Cartesian3): Cartesian3;
static fromDegrees(longitude: number, latitude: number, height?: number, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3;
static fromDegreesArray(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
static fromDegreesArrayHeights(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
static fromElements(x: number, y: number, z: number, result?: Cartesian3): Cartesian3;
static fromRadians(longitude: number, latitude: number, height?: number, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3;
static fromRadiansArray(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
static fromRadiansArrayHeights(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
static fromSpherical(spherical: Spherical, result?: Cartesian3): Cartesian3;
static lerp(start: Cartesian3, end: Cartesian3, t: number, result: Cartesian3): Cartesian3;
static magnitude(cartesian: Cartesian3): number;
static magnitudeSquared(cartesian: Cartesian3): number;
static maximumByComponent(first: Cartesian3, second: Cartesian3, result: Cartesian3): Cartesian3;
static maximumComponent(cartesian: Cartesian3): number;
static midpoint(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static minimumByComponent(first: Cartesian3, second: Cartesian3, result: Cartesian3): Cartesian3;
static minimumComponent(cartesian: Cartesian3): number;
static mostOrthogonalAxis(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static multiplyByScalar(cartesian: Cartesian3, scalar: number, result: Cartesian3): Cartesian3;
static multiplyComponents(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static negate(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static normalize(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static pack(value: Cartesian3, array: number[], startingIndex?: number): number[];
static packArray(array: Cartesian3[], result: number[]): number[];
static subtract(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static unpack(array: number[], startingIndex?: number, result?: Cartesian3): Cartesian3;
static unpackArray(array: number[], result?: Cartesian3[]): Cartesian3[];
}
class Cartesian4 {
x: number;
y: number;
z: number;
w: number;
static packedLength: number;
static ZERO: Cartesian4;
static UNIT_X: Cartesian4;
static UNIT_Y: Cartesian4;
static UNIT_Z: Cartesian4;
static UNIT_W: Cartesian4;
constructor(x?: number, y?: number, z?: number, w?: number);
clone(result?: Cartesian4): Cartesian4;
equals(right?: Cartesian4): boolean;
equalsEpsilon(right: Cartesian4, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
toString(): string;
static fromElements(x: number, y: number, z: number, w: number, result?: Cartesian4): Cartesian4;
static fromColor(color: Color, result?: Cartesian4): Cartesian4;
static clone(cartesian: Cartesian4, result?: Cartesian4): Cartesian4;
static pack(value: Cartesian4, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: Cartesian4): Cartesian4;
static fromArray(array: number[], startingIndex?: number, result?: Cartesian4): Cartesian4;
static maximumComponent(cartesian: Cartesian4): number;
static minimumComponent(cartesian: Cartesian4): number;
static minimumByComponent(first: Cartesian4, second: Cartesian4, result: Cartesian4): Cartesian4;
static maximumByComponent(first: Cartesian4, second: Cartesian4, result: Cartesian4): Cartesian4;
static magnitudeSquared(cartesian: Cartesian4): number;
static magnitude(cartesian: Cartesian4): number;
static distance(left: Cartesian4, right: Cartesian4): number;
static distanceSquared(left: Cartesian4, right: Cartesian4): number;
static normalize(cartesian: Cartesian4, result: Cartesian4): Cartesian4;
static dot(left: Cartesian4, right: Cartesian4): number;
static multiplyComponents(left: Cartesian4, right: Cartesian4, result: Cartesian4): Cartesian4;
static add(left: Cartesian4, right: Cartesian4, result: Cartesian4): Cartesian4;
static subtract(left: Cartesian4, right: Cartesian4, result: Cartesian4): Cartesian4;
static multiplyByScalar(cartesian: Cartesian4, scalar: number, result: Cartesian4): Cartesian4;
static divideByScalar(cartesian: Cartesian4, scalar: number, result: Cartesian4): Cartesian4;
static negate(cartesian: Cartesian4, result: Cartesian4): Cartesian4;
static abs(cartesian: Cartesian4, result: Cartesian4): Cartesian4;
static lerp(start: Cartesian4, end: Cartesian4, t: number, result: Cartesian4): Cartesian4;
static mostOrthogonalAxis(cartesian: Cartesian4, result: Cartesian4): Cartesian4;
static equals(left?: Cartesian4, right?: Cartesian4): boolean;
static equalsEpsilon(left: Cartesian4, right: Cartesian4, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
}
class Cartographic {
longitude: number;
latitude: number;
height: number;
static ZERO: Cartographic;
constructor(longitude?: number, latitude?: number, height?: number);
static clone(cartographic: Cartographic, result?: Cartographic): Cartographic;
static equals(left?: Cartographic, right?: Cartographic): boolean;
static equalsEpsilon(left: Cartographic, right: Cartographic, epsilon: number): boolean;
static fromCartesian(cartesian: Cartesian3, ellipsoid?: Ellipsoid, result?: Cartographic): Cartographic;
static fromDegrees(longitude: number, latitude: number, height?: number, result?: Cartographic): Cartographic;
static fromRadians(longitude: number, latitude: number, height?: number, result?: Cartographic): Cartographic;
static toCartesian(cartographic: Cartographic, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3;
clone(result?: Cartographic): Cartographic;
equals(right?: Cartographic): boolean;
equalsEpsilon(right: Cartographic, epsilon: number): boolean;
toString(): string;
}
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 Cesium3DTileset {
// TODO
}
class CesiumTerrainProvider extends TerrainProvider {
requestVertexNormals: boolean;
requestWaterMask: boolean;
constructor(options: {
url: Resource | string;
requestVertexNormals?: boolean;
requestWaterMask?: boolean;
ellipsoid?: Ellipsoid;
credit?: Credit | string;
});
getLevelMaximumGeometricError(level: number): number;
getTileDataAvailable(x: number, y: number, level: number): boolean;
loadTileDataAvailability(x: number, y: number, level: number): Promise<void> | undefined;
requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
}
class CircleGeometry {
static packedLength: number;
constructor(options: CircleGeometry.ConstructorOptions);
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CircleGeometry): CircleGeometry;
static createGeometry(circleGeometry: CircleGeometry): Geometry;
}
namespace CircleGeometry {
interface ConstructorOptions {
center: Cartesian3;
radius: number;
ellipsoid?: Ellipsoid;
height?: number;
granularity?: number;
vertexFormat?: VertexFormat;
extrudedHeight?: number;
stRotation?: number;
}
}
class CircleOutlineGeometry {
static packedLength: number;
constructor(options: { center: Cartesian3; radius: number; ellipsoid?: Ellipsoid; height?: number; granularity?: number; extrudedHeight?: number; numberOfVerticalLines?: number });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CircleOutlineGeometry): CircleOutlineGeometry;
static createGeometry(circleGeometry: CircleOutlineGeometry): Geometry;
}
enum ClassificationType { CESIUM_3D_TILE, TERRAIN, BOTH }
class ClippingPlaneCollection {
// TODO
}
class Clock {
canAnimate: boolean;
clockRange: ClockRange;
clockStep: ClockStep;
currentTime: JulianDate;
multiplier: number;
onStop: Event<(c: this) => void>;
onTick: Event<(c: this) => void>;
shouldAnimate: boolean;
startTime: JulianDate;
stopTime: JulianDate;
constructor(options: {
startTime?: JulianDate;
stopTime?: JulianDate;
currentTime?: JulianDate;
multiplier?: number;
clockStep?: ClockStep;
clockRange?: ClockRange;
canAnimate?: boolean;
shouldAnimate?: boolean;
});
tick(): JulianDate;
}
class Color {
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 CoplanarPolygonGeometry {
packedLength: number;
constructor(options: {polygonHierarchy: PolygonHierarchy, stRotation?: number, vertexFormat?: VertexFormat});
static createGeometry(polygonGeometry: CoplanarPolygonGeometry): Geometry;
static fromPositions(options: {positions: Cartesian3[], vertexFormat?: VertexFormat, stRotation?: number}): CoplanarPolygonGeometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CoplanarPolygonGeometry): CoplanarPolygonGeometry;
}
class CoplanarPolygonOutlineGeometry {
packedLength: number;
constructor(options: {polygonHierarchy: PolygonHierarchy});
static createGeometry(polygonGeometry: CoplanarPolygonOutlineGeometry): Geometry;
static fromPositions(options: {positions: Cartesian3[]}): CoplanarPolygonOutlineGeometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CoplanarPolygonOutlineGeometry): CoplanarPolygonOutlineGeometry;
}
class CorridorGeometry {
packedLength: number;
constructor(options: { positions: Cartesian3[]; width: number; ellipsoid?: Ellipsoid; granularity?: number; height?: number; extrudedHeight?: number; vertexFormat?: VertexFormat; cornerType?: CornerType });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CorridorGeometry): CorridorGeometry;
static createGeometry(corridorGeometry: CorridorGeometry): Geometry;
}
class CorridorOutlineGeometry {
packedLength: number;
constructor(options: { positions: Cartesian3[]; width: number; ellipsoid?: Ellipsoid; granularity?: number; height?: number; extrudedHeight?: number; cornerType?: CornerType });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CorridorOutlineGeometry): CorridorOutlineGeometry;
static createGeometry(corridorOutlineGeometry: CorridorOutlineGeometry): Geometry;
}
class Credit {
readonly element: HTMLElement;
readonly html: string;
readonly showOnScreen: boolean;
constructor(html: string, showOnScreen?: boolean);
static equals(left: Credit, right: Credit): boolean;
equals(credits: Credit): boolean;
}
class CylinderGeometry {
static packedLength: number;
constructor(options: { length: number; topRadius: number; bottomRadius: number; slices?: number; vertexFormat?: VertexFormat });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CylinderGeometry): CylinderGeometry;
static createGeometry(cylinderGeometry: CylinderGeometry): Geometry;
}
class CylinderOutlineGeometry {
static packedLength: number;
constructor(options: { length: number; topRadius: number; bottomRadius: number; slices?: number; numberOfVerticalLines?: number });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CylinderOutlineGeometry): CylinderOutlineGeometry;
static createGeometry(cylinderGeometry: CylinderOutlineGeometry): Geometry;
}
class DefaultProxy {
constructor(proxy: string);
getURL(resource: string): string;
}
class DeveloperError {
name: string;
message: string;
stack: string;
constructor(message?: string);
}
class DistanceDisplayCondition {
far: number;
near: 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;
static pack(value: DistanceDisplayCondition, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: DistanceDisplayCondition): DistanceDisplayCondition;
}
class EllipseGeometry {
static packedLength: number;
constructor(options: { center: Cartesian3; semiMajorAxis: number; semiMinorAxis: number; ellipsoid?: Ellipsoid; height?: number; extrudedHeight?: number; rotation?: number; stRotation?: number; granularity?: number; vertexFormat?: VertexFormat });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: EllipseGeometry): EllipseGeometry;
static createGeometry(ellipseGeometry: EllipseGeometry): Geometry;
}
class EllipseOutlineGeometry {
static packedLength: number;
constructor(options: { center: Cartesian3; semiMajorAxis: number; semiMinorAxis: number; ellipsoid?: Ellipsoid; height?: number; extrudedHeight?: number; rotation?: number; granularity?: number; numberOfVerticalLines?: number });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: EllipseOutlineGeometry): EllipseOutlineGeometry;
static createGeometry(ellipseGeometry: EllipseOutlineGeometry): Geometry;
}
class Ellipsoid {
radii: Cartesian3;
radiiSquared: Cartesian3;
radiiToTheFourth: Cartesian3;
oneOverRadii: Cartesian3;
oneOverRadiiSquared: Cartesian3;
minimumRadius: number;
maximumRadius: number;
static WGS84: Ellipsoid;
static UNIT_SPHERE: Ellipsoid;
static MOON: Ellipsoid;
static packedLength: number;
constructor(x?: number, y?: number, z?: number);
clone(result?: Ellipsoid): Ellipsoid;
geocentricSurfaceNormal(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
geodeticSurfaceNormalCartographic(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
geodeticSurfaceNormal(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
cartographicToCartesian(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
cartographicArrayToCartesianArray(cartographics: Cartographic[], result?: Cartesian3[]): Cartesian3[];
cartesianToCartographic(cartesian: Cartesian3, result?: Cartographic): Cartographic;
cartesianArrayToCartographicArray(cartesians: Cartesian3[], result?: Cartographic[]): Cartographic[];
scaleToGeodeticSurface(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
scaleToGeocentricSurface(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
transformPositionToScaledSpace(position: Cartesian3, result?: Cartesian3): Cartesian3;
transformPositionFromScaledSpace(position: Cartesian3, result?: Cartesian3): Cartesian3;
equals(right?: Ellipsoid): boolean;
toString(): string;
static clone(ellipsoid: Ellipsoid, result?: Ellipsoid): Ellipsoid;
static fromCartesian3(radii?: Cartesian3): Ellipsoid;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: Ellipsoid): Ellipsoid;
}
class EllipsoidGeodesic {
surfaceDistance: number;
start: Cartographic;
end: Cartographic;
startHeading: number;
endHeading: number;
constructor(start?: Cartographic, end?: Cartographic, ellipsoid?: Ellipsoid);
setEndPoints(start: Cartographic, end: Cartographic): void;
interpolateUsingFraction(fraction: number): Cartographic;
interpolateUsingSurfaceDistance(distance: number): Cartographic;
}
class EllipsoidGeometry {
static packedLength: number;
constructor(options?: { radii?: Cartesian3; stackPartitions?: number; slicePartitions?: number; vertexFormat?: VertexFormat });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: EllipsoidGeometry): EllipsoidGeometry;
static createGeometry(ellipsoidGeometry: EllipsoidGeometry): Geometry;
}
class EllipsoidOutlineGeometry {
static packedLength: number;
constructor(options?: { radii?: Cartesian3; stackPartitions?: number; slicePartitions?: number; subdivisions?: number });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: EllipsoidOutlineGeometry): EllipsoidOutlineGeometry;
static createGeometry(ellipsoidGeometry: EllipsoidOutlineGeometry): Geometry;
}
class EllipsoidTangentPlane {
ellipsoid: Ellipsoid;
origin: Cartesian3;
constructor(ellipsoid: Ellipsoid, origin: Cartesian3);
projectPointOntoPlane(cartesian: Cartesian3, result?: Cartesian2): Cartesian2;
projectPointsOntoPlane(cartesians: Cartesian3[], result?: Cartesian2[]): Cartesian2[];
projectPointsOntoEllipsoid(cartesians: Cartesian2[], result?: Cartesian3[]): Cartesian3[];
static fromPoints(ellipsoid: Ellipsoid, cartesians: Cartesian3): EllipsoidTangentPlane;
}
class EllipsoidTerrainProvider extends TerrainProvider {
constructor(options?: { tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid });
getLevelMaximumGeometricError(level: number): number;
getTileDataAvailable(x: number, y: number, level: number): boolean;
loadTileDataAvailability(x: number, y: number, level: number): Promise<void> | undefined;
requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
}
class Event<CB extends (...args: any[]) => void = (...args: any[]) => void> {
numberOfListeners: number;
addEventListener(listener: CB, scope?: any): Event.RemoveCallback;
removeEventListener(listener: CB, scope?: any): boolean;
raiseEvent(...args: any[]): void;
}
namespace Event {
type RemoveCallback = () => void;
}
class EventHelper {
add(event: Event, listener: Function, scope?: any): EventHelper.RemoveCallback;
removeAll(): void;
}
namespace 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?: number[] });
}
class GeometryAttributes {
position: GeometryAttribute;
normal: GeometryAttribute;
st: GeometryAttribute;
binormal: GeometryAttribute;
tangent: GeometryAttribute;
color: GeometryAttribute;
}
class GeometryInstance {
geometry: Geometry;
modelMatrix: Matrix4;
id: any;
attributes: any;
constructor(options: {
geometry: Geometry;
modelMatrix?: Matrix4;
id?: any;
attributes?: any;
});
}
class GeometryInstanceAttribute {
componentDatatype: ComponentDatatype;
componentsPerAttribute: number;
normalize: boolean;
value: number[];
constructor(options: { componentDatatype?: ComponentDatatype; componentsPerAttribute?: number; normalize?: boolean; value?: number[] });
}
class GregorianDate {
year: number;
month: number;
day: number;
hour: number;
minute: number;
second: number;
millisecond: number;
isLeapSecond: boolean;
constructor(
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 fromGregorianDate(date: GregorianDate, result?: JulianDate): JulianDate;
static fromIso8601(iso8601String: string, result?: JulianDate): JulianDate;
static now(result?: JulianDate): JulianDate;
static toGregorianDate(julianDate: JulianDate, result?: GregorianDate): GregorianDate;
static toDate(julianDate: JulianDate): Date;
static toIso8601(julianDate: JulianDate, precision?: number): string;
static clone(julianDate: JulianDate, result?: JulianDate): JulianDate;
static compare(left: JulianDate, right: JulianDate): number;
static equals(left?: JulianDate, right?: JulianDate): boolean;
static equalsEpsilon(left: JulianDate, right: JulianDate, epsilon: number): boolean;
static totalDays(julianDate: JulianDate): number;
static secondsDifference(left: JulianDate, right: JulianDate): number;
static daysDifference(left: JulianDate, right: JulianDate): number;
static computeTaiMinusUtc(julianDate: JulianDate): number;
static addSeconds(julianDate: JulianDate, seconds: number, result: JulianDate): JulianDate;
static addMinutes(julianDate: JulianDate, minutes: number, result: JulianDate): JulianDate;
static addHours(julianDate: JulianDate, hours: number, result: JulianDate): JulianDate;
static addDays(julianDate: JulianDate, days: number, result: JulianDate): JulianDate;
static lessThan(left: JulianDate, right: JulianDate): boolean;
static lessThanOrEquals(left: JulianDate, right: JulianDate): boolean;
static greaterThan(left: JulianDate, right: JulianDate): boolean;
static greaterThanOrEquals(left: JulianDate, right: JulianDate): boolean;
}
class LeapSecond {
julianDate: JulianDate;
offset: number;
constructor(date?: JulianDate, offset?: number);
}
class LinearSpline {
times: number[];
points: Cartesian3[];
constructor();
findTimeInterval(time: number): number;
evaluate(time: number, result?: Cartesian3): Cartesian3;
}
class MapProjection {
ellipsoid: Ellipsoid;
project(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
unproject(cartesian: Cartesian3, result?: Cartographic): Cartographic;
}
class Matrix2 {
static packedLength: number;
static IDENTITY: Matrix2;
static COLUMN0ROW0: number;
static COLUMN0ROW1: number;
static COLUMN1ROW0: number;
static COLUMN1ROW1: number;
constructor(column0Row0?: number, column1Row0?: number, column0Row1?: number, column1Row1?: number);
clone(result?: Matrix2): Matrix2;
equals(right?: Matrix2): boolean;
equalsEpsilon(right: Matrix2, epsilon: number): boolean;
toString(): string;
static pack(value: Matrix2, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: Matrix2): Matrix2;
static clone(matrix: Matrix2, result?: Matrix2): Matrix2;
static fromArray(array: number[], startingIndex?: number, result?: Matrix2): Matrix2;
static fromColumnMajorArray(values: number[], result?: Matrix2): Matrix2;
static fromRowMajorArray(values: number[], result?: Matrix2): Matrix2;
static fromScale(scale: Cartesian2, result?: Matrix2): Matrix2;
static fromUniformScale(scale: number, result?: Matrix2): Matrix2;
static fromRotation(angle: number, result?: Matrix2): Matrix2;
static toArray(matrix: Matrix2, result?: number[]): number[];
static getElementIndex(row: number, column: number): number;
static getColumn(matrix: Matrix2, index: number, result: Cartesian2): Cartesian2;
static setColumn(matrix: Matrix2, index: number, cartesian: Cartesian2, result: Cartesian2): Matrix2;
static getRow(matrix: Matrix2, index: number, result: Cartesian2): Cartesian2;
static setRow(matrix: Matrix2, index: number, cartesian: Cartesian2, result: Matrix2): Matrix2;
static getScale(matrix: Matrix2, result: Cartesian2): Cartesian2;
static getMaximumScale(matrix: Matrix2): number;
static multiply(left: Matrix2, right: Matrix2, result: Matrix2): Matrix2;
static add(left: Matrix2, right: Matrix2, result: Matrix2): Matrix2;
static subtract(left: Matrix2, right: Matrix2, result: Matrix2): Matrix2;
static multiplyByVector(matrix: Matrix2, cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static multiplyByScalar(matrix: Matrix2, scalar: number, result: Matrix2): Matrix2;
static negate(matrix: Matrix2, result: Matrix2): Matrix2;
static transpose(matrix: Matrix2, result: Matrix2): Matrix2;
static abs(matrix: Matrix2, result: Matrix2): Matrix2;
static equals(left?: Matrix2, right?: Matrix2): boolean;
static equalsEpsilon(left: Matrix2, right: Matrix2, epsilon: number): boolean;
}
class Matrix3 {
static packedLength: number;
static IDENTITY: Matrix3;
static COLUMN0ROW0: number;
static COLUMN0ROW1: number;
static COLUMN0ROW2: number;
static COLUMN1ROW0: number;
static COLUMN1ROW1: number;
static COLUMN1ROW2: number;
static COLUMN2ROW0: number;
static COLUMN2ROW1: number;
static COLUMN2ROW2: number;
constructor(column0Row0?: number, column1Row0?: number, column2Row0?: number, column0Row1?: number, column1Row1?: number, column2Row1?: number, column0Row2?: number, column1Row2?: number, column2Row2?: number);
clone(result?: Matrix3): Matrix3;
equals(right?: Matrix3): boolean;
equalsEpsilon(right: Matrix3, epsilon: number): boolean;
toString(): string;
static pack(value: Matrix3, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: Matrix3): Matrix3;
static clone(matrix: Matrix3, result?: Matrix3): Matrix3;
static fromArray(array: number[], startingIndex?: number, result?: Matrix3): Matrix3;
static fromColumnMajorArray(values: number[], result?: Matrix3): Matrix3;
static fromRowMajorArray(values: number[], result?: Matrix3): Matrix3;
static fromQuaternion(quaternion: Quaternion): Matrix3;
static fromScale(scale: Cartesian3, result?: Matrix3): Matrix3;
static fromUniformScale(scale: number, result?: Matrix3): Matrix3;
static fromCrossProduct(the: Cartesian3, result?: Matrix3): Matrix3;
static fromRotationX(angle: number, result?: Matrix3): Matrix3;
static fromRotationY(angle: number, result?: Matrix3): Matrix3;
static fromRotationZ(angle: number, result?: Matrix3): Matrix3;
static toArray(matrix: Matrix3, result?: number[]): number[];
static getElementIndex(row: number, column: number): number;
static getColumn(matrix: Matrix3, index: number, result: Cartesian3): Cartesian3;
static setColumn(matrix: Matrix3, index: number, cartesian: Cartesian3, result: Cartesian3): Matrix3;
static getRow(matrix: Matrix3, index: number, result: Cartesian3): Cartesian3;
static setRow(matrix: Matrix3, index: number, cartesian: Cartesian3, result: Cartesian3): Matrix3;
static getScale(matrix: Matrix3, result: Cartesian3): Cartesian3;
static getMaximumScale(matrix: Matrix3): number;
static multiply(left: Matrix3, right: Matrix3, result: Matrix3): Matrix3;
static add(left: Matrix3, right: Matrix3, result: Matrix3): Matrix3;
static subtract(left: Matrix3, right: Matrix3, result: Matrix3): Matrix3;
static multiplyByVector(matrix: Matrix3, cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static multiplyByScalar(matrix: Matrix3, scalar: number, result: Matrix3): Matrix3;
static negate(matrix: Matrix3, result: Matrix3): Matrix3;
static transpose(matrix: Matrix3, result: Matrix3): Matrix3;
static computeEigenDecomposition(matrix: Matrix3, result?: any): any;
static abs(matrix: Matrix3, result: Matrix3): Matrix3;
static determinant(matrix: Matrix3): number;
static inverse(matrix: Matrix3, result: Matrix3): Matrix3;
static equals(left?: Matrix3, right?: Matrix3): boolean;
static equalsEpsilon(left: Matrix3, right: Matrix3, epsilon: number): boolean;
}
class Matrix4 {
static packedLength: number;
static IDENTITY: Matrix4;
static COLUMN0ROW0: number;
static COLUMN0ROW1: number;
static COLUMN0ROW2: number;
static COLUMN0ROW3: number;
static COLUMN1ROW0: number;
static COLUMN1ROW1: number;
static COLUMN1ROW2: number;
static COLUMN1ROW3: number;
static COLUMN2ROW0: number;
static COLUMN2ROW1: number;
static COLUMN2ROW2: number;
static COLUMN2ROW3: number;
static COLUMN3ROW0: number;
static COLUMN3ROW1: number;
static COLUMN3ROW2: number;
static COLUMN3ROW3: number;
constructor(column0Row0?: number, column1Row0?: number, column2Row0?: number, column3Row0?: number, column0Row1?: number, column1Row1?: number, column2Row1?: number, column3Row1?: number, column0Row2?: number, column1Row2?: number, column2Row2?: number, column3Row2?: number, column0Row3?: number, column1Row3?: number, column2Row3?: number, column3Row3?: number);
clone(result?: Matrix4): Matrix4;
equals(right?: Matrix4): boolean;
equalsEpsilon(right: Matrix4, epsilon: number): boolean;
toString(): string;
static pack(value: Matrix4, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: Matrix4): Matrix4;
static clone(matrix: Matrix4, result?: Matrix4): Matrix4;
static fromArray(array: number[], startingIndex?: number, result?: Matrix4): Matrix4;
static fromColumnMajorArray(values: number[], result?: Matrix4): Matrix4;
static fromRowMajorArray(values: number[], result?: Matrix4): Matrix4;
static fromRotationTranslation(rotation: Matrix3, translation?: Cartesian3, result?: Matrix4): Matrix4;
static fromTranslationQuaternionRotationScale(translation: Cartesian3, rotation: Quaternion, scale: Cartesian3, result?: Matrix4): Matrix4;
static fromTranslation(translation: Cartesian3, result?: Matrix4): Matrix4;
static fromScale(scale: Cartesian3, result?: Matrix4): Matrix4;
static fromUniformScale(scale: number, result?: Matrix4): Matrix4;
static fromCamera(camera: Camera, result?: Matrix4): Matrix4;
static computePerspectiveFieldOfView(fovY: number, aspectRatio: number, near: number, far: number, result: Matrix4): Matrix4;
static computeOrthographicOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4): Matrix4;
static computePerspectiveOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4): Matrix4;
static computeInfinitePerspectiveOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4): Matrix4;
static computeViewportTransformation(viewport: any, nearDepthRange: number, farDepthRange: number, result: Matrix4): Matrix4;
static toArray(matrix: Matrix4, result?: number[]): number[];
static getElementIndex(row: number, column: number): number;
static getColumn(matrix: Matrix4, index: number, result: Cartesian4): Cartesian4;
static setColumn(matrix: Matrix4, index: number, cartesian: Cartesian4, result: Cartesian4): Matrix4;
static getRow(matrix: Matrix4, index: number, result: Cartesian4): Cartesian4;
static setRow(matrix: Matrix4, index: number, cartesian: Cartesian4, result: Cartesian4): Matrix4;
static getScale(matrix: Matrix4, result: Cartesian3): Cartesian3;
static getMaximumScale(matrix: Matrix4): number;
static multiply(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
static add(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
static subtract(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
static multiplyTransformation(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
static multiplyByMatrix3(matrix: Matrix4, rotation: Matrix3, result: Matrix4): Matrix4;
static multiplyByTranslation(matrix: Matrix4, translation: Cartesian3, result: Matrix4): Matrix4;
static multiplyByUniformScale(matrix: Matrix4, scale: number, result: Matrix4): Matrix4;
static multiplyByScale(matrix: Matrix4, scale: Cartesian3, result: Matrix4): Matrix4;
static multiplyByVector(matrix: Matrix4, cartesian: Cartesian4, result: Cartesian4): Cartesian4;
static multiplyByPointAsVector(matrix: Matrix4, cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static multiplyByPoint(matrix: Matrix4, cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static multiplyByScalar(matrix: Matrix4, scalar: number, result: Matrix4): Matrix4;
static negate(matrix: Matrix4, result: Matrix4): Matrix4;
static transpose(matrix: Matrix4, result: Matrix4): Matrix4;
static abs(matrix: Matrix4, result: Matrix4): Matrix4;
static equals(left?: Matrix4, right?: Matrix4): boolean;
static equalsEpsilon(left: Matrix4, right: Matrix4, epsilon: number): boolean;
static getTranslation(matrix: Matrix4, result: Cartesian3): Cartesian3;
static getRotation(matrix: Matrix4, result: Matrix3): Matrix3;
static inverse(matrix: Matrix4, result: Matrix4): Matrix4;
static inverseTransformation(matrix: Matrix4, result: Matrix4): Matrix4;
}
class NearFarScalar {
near: number;
nearValue: number;
far: number;
farValue: number;
static packedLength: number;
constructor(near?: number, nearValue?: number, far?: number, farValue?: number);
clone(result?: NearFarScalar): NearFarScalar;
equals(right?: NearFarScalar): boolean;
static clone(nearFarScalar: NearFarScalar, result?: NearFarScalar): NearFarScalar;
static pack(value: NearFarScalar, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: NearFarScalar): NearFarScalar;
static equals(left?: NearFarScalar, right?: NearFarScalar): boolean;
}
class OrientedBoundingBox implements BoundingVolume {
static packedLength: number;
center: Cartesian3;
halfAxes: Matrix3;
constructor(center?: Cartesian3, halfAxes?: Matrix3);
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;
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;
static pack(value: OrientedBoundingBox, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: OrientedBoundingBox): OrientedBoundingBox;
}
class Occluder {
position: Cartesian3;
radius: number;
cameraPosition: Cartesian3;
constructor(occluderBoundingSphere: BoundingSphere, cameraPosition: Cartesian3);
isPointVisible(occludee: Cartesian3): boolean;
isBoundingSphereVisible(occludee: BoundingSphere): boolean;
computeVisibility(occludeeBS: BoundingSphere): number;
static fromBoundingSphere(occluderBoundingSphere: BoundingSphere, cameraPosition: Cartesian3, result?: Occluder): Occluder;
static computeOccludeePoint(occluderBoundingSphere: BoundingSphere, occludeePosition: Cartesian3, positions: Cartesian3[]): any;
static computeOccludeePointFromRectangle(rectangle: Rectangle, ellipsoid?: Ellipsoid): any;
}
class PinBuilder {
fromColor(color: Color, size: number): HTMLCanvasElement;
fromUrl(url: string, color: Color, size: number): HTMLCanvasElement | Promise<HTMLCanvasElement>;
fromMakiIconId(id: string, color: Color, size: number): HTMLCanvasElement | Promise<HTMLCanvasElement>;
fromText(text: string, color: Color, size: number): HTMLCanvasElement;
}
class Plane {
normal: Cartesian3;
distance: number;
constructor(normal: Cartesian3, distance: number);
static clone(plane: Plane, result?: Plane): Plane;
static equals(left: Plane, right: Plane): boolean;
static fromCartesian4(coefficients: Cartesian4, result?: Plane): Plane;
static fromPointNormal(point: Cartesian3, normal: Cartesian3, result?: Plane): Plane;
static getPointDistance(plane: Plane, point: Cartesian3): number;
static projectPointOntoPlane(plane: Plane, point: Cartesian3, result?: Cartesian3): Cartesian3;
static transform(plane: Plane, transform: Matrix4, result?: Plane): Plane;
}
class PolygonGeometry {
constructor(options: PolygonGeometry.ConstructorOptions);
packedLength: number;
static createGeometry(polygonGeometry: PolygonGeometry): Geometry;
static fromPositions(options: PolygonGeometry.PositionOptions): PolygonGeometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: PolygonGeometry): PolygonGeometry;
}
namespace PolygonGeometry {
type BaseOptions = {
stRotation?: number;
closeBottom?: boolean;
closeTop?: boolean;
};
type ConstructorOptions = PolygonOutlineGeometry.ConstructorOptions & BaseOptions;
type PositionOptions = PolygonOutlineGeometry.PositionOptions & BaseOptions;
}
class PolygonHierarchy {
holes: PolygonHierarchy[];
positions: Cartesian3[];
constructor(positions?: Cartesian3[], holes?: PolygonHierarchy[]);
}
class PolygonOutlineGeometry {
constructor(options: PolygonOutlineGeometry.ConstructorOptions);
packedLength: number;
static createGeometry(polygonGeometry: PolygonOutlineGeometry): Geometry;
static fromPositions(options: PolygonOutlineGeometry.PositionOptions): PolygonOutlineGeometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: PolygonOutlineGeometry): PolygonOutlineGeometry;
}
namespace PolygonOutlineGeometry {
type BaseOptions = {
ellipsoid?: Ellipsoid;
extrudedHeight?: number;
granularity?: number;
height?: number;
perPositionHeight?: boolean;
};
type ConstructorOptions = BaseOptions & {
polygonHierarchy: PolygonHierarchy;
vertexFormat?: VertexFormat;
};
type PositionOptions = BaseOptions & {
positions: Cartesian3[];
};
}
class PolylineGeometry {
packedLength: number;
constructor(options: PolylineGeometry.ConstructorOptions);
static createGeometry(polylineGeometry: PolylineGeometry): Geometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: PolylineGeometry): PolylineGeometry;
}
namespace PolylineGeometry {
interface ConstructorOptions {
positions: Cartesian3[];
width?: number;
colors?: Color[];
colorsPerVertex?: boolean;
arcType?: ArcType;
granularity?: number;
vertexFormat?: VertexFormat;
ellipsoid?: Ellipsoid;
}
}
class PolylineVolumeGeometry {
packedLength: number;
constructor(options: { polylinePositions: Cartesian3[]; shapePositions: Cartesian2[]; ellipsoid?: Ellipsoid; granularity?: number; vertexFormat?: VertexFormat; cornerType?: CornerType });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: PolylineVolumeGeometry): PolylineVolumeGeometry;
static createGeometry(polylineVolumeGeometry: PolylineVolumeGeometry): Geometry;
}
class PolylineVolumeOutlineGeometry {
packedLength: number;
constructor(options: { polylinePositions: Cartesian3[]; shapePositions: number; ellipsoid?: Ellipsoid; granularity?: number; cornerType?: CornerType });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: PolylineVolumeOutlineGeometry): PolylineVolumeOutlineGeometry;
static createGeometry(polylineVolumeOutlineGeometry: PolylineVolumeOutlineGeometry): Geometry;
}
class QuantizedMeshTerrainData {
waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement;
constructor(options: { quantizedVertices: Uint16Array; indices: Uint16Array | Uint32Array; minimumHeight: number; maximumHeight: number; boundingSphere: BoundingSphere; horizonOcclusionPoint: Cartesian3; westIndices: number[]; southIndices: number[]; eastIndices: number[]; northIndices: number[]; westSkirtHeight: number; southSkirtHeight: number; eastSkirtHeight: number; northSkirtHeight: number; childTileMask?: number; createdByUpsampling?: boolean; encodedNormals?: Uint8Array; waterMask?: Uint8Array });
createMesh(tilingScheme: TilingScheme, x: number, y: number, level: number): Promise<TerrainMesh>;
upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<QuantizedMeshTerrainData>;
interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number;
isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean;
wasCreatedByUpsampling(): boolean;
}
class Quaternion {
x: number;
y: number;
z: number;
w: number;
static packedLength: number;
static packedInterpolationLength: number;
static ZERO: Quaternion;
static IDENTITY: Quaternion;
constructor(x?: number, y?: number, z?: number, w?: number);
clone(result?: Quaternion): Quaternion;
equals(right?: Quaternion): boolean;
equalsEpsilon(right: Quaternion, epsilon: number): boolean;
toString(): string;
static fromAxisAngle(axis: Cartesian3, angle: number, result?: Quaternion): Quaternion;
static fromRotationMatrix(matrix: Matrix3, result?: Quaternion): Quaternion;
static fromHeadingPitchRoll(hpr: 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;
}
class Queue<T> {
readonly length: number;
clear(): void;
contains(item: T): boolean;
dequeue(): T | undefined;
enqueue(item: T): void;
peek(): T | undefined;
sort(compareFunction: Queue.Comparator<T>): void;
}
namespace Queue {
type Comparator<T> = (a: T, b: T) => number;
}
class Ray {
origin: Cartesian3;
direction: Cartesian3;
constructor(origin?: Cartesian3, direction?: Cartesian3);
static getPoint(ray: Ray, t: number, result?: Cartesian3): Cartesian3;
}
class Rectangle {
east: number;
height: number;
north: number;
south: number;
west: number;
width: number;
static MAX_VALUE: Rectangle;
static packedLength: number;
constructor(west?: number, south?: number, east?: number, north?: number);
clone(result?: Rectangle): Rectangle;
equals(other?: Rectangle): boolean;
equalsEpsilon(other: Rectangle, epsilon: number): boolean;
static center(rectangle: Rectangle, result?: Cartographic): Cartographic;
static clone(rectangle: Rectangle, result?: Rectangle): Rectangle;
static computeHeight(rectangle: Rectangle): number;
static computeWidth(rectangle: Rectangle): number;
static contains(rectangle: Rectangle, cartographic: Cartographic): boolean;
static equals(left: Rectangle, right: Rectangle): boolean;
static equalsEpsilon(left: Rectangle, right: Rectangle, absoluteEpsilon: number): boolean;
static expand(rectangle: Rectangle, cartographic: Cartographic, result?: Rectangle): Rectangle;
static fromCartesianArray(cartesians: Cartesian3[], ellipsoid?: Ellipsoid, result?: Rectangle): Rectangle;
static fromCartographicArray(cartographics: Cartographic[], result?: Rectangle): Rectangle;
static fromDegrees(west?: number, south?: number, east?: number, north?: number, result?: Rectangle): Rectangle;
static fromRadians(west?: number, south?: number, east?: number, north?: number, result?: Rectangle): Rectangle;
static intersection(rectangle: Rectangle, otherRectangle: Rectangle, result?: Rectangle): Rectangle | undefined;
static northeast(rectangle: Rectangle, result?: Cartographic): Cartographic;
static northwest(rectangle: Rectangle, result?: Cartographic): Cartographic;
static pack(value: Rectangle, array: number[], startingIndex?: number): number[];
static simpleIntersection(rectangle: Rectangle, otherRectangle: Rectangle, result?: Rectangle): Rectangle | undefined;
static southeast(rectangle: Rectangle, result?: Cartographic): Cartographic;
static southwest(rectangle: Rectangle, result?: Cartographic): Cartographic;
static subsample(rectangle: Rectangle, ellipsoid?: Ellipsoid, surfaceHeight?: number, result?: Cartesian3[]): Cartesian3[];
static union(rectangle: Rectangle, otherRectangle: Rectangle, result?: Rectangle): Rectangle;
static unpack(array: number[], startingIndex?: number, result?: Rectangle): Rectangle;
static validate(rectangle: Rectangle): void;
}
class RectangleGeometry {
static packedLength: number;
constructor(options: { });
static pack(value: BoundingSphere, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: RectangleGeometry): RectangleGeometry;
static createGeometry(rectangleGeometry: RectangleGeometry): Geometry;
}
namespace RectangleGeometry {
interface ConstructorOptions {
rectangle: Rectangle;
vertexFormat?: VertexFormat;
ellipsoid?: Ellipsoid;
granularity?: number;
height?: number;
rotation?: number;
stRotation?: number;
extrudedHeight?: number;
zIndex?: number;
}
}
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;
}
// This is a bad idea because it conflicts with window.Request!
class Request {
cancelFunction: Request.CancelCallback;
priority: number;
priorityFunction: Request.PriorityCallback;
requestFunction: Request.RequestCallback;
readonly state: RequestState;
readonly throttle: boolean;
readonly throttleByServer: boolean;
readonly type: RequestType;
url: string;
clone(result: Request): Request;
}
namespace Request {
type CancelCallback = () => void;
type PriorityCallback = () => number;
type RequestCallback = () => void;
}
class RequestErrorEvent {
statusCode: number;
response: any;
responseHeaders: any;
constructor(statusCode?: number, response?: any, responseHeaders?: string | any);
toString(): string;
}
enum RequestState {
ACTIVE, CANCELLED, FAILED, ISSUED, RECEIVED, UNISSUED,
}
enum RequestType {
IMAGERY, OTHER, TERRAIN, TILES3D,
}
/**
* The various fetch/post methods are declared as always returning a
* Promise, even though technically they may return undefined, because
* it would force a null-check or assert for the 99% case in order to
* cover the 1% case. These functions return undefined only when the
* `request` option is specified (which is described as "internal use
* only"), and this Request has its `throttle` option set, *and* the
* request is actually denied due to throttling. Users who specify a
* throttled request (against the guidance of the documentation!),
* consider yourselves advised to check for undefined responses when
* calling these methods.
*/
class Resource {
constructor(options: Resource.ConstructorOptions);
static readonly DEFAULT: Resource;
static readonly isBlobSupported: boolean;
readonly extension: string;
hasHeaders: boolean;
headers: {[headerName: string]: string};
isBlobUri: boolean;
isCrossOriginUrl: boolean;
isDataUri: boolean;
proxy: DefaultProxy;
readonly queryParameters: Resource.QueryParameters;
request: Request;
retryAttempts: number;
retryCallback: Resource.RetryCallback;
readonly templateValues: {[templateKey: string]: string};
url: string;
static delete(options: string | (Resource.ConstructorOptions & {
responseType?: string;
overrideMimeType?: string;
})): Promise<any>;
static fetch(options: string | (Resource.ConstructorOptions & {
responseType?: string;
overrideMimeType?: string;
})): Promise<any>;
static fetchArrayBuffer(options: string | Resource.ConstructorOptions): Promise<ArrayBuffer>;
static fetchBlob(options: string | Resource.ConstructorOptions): Promise<Blob>;
static fetchImage(options: string | (Resource.ConstructorOptions & {
preferBlob?: boolean;
preferImageBitmap?: boolean;
flipY?: boolean;
})): Promise<HTMLImageElement>;
static fetchJson(options: string | Resource.ConstructorOptions): Promise<any>;
static fetchJsonp(options: string | (Resource.ConstructorOptions & {
callbackParameterName: string;
})): Promise<any>;
static fetchText(options: string | Resource.ConstructorOptions): Promise<string>;
static fetchXML(options: string | Resource.ConstructorOptions): Promise<XMLDocument>;
static head(options: string | (Resource.ConstructorOptions & {
responseType?: string;
overrideMimeType?: string;
})): Promise<any>;
static options(options: string | (Resource.ConstructorOptions & {
responseType?: string;
overrideMimeType?: string;
})): Promise<any>;
static patch(options: string | (Resource.ConstructorOptions & {
data: {};
responseType?: string;
overrideMimeType?: string;
})): Promise<any>;
static post(options: Resource.ConstructorOptions & {
data: {};
responseType?: string;
overrideMimeType?: string;
}): Promise<any>;
static put(options: Resource.ConstructorOptions & {
data: {};
responseType?: string;
overrideMimeType?: string;
}): Promise<any>;
appendForwardSlash(): void;
clone(result?: Resource): Resource;
delete(options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
fetch(options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
fetchArrayBuffer(): Promise<ArrayBuffer>;
fetchBlob(): Promise<Blob>;
fetchImage(options?: {
preferBlob?: boolean;
preferImageBitmap?: boolean;
flipY?: boolean;
}): Promise<HTMLImageElement> | Promise<ImageBitmap>;
fetchJson(): Promise<any>;
fetchJsonp(callbackParameterName: string): Promise<any>;
fetchText(): Promise<string>;
fetchXML(): Promise<XMLDocument>;
getBaseUri(includeQuery?: boolean): string;
getDerivedResource(options: Resource.DerivedOptions): Resource;
getUrlComponent(query?: boolean, proxy?: boolean): string;
head(options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
options(options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
patch(data: any, options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
post(data: any, options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
put(data: any, options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
setQueryParameters(params: Resource.QueryParameters, useAsDefault?: boolean): void;
setTemplateValues(params: {[templateKey: string]: string}, useAsDefault?: boolean): void;
}
namespace Resource {
type QueryValue = string | number | boolean;
interface QueryParameters {
[queryKey: string]: QueryValue | QueryValue[] | undefined;
}
type BaseOptions = {
headers?: {[headerName: string]: string};
proxy?: DefaultProxy;
queryParameters?: QueryParameters;
request?: Request;
retryAttempts?: number;
retryCallback?: Resource.RetryCallback;
templateValues?: {[templateKey: string]: string};
}
type ConstructorOptions = Resource.BaseOptions & {
url: string;
};
type DerivedOptions = Resource.BaseOptions & {
url?: string;
preserveQueryParameters?: boolean;
};
type RetryCallback = (resource: Resource, error: Error) => boolean | Promise<boolean>;
}
class RuntimeError {
name: string;
message: string;
stack: string;
constructor(message?: string);
}
class ScreenSpaceEventHandler {
constructor(element?: HTMLCanvasElement);
setInputAction(action: ScreenSpaceEventAction, type: number, modifier?: number): void;
getInputAction(type: number, modifier?: number): ScreenSpaceEventAction;
removeInputAction(type: number, modifier?: number): void;
isDestroyed(): boolean;
destroy(): void;
}
type ScreenSpaceEventAction = (evt: PositionedEvent | MoveEvent | Touch2Event) => void;
class ShowGeometryInstanceAttribute {
value: Uint8Array;
componentDatatype: ComponentDatatype;
componentsPerAttribute: number;
normalize: boolean;
constructor(show?: boolean);
static toValue(show: boolean, result?: Uint8Array): Uint8Array;
}
class SimplePolylineGeometry {
packedLength: number;
constructor(options: SimplePolylineGeometry.ConstructorOptions);
static createGeometry(simplePolylineGeometry: SimplePolylineGeometry): Geometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: SimplePolylineGeometry): SimplePolylineGeometry;
}
namespace SimplePolylineGeometry {
interface ConstructorOptions {
positions: Cartesian3[];
colors?: Color[];
colorsPerVertex?: boolean;
arcType?: ArcType;
granularity?: number;
ellipsoid?: Ellipsoid;
}
}
class SphereGeometry {
static packedLength: number;
constructor(options?: { radius?: number; stackPartitions?: number; slicePartitions?: number; vertexFormat?: VertexFormat });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: SphereGeometry): SphereGeometry;
static createGeometry(sphereGeometry: SphereGeometry): Geometry;
}
class SphereOutlineGeometry {
static packedLength: number;
constructor(options?: { radius?: number; stackPartitions?: number; slicePartitions?: number; subdivisions?: number });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: SphereOutlineGeometry): SphereOutlineGeometry;
static createGeometry(sphereGeometry: SphereOutlineGeometry): Geometry;
}
class Spherical {
constructor(clock?: number, cone?: number, magnitude?: number);
equals(other: Spherical): boolean;
clone(result?: Spherical): Spherical;
equalsEpsilon(other: Spherical, epsilon: number): boolean;
toString(): string;
static fromCartesian3(cartesian3: Cartesian3, spherical?: Spherical): Spherical;
static clone(spherical: Spherical, result?: Spherical): Spherical;
static normalize(spherical: Spherical, result?: Spherical): Spherical;
static equals(left: Spherical, right: Spherical): boolean;
static equalsEpsilon(left: Spherical, right: Spherical, epsilon?: number): boolean;
}
abstract class Spline {
points: Cartesian3[] | Quaternion[];
times: number[];
private constructor();
clampTime(time: number): number;
abstract evaluate(time: number, result?: Cartesian3 | Quaternion): Cartesian3 | Quaternion | number[];
findTimeInterval(time: number, startIndex: number): number;
wrapTime(time: number): number;
}
class TaskProcessor {
constructor(workerName: string, maximumActiveTasks?: number);
destroy(): void;
initWebAssemblyModule(options: {
modulePath?: string,
wasmBinaryFile?: string,
fallbackModulePath?: string,
}): Promise<any>;
isDestroyed(): boolean;
scheduleTask(parameters: any, transferableObjects?: any[]): Promise<any>;
}
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);
}
abstract class TerrainProvider {
readonly availability: TileAvailability;
readonly credit: Credit;
readonly errorEvent: Event<(prov: this, err: TileProviderError) => void>;
readonly hasVertexNormals: boolean;
readonly hasWaterMask: boolean;
readonly ready: boolean;
readonly readyPromise: Promise<boolean>;
readonly tilingScheme: TilingScheme;
static heightmapTerrainQuality: number;
abstract getLevelMaximumGeometricError(level: number): number;
abstract getTileDataAvailable(x: number, y: number, level: number): boolean;
abstract loadTileDataAvailability(x: number, y: number, level: number): Promise<void> | undefined;
abstract requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
static getEstimatedLevelZeroGeometricErrorForAHeightmap(ellipsoid: Ellipsoid, tileImageWidth: number, numberOfTilesAtLevelZero: number): number;
static getRegularGridIndices(width: number, height: number): Uint16Array;
}
class TileAvailability {
// TODO
}
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;
}
namespace 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: TimeInterval.DataType;
isStartIncluded: boolean;
isStopIncluded: boolean;
isEmpty: boolean;
static EMPTY: TimeInterval;
constructor(options?: TimeInterval.ConstructorOptions);
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?: TimeInterval.DataType }, 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;
}
namespace TimeInterval {
type DataType = {}; // TODO: are there other constraints on this?
type MergeCallback = (leftData: DataType, rightData: DataType) => DataType;
type DataComparer = (leftData: DataType, rightData: DataType) => boolean;
interface ConstructorOptions {
start?: JulianDate;
stop?: JulianDate;
isStartIncluded?: boolean;
isStopIncluded?: boolean;
data?: DataType;
}
}
class TimeIntervalCollection {
readonly changedEvent: Event<(coll: this) => void>;
readonly isEmpty: boolean;
readonly isStartIncluded: boolean;
readonly isStopIncluded: boolean;
readonly length: number;
readonly start: JulianDate;
readonly stop: JulianDate;
constructor(intervals?: TimeInterval[]);
addInterval(interval: TimeInterval, dataComparer?: TimeInterval.DataComparer): void;
contains(julianDate: JulianDate): boolean;
equals(right?: TimeIntervalCollection, dataComparer?: TimeInterval.DataComparer): boolean;
findDataForIntervalContainingDate(date: JulianDate): TimeInterval.DataType | undefined;
findInterval(options?: TimeIntervalCollection.FindOptions): TimeInterval | undefined;
findIntervalContainingDate(date: JulianDate): TimeInterval | undefined;
get(index: number): TimeInterval | undefined;
indexOf(date: JulianDate): number;
intersect(other: TimeIntervalCollection, dataComparer?: TimeInterval.DataComparer, mergeCallback?: TimeInterval.MergeCallback): TimeIntervalCollection;
removeAll(): void;
removeInterval(interval: TimeInterval): void;
static fromIso8601(options: {iso8601: string} & TimeIntervalCollection.HelperOptions, result?: TimeIntervalCollection): TimeIntervalCollection;
static fromIso8601DateArray(options: {iso8601Dates: string[]} & TimeIntervalCollection.HelperOptions, result?: TimeIntervalCollection): TimeIntervalCollection;
static fromIso8601DurationArray(options: {epoch: JulianDate, iso8601Durations: string[]} & TimeIntervalCollection.HelperOptions, result?: TimeIntervalCollection): TimeIntervalCollection;
static fromJulianDateArray(options: {julianDates: JulianDate[]} & TimeIntervalCollection.HelperOptions, result?: TimeIntervalCollection): TimeIntervalCollection;
}
namespace TimeIntervalCollection {
interface HelperOptions {
isStartIncluded?: boolean;
isStopIncluded?: boolean;
leadingInterval?: boolean;
trailingInterval?: boolean;
dataCallback?: DataCallback;
}
type DataCallback = (interval: TimeInterval, index: number) => TimeInterval.DataType;
interface FindOptions {
start?: JulianDate;
stop?: JulianDate;
isStartIncluded?: boolean;
isStopIncluded?: boolean;
}
}
class TranslationRotationScale {
rotation: Quaternion;
scale: Cartesian3;
translation: Cartesian3;
constructor(translation?: Cartesian3, rotation?: Quaternion, scale?: Cartesian3);
equals(right?: TranslationRotationScale): boolean;
}
namespace TrustedServers {
function add(host: string, port: number): void;
function clear(): void;
function contains(url: string): boolean;
function remove(host: string, port: number): void;
}
class VRTheWorldTerrainProvider extends TerrainProvider {
constructor(options: {
url: Resource | string;
ellipsoid?: Ellipsoid;
credit?: Credit | string;
});
getLevelMaximumGeometricError(level: number): number;
getTileDataAvailable(x: number, y: number, level: number): boolean;
loadTileDataAvailability(x: number, y: number, level: number): Promise<void> | undefined;
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 pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: WallGeometry): WallGeometry;
static fromConstantHeights(positions: Cartesian3[], maximumHeight?: number, minimumHeight?: number, ellipsoid?: Ellipsoid): WallGeometry;
static createGeometry(wallGeometry: WallGeometry): Geometry;
}
class WallOutlineGeometry {
packedLength: number;
constructor(options: { positions: Cartesian3[]; granularity?: number; maximumHeights?: number[]; minimumHeights?: number[]; ellipsoid?: Ellipsoid });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: WallOutlineGeometry): WallOutlineGeometry;
static fromConstantHeights(positions: Cartesian3[], maximumHeight?: number, minimumHeight?: number, ellipsoid?: Ellipsoid): WallOutlineGeometry;
static createGeometry(wallGeometry: WallOutlineGeometry): Geometry;
}
class WebMercatorProjection {
ellipsoid: Ellipsoid;
static MaximumLatitude: number;
constructor(ellipsoid?: Ellipsoid);
project(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
unproject(cartesian: Cartesian3, result?: Cartographic): Cartographic;
static mercatorAngleToGeodeticLatitude(mercatorAngle: number): number;
static geodeticLatitudeToMercatorAngle(latitude: number): number;
}
class WebMercatorTilingScheme {
ellipsoid: Ellipsoid;
rectangle: Rectangle;
projection: MapProjection;
constructor(options?: { ellipsoid?: Ellipsoid; numberOfLevelZeroTilesX?: number; numberOfLevelZeroTilesY?: number; rectangleSouthwestInMeters?: Cartesian2; rectangleNortheastInMeters?: Cartesian2 });
getNumberOfXTilesAtLevel(level: number): number;
getNumberOfYTilesAtLevel(level: number): number;
rectangleToNativeRectangle(rectangle: Rectangle, result?: Rectangle): Rectangle;
tileXYToNativeRectangle(x: number, y: number, level: number, result?: any): Rectangle;
tileXYToRectangle(x: number, y: number, level: number, result?: any): Rectangle;
positionToTileXY(position: Cartographic, level: number, result?: Cartesian2): Cartesian2;
}
class BillboardGraphics {
alignedAxis: Property;
color: Property;
readonly definitionChanged: Event;
disableDepthTestDistance: Property;
distanceDisplayCondition: Property;
eyeOffset: Property;
height: Property;
heightReference: Property;
horizontalOrigin: Property;
image: Property;
imageSubRegion: Property;
pixelOffset: Property;
pixelOffsetScaleByDistance: Property;
rotation: Property;
scale: Property;
scaleByDistance: Property;
show: boolean;
sizeInMeters: boolean;
translucencyByDistance: Property;
verticalOrigin: Property;
width: Property;
constructor(options?: BillboardGraphics.ConstructorOptions);
clone(result?: BillboardGraphics): BillboardGraphics;
merge(source: BillboardGraphics): void;
}
namespace BillboardGraphics {
type ConstructorOptions = {
image?: Property | string | HTMLCanvasElement;
show?: Property | boolean;
scale?: Property | number;
horizontalOrigin?: Property | HorizontalOrigin;
verticalOrigin?: Property | VerticalOrigin;
eyeOffset?: Property;
pixelOffset?: Property | Cartesian2;
rotation?: Property;
alignedAxis?: Property;
width?: Property | number;
height?: Property | number;
color?: Property;
scaleByDistance?: Property | NearFarScalar;
translucencyByDistance?: Property | NearFarScalar;
pixelOffsetScaleByDistance?: Property | NearFarScalar;
imageSubRegion?: Property;
disableDepthTestDistance?: Property | number;
heightReference?: Property | HeightReference;
}
}
class BillboardVisualizer {
constructor(scene: Scene, entityCollection: EntityCollection);
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy(): void;
}
class BoxGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
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 {
readonly definitionChanged: Event;
show: Property;
dimensions: Property;
material: MaterialProperty;
fill: Property;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
constructor(options?: BoxGraphics.ConstructorOptions);
clone(result?: BoxGraphics): BoxGraphics;
merge(source: BoxGraphics): void;
}
namespace BoxGraphics {
type ConstructorOptions = {
dimensions?: Property;
show?: Property;
fill?: Property;
material?: MaterialProperty;
outline?: Property;
outlineColor?: Property;
outlineWidth?: Property;
};
}
class CallbackProperty extends Property {
constructor(callback: CallbackProperty.Callback, isConstant: boolean);
equals(other?: Property): boolean;
getValue(time?: JulianDate, result?: any): any;
setCallback(callback: CallbackProperty.Callback, isConstant: boolean): void;
}
namespace CallbackProperty {
type Callback = (time?: JulianDate, result?: any) => any;
}
class CheckerboardMaterialProperty extends MaterialProperty {
evenColor: Property;
oddColor: Property;
repeat: Property;
constructor(options?: { evenColor?: Property; oddColor?: Property; repeat?: Property });
equals(other?: Property): boolean;
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
}
class ColorMaterialProperty extends MaterialProperty {
color: Property;
constructor(color?: Property);
equals(other?: Property): boolean;
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
}
class CompositeEntityCollection {
readonly definitionChanged: Event<EntityCollection.collectionChangedEventCallback>;
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 extends MaterialProperty implements CompositeProperty {
readonly intervals: TimeIntervalCollection;
constructor();
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class CompositePositionProperty extends PositionProperty implements CompositeProperty {
readonly intervals: TimeIntervalCollection;
}
class CompositeProperty extends Property {
readonly intervals: TimeIntervalCollection;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class TimeIntervalCollectionProperty extends CompositeProperty {} // Exact same shape
class ConstantPositionProperty extends Property {
referenceFrame: ReferenceFrame;
constructor(value?: Cartesian3, referenceFrame?: ReferenceFrame);
equals(other?: Property): boolean;
// TODO: Remove `true` when GH #8676 is resolved
getValue(time: JulianDate | true, result?: any): Cartesian3;
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
setValue(value: Cartesian3, referenceFrame?: ReferenceFrame): void;
}
class ConstantProperty extends Property {
constructor(value?: any);
equals(other?: Property): boolean;
getValue(time?: JulianDate, result?: any): any;
setValue(value: any): void;
}
class CorridorGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
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 {
classificationType: Property;
cornerType: Property;
readonly definitionChanged: Event;
distanceDisplayCondition: Property;
extrudedHeight: Property;
extrudedHeightReference: Property;
fill: Property;
granularity: Property;
height: Property;
heightReference: Property;
material: MaterialProperty;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
positions: Property;
shadows: Property;
show: Property;
width: Property;
zIndex: Property;
constructor(options?: CorridorGraphics.ConstructorOptions);
clone(result?: CorridorGraphics): CorridorGraphics;
merge(source: CorridorGraphics): void;
}
namespace CorridorGraphics {
type ConstructorOptions = {
positions?: Property | Cartesian3[];
width?: Property | number;
cornerType?: Property | CornerType;
height?: Property | number;
heightReference?: Property | HeightReference;
extrudedHeight?: Property | number;
extrudedHeightReference?: Property | HeightReference;
show?: Property | boolean;
fill?: Property | boolean;
material?: MaterialProperty | Color;
outline?: Property | boolean;
outlineColor?: Property | Color;
outlineWidth?: Property | number;
granularity?: Property | number;
shadows?: Property | ShadowMode;
distanceDisplayCondition?: Property | DistanceDisplayCondition;
zIndex?: Property | number;
}
}
class CustomDataSource extends DataSource {
constructor(name?: string);
}
class CylinderGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
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 {
readonly definitionChanged: Event;
length: Property;
topRadius: Property;
bottomRadius: Property;
numberOfVerticalLines: Property;
slices: Property;
show: Property;
material: MaterialProperty;
fill: Property;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
constructor(options?: CylinderGraphics.ConstructorOptions);
clone(result?: CylinderGraphics): CylinderGraphics;
merge(source: CylinderGraphics): void;
}
namespace CylinderGraphics {
type ConstructorOptions = {
length?: Property;
topRadius?: Property;
bottomRadius?: Property;
show?: Property;
fill?: Property;
material?: MaterialProperty;
outline?: Property;
outlineColor?: Property;
outlineWidth?: Property;
numberOfVerticalLines?: Property;
slices?: Property;
};
}
class CzmlDataSource extends DataSource {
static updaters: any[];
constructor(name?: string);
process(data: string | CZMLObject, options?: CzmlDataSource.LoadOptions): Promise<CzmlDataSource>;
load(data: Resource | string | CZMLObject, 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;
}
namespace CzmlDataSource {
interface