>;
/**
* Constructor
*/
constructor(prop?: IDbTable);
}
/**
* `DbText` Text entity.
*
*/
export class DbText extends DbEntity {
/** Height. */
height?: number;
/** Rotation angle. */
rotation?: number;
/** Text content, same as contents. */
text?: string;
/** Text content, same as text. */
contents?: string;
/** Position. */
position?: [number, number, number?];
/** Text style. */
textStyle?: string;
/** Horizontal mode. */
horizontalMode?: DbTextHorzMode;
/** Vertical mode. */
verticalMode?: DbTextVertMode;
/**
* Constructor
*/
constructor(prop?: IDbText);
}
export enum DbTextHorzMode {
kTextLeft = 0,
kTextCenter = 1,
kTextRight = 2,
kTextAlign = 3,
kTextMid = 4,
kTextFit = 5
}
/**
* `DbTextStyle` Text style.
*
*/
export class DbTextStyle {
/** Text style name. */
name?: string;
/** Whether shape file. */
isShapeFile?: boolean;
/** Text size. */
textSize?: number;
/** X scale. */
xScale?: number;
/** Prior size for text created with this style. */
priorSize?: number;
/** Obliquing angle. Positive angles tilt right, negative left. Default 0.0. */
obliquingAngle?: number;
/** Font file name. */
fileName?: string;
/** Font. */
typeFace?: string;
/** Whether bold. */
bold?: boolean;
/** Whether italic. */
italic?: boolean;
/** Charset identifier, default 0. */
charset?: number;
/** Pitch and family, default 34. */
pitchAndFamily?: number;
/**
* Constructor
*/
constructor(prop?: IDbTextStyle);
}
export enum DbTextVertMode {
kTextBase = 0,
kTextBottom = 1,
kTextVertMid = 2,
kTextTop = 3
}
/**
* `DbWipeout` Wipeout entity.
*
*/
export class DbWipeout extends DbRasterImage {
/** Coordinates. */
points?: Array<[number, number, number?]>;
/**
* Constructor
*/
constructor(prop?: IDbWipeout);
}
export function decay({ velocity, from, power, timeConstant, restDelta, modifyTarget }: DecayOptions): any;
export interface DecayOptions {
from?: number;
to?: number;
velocity?: number;
power?: number;
timeConstant?: number;
modifyTarget?: (target: number) => number;
restDelta?: number;
}
/**
* deck.gl layer.
*
**/
export class DeckLayer extends Evented implements CustomLayerInterface {
id: string;
deckNs: object;
layer: object;
type: "custom";
renderingMode?: "2d" | "3d" | undefined;
constructor(props: any);
onAdd(map: any, gl: any): void;
onRemove(): void;
setProps(props: any): void;
render(gl: any, matrix: any): void;
}
export const degreesToRadians: (degrees: number) => number;
/**
* Convert degrees to radians
* @param a
* @return {number}
*/
export function degToRad(a: number): number;
/**
* Diffused point.
*/
export class DiffusedApertureMarker extends MarkerBase {
constructor(features: FeatureCollection | {
lngLat: LngLatLike;
text?: string;
}, options?: AnimateMarkerLayerOption);
setMarkersWidth(width: number, index?: number): void;
setMarkersColors(colors: string[], index?: number): void;
_createMarker(): void;
}
type Direction = "start" | "end";
export function distance(a: P, b: P): number;
/**
* Create a div overlay that scales with zoom within a geographic bounds
* Note: For SVG, set viewBox="0 0 width height" preserveAspectRatio="xMinYMin meet", and set updateDivSize option to true
**/
export class DivOverlay {
options: DivOverlayOptions;
_map?: Map;
isShow: boolean;
minZoom: number;
maxZoom: number;
maxPitch: number;
isRemoved: boolean;
parentContainer?: HTMLElement;
constructor(options: DivOverlayOptions);
addTo(map: Map, insertId?: string | HTMLElement): void;
private _isShow;
private _add;
private _remove;
/**
* Set visibility
* @param visible Whether to show
* @param isDisplay If true, use style display to control visibility, DOM stays in document. If false, dynamically add/remove from document
*/
setVisible(visible?: boolean, isDisplay?: boolean): void;
remove(): void;
updateBounds(bounds: [GeoPointLike, GeoPointLike, GeoPointLike, GeoPointLike] | GeoBounds): void;
updateSize(width: number, height: number): void;
private _updateZoom;
private _updateDivSize;
private _adjustCoord;
private _update;
}
export interface DivOverlayOptions {
/** Bounds, four point coordinates */
bounds: [GeoPointLike, GeoPointLike, GeoPointLike, GeoPointLike] | GeoBounds;
/** HTML element */
element: HTMLElement;
/** Element width */
width: number;
/** Element height */
height: number;
/** Maximum zoom level to display */
minZoom?: number;
/** Minimum zoom level to display */
maxZoom?: number;
/** Maximum pitch angle */
maxPitch?: number;
/** Auto-update div size (set true for SVG scaling) */
updateDivSize?: boolean;
/** Max div size when scaling; beyond this, pixel scaling is used */
maxDivSize?: number;
}
export namespace Dom {
export function create(tagName: string, className?: string, container?: HTMLElement): HTMLElement;
export function createNS(namespaceURI: string, tagName: string): Element;
export function disableDrag(): void;
export function enableDrag(): void;
export function setTransform(el: HTMLElement, value: string): void;
export function addEventListener(target: any, type: any, callback: any, options?: {
passive?: boolean;
capture?: boolean;
}): void;
export function removeEventListener(target: any, type: any, callback: any, options?: {
passive?: boolean;
capture?: boolean;
}): void;
export function suppressClick(): void;
export function mousePos(el: HTMLElement, e: MouseEvent | WheelEvent): GeoPoint;
export function touchPos(el: HTMLElement, touches: TouchList): GeoPoint[];
export function mouseButton(e: MouseEvent): number;
export function remove(node: HTMLElement): void;
export function hasClass(el: HTMLElement, name: string): boolean;
export function addClass(el: HTMLElement, name: string): void;
export function removeClass(el: HTMLElement, name: string): void;
export function setClass(el: HTMLElement, name: string): void;
export function getClass(el: HTMLElement): any;
export type Anchor = 'center' | 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
const anchorTranslate: Record;
}
export const Draw: {
/** Tool class. */
Tool: new (options?: IDrawOptions | undefined) => IDrawTool;
/** Default options. */
defaultOptions: () => any;
/** Modes. */
modes: Record;
/** Draw action. */
actionDraw: (map: any, modename: string, options?: Record | undefined) => any;
/** Draw circle action. */
actionDrawCircle: (map: any, options?: Record | undefined) => any;
/** Draw line action. */
actionDrawLineSting: (map: any, options?: Record | undefined) => any;
/** Draw point action. */
actionDrawPoint: (map: any, options?: Record | undefined) => any;
/** Draw polygon action. */
actionDrawPolygon: (map: any, options?: Record | undefined) => any;
/** Draw rectangle action. */
actionDrawRectangle: (map: any, options?: Record | undefined) => any;
/** Draw slant rectangle action. */
actionDrawSlantRectangle: (map: any, options?: Record | undefined) => any;
/** Select entity. For single selection only, set options.selectSingle to true */
actionSelect: (map: any, draw: any, options?: Record | undefined) => any;
};
export type Driver = (update: Update) => DriverControls;
/**
* Drivers accept a update function and call it at an interval. This interval
* could be a synchronous loop, a setInterval, or tied to the device's framerate.
*/
export interface DriverControls {
start: () => void;
stop: () => void;
}
export const easeIn: Easing;
export const easeInOut: Easing;
export const easeOut: Easing;
export type Easing = (v: number) => number;
export type EasingModifier = (easing: Easing) => Easing;
type EdgeWeight = number;
/**
* Create ellipse or elliptic arc with border only
*
**/
export class EllipseEdge extends Polyline {
constructor(options: EllipseEdgeOptions);
addTo(map: Map, beforeId?: string): void;
updateData(): void;
/** Set center point. */
setCenter(value: GeoPointLike, bFocusUpdateData?: boolean): this;
/** Get center point. */
getCenter(): GeoPointLike;
/** Set major axis radius. */
setMajorAxisRadius(value: number, bFocusUpdateData?: boolean): this;
/** Get major axis radius. */
getMajorAxisRadius(): number;
/** Set minor axis radius. */
setMinorAxisRadius(value: number, bFocusUpdateData?: boolean): this;
/** Get minor axis radius. */
getMinorAxisRadius(): number;
/** Set start angle. */
setStartAngle(value: number, bFocusUpdateData?: boolean): this;
/** Get start angle. */
getStartAngle(): number;
/** Set end angle. */
setEndAngle(value: number, bFocusUpdateData?: boolean): this;
/** Get end angle. */
getEndAngle(): number;
/** Set number of discretized points. */
setPoints(value: number, bFocusUpdateData?: boolean): this;
/** Get number of discretized points. */
getPoints(): number;
}
export interface EllipseEdgeOptions extends PolylineOptions {
/** Center point */
center: GeoPointLike;
/** Major axis radius */
majorAxisRadius: number;
/** Minor axis radius */
minorAxisRadius: number;
/** Start angle */
startAngle?: number;
endAngle?: number;
points?: number;
/** Property data */
properties?: object;
}
/**
* Create filled ellipse or elliptic arc
*
**/
export class EllipseFill extends Polygon {
constructor(options: EllipseFillOptions);
addTo(map: Map, beforeId?: string): void;
updateData(): void;
/** Set center point. */
setCenter(value: GeoPointLike, bFocusUpdateData?: boolean): this;
/** Get center point. */
getCenter(): GeoPointLike;
/** Set major axis radius. */
setMajorAxisRadius(value: number, bFocusUpdateData?: boolean): this;
/** Get major axis radius. */
getMajorAxisRadius(): number;
/** Set minor axis radius. */
setMinorAxisRadius(value: number, bFocusUpdateData?: boolean): this;
/** Get minor axis radius. */
getMinorAxisRadius(): number;
/** Set start angle. */
setStartAngle(value: number, bFocusUpdateData?: boolean): this;
/** Get start angle. */
getStartAngle(): number;
/** Set end angle. */
setEndAngle(value: number, bFocusUpdateData?: boolean): this;
/** Get end angle. */
getEndAngle(): number;
/** Set number of discretized points. */
setPoints(value: number, bFocusUpdateData?: boolean): this;
/** Get number of discretized points. */
getPoints(): number;
}
export interface EllipseFillOptions extends PolygonOptions {
/** Center point */
center: GeoPointLike;
/** Major axis radius */
majorAxisRadius: number;
/** Minor axis radius */
minorAxisRadius: number;
/** Start angle */
startAngle?: number;
endAngle?: number;
points?: number;
/** Property data */
properties?: object;
}
/**
* Convert entity color to HTML color
* @param color Entity color
* @param darkMode Whether style is dark mode
* @param alpha Alpha value
* @return {string}
*/
export function entColorToHtmlColor(color: number | string, darkMode?: boolean, alpha?: number): string;
enum EpsgCrsTypes {
Beijing54 = "Beijing54",
Xian80 = "Xian80",
CGCS2000 = "CGCS2000",
Wgs84 = "Wgs84",
Merc3857 = "Merc3857",
NewBeijing54 = "NewBeijing54"
}
export const EPSILON = 1e-8;
/**
* Tests whether or not the arguments have approximately the same value, within an absolute
* or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less
* than or equal to 1.0, and a relative tolerance is used for larger values)
*
* @param {Number} a The first number to test.
* @param {Number} b The second number to test.
* @returns {Boolean} True if the numbers are approximately equal, false otherwise.
*/
export function equals(a: number, b: number): boolean;
export const EVENTS: {
READY_STATE_CHANGE: string;
LOAD_START: string;
PROGRESS: string;
ABORT: string;
ERROR: string;
LOAD: string;
TIMEOUT: string;
LOAD_END: string;
};
export interface Events {
READY_STATE_CHANGE: "readystatechange";
LOAD_START: "loadstart";
PROGRESS: "progress";
ABORT: "abort";
ERROR: "error";
LOAD: "load";
TIMEOUT: "timeout";
LOAD_END: "loadend";
}
export type ExpressionSpecificationEx = Array;
/**
* Given a destination object and optionally many source objects,
* copy all properties from the source objects into the destination.
* The last source object given overrides properties from previous
* source objects.
*
* @param dest destination object
* @param sources sources from which properties are pulled
* @private
*/
export function extend(dest: Object, ...sources: Object[]): Object;
/**
* Feature
*
* https://tools.ietf.org/html/rfc7946#section-3.2
* A Feature object represents a spatially bounded thing.
* Every Feature object is a GeoJSON object no matter where it occurs in a GeoJSON text.
*/
interface Feature extends GeoJSONObject {
type: "Feature";
geometry: G;
/**
* A value that uniquely identifies this feature in a
* https://tools.ietf.org/html/rfc7946#section-3.2.
*/
id?: Id;
/**
* Properties associated with this feature.
*/
properties: P;
}
/**
* Feature Collection
*
* https://tools.ietf.org/html/rfc7946#section-3.3
* A GeoJSON object with the type 'FeatureCollection' is a FeatureCollection object.
* A FeatureCollection object has a member with the name 'features'.
* The value of 'features' is a JSON array. Each element of the array is a Feature object as defined above.
* It is possible for this array to be empty.
*/
interface FeatureCollection extends GeoJSONObject {
type: "FeatureCollection";
features: Array>;
}
/**
* Create extruded polygon.
*
**/
export class FillExtrusion extends OverlayLayerBase {
options: FillExtrusionOptions;
constructor(options: FillExtrusionOptions);
addTo(map: Map, beforeId?: string): void;
/** Replace the current data of the GeoJSON layer.
@param {GeoJSON} [data] GeoJSON object to set. If not provided, defaults to an empty FeatureCollection.
*/
setData(data: PointGeoJsonInput | PointGeoJsonInput[] | GeoJsonGeomertry | GeoPointLike | any): void;
setFillExtrusionOpacity(value: PropertyValueSpecificationEx): this;
getFillExtrusionOpacity(): PropertyValueSpecificationEx;
setFillExtrusionColor(value: DataDrivenPropertyValueSpecification): this;
getFillExtrusionColor(): DataDrivenPropertyValueSpecification;
setFillExtrusionTranslate(value: PropertyValueSpecificationEx<[number, number]>): this;
getFillExtrusionTranslate(): PropertyValueSpecificationEx<[number, number]>;
setFillExtrusionTranslateAnchor(value: PropertyValueSpecificationEx<"map" | "viewport">): this;
getFillExtrusionTranslateAnchor(): PropertyValueSpecificationEx<"map" | "viewport">;
setFillExtrusionPattern(value: DataDrivenPropertyValueSpecification): this;
getFillExtrusionPattern(): DataDrivenPropertyValueSpecification;
setFillExtrusionHeight(value: DataDrivenPropertyValueSpecification): this;
getFillExtrusionHeight(): DataDrivenPropertyValueSpecification;
setFillExtrusionBase(value: DataDrivenPropertyValueSpecification): this;
getFillExtrusionBase(): DataDrivenPropertyValueSpecification;
setFillExtrusionVerticalGradient(value: PropertyValueSpecificationEx): this;
getFillExtrusionVerticalGradient(): PropertyValueSpecificationEx;
}
export type FillExtrusionLayerSpecification = {
id: string;
type: "fill-extrusion";
metadata?: unknown;
source: string;
"source-layer"?: string;
minzoom?: number;
maxzoom?: number;
filter?: FilterSpecification;
layout?: {
visibility?: "visible" | "none";
};
paint?: {
"fill-extrusion-opacity"?: PropertyValueSpecificationEx;
"fill-extrusion-color"?: DataDrivenPropertyValueSpecification;
"fill-extrusion-translate"?: PropertyValueSpecificationEx<[number, number]>;
"fill-extrusion-translate-anchor"?: PropertyValueSpecificationEx<"map" | "viewport">;
"fill-extrusion-pattern"?: DataDrivenPropertyValueSpecification;
"fill-extrusion-height"?: DataDrivenPropertyValueSpecification;
"fill-extrusion-base"?: DataDrivenPropertyValueSpecification;
"fill-extrusion-vertical-gradient"?: PropertyValueSpecificationEx;
};
};
export type FillExtrusionLayerStyleProp = {
metadata?: unknown;
source?: string;
sourceLayer?: string;
minzoom?: number;
maxzoom?: number;
filter?: FilterSpecification;
visibility?: "visible" | "none";
fillExtrusionOpacity?: PropertyValueSpecificationEx;
fillExtrusionColor?: DataDrivenPropertyValueSpecification;
fillExtrusionTranslate?: PropertyValueSpecificationEx<[number, number]>;
fillExtrusionTranslateAnchor?: PropertyValueSpecificationEx<"map" | "viewport">;
fillExtrusionPattern?: DataDrivenPropertyValueSpecification;
fillExtrusionHeight?: DataDrivenPropertyValueSpecification;
fillExtrusionBase?: DataDrivenPropertyValueSpecification;
fillExtrusionVerticalGradient?: PropertyValueSpecificationEx;
};
export interface FillExtrusionOptions extends OverlayLayerBaseOptions {
data: PointGeoJsonInput | PointGeoJsonInput[] | GeoJsonGeomertry | GeoPointLike | any;
fillExtrusionOpacity?: PropertyValueSpecificationEx;
fillExtrusionColor?: DataDrivenPropertyValueSpecification;
fillExtrusionTranslate?: PropertyValueSpecificationEx<[number, number]>;
fillExtrusionTranslateAnchor?: PropertyValueSpecificationEx<"map" | "viewport">;
fillExtrusionPattern?: DataDrivenPropertyValueSpecification;
fillExtrusionHeight?: DataDrivenPropertyValueSpecification;
fillExtrusionBase?: DataDrivenPropertyValueSpecification;
fillExtrusionVerticalGradient?: PropertyValueSpecificationEx;
}
export type FillLayerSpecification = {
id: string;
type: "fill";
metadata?: unknown;
source: string;
"source-layer"?: string;
minzoom?: number;
maxzoom?: number;
filter?: FilterSpecification;
layout?: {
"fill-sort-key"?: DataDrivenPropertyValueSpecification;
visibility?: "visible" | "none";
};
paint?: {
"fill-antialias"?: PropertyValueSpecificationEx;
"fill-opacity"?: DataDrivenPropertyValueSpecification;
"fill-color"?: DataDrivenPropertyValueSpecification;
"fill-outline-color"?: DataDrivenPropertyValueSpecification;
"fill-translate"?: PropertyValueSpecificationEx<[number, number]>;
"fill-translate-anchor"?: PropertyValueSpecificationEx<"map" | "viewport">;
"fill-pattern"?: DataDrivenPropertyValueSpecification;
};
};
export type FillLayerStyleProp = {
metadata?: unknown;
source?: string;
sourceLayer?: string;
minzoom?: number;
maxzoom?: number;
filter?: FilterSpecification;
visibility?: "visible" | "none";
fillSortKey?: DataDrivenPropertyValueSpecification;
fillAntialias?: PropertyValueSpecificationEx;
fillOpacity?: DataDrivenPropertyValueSpecification;
fillColor?: DataDrivenPropertyValueSpecification;
fillOutlineColor?: DataDrivenPropertyValueSpecification;
fillTranslate?: PropertyValueSpecificationEx<[number, number]>;
fillTranslateAnchor?: PropertyValueSpecificationEx<"map" | "viewport">;
fillPattern?: DataDrivenPropertyValueSpecification;
};
export type FilterSpecification = ["has", string] | ["!has", string] | ["==", string, string | number | boolean] | ["!=", string, string | number | boolean] | [">", string, string | number | boolean] | [">=", string, string | number | boolean] | ["<", string, string | number | boolean] | ["<=", string, string | number | boolean] | Array;
/**
* Generate shortest path given all routes, start and end points
* @param startPoint Start point
* @param endPoint End point
* @param lines Coordinates, convert to geometric coordinates before passing
* @param precision Tolerance, decimal places; if distance between two points is less than this value, they are considered the same node
* @param hasDirection Whether to consider direction
*/
export function findShortestPath(startPoint: GeoPoint, endPoint: GeoPoint, lines: Array<{
points: GeoPoint[];
id?: string;
weight?: number;
}>, precision?: number, hasDirection?: boolean): {
startPoint: {
closestLength: number;
closestPoint: GeoPoint;
closestIndex: number;
closestPointIndex: number;
closestPrePointDist: number;
};
endPoint: {
closestLength: number;
closestPoint: GeoPoint;
closestIndex: number;
closestPointIndex: number;
closestPrePointDist: number;
};
route: any[];
routeDetail: {
points: any[];
index: any;
reverse: boolean;
}[];
error?: undefined;
} | {
error: any;
startPoint?: undefined;
endPoint?: undefined;
route?: undefined;
routeDetail?: undefined;
};
/**
* Fluorescent point.
*/
export class FluorescenceMarker extends MarkerBase {
constructor(features: FeatureCollection | {
lngLat: LngLatLike;
text?: string;
}, options?: AnimateMarkerLayerOption);
setMarkersWidth(width: number, index?: number): void;
setMarkersColors(colors: string[], index?: number): void;
_createMarker(): void;
private _setFluorescenceWidth;
private _setFluorescenceColor;
}
export type FogSpecification = {
range?: PropertyValueSpecificationEx<[number, number]>;
color?: PropertyValueSpecificationEx;
"horizon-blend"?: PropertyValueSpecificationEx;
};
export type FormattedSpecification = string;
/**
* @property {Boolean} running - Getter that indicates if animation is running.
* @property {function():void} stop - Stops the animation.
* @property {function():void} start - Starts the animation.
*/
export interface FrameAnimation {
/**
* A getter property that indicates if animation is running.
*/
readonly running: boolean;
/**
* A getter property that indicates if animation is running.
*/
readonly status: FrameAnimationStatus;
/**
* Stops the animation.
*/
stop: () => void;
/**
* Starts the animation.
*/
start: () => void;
/**
* pause the animation.
*/
pause: () => void;
/**
* Frames per second to control speed
*/
changeFps: (fps: number) => void;
}
export enum FrameAnimationStatus {
/** Running. */
Run = 0,
/** Stopped (user called stop). */
Stop = 1,
/** Paused. */
Pause = 2,
/** Ended (callback returned true). */
End = 3
}
/**
* `GeoBounds` Geographic bounds.
*/
export class GeoBounds {
min: GeoPoint;
max: GeoPoint;
constructor(min?: GeoPoint, max?: GeoPoint);
/**
* Create `GeoBounds` from array.
*
* Example:
* ```typescript
* const b = GeoBounds.fromArray([left, bottom, right, top]);
* ```
*/
static fromArray(input: [number, number, number, number]): GeoBounds;
/**
* Create `GeoBounds` from array.
*
* Example:
* ```typescript
* const b = GeoBounds.fromString("[1,2,3,4]");
* ```
*/
static fromString(input: string): GeoBounds;
/**
* Generate bounds from data extent
* @param input
* @return {GeoBounds}
*/
static fromDataExtent(input: GeoJsonGeomertry | GeoPoint | GeoPointLike | GeoPointLike[]): GeoBounds;
/**
* Generate bounds from center point and width, height
* @return {GeoBounds}
* @param center Center point
* @param width Width
* @param height Height, same as width if not provided
*/
static fromCenterWH(center: GeoPointLike, width: number, height?: number): GeoBounds;
/**
* Set bounding box range
*
* @param min Minimum
* @param max Maximum
*/
set(min: GeoPoint, max: GeoPoint): void;
/**
* Get center point
* @return {GeoPoint}
*/
center(): GeoPoint;
/**
* Get top-left corner
* @return {GeoPoint}
*/
leftTop(): GeoPoint;
/**
* Get bottom-left corner
* @return {GeoPoint}
*/
leftBottom(): GeoPoint;
/**
* Get top-right corner
* @return {GeoPoint}
*/
rightTop(): GeoPoint;
/**
* Get bottom-right corner
* @return {GeoPoint}
*/
rightBottom(): GeoPoint;
/**
* Generate a random point
* @return {GeoPoint}
* @param xRatio X-axis range ratio, default 0.6
* @param yRatio Y-axis range ratio, default 0.6
*/
randomPoint(xRatio?: number, yRatio?: number): GeoPoint;
/**
* Generate a random point sequence
* @return {GeoPoint}
* @param xRatio X-axis range ratio, default 0.6
* @param yRatio Y-axis range ratio, default 0.6
* @param minPointCount Minimum point count
* @param maxPointCount Maximum point count
*/
randomPoints(minPointCount: number, maxPointCount: number, xRatio?: number, yRatio?: number): GeoPoint[];
/**
* Generate random GeoJSON point collection
* @return {GeoPoint}
* @param xRatio X-axis range ratio, default 0.6
* @param yRatio Y-axis range ratio, default 0.6
* @param count Point count
* @param propertiesCb Properties callback
*/
randomGeoJsonPointCollection(count: number, xRatio?: number, yRatio?: number, propertiesCb?: (index: number) => Object): GeoJsonGeomertry;
/**
* Generate random GeoJSON line collection
* @return {GeoPoint}
* @param xRatio X-axis range ratio, default 0.6
* @param yRatio Y-axis range ratio, default 0.6
* @param maxLineCount Maximum line count
* @param maxPointCount Maximum points per line
* @param propertiesCb Properties callback
* @param minLineCount Minimum line count (default 1)
* @param minPointCount Minimum points per line (default 2)
*/
randomGeoJsonLineCollection(maxLineCount: number, maxPointCount: number, xRatio?: number, yRatio?: number, propertiesCb?: (index: number) => Object, minLineCount?: number, minPointCount?: number): GeoJsonGeomertry;
/**
* Generate random GeoJSON polygon collection
* @return {GeoPoint}
* @param xRatio X-axis range ratio, default 0.6
* @param yRatio Y-axis range ratio, default 0.6
* @param maxPolygonCount Maximum polygon count
* @param maxPointCount Maximum points per line
* @param propertiesCb Properties callback
* @param minPolygonCount Minimum polygon count (default 1)
* @param minPointCount Minimum points per line (default 3)
*/
randomGeoJsonPolygonCollection(maxPolygonCount: number, maxPointCount: number, xRatio?: number, yRatio?: number, propertiesCb?: (index: number) => Object, minPolygonCount?: number, minPointCount?: number): GeoJsonGeomertry;
/**
* Return array
*
* @returns {Array} The coordinates represented as a array of the format `[minx, miny, maxx, maxy]'`.
*
*/
toArray(): number[];
/**
* Return point array including four vertices
*
* @returns {Array} The coordinates represented as a array of the format `[[minx,maxy], [maxx,maxy], [maxx,miny], [minx,miny]]'`.
*
*/
toPointArray(): Array<[number, number]>;
/**
* Return string.
*
* @returns {string} The coordinates represented as a string of the format `minx, miny, maxx, maxy'`.
*
*/
toString(fixed?: number): string;
/**
* Clone
*
*/
clone(): GeoBounds;
/**
* Make square, equal width and height
* @param isLatlng Whether lat/lng
* @param isMinValue Use min or max of width/height, default max
* @return{GeoBounds}
*/
square(isLatlng?: boolean, isMinValue?: boolean): GeoBounds;
/**
* Get width
*
*/
width(): number;
/**
* Get height
*
*/
height(): number;
/**
* Scale to create new GeoBounds by ratio.
* @param ratio Ratio
* @param origin Base point for scaling, default bounds center
*/
scale(ratio: number, origin?: GeoPoint | null): GeoBounds;
/**
* Scale by XY ratio to create new GeoBounds.
* @param ratioX X ratio
* @param ratioY Y ratio
* @param origin Base point for scaling, default bounds center
*/
scaleXY(ratioX: number, ratioY: number, origin?: GeoPoint | null): GeoBounds;
/**
* Translate bounding box
* @param dx
* @param dy
*/
translate(dx: number, dy: number): void;
/**
* Update bounding box
* @param vertices
*/
update(vertices: GeoPoint[]): void;
/**
* Update bounds from child bounds
* @param bounds
*/
updateByBounds(bounds: GeoBounds[] | GeoBounds): void;
/**
* Intersect two bounding boxes
* @param b
*/
intersect(b: GeoBounds): GeoBounds | null;
/**
* Union of multiple bounding boxes
* @param bound
*/
union(bound: GeoBounds): GeoBounds;
/**
* Check if intersects another bounding box
* @param bound
*/
isIntersect(bound: GeoBounds): boolean;
/**
* Check if one bounds contains another
* @param bound
*/
isContains(bound: GeoBounds): boolean;
/**
* Check if point is in bounding box
* @param point
*/
contains(point: GeoPoint): boolean;
/**
* Returns the value in the interval that is nearest to `targetValue`.
*
* @ignore
* @param interval The interval to find the value within.
* @param targetValue The value to get nearest to.
* @param includeInterior If false, the value will either be [[min]] or [[max]].
* If true, the value may be any number between [[min]] and [[max]].
*/
private closestInterval;
/**
* Find closest point on bounding box and return it.
* @param testPoint Point.
* @param includeInterior If true, closest point can be inside. If false, only on outer edge.
*/
closestPoint(testPoint: GeoPoint, includeInterior?: boolean): GeoPoint;
}
/**
* Create a GeoBounds instance
* @param min
* @param max
*/
export function geoBounds(min?: GeoPoint, max?: GeoPoint): GeoBounds;
/**
* GeoJSON
*
* All GeoJSON objects
*/
type GeoJsonGeomertry = Feature | FeatureCollection | Geometry | GeometryCollection;
/**
* GeoJSON Object
*
* https://tools.ietf.org/html/rfc7946#section-3
* The GeoJSON specification also allows [foreign members](https://tools.ietf.org/html/rfc7946#section-6.1)
* Developers should use '&' type in TypeScript or extend the interface to add these foreign members.
*/
interface GeoJSONObject {
/**
* Specifies the type of GeoJSON object.
*/
type: string;
/**
* Bounding box of the coordinate range of the object's Geometries, Features, or Feature Collections.
* https://tools.ietf.org/html/rfc7946#section-5
*/
bbox?: BBox;
}
export type GeoJSONSourceSpecification = {
type: "geojson";
data?: unknown;
maxzoom?: number;
attribution?: string;
buffer?: number;
filter?: unknown;
tolerance?: number;
cluster?: boolean;
clusterRadius?: number;
clusterMaxZoom?: number;
clusterMinPoints?: number;
clusterProperties?: unknown;
lineMetrics?: boolean;
generateId?: boolean;
promoteId?: PromoteIdSpecificationEx;
};
/**
* Geometry
*
* https://tools.ietf.org/html/rfc7946#section-3
*/
interface Geometry extends GeoJSONObject {
coordinates: Position | Position[] | Position[][] | Position[][][];
}
/**
* GeometryCollection
*
* https://tools.ietf.org/html/rfc7946#section-3.1.8
*
* A GeoJSON object with type 'GeometryCollection' is a Geometry object.
* A GeometryCollection has a member with the name 'geometries'.
* The value of 'geometries' is an array. Each element of this array is a GeoJSON Geometry object.
* It is possible for this array to be empty.
*/
interface GeometryCollection extends GeometryObject {
type: "GeometryCollection";
geometries: Array;
}
/**
* Geometry Object
*
* https://tools.ietf.org/html/rfc7946#section-3
*/
interface GeometryObject extends GeoJSONObject {
type: GeometryTypes;
}
/**
* Point Geometry Object
*
* https://tools.ietf.org/html/rfc7946#section-3.1.2
*/
interface GeometryPoint extends GeometryObject {
type: "GeometryPoint";
coordinates: Position;
}
/**
* GeometryTypes
*
* https://tools.ietf.org/html/rfc7946#section-1.4
* The valid values for the 'type' property of GeoJSON geometry objects.
*/
type GeometryTypes = "GeometryPoint" | "LineString" | "Polygon" | "MultiPoint" | "MultiLineString" | "MultiPolygon" | "GeometryCollection";
/**
* `GeoPoint` Geographic coordinates.
*/
export class GeoPoint {
/**
* Create geographic coordinates from different types {@link GeoPoint}.
*
* Example:
* ```typescript
* const p1 = GeoPoint.convert(new GeoPoint(x, y, z));
* const p2 = GeoPoint.convert([x, y]);
* const p3 = GeoPoint.convert([x, y, z]);
* const p4 = GeoPoint.convert(lng: -73.9749, lat: 40.7736});
* const p5 = GeoPoint.convert(lon: -73.9749, lat: 40.7736});
* ```
*
* @param input - Either [[GeoPointLike]], {@link GeoPointLike}
* or {@link GeoPointLike} object literal.
*/
static convert(input: GeoPointLike): GeoPoint;
/**
* Create `GeoPoint` from string.
*
* Example:
* ```typescript
* const b = GeoPoint.fromString("1,2");
* ```
*/
static fromString(input: string): GeoPoint;
/** Coordinate X. */
x: number;
/** Coordinate Y. */
y: number;
/** Coordinate Z (optional). */
z?: number;
/**
* GeoPoint constructor
*
* @param x - X coordinate.
* @param y - Y coordinate.
* @param z - Z coordinate (optional).
*/
constructor(x: number, y: number, z?: number);
/**
* Clone a coordinate
*
*/
clone(): GeoPoint;
private _add;
/**
* Return array
*
* @returns {Array} The coordinates represeted as an array of x and y.
* ```typescript
* var ll = new vjmap.GeoPoint(-73.9749, 40.7736);
* ll.toArray(); // = [-73.9749, 40.7736]
* ```
*/
toArray(): number[];
/**
* Return string.
* @param fixed
* @returns {string} The coordinates represented as a string of the format `'x, y, z?'`.
* ```typescript
* var ll = new vjmap.GeoPoint(-73.9749, 40.7736);
* ll.toString(); // = "GeoPoint(-73.9749, 40.7736)"
* ```
*/
toString(fixed?: number): string;
/**
* Round to decimal places
* @param fixed
* @return {GeoPoint}
*/
round(fixed?: number): GeoPoint;
roundStr(fixed?: number): string;
/**
* Add two points.
*
* @param p - Point to add.
*/
add(p: GeoPoint): GeoPoint;
private _sub;
/**
* Subtract two points.
*
* @param p - Point to subtract.
*/
sub(p: GeoPoint): GeoPoint;
lengthSq(): number;
private _multByPoint;
/**
* Multiply two points.
*
* @param p - Point to multiply.
*/
multByPoint(p: GeoPoint): GeoPoint;
private _divByPoint;
/**
* Divide two points.
*
* @param p - Point to divide.
*/
divByPoint(p: GeoPoint): GeoPoint;
dot(p: GeoPoint): number;
lerp(v: GeoPoint, alpha: number): this;
private _mult;
/**
* Multiply by coefficient.
*
* @param k - Coefficient.
*/
mult(k: number): GeoPoint;
private _div;
/**
* Divide by coefficient.
*
* @param k - Coefficient.
*/
div(k: number): GeoPoint;
private _rotate;
/**
* Rotate.
*
* @param angle - Radians.
*/
rotate(angle: number): GeoPoint;
private _rotateAround;
/**
* Rotate around a point.
*
* @param angle - Radians.
* @param p - Point to rotate around.
*/
roateAround(angle: number, p: GeoPoint): GeoPoint;
private _matMult;
/**
* Multiply by matrix.
*
* @param m - Matrix value.
*/
matMult(m: number[]): GeoPoint;
private _unit;
/**
* Unit length.
*
*/
unit(): GeoPoint;
private _perp;
/**
* Project [x,y] = [-y, x].
*
*/
perp(): GeoPoint;
private _round;
/**
* Round to integer.
*
*/
roundInt(): GeoPoint;
/**
* Length.
*
*/
mag(): number;
/**
* Check if equal
* @param other Other point
* @param dotErr Decimal places for tolerance, default 8
* @return {boolean}
*/
equals(other: GeoPoint, dotErr?: number): boolean;
/**
* Check equality (including z).
*
*/
equalsZ(other: GeoPoint): boolean;
/**
* Distance between two points.
*
*/
distanceTo(p: GeoPoint): number;
/**
* Squared distance between two points.
*
*/
distSqr(p: GeoPoint): number;
/**
* Angle (radians).
*
*/
angle(): number;
/**
* Angle to a point (radians)
*
*/
angleTo(b: GeoPoint): number;
/**
* Interior angle to a point (radians)
*
*/
angleWith(b: GeoPoint): number;
/**
* Interior angle to a point (radians)
*
*/
angleWithSep(x: number, y: number): number;
/**
* Scale, rotate, translate a point around a base point.
* @param basePt Base point coordinates
* @param destPt Destination coordinates
* @param scale Scale factor, default 1.0
* @param angle Rotation angle, counterclockwise, default 0
* @return {GeoPoint}
*
*/
transform(basePt: GeoPoint, destPt: GeoPoint, scale?: number, angle?: number): this;
}
/**
* Create a GeoPoint instance
* @param input
* @return {GeoPoint}
*/
export function geoPoint(input: GeoPointLike): GeoPoint;
export type GeoPointLike = [number, number] | [number, number, number] | GeoPoint | {
x: number;
y: number;
z?: number;
} | {
lng: number;
lat: number;
} | {
lon: number;
lat: number;
};
/**
* `GeoProjection` Geographic coordinate projection.
*
* Example:
* ```typescript
* const mapExtent = new GeoBounds(new GeoPoint(10, 20), new GeoPoint(80, 90));
* const prj = new GeoProjection(mapExtent);
* const pt = [30, 30];
* const latlng = prj.toLngLat(pt);
* const pt_geo = prj.fromLngLat(latlng);
* const mkt = prj.toMercator(pt);
* const pt_mkt = prj.fromMercator(mkt);
* ```
*/
export class GeoProjection extends Projection {
/** Map geographic extent. */
mapExtent: GeoBounds;
private _ratio_x;
private _ratio_y;
/**
* GeoBounds constructor
*
* @param extent - Map geographic extent.
*/
constructor(extent: GeoBounds);
/**
* Set map extent
*
* @param extent - Map geographic extent.
*/
setExtent(extent: GeoBounds): void;
/**
* Convert coordinates to Mercator (epsg:3857)
* @param input Coordinate point
* @return {[number, number]}
*/
toMercator(input: GeoPointLike): [number, number];
/**
* Convert Mercator (epsg:3857) to coordinates
* @param input Mercator coordinate point
* @return {[number, number]}
*/
fromMercator(input: GeoPointLike): [number, number];
/**
* Convert map coordinates to lat/lng
* @param input Geographic coordinate point
* @return {[number, number]}
*/
toLngLat(input: GeoJsonGeomertry | GeoPoint | GeoPointLike | GeoPointLike[]): LngLatLike;
/**
* Convert lat/lng to map coordinates
* @param input Lat/lng coordinate point
* @return {GeoPoint}
*/
fromLngLat(input: GeoJsonGeomertry | GeoPoint | GeoPointLike | GeoPointLike[]): GeoJsonGeomertry | GeoPoint | GeoPointLike | GeoPointLike[];
/**
* Get map extent
* @return {GeoBounds}
*/
getMapExtent(): GeoBounds;
/**
* Convert distance to meters
* @param dist
*/
toMeter(dist: number): number;
/**
* Convert meters to distance
* @param meter
*/
fromMeter(meter: number): number;
}
/**
* Calculate Bezier curve length
* @param bezierCurve Bezier curve
* @param precision Required precision
* @param recursiveCount Iteration count
*/
export function getBezierCurveLength(bezierCurve: BezierCurve, precision?: number, recursiveCount?: number): number;
/**
* Get discretized polygon GeoJSON for circle or arc
* @param center Center point
* @param radius Radius
* @param points Number of discretized points
* @param startAngle Start angle
* @param endAngle End angle
* @param includeCenterWhenArc For arc, add center point as last point
* @return {{geometry: {coordinates: [number[][]], type: string}, type: string, properties: {}}}
*/
export function getCircleFeature(center: GeoPointLike, radius: number, points?: number, startAngle?: number, endAngle?: number, includeCenterWhenArc?: boolean): GeoJsonGeomertry;
/**
* Get discretized polygon points for circle or arc
* @param center Center point
* @param radius Radius
* @param points Number of discretized points
* @param startAngle Start angle
* @param endAngle End angle
* @param includeCenterWhenArc For arc, add center point as last point
*/
export function getCirclePolygonCoordinates(center: GeoPointLike, radius: number, points?: number, startAngle?: number, endAngle?: number, includeCenterWhenArc?: boolean): number[][];
export function _getEdgeIntersection(a: GeoPoint, b: GeoPoint, code: number, bounds: GeoBounds): GeoPoint;
/**
* Get discretized polygon GeoJSON for circle or arc
* @param center Center point
* @param majorAxisRadius: number,
* @param minorAxisRadius: number,
* @param points Number of discretized points
* @param startAngle Start angle
* @param endAngle End angle
* @param includeCenterWhenArc For arc, add center point as last point
* @return {{geometry: {coordinates: [number[][]], type: string}, type: string, properties: {}}}
*/
export function getEllipseFeature(center: GeoPointLike, majorAxisRadius: number, minorAxisRadius: number, points?: number, startAngle?: number, endAngle?: number, includeCenterWhenArc?: boolean): GeoJsonGeomertry;
/**
* Get discretized polygon points for ellipse or elliptic arc
* @param center Center point
* @param points Number of discretized points
* @param startAngle Start angle
* @param endAngle End angle
* @param includeCenterWhenArc For ellipse/arc, add center as last point
* @param majorAxisRadius Major axis radius
* @param minorAxisRadius Minor axis radius
* @return {any[]}
*/
export function getEllipsePolygonCoordinates(center: GeoPointLike, majorAxisRadius: number, minorAxisRadius: number, points?: number, startAngle?: number, endAngle?: number, includeCenterWhenArc?: boolean): number[][];
/**
* Create `GeoBounds` from bounding rectangle.
*
* Example:
* ```typescript
* const b = vjmap.getEnvelopBounds('POLYGON((3466315.697899 6704304.297588, 3466315.697899 7784496.211226, 4546475.901198 7784496.211226, 4546475.901198 6704304.297588, 3466315.697899 6704304.297588))', prj);
* ```
*/
export function getEnvelopBounds(envelop: string, prj: any): GeoBounds;
/**
* Get EPSG code from coordinates
* @param coordinate Coordinates; for zone-prefixed x, use first 2 digits; or [x,y] or [lng,lat]
* @param crs CRS type to filter results, empty for all
* @param is3DegreeBelt Whether 3-degree zone, to filter results, empty for all
* @returns
*/
function getEpsgCode(coordinate: number | [number, number], crs?: EpsgCrsTypes, is3DegreeBelt?: boolean): {
crs: string;
is3DegreeBelt: boolean;
epsg: string;
proj: string | undefined;
}[];
/**
* Get proj4 parameters from zone and CRS
* @param crs CRS type
* @param lon For Beijing54, Xian80, CGCS2000: 8-digit longitude or zone prefix. Not needed for WGS84/3857
* @returns {null | {epsg: string, proj: string}}
*/
function getEpsgParam(crs: EpsgCrsTypes, lon?: number): {
epsg: string;
proj: string;
} | null;
/**
* Get extent of a GeoJSON
* @param data Input value
* @return {GeoBounds} Extent value
*/
export function getGeoBounds(data: T | string): GeoBounds;
/**
* Get first defined value.
*
* Specialized "replacement" for `a || b || c` used frequently to get value from various sources
* (defaults, configs constants).
* In contrast to `||`, this function provides proper typing for usual use cases (constant as last
* argument) and correct treatment of `null` and `undefined`.
*
* If last parameter is "defined" then return type is `T`, otherwise return type is `T | undefined`.
*
* Usage example:
*
* interface Config {
* x?: number;
* }
* const someConfig: Config = {};
* const val: number | undefined = undefined;
* const DEFAULT = 5;
* const x = getOptionValue(val, someConfig.x, DEFAULT);
* // typeof x === 'number' because DEFAULT is defined
* const y = getOptionValue(val, someConfig.x);
* // typeof y === 'number | undefined' because someConfig.x is possibly undefined
*/
export function getOptionValue(a: T): T;
export function getOptionValue(a: T | undefined, b: T): T;
export function getOptionValue(a: T | undefined, b: T | undefined, c: T): T;
export function getOptionValue(a: T | undefined, b: T | undefined, c: T | undefined, d: T): T;
export function getOptionValue(...values: Array): T | undefined;
/**
* Get proj string from EPSG code
* @param epsg EPSG code e.g. 2346
* @returns
*/
function getProjByEpsgCode(epsg: number): string | undefined;
/**
* Get temporary map ID (temp maps auto-delete when expired)
* @param expireTime Auto-delete time when not viewed, minutes. Default 30
* @param isVisible Whether visible (visible maps in ListMaps). Default invisible
* @return
*/
export function getTempMapId(expireTime?: number, isVisible?: boolean): string;
/**
* Graph data structure with depth-first search and topological sort.
*
* @example
* var graph = Graph()
* .addEdge("s", "t", 10)
* .addEdge("s", "y", 5)
* .addEdge("s", "y", 4)
* .addEdge("t", "y", 2)
* .addEdge("y", "t", 3)
* .addEdge("t", "x", 1)
* .addEdge("y", "x", 9)
* .addEdge("y", "z", 2)
* .addEdge("x", "z", 4)
* .addEdge("z", "x", 6);
* var res = graph.shortestPath("s", "z")
*/
export function Graph(serialized?: Serialized): {
addNode: (node: NodeId) => any;
removeNode: (node: NodeId) => any;
nodes: () => NodeId[];
adjacent: (node: NodeId) => NodeId[];
addEdge: (u: NodeId, v: NodeId, weight?: number | undefined) => any;
removeEdge: (u: NodeId, v: NodeId) => any;
hasEdge: (u: NodeId, v: NodeId) => boolean;
setEdgeWeight: (u: NodeId, v: NodeId, weight: EdgeWeight) => any;
getEdgeWeight: (u: NodeId, v: NodeId) => EdgeWeight;
indegree: (node: NodeId) => number;
outdegree: (node: NodeId) => number;
depthFirstSearch: (sourceNodes?: string[] | undefined, includeSourceNodes?: boolean, errorOnCycle?: boolean) => string[];
hasCycle: () => boolean;
lowestCommonAncestors: (node1: NodeId, node2: NodeId) => string[];
topologicalSort: (sourceNodes?: string[] | undefined, includeSourceNodes?: boolean) => string[];
shortestPath: (source: NodeId, destination: NodeId) => string[] & {
weight?: number | undefined;
};
serialize: () => Serialized;
deserialize: (serialized: Serialized) => any;
};
/**
* Glowing halo.
*/
export class HaloRingMarker extends MarkerBase {
constructor(features: FeatureCollection | {
lngLat: LngLatLike;
text?: string;
}, options?: AnimateMarkerLayerOption);
setMarkersWidth(width: number, index?: number): void;
setMarkersColors(colors: string[], index?: number): void;
_createMarker(): void;
private _createMakerElement;
}
/**
* Create heatmap layer.
*
**/
export class Heatmap extends OverlayLayerBase {
options: HeatmapOptions;
constructor(options: HeatmapOptions);
addTo(map: Map, beforeId?: string): void;
/** Replace the current data of the GeoJSON layer.
@param {GeoJSON} [data] GeoJSON object to set. If not provided, defaults to an empty FeatureCollection.
*/
setData(data: PointGeoJsonInput | PointGeoJsonInput[] | GeoJsonGeomertry | GeoPointLike | any): void;
setHeatmapRadius(value: DataDrivenPropertyValueSpecification): this;
getHeatmapRadius(): DataDrivenPropertyValueSpecification;
setHeatmapWeight(value: DataDrivenPropertyValueSpecification): this;
getHeatmapWeight(): DataDrivenPropertyValueSpecification;
setHeatmapIntensity(value: PropertyValueSpecificationEx): this;
getHeatmapIntensity(): PropertyValueSpecificationEx;
setHeatmapColor(value: ExpressionSpecificationEx): this;
getHeatmapColor(): ExpressionSpecificationEx;
setHeatmapOpacity(value: PropertyValueSpecificationEx): this;
getHeatmapOpacity(): PropertyValueSpecificationEx;
}
export type HeatmapLayerSpecification = {
id: string;
type: "heatmap";
metadata?: unknown;
source: string;
"source-layer"?: string;
minzoom?: number;
maxzoom?: number;
filter?: FilterSpecification;
layout?: {
visibility?: "visible" | "none";
};
paint?: {
"heatmap-radius"?: DataDrivenPropertyValueSpecification;
"heatmap-weight"?: DataDrivenPropertyValueSpecification;
"heatmap-intensity"?: PropertyValueSpecificationEx;
"heatmap-color"?: ExpressionSpecificationEx;
"heatmap-opacity"?: PropertyValueSpecificationEx;
};
};
export type HeatmapLayerStyleProp = {
metadata?: unknown;
source?: string;
sourceLayer?: string;
minzoom?: number;
maxzoom?: number;
filter?: FilterSpecification;
visibility?: "visible" | "none";
heatmapRadius?: DataDrivenPropertyValueSpecification;
heatmapWeight?: DataDrivenPropertyValueSpecification;
heatmapIntensity?: PropertyValueSpecificationEx;
heatmapColor?: ExpressionSpecificationEx;
heatmapOpacity?: PropertyValueSpecificationEx;
};
export interface HeatmapOptions extends OverlayLayerBaseOptions {
data: PointGeoJsonInput | PointGeoJsonInput[] | GeoJsonGeomertry | GeoPointLike | any;
heatmapRadius?: DataDrivenPropertyValueSpecification;
heatmapWeight?: DataDrivenPropertyValueSpecification;
heatmapIntensity?: PropertyValueSpecificationEx;
heatmapColor?: ExpressionSpecificationEx;
heatmapOpacity?: PropertyValueSpecificationEx;
}
/**
* Convert hex string to binary (for collaborative graphics, layer display)
* @param strHex Hex content
* @param isPadding Auto-pad leading zeros, default true
* @param reverse Reverse result, default true
*/
export function hexToBinStr(strHex: string, isPadding?: boolean, reverse?: boolean): string;
export type HillshadeLayerSpecification = {
id: string;
type: "hillshade";
metadata?: unknown;
source: string;
"source-layer"?: string;
minzoom?: number;
maxzoom?: number;
filter?: FilterSpecification;
layout?: {
visibility?: "visible" | "none";
};
paint?: {
"hillshade-illumination-direction"?: PropertyValueSpecificationEx;
"hillshade-illumination-anchor"?: PropertyValueSpecificationEx<"map" | "viewport">;
"hillshade-exaggeration"?: PropertyValueSpecificationEx;
"hillshade-shadow-color"?: PropertyValueSpecificationEx;
"hillshade-highlight-color"?: PropertyValueSpecificationEx;
"hillshade-accent-color"?: PropertyValueSpecificationEx;
};
};
export type HillshadeLayerStyleProp = {
metadata?: unknown;
source?: string;
sourceLayer?: string;
minzoom?: number;
maxzoom?: number;
filter?: FilterSpecification;
visibility?: "visible" | "none";
hillshadeIlluminationDirection?: PropertyValueSpecificationEx;
hillshadeIlluminationAnchor?: PropertyValueSpecificationEx<"map" | "viewport">;
hillshadeExaggeration?: PropertyValueSpecificationEx;
hillshadeShadowColor?: PropertyValueSpecificationEx;
hillshadeHighlightColor?: PropertyValueSpecificationEx;
hillshadeAccentColor?: PropertyValueSpecificationEx;
};
/**
* Convert HTML color to entity color
* @param color html
* @param isEntClr Whether entity color for background display
* @return {number}
*/
export function htmlColorToEntColor(color: string, isEntClr?: boolean): number;
export const httpHelper: {
configure: (opts: Partial) => void;
event: {
READY_STATE_CHANGE: string;
LOAD_START: string;
PROGRESS: string;
ABORT: string;
ERROR: string;
LOAD: string;
TIMEOUT: string;
LOAD_END: string;
};
methods: Methods;
rqeust: (args: Partial) => Promise;
get: (url: string, params?: Record | undefined, args?: Partial> | undefined) => Promise;
put: (url: string, data: any, args?: Partial> | undefined) => Promise;
post: (url: string, data: any, args?: Partial> | undefined) => Promise;
patch: (url: string, data: any, args?: Partial> | undefined) => Promise;
del: (url: string, args?: Partial> | undefined) => Promise;
options: (url: string, args?: Partial> | undefined) => Promise;
};
export interface IAnimateFillLayerOptions extends Omit {
/** Animation image set. */
animateImages?: Array;
/** Speed, default 1. */
speed?: number;
/** Auto-animate on start, default true. */
startAutoAnimation?: boolean;
/** Layer to insert before. */
layerBefore?: string;
}
export interface IAnimateLineLayerOptions extends Omit {
/** Animation image set. */
animateImages?: Array;
/** Speed, default 1. */
speed?: number;
/** Auto-animate on start, default true. */
startAutoAnimation?: boolean;
/** Layer to insert before. */
layerBefore?: string;
}
export interface IAnimateSymbolLayerOptions extends Omit {
/** Animation image set. */
animateImages?: Array;
/** Speed, default 1. */
speed?: number;
/** Auto-animate on start, default true. */
startAutoAnimation?: boolean;
/** Layer to insert before. */
layerBefore?: string;
}
export interface IAnimateVectorLayerOptions {
/** Animation image set. */
animateImages?: Array;
/** Speed, default 1. */
speed?: number;
/** Auto-animate on start, default true. */
startAutoAnimation?: boolean;
}
export interface IAnimateVectorLayerResult {
/** Start animation function. */
startAnimation: () => void;
/** End animation function. */
stopAnimation: () => void;
/** Remove. */
remove: () => void;
/** Set speed. */
setSpeed: (speed: number) => void;
/** Update animation image set. */
updateImages: (images: Array) => void;
}
/**
* Combine new map parameters
*/
export interface IComposeNewMap {
/** Map ID. */
mapid: string;
/** Map version (empty uses current). */
version?: string;
/** Map clip bounds [x1,y1,x2,y2]; empty for no clip */
clipbounds?: [number, number, number, number];
/** Include or intersect (default false=include, true=intersect) */
selByCrossing?: boolean;
/** Four params (dx, dy, scale, rotate); optional coordinate correction */
fourParameter?: [number, number, number, number];
/** Use inverse of four params above, default false */
isInverseFourParamter?: boolean;
/** Layer names to display; empty for all */
layers?: string[];
/** Layer name prefix for new map; null for no default. Without prefix, layer name conflicts may cause different rendering with ByLayer */
layerPrefix?: string;
/** Layer name suffix for new map */
layerSuffix?: string;
/** File name to save; empty for auto-generate from params */
savefilename?: string;
/** Clean drawing data after generation to reduce DWG file size */
purge?: boolean;
/** When entities from other maps: auto-rename if block definition exists, default true */
isRenameBlockNameIfExist?: boolean;
/** Zoom to extent after creation, default false (for multi-map merge, set only for first) */
isZoomExtents?: boolean;
/** CAD version for export; * for current CAD version */
cadVersion?: string | "*" | "cad2000" | "cad2004" | "cad2007" | "cad2010" | "cad2013" | "cad2018";
}
/**
* Conditional query entity parameters
*/
export interface IConditionQueryFeatures extends IQueryBaseFeatures {
/** Condition. */
condition: string;
/** Bounds or point coordinate array */
bounds?: [number, number, number, number] | [number, number][];
/** Get intersection points; valid when bounds is point array, default false */
isGetIntersections?: boolean;
/** Record start position. */
beginpos?: number;
/** Return geometry data; for performance, when realgeom=false: >1 returns bbox only, =1 returns real GeoJSON; realgeom=true returns GeoJSON for each */
includegeom?: boolean;
/** Return real entity geometry GeoJSON. Use with includegeom. See includegeom usage */
realgeom?: boolean;
/** Containment: true=contain, false=intersect, default false. (Valid when bounds query) */
isContains?: boolean;
}
export interface ICreateAnimateImagesOptions {
/** Tile width (power of 2, e.g. 2,4,8,16,32...). Default 64 */
canvasWidth?: number;
/** Tile height (power of 2, e.g. 2,4,8,16,32...). Default 32 */
canvasHeight?: number;
/** Draw content callback (draw first frame only; other frames auto-calculated from direction and count). */
draw?: (context: CanvasRenderingContext2D, width: number, height: number, opts: ICreateAnimateImagesOptions) => void;
/** Per-frame callback (called each frame; conflicts with draw; if set, draw is ignored). */
drawFrame?: (context: CanvasRenderingContext2D, width: number, height: number, frameCount: number, curFrameIndex: number, opts: ICreateAnimateImagesOptions) => void;
/** Number of animation frames to generate. Default 2 */
frameCount?: number;
/** Whether direction is reversed. */
directionReverse?: boolean;
/** Generate animation image set in Y direction. */
yAxis?: boolean;
/** Source image. */
fromImage?: HTMLImageElement;
/** Sprite width in source image. */
spriteWidth?: number;
/** Sprite height in source image. */
spriteHeight?: number;
/** Start index in generated animation set. Default 0 */
from?: number;
/** End index in generated animation set. Default last */
to?: number;
/** Other data. */
[key: string]: any;
}
export interface ICreateAnimateLayerResult {
/** Data source ID. */
sourceId: string;
/** Layer ID. */
layerId: string;
/** Start animation function. */
startAnimation: () => void;
/** End animation function. */
stopAnimation: () => void;
/** Remove. */
remove: () => void;
/** Set speed. */
setSpeed: (speed: number) => void;
/** Update data. */
updateData: (input: LineGeoJsonInput | LineGeoJsonInput[] | GeoJsonGeomertry | GeoPointLike[] | any) => void;
/** Update animation image set. */
updateImages: (images: Array) => void;
/** Create animated image set. */
createAnimateImages: (options: ICreateAnimateImagesOptions) => Array;
}
export interface ICreateAntPathAnimateLineLayerOptions extends IAnimateLineLayerOptions, ICreateAnimateImagesOptions {
/** Fill background color 1. */
fillColor1?: string | CanvasGradient | CanvasPattern;
/** Fill background color 1. */
fillColor2?: string | CanvasGradient | CanvasPattern;
}
export interface ICreateArrowAnimateLineLayerOptions extends IAnimateLineLayerOptions, ICreateAnimateImagesOptions {
/** Arrow fill background color. */
arrowFillColor?: string | CanvasGradient | CanvasPattern;
/** Arrow color. */
arrowStrokeColor?: string | CanvasGradient | CanvasPattern;
/** Arrow line width. */
arrowStrokeWidth?: number;
/** Arrow width (default half of canvas). */
arrowWidth?: number;
}
/**
* Get geometry data for creating entities
*/
export interface ICreateEntitiesGeomData {
/** File document. */
filedoc: string;
/** Drawing extent; empty for full map extent */
mapBounds?: [number, number, number, number];
/** Render precision, default 1. For large drawings with rough arcs, clear cache and re-upload with higher precision. Note: higher precision increases file size and reduces performance */
renderAccuracy?: number;
/** Exclude attribute data from result (default true) */
excludeAttribute?: boolean;
/** Enable zip compression for result (default true) */
useZip?: boolean;
}
export interface ICreateFillAnimateLayerResult extends ICreateAnimateLayerResult {
polygon: Polygon;
}
export interface ICreateLineAnimateLayerResult extends ICreateAnimateLayerResult {
polyline: Polyline;
}
export interface ICreateSymbolAnimateLayerResult extends ICreateAnimateLayerResult {
symbol: Symbol_2;
}
/**
* Id
*
* https://tools.ietf.org/html/rfc7946#section-3.2
* If a Feature has a commonly used identifier, that identifier SHOULD be included as a member of
* the Feature object with the name 'id', and the value of this member is either a JSON string or number.
*/
type Id = string | number;
/**
* 2D polyline entity type interface
*/
export interface IDb2dPolyline extends IDbCurve {
/** Whether closed. */
closed?: boolean;
/** Elevation. */
elevation?: number;
/** 2D polyline type */
polyType?: Poly2dType;
/** Coordinates. */
points?: Array<[number, number, number?]>;
}
/**
* Angular dimension [two lines] entity type interface
*/
export interface IDb2LineAngularDimension extends IDbDimension {
/** Arc point position. */
arcPoint?: Array<[number, number, number?]>;
/** Line 1 start point. */
xLine1Start?: Array<[number, number, number?]>;
/** Line 1 end point. */
xLine1End?: Array<[number, number, number?]>;
/** Line 2 start point. */
xLine2Start?: Array<[number, number, number?]>;
/** Line 2 end point. */
xLine2End?: Array<[number, number, number?]>;
}
/**
* 3D polyline entity type interface
*/
export interface IDb3dPolyline extends IDbCurve {
/** Whether closed. */
closed?: boolean;
/** 3D polyline type */
polyType?: Poly3dType;
/** Coordinates. */
points?: Array<[number, number, number?]>;
}
/**
* Angular dimension [three points] entity type interface
*/
export interface IDb3PointAngularDimension extends IDbDimension {
/** Arc point position. */
arcPoint?: Array<[number, number, number?]>;
/** Center point. */
centerPoint?: Array<[number, number, number?]>;
/** Point 1. */
xLine1Point?: Array<[number, number, number?]>;
/** Point 2. */
xLine2Point?: Array<[number, number, number?]>;
}
/**
* Aligned dimension entity type interface
*/
export interface IDbAlignedDimension extends IDbDimension {
/** Line 1 point. */
xLine1Point?: Array<[number, number, number?]>;
/** Line 2 point. */
xLine2Point?: Array<[number, number, number?]>;
/** WCS point defining dimension line position. */
dimLinePoint?: Array<[number, number, number?]>;
/** Symbol height for this entity. */
jogSymbolHeight?: number;
}
/**
* Arc entity type interface
*/
export interface IDbArc extends IDbCurve {
/** Center coordinates. */
center?: [number, number, number?];
/** Radius. */
radius?: number;
/** Start angle (radians). */
startAngle?: number;
/** End angle (radians). */
endAngle?: number;
/** Thickness. */
thickness?: number;
/** Normal vector. */
normal?: [number, number, number?];
}
/**
* Arc dimension entity type interface
*/
export interface IDbArcDimension extends IDbDimension {
/** Line 1 point. */
xLine1Point?: Array<[number, number, number?]>;
/** Line 2 point. */
xLine2Point?: Array<[number, number, number?]>;
/** Center point. */
centerPoint?: Array<[number, number, number?]>;
/** Arc point. */
arcPoint?: Array<[number, number, number?]>;
/** Arc symbol type in text. 0 arc symbol before text; 1 arc symbol above text; 2 no symbol. */
arcSymbolType?: number;
}
/**
* Block definition interface
*/
export interface IDbBlock {
/** Block name. */
name?: string;
/** Scaling reference for this block. */
scaling?: number;
/** Block insert units for this block. */
insertUnits?: number;
/** Origin. */
origin?: Array<[number, number, number?]>;
/** Comments. */
comments?: string;
/** Whether explodable. */
explodable?: boolean;
/** Entities created from. */
entitys?: IDbEntity[];
}
/**
* Block reference entity type interface
*/
export interface IDbBlockReference extends IDbEntity {
/** Block name. */
blockname?: string;
/** External drawing reference, format mapid/version, e.g. exam/v1. */
ref?: string;
/** Coordinates. */
position?: [number, number, number?];
/** Normal vector. */
normal?: [number, number, number?];
/** Rotation angle. */
rotation?: number;
/** Scale factor. */
scaleFactors?: number;
}
/**
* Circle entity type interface
*/
export interface IDbCircle extends IDbCurve {
/** Center coordinates. */
center?: [number, number, number?];
/** Radius. */
radius?: number;
/** Thickness. */
thickness?: number;
/** Normal vector. */
normal?: [number, number, number?];
}
/**
* Curve entity type interface
*/
export interface IDbCurve extends IDbEntity {
}
/**
* Diametric dimension entity type interface
*/
export interface IDbDiametricDimension extends IDbDimension {
/** Point 1 on circle. */
chordPoint?: Array<[number, number, number?]>;
/** Point 2 on circle. */
farChordPoint?: Array<[number, number, number?]>;
/** Leader length. */
leaderLength?: number;
}
/**
* Dimension entity type interface
*/
export interface IDbDimension extends IDbEntity {
/** Dimension style. */
dimStyle?: string;
/** Text position. */
textPosition?: Array<[number, number, number?]>;
}
/**
* Dimension style interface
*/
export interface IDbDimStyle {
/** Style name. */
name?: string;
/** Text style name. */
textStyle?: string;
/** Dimension line arrow block display. */
dimsah?: boolean;
/** 符号和箭头1 .“” 实心闭合,“_DOT” 点,“_DOTSMALL” 小点,“_DOTBLANK” 空心点,“_ORIGIN” 指示原点,“_ORIGIN2” 指示原点 2,“_OPEN” 打开,“_OPEN90” 直角,“_OPEN30” 30 度角,“_CLOSED” 闭合,“_SMALL” 空心小点,“_NONE” 无,“_OBLIQUE” 倾斜,“_BOXFILLED” 填充框,“_BOXBLANK” 框,“_CLOSEDBLANK” 空心闭合,“_DATUMFILLED” 实心基准三角形,“_DATUMBLANK” 基准三角形,“_INTEGRAL” 完整标记,“_ARCHTICK” 建筑标记*/
dimblk1?: string;
/** Symbol and arrow 2. Same as dimblk1 */
dimblk2?: string;
}
/**
* DB document definition interface
*/
export interface IDbDocument {
/** Source map to modify/add/delete on, format mapid/version, e.g. exam/v1. */
from?: string;
/** Entity set. */
entitys?: IDbEntity[];
/** Layer set. */
layers?: IDbLayer[];
/** Text style. */
textStyles?: IDbTextStyle[];
/** Dimension style. */
dimStyles?: IDbDimStyle[];
/** Linetype. */
linetypes?: IDbLinetype[];
/** Block definition. */
blocks?: IDbBlock[];
}
/**
* Ellipse entity type interface
*/
export interface IDbEllipse extends IDbCurve {
/** Center coordinates. */
center?: [number, number, number?];
/** Major axis direction. */
minorAxis?: [number, number, number?];
/** Start angle (radians). */
startAngle?: number;
/** End angle (radians). */
endAngle?: number;
/** Ratio of minor to major axis. */
radiusRatio?: number;
}
/**
* Entity type interface
*/
export interface IDbEntity {
/** Type. */
typename?: string;
/** Color. */
color?: number;
/** Color index. */
colorIndex?: number;
/** Layer. */
layer?: string;
/** Linetype. */
linetype?: string;
/** Linetype scale. */
linetypeScale?: number;
/** Line width. */
lineWidth?: number;
/** Transparency [0-255]. 0 fully transparent, 255 fully opaque */
alpha?: number;
/** Visible. */
visibility?: boolean;
/** Matrix. */
matrix?: IDbMatrixOp[];
/** Extended data. */
xdata?: string;
/** Entity handle; if provided, modifies this entity. */
objectid?: string;
/** Whether to delete this entity. */
delete?: boolean;
}
/**
* Hatch entity type interface
*/
export interface IDbHatch extends IDbEntity {
/** Elevation. */
elevation?: number;
/** Hatch pattern, default SOLID */
pattern?: string;
/** Coordinates. */
points?: Array<[number, number, number?]>;
}
/**
* Layer interface
*/
export interface IDbLayer {
/** Layer name. */
name?: string;
/** Layer color index. */
color?: number;
/** Layer linetype, default CONTINUOUS. */
linetype?: string;
}
/**
* Line entity type interface
*/
export interface IDbLine extends IDbEntity {
/** Start point. */
start?: [number, number, number?];
/** End point. */
end?: [number, number, number?];
/** Thickness. */
thickness?: number;
}
/**
* Linetype interface
*/
export interface IDbLinetype {
/** Linetype name. */
name?: string;
/** Comments. */
comments?: string;
/** Linetype style. */
style?: IDbLinetypeStyle[];
}
/**
* Linetype style interface
*/
export interface IDbLinetypeStyle {
/** Method. */
method?: IDbLinetypeStyleMethod;
/** Parameters. */
parameter?: string;
}
export enum IDbLinetypeStyleMethod {
/** [int count] . */
numDashes = "numDashes",
/** [double dPatLen] . */
patternLength = "patternLength",
/** [int dashIndex, double dashLength ]. */
dashLengthAt = "dashLengthAt",
/** [int dashIndex, string idTextStyle] . */
shapeStyleAt = "shapeStyleAt",
/** [int dashIndex, [int, int] shapeOffset] . */
shapeOffsetAt = "shapeOffsetAt",
/** [int dashIndex, string textString] . */
textAt = "textAt",
/** [ int dashIndex, double shapeScale] . */
shapeScaleAt = "shapeScaleAt",
/** [int dashIndex, int shapeNumber] . */
shapeNumberAt = "shapeNumberAt",
/** [int dashIndex, double shapeRotation] . */
shapeRotationAt = "shapeRotationAt",
/** [ bool bScaleToFit] . */
isScaledToFit = "isScaledToFit"
}
/**
* Matrix operation interface
*/
export interface IDbMatrixOp {
/** Operation name. */
op?: IDbMatrixOpName;
/** Translation vector. */
vector?: [number, number, number?];
/** Scale size. */
scale?: number;
/** Rotation angle (radians). */
angle?: number;
/** Origin point. */
origin?: [number, number, number?];
}
export enum IDbMatrixOpName {
/** Translate. */
translation = "translation",
/** Scale. */
scale = "scale",
/** rotate. */
rotate = "rotate"
}
/**
* Multi-line text entity type interface
*/
export interface IDbMText extends IDbEntity {
/** Width. */
width?: number;
/** Height. */
height?: number;
/** Rotation angle. */
rotation?: number;
/** Text height. */
textHeight?: number;
/** Text content. */
contents?: string;
/** Position. */
location?: [number, number, number?];
/** Alignment. */
attachment?: MTextAttachmentPoint;
/** Text style. */
textStyle?: string;
}
/**
* Ordinate dimension entity type interface
*/
export interface IDbOrdinateDimension extends IDbDimension {
/** Origin point. */
origin?: Array<[number, number, number?]>;
/** Defining point. */
definingPoint?: Array<[number, number, number?]>;
/** Leader point. */
leaderEndPoint?: Array<[number, number, number?]>;
/** Whether to use X axis. */
useXAxis?: boolean;
}
/**
* Entity basic properties
*/
/**
* Coordinate type interface
*/
export type IDbPoint = [number, number, number?];
/**
* Polyline entity type interface
*/
export interface IDbPolyline extends IDbCurve {
/** Whether closed. */
closed?: boolean;
/** Elevation. */
elevation?: number;
/** Coordinates. */
points?: Array<[number, number, number?]>;
/** Bulge. */
bulge?: number[];
/** Start width. */
startWidth?: number[];
/** End width. */
endWidth?: number[];
}
/**
* Radial dimension entity type interface
*/
export interface IDbRadialDimension extends IDbDimension {
/** Center point. */
center?: Array<[number, number, number?]>;
/** Point on circle. */
chordPoint?: Array<[number, number, number?]>;
/** Leader length. */
leaderLength?: number;
}
/**
* Radial dimension large entity type interface
*/
export interface IDbRadialDimensionLarge extends IDbDimension {
/** Center point. */
center?: Array<[number, number, number?]>;
/** Point on circle. */
chordPoint?: Array<[number, number, number?]>;
/** WCS override center for arc determined by this dimension. */
overrideCenter?: Array<[number, number, number?]>;
/** Jog point for this dimension. */
jogPoint?: Array<[number, number, number?]>;
/** Jog angle for this dimension. */
jogAngle?: number;
}
/**
* Raster image entity type interface
*/
export interface IDbRasterImage extends IDbEntity {
/** Brightness [0.0 .. 100.0] */
brightness?: number;
/** Image URL. */
sourceHttpUrl?: string;
/** Source image width. */
pixelWidth?: number;
/** Source image height. */
pixelHeight?: number;
/** Units. */
units?: RasterImageUnits;
/** X pixels per unit. */
xPelsPerUnit?: number;
/** Y pixels per unit. */
yPelsPerUnit?: number;
/** Width. */
width?: number;
/** Height. */
height?: number;
/** Position. */
position?: [number, number, number?];
/** Whether to display. */
imageDisplayOptShow?: boolean;
/** Whether to clip. */
imageDisplayOptClip?: boolean;
/** Whether aligned. */
imageDisplayOptShowUnAligned?: boolean;
/** Whether transparent. */
imageDisplayOptTransparent?: boolean;
}
/**
* Rotated dimension entity type interface
*/
export interface IDbRotatedDimension extends IDbDimension {
/** Point 1 on line. */
xLine1Point?: Array<[number, number, number?]>;
/** Point 2 on line. */
xLine2Point?: Array<[number, number, number?]>;
/** WCS point defining dimension line position. */
dimLinePoint?: Array<[number, number, number?]>;
}
/**
* Shape entity type interface
*/
export interface IDbShape extends IDbEntity {
/** Rotation angle. */
rotation?: number;
/** Position. */
position?: [number, number, number?];
/** Size. */
size?: number;
/** Normal vector. */
normal?: [number, number, number?];
/** Shape name. */
name?: string;
}
/**
* Spline entity type interface
*/
export interface IDbSpline extends IDbCurve {
/** the curve fitting tolerance for this Spline entity. */
fitTol?: number;
/** Increased the degree of this spline to the specified value. */
degree?: number;
/** Fit points. */
fitPoints?: Array<[number, number, number?]>;
/** Control points. */
controlPoints?: Array<[number, number, number?]>;
}
/**
* Table entity type interface
*/
export interface IDbTable extends IDbBlockReference {
/** Table style name. */
tableStyleName?: string;
/** Number of columns. */
numColumns?: number;
/** Number of rows. */
numRows?: number;
/** Column width. */
columnWidth?: number;
/** Row height. */
rowHeight?: number;
/** Total table width. */
width?: number;
/** Total table height. */
height?: number;
/** Whether to disable title. */
disableTitle?: boolean;
/** Whether table direction is bottom to top. */
directionBottomToTop?: boolean;
/** Text height (all cells). */
textHeight?: number;
/** Grid visibility. 2nd param (kHorzTop(1), kHorzInside(2), kHorzBottom(4), kVertLeft(8), kVertInside(16), kVertRight(32)); 3rd param kTitleRow(1), kHeaderRow(2), kDataRow(4) */
gridVisibility?: [boolean, number, number];
/** Background color (all cells). */
backgroundColor?: number;
/** Text color (all cells). */
contentColor?: number;
/** Grid line color (all cells). */
gridColor?: number;
/** Cell alignment (all cells). */
alignment?: TableCellAlignment;
/** Horizontal cell margin. */
horzCellMargin?: number;
/** Vertical cell margin. */
vertCellMargin?: number;
/** Cells to merge [[minRow, maxRow, minColumn, maxColumn], ...] */
mergeCells?: Array<[number, number, number, number]>;
/** Data. */
data?: Array>;
}
/**
* Single-line text entity type interface
*/
export interface IDbText extends IDbEntity {
/** Height. */
height?: number;
/** Rotation angle. */
rotation?: number;
/** Text content, same as contents. */
text?: string;
/** Text content, same as text. */
contents?: string;
/** Width factor. */
widthFactor?: number;
/** Position. */
position?: [number, number, number?];
/** Text style. */
textStyle?: string;
/** Horizontal mode. */
horizontalMode?: DbTextHorzMode;
/** Vertical mode. */
verticalMode?: DbTextVertMode;
}
/**
* Text style interface
*/
export interface IDbTextStyle {
/** Text style name. */
name?: string;
/** Whether shape file. */
isShapeFile?: boolean;
/** Text size. */
textSize?: number;
/** X scale. */
xScale?: number;
/** Prior size for text created with this style. */
priorSize?: number;
/** Obliquing angle. Positive angles tilt right, negative left. Default 0.0. */
obliquingAngle?: number;
/** Font file name. */
fileName?: string;
/** Font. */
typeFace?: string;
/** Whether bold. */
bold?: boolean;
/** Whether italic. */
italic?: boolean;
/** Charset identifier, default 0. */
charset?: number;
/** Pitch and family, default 34. */
pitchAndFamily?: number;
}
/**
* Wipeout entity type interface
*/
export interface IDbWipeout extends IDbRasterImage {
/** Coordinates. */
points?: Array<[number, number, number?]>;
}
/**
* Clear map cache interface
*/
export interface IDeleteCache {
/** Map ID (empty for current). */
mapid?: string;
/** Map version (empty for current; "*" to clear all). */
version?: string;
/** Match key. */
key?: string;
}
/**
* Delete map style interface
*/
export interface IDeleteStyle {
/** Map ID (empty for current). */
mapid?: string;
/** Map version (empty for current; "*" to delete all). */
version?: string;
/** Style name. "*"=all; "a*"=system; "m*"=memory; "s*"=geometry */
styleid: string;
/** Clear data only: false=delete table and data; true=delete data only. */
onlycleardata: boolean;
}
export interface IDraw {
/** Tool class. */
Tool: new (options?: IDrawOptions) => IDrawTool;
/** Default options. */
defaultOptions: () => any;
/** Modes. */
modes: Record;
/** Draw action. */
actionDraw: (map: any, modename: string, options?: Record) => any;
/** Draw circle action. */
actionDrawCircle: (map: any, options?: Record) => any;
/** Draw line action. */
actionDrawLineSting: (map: any, options?: Record) => any;
/** Draw point action. */
actionDrawPoint: (map: any, options?: Record) => any;
/** Draw polygon action. */
actionDrawPolygon: (map: any, options?: Record) => any;
/** Draw rectangle action. */
actionDrawRectangle: (map: any, options?: Record) => any;
/** Draw slant rectangle action. */
actionDrawSlantRectangle: (map: any, options?: Record) => any;
/** Select entity. For single selection only, set options.selectSingle to true */
actionSelect: (map: any, draw: any, options?: Record) => any;
}
export interface IDrawOptions {
addControls?: any[];
controls?: Record;
guides?: boolean;
modes?: Record;
snap?: boolean;
midpoints?: boolean;
api: {
getSnapFeatures: any;
[key: string]: any;
};
snapOptions: {
snapGridPx?: number;
snapPx?: number;
snapToMidPoints?: boolean;
snapVertexPriorityDistance?: number;
};
styles?: any[];
userProperties?: boolean;
[key: string]: any;
}
export interface IDrawTool {
/** Adds GeoJSON Feature, FeatureCollection or Geometry to Draw. Returns id array for interaction. Auto-generates id if missing. */
add: (geojson: any) => Array;
/** Change draw to another mode. Returns draw instance for chaining. */
changeMode: (mode: string, modeOptions?: any) => IDrawTool;
/** Call current mode's combineFeatures. Returns draw instance for chaining. */
combineFeatures: () => IDrawTool;
/** Delete feature with specified ID. Returns draw instance for chaining. */
delete: (featureIds: string[] | string) => IDrawTool;
/** Delete all features. Returns draw instance for chaining. */
deleteAll: () => IDrawTool;
/** Execute action in current mode. */
doAction: (actionName: string) => any;
/** Force refresh. */
forceRefresh: () => any;
/** Return GeoJSON feature with specified id, or undefined if no match. */
get: (id: string) => any;
/** Return FeatureCollection of all features. */
getAll: () => FeatureCollection;
/** Return feature IDs at specified point. */
getFeatureIdsAt: (point: {
x: number;
y: number;
}) => Array;
/** Return Draw's current mode. */
getMode: () => string;
/** Return FeatureCollection of selected features. */
getSelected: () => FeatureCollection;
/** Return selected feature IDs. */
getSelectedIds: () => Array;
/** Return FeatureCollection points of selected vertices. */
getSelectedPoints: () => FeatureCollection;
/** Internal mode value. */
modes: Record;
/** Add callback interface. */
onAdd: (map: any) => any;
/** Remove callback interface. */
onRemove: () => any;
/** Internal options value. */
options: Record;
redo: () => any;
/** Set Draw features to specified FeatureCollection. */
set: (featureCollection: FeatureCollection) => Array;
/** Set property value for feature with id. Returns draw instance for chaining. */
setFeatureProperty: (featureId: string, property: string, value: any) => IDrawTool;
/** Call current mode's trash delete. Returns draw instance for chaining. */
trash: () => IDrawTool;
uncombineFeatures: () => IDrawTool;
undo: () => any;
}
/**
* Export layout space to DWG
*/
export interface IExportLayout {
/** Map ID. */
mapid: string;
/** Map version (empty uses current). */
version?: string;
/** Layout index (takes precedence over layoutName). Empty for current layout. */
layoutIndex?: string;
/** Layout name. layoutIndex takes precedence. Empty for current layout. */
layoutName?: string;
}
/**
* Expression query entity parameters
*/
export interface IExprQueryFeatures extends IQueryBaseFeatures {
/** Expression (supports JS or expression syntax). */
expr: string;
/** Record start position. */
beginpos?: number;
}
/**
* Auto-extract table parameters from drawing
*/
export interface IExtractTable {
/** Map ID. */
mapid?: string;
/** Map version (empty uses current). */
version?: string;
/** Layer style name. Empty for entity's layer. */
layer?: string;
/** Bounds [x1,y1,x2,y2]; empty for full map. */
bounds?: string;
/** Query condition (default all lines). */
condition?: string;
/** Output debug data. */
debug?: boolean;
/** Decimal precision. Positive=decimal places, negative=integer places. Default 4 */
digit?: number;
/** Tolerance. Positive=line threshold. 0=auto. Negative=auto tolerance multiplier. Default 0 */
tol?: number;
/** Min table border points. Default 12 */
tableEdgeMinPoint?: number;
/** Min table text count. Default 4 */
tableTextMinCount?: number;
/** Max cell area ratio. Default 90 */
cellMaxArea?: number;
/** Min empty value ratio. Default 90 */
cellEmptyRatio?: number;
/** Max cell count. Default 100000 */
tableMaxCellCount?: number;
/** Allowed polyline segments. Default 0 (horizontal/vertical only) */
noHvLineSegCount?: number;
/** Allow duplicate table data. Default false */
seachTableMost?: boolean;
/** Find subgraph bounds. Default false */
findChildMapRects?: boolean;
}
export type ImageSourceSpecification = {
type: "image";
url: string;
coordinates: [[number, number], [number, number], [number, number], [number, number]];
};
/**
* Compare map differences
*/
export interface IMapDiff {
/** Map 1 ID. */
mapid1: string;
/** Map 1 version (empty for current). */
version1?: string;
/** Map 1 style layer. */
layer1?: string;
/** Map 2 ID. */
mapid2: string;
/** Map 2 version (empty for current). */
version2?: string;
/** Map 2 style layer. */
layer2?: string;
/** Don't compare added parts. */
noCompareNew?: boolean;
/** Don't compare deleted parts. */
noCompareDelete?: boolean;
/** Compare size. Default 4096 */
size?: number;
/** Compare cell size. Default 10 */
cellsize?: number;
/** Min diff pixel. Default 0 */
diffMinPixel?: number;
/** Min diff transparency. Default 25 */
diffMinAlpha?: number;
/** Min diff color. Default 6 */
diffMinColor?: number;
}
/**
* Map layer
*/
export interface IMapLayer {
/** Layer name. */
name: string;
/** Color. */
color: string;
/** Layer index. */
index: number;
/** Whether frozen. */
isFrozen: boolean;
/** Whether locked. */
isLocked: boolean;
/** Whether layer is off. */
isOff: boolean;
/** Line width. */
lineWeight: number;
/** Linetype. */
linetype: number;
}
/**
* Map style parameters
*/
export interface IMapStyleParam {
/** Style name. */
name?: string;
/** Layer indices to turn on, e.g. [0,1,3]. */
layeron?: string | number[];
/** Layer indices to turn off, e.g. [2,4]. */
layeroff?: string | number[];
/** Map clip bounds [x1,y1,x2,y2]; or single number for scale */
clipbounds?: [number, number, number, number] | number;
/** Color. */
backcolor?: number;
/** Line width [1,1,1,1,0] for levels 1-5 on/off. Empty for original. */
lineweight?: string | number[];
/** 表达式. */
expression?: string;
}
/**
* Target matching
*/
export interface IMatchObject {
/** Map ID. */
mapid: string;
/** Map version (empty uses current). */
version?: string;
/** Layer style name. Empty for entity's layer. */
layer?: string;
/** Target matching的地图范围，默认为全图的数据范围. */
mapBounds?: string;
/** Target matching的实体objectid数组，用||隔开. */
objectIds?: string;
/** Target matching的实体范围 */
objectBounds: string;
/** Target matching的地图打开的图层 */
layeron?: string;
/** Match image size. Default 10000 */
size?: number;
/** Method. Default matchPattern */
method?: "matchTemplate" | "matchPattern";
/** Max results. Default 200 */
maxCount?: number;
/** Score threshold (0-1). Default 0.6 */
score?: number;
/** Pyramid size (64-2048). Default 256. For matchPattern */
minReduceArea?: number;
/** Allow overlap. Default false */
canOverlap?: boolean;
/** Overlap ratio (0-0.8). Default 0.3 */
maxOverlap?: number;
/** Angle range (-180,180). For matchPattern. Default 180 */
toleranceAngle?: number;
/** Use angle range. Default false. For matchPattern */
useToleranceRange?: boolean;
/** Angle range 1 start. For matchPattern */
tolerance1?: number;
/** Angle range 1 end. For matchPattern */
tolerance2?: number;
/** Angle range 2 start. For matchPattern */
tolerance3?: number;
/** Angle range 2 end. For matchPattern */
tolerance4?: number;
}
export function inertia({ from, velocity, min, max, power, timeConstant, bounceStiffness, bounceDamping, restDelta, modifyTarget, driver, onUpdate, onComplete, onStop }: InertiaOptions): {
stop: () => void;
};
export interface InertiaOptions extends DecayOptions {
bounceStiffness?: number;
bounceDamping?: number;
min?: number;
max?: number;
restSpeed?: number;
restDelta?: number;
driver?: Driver;
onUpdate?: (v: number) => void;
onComplete?: () => void;
onStop?: () => void;
}
/**
* Create a function that maps from a numerical input array to a generic output array.
*
* Accepts:
* - Numbers
* - Colors (hex, hsl, hsla, rgb, rgba)
* - Complex (combinations of one or more numbers or strings)
*
* ```jsx
* const mixColor = interpolate([0, 1], ['#fff', '#000'])
*
* mixColor(0.5) // 'rgba(128, 128, 128, 1)'
* ```
*
* @public
*/
export function interpolate(input: number[], output: T[], { clamp: isClamp, ease, mixer }?: InterpolateOptions): (v: number) => T;
/**
* @param points Vertices of (poly)line to interpolate (must be lng/lat).
* @param number Points to insert along line; includes endpoints, min 2.
* @param offsetDist Optional perpendicular offset from segment.
* @param minGap 在后续插值点之间保持可选的最小间隙；如果一组“number”点的后续点之间的投影间隙低于此值，则“number”将减小到合适的值.
* @param includeSrcPoint Include source points
* @param isLngLat Whether point sequence is lng/lat
* @return {any[]}
*/
export function interpolateLineRange(points: GeoPointLike[] | any, number: number, isLngLat?: boolean, offsetDist?: number, minGap?: number, includeSrcPoint?: boolean): any[];
interface InterpolateOptions {
clamp?: boolean;
ease?: MixEasing;
mixer?: MixerFactory;
}
/**
* Get point at ratio (0-1) along coordinate sequence
* @param points
* @param isLngLat
* @param ratio
* @return {any[]}
*/
export function interpolatePointsByRatio(points: GeoPointLike[] | any, ratio: number, isLngLat?: boolean): any[];
/**
* Map open parameters
*/
export interface IOpenMapBaseParam {
/** Map ID. */
mapid: string;
/** Map open mode (default: GeomRender). */
mapopenway?: MapOpenWay;
/** File ID. Required first open. */
fileid?: string;
/** File document. */
filedoc?: string;
/** File name. */
filename?: string;
/** Upload file name. */
uploadname?: string;
/** Secret key (first upload, password protection). */
secretKey?: string;
/** Access key; less than secretKey cannot delete. */
accessKey?: string;
/** Password input callback. */
cbInputPassword?: (param: {
mapid: string;
isPasswordError: boolean;
tryPasswordCount: number;
result: any;
}) => Promise;
/** Map source parameters. */
mapfrom?: string;
/** Map dependencies. */
mapdependencies?: string;
/** 地图来源参数(这是子项的设置，与mapfrom不同的是，这个没有转化为基础图形，有可能还有依赖关系）.如与mapfrom一样的话，则为空 */
subfrom?: string;
/** 地图依赖项(这是子项的设置，与mapdependencies不同的是，这个没有转化为基础图形，有可能还有依赖关系）.如与mapdependencies一样的话，则为空 */
subdependencies?: string;
/** Render precision, default 1. For large drawings with rough arcs, clear cache and re-upload with higher precision. Note: higher precision increases file size and reduces performance */
renderAccuracy?: number;
/** Style. */
style?: IMapStyleParam;
/** Use default shape file instead of font. */
notUseDefaultTtfFont?: boolean;
/** Use default font instead of shape file. */
notUseDefaultShxFont?: boolean;
/** Don't auto-replace linetype. */
notReplaceLineType?: boolean;
/** Font replace rule. See findFonts from openMap. */
fontReplaceRule?: Record | string;
/** Init view scale for small points. Default 16. */
mapInitViewErrMaxRatio?: number;
/** Image top-left X. For first image open. */
imageLeft?: number;
/** Image top-left Y. For first image open. */
imageTop?: number;
/** Image resolution. Geo length per pixel = coord length / pixel width. */
imageResolution?: number;
/** Retry interval for open/update (seconds). Default 5 */
openFinishTryInterval?: number;
/** Max retries for open/update. Default 120 */
openFinishMaxTryCount?: number;
/** Valid for new map with fileDoc */
cadVersion?: string;
/** Use POST for open (default GET). */
httpUsePost?: boolean;
/** Use 3D view (default auto). */
open3dview?: boolean;
/** Custom extension params */
extData?: Record;
}
/**
* Map open parameters
*/
export interface IOpenMapParam extends IOpenMapBaseParam {
/** Version (default ""). */
version?: string;
/** Layer names, comma-separated for combined. */
layer?: string;
/** Layout index (1-based). 0=model space. */
layoutIndex?: number;
}
/**
* Map open success response
*/
export interface IOpenMapResponse {
/** Map ID. */
mapid?: string;
/** Version (default ""). */
version?: string;
/** 图层名称 */
layer?: string;
/** Map open mode (default: GeomRender). */
mapopenway?: MapOpenWay;
/** DbID. */
dbid?: string;
/** File ID. */
fileid?: string;
/** File name. */
filename?: string;
/** Map extent (clipBounds if used). */
bounds?: GeoBounds;
/** Map extent (empty if no clipBounds). */
mapBounds?: GeoBounds;
/** Database map extent */
dbBounds?: GeoBounds;
/** Drawing data extent (approximate; use cmdGetDrawBounds for exact) */
drawBounds?: GeoBounds;
/** Layer style. */
styles?: any;
/** Layer list. */
layers?: any;
/** Map type. Empty for CAD, image for raster. */
maptype?: string;
/** Status. */
status?: string;
/** Dark mode (black background). */
darkMode?: boolean;
/** Type. */
type?: string;
/** UCS base point. */
ucsorg?: string;
/** Uploaded file name. */
uploadname?: string;
/** Description. */
description?: string;
/** Default line width display. */
lineWidthDisplay?: boolean;
/** All layouts. */
layouts?: string[];
/** Map source parameters. */
mapfrom?: string;
/** Map dependencies. */
mapdependencies?: string;
/** 地图来源参数(这是子项的设置，与mapfrom不同的是，这个没有转化为基础图形，有可能还有依赖关系）.如与mapfrom一样的话，则为空 */
subfrom?: string;
/** 地图依赖项(这是子项的设置，与mapdependencies不同的是，这个没有转化为基础图形，有可能还有依赖关系）.如与mapdependencies一样的话，则为空 */
subdependencies?: string;
/** Render precision, default 1. For large drawings with rough arcs, clear cache and re-upload with higher precision. Note: higher precision increases file size and reduces performance */
renderAccuracy?: number;
/** Init view scale: bounds * initViewScale = dbBounds */
initViewScale?: number;
/** Initial view. */
view?: {
/** Initial view center. */
center?: [number, number];
/** Initial view zoom. */
zoom?: number;
/** Initial view bearing. */
bearing?: number;
};
/** Max zoom for image type */
maxzoom?: number;
/** Image pixel width for image type */
imageWidth?: number;
/** Image pixel height for image type */
imageHeight?: number;
/** Image top-left X */
imageLeft?: number;
/** Image top-left Y */
imageTop?: number;
/** Image resolution. Geo length per pixel. */
imageResolution?: number;
/** Whether 3D map */
isMap3d?: boolean;
/** Create time */
createTime?: string;
/** Spatial data record count */
geomRecordCount?: string;
}
/**
* Point query entity parameters
*/
export interface IPointQueryFeatures extends IQueryBaseFeatures {
/** Query coordinate X. */
x: number;
/** Query coordinate Y. */
y: number;
/** Pixel size. */
pixelsize?: number;
/** Condition. */
condition?: string;
/** Max geometry bytes to return. */
maxGeomBytesSize?: number;
/** Geo length per pixel; if set, overrides zoom-based calc. */
pixelToGeoLength?: number;
}
/**
* Query entity parameters
*/
export interface IQueryBaseFeatures {
/** Current zoom. */
zoom?: number;
/** Map ID (empty for current). */
mapid?: string;
/** Map version (empty uses current). */
version?: string;
/** Layer name (empty for current). */
layer?: string;
/** Max records to return. */
limit?: number;
/** Return fields, comma-separated, e.g. "name,objectid" */
fields?: string;
/** Whether geometry query. */
geom?: boolean;
/** GeoJSON simplify tolerance. 0=no simplify. */
simplifyTolerance?: boolean;
/** Enable cache (for memory-opened). */
useCache?: boolean;
/** Return Mercator by default; toMapCoordinate=true for CAD coords. */
toMapCoordinate?: boolean;
}
/**
* Rectangle query entity parameters
*/
export interface IRectQueryFeatures extends IQueryBaseFeatures {
/** Query X1. (Empty for full map) */
x1?: number;
/** Query Y1. */
y1?: number;
/** Query X2. */
x2?: number;
/** Query Y2. */
y2?: number;
/** Condition. */
condition?: string;
/** Max geometry bytes to return. */
maxGeomBytesSize?: number;
}
export interface IRequest {
get: (url: string, params?: Record, args?: Partial) => Promise;
put: (url: string, data: any, args?: Partial) => Promise;
post: (url: string, data: any, args?: Partial) => Promise;
patch: (url: string, data: any, args?: Partial) => Promise;
del: (url: string, args?: Partial) => Promise;
options: (url: string, args?: Partial) => Promise;
}
/**
* Whether polygon is closed
* @param points
* @return {boolean}
*/
export function isClosedPolygon(points: GeoPoint[]): boolean;
/**
* Whether points are counterclockwise (true) or clockwise (false)
* @param a
* @param b
* @param c
* @return {boolean}
*/
export function isCounterClockwise(a: GeoPoint, b: GeoPoint, c: GeoPoint): boolean;
/**
* A {@link GeoPointLike} object, an array of two numbers representing longitude and latitude,
* or an object with `lng` and `lat` or `lon` and `lat` properties.
*
* Example:
* ```typescript
* const center = { lat: 53.3, lng: 13.4 };
* mapView.geoCenter = GeoCoordinates.fromLatLng(center);
* ```
*/
export function isGeoPointLike(geoPoint: any): geoPoint is GeoPointLike;
/**
* Get image tile cache level
*/
export interface ISliceCacheZoom {
/** Map ID (empty for current). */
mapid?: string;
/** Map version (empty uses current). */
version?: string;
/** Layer name (empty for current) */
layer?: string;
/** Whether vector tile (else raster) */
ismvt: boolean;
}
/**
* Tile layer
*/
export interface ISliceLayer {
/** Map ID (empty for current). */
mapid?: string;
/** Map version (empty uses current). */
version?: string;
/** Layer name(s). Array for multiple. */
layer: string | string[];
/** Level(s). Array if layer is array. */
zoom: number | number[];
/** Vector tile (else raster). Array if layer is array. */
ismvt: boolean | boolean[];
/** Cancel this layer's tiling. */
iscancel?: boolean;
/** Cancel all tiling. */
isAllCancel?: boolean;
/** Batch size. Default 10000 */
batchNum?: number;
/** Idle batch wait. Default 1ms */
idleBatchSleepMs?: number;
/** Busy batch wait. Default 10000ms */
busyBatchSleepMs?: number;
}
/**
* Split submap parameters
*/
export interface ISplitChildMaps {
/** Map ID. */
mapid?: string;
/** File ID. mapid takes precedence. */
fileid?: string;
/** Map version (empty uses current). */
version?: string;
/** Zoom to extent per submap. Default false */
isFullExtent?: boolean;
/** Submap bounds array. */
clipBounds: string[];
/** Method: cloneObjects (fast), cloneDb, cloneMap (most faithful) */
method?: "cloneObjects" | "cloneDb" | "cloneMap";
/** Use new process. Default true */
startNewProcess?: boolean;
}
export const isPoint: (point: Object) => point is Point23D;
export const isPoint3D: (point: Point23D) => point is Point3D;
/**
* Check if point is inside polygon.
* @param pos 点
* @param polygon 多边形坐标
* @return {boolean}
*/
export const isPointInPolygon: (pos: GeoPoint, polygon: GeoPoint[]) => boolean;
/**
* 判断是否为零
* @param value 值
* @param precision 精度，缺省1e-6
*/
export function isZero(value: number, precision?: number): boolean;
/**
* 地图瓦片参数
*/
export interface ITileUrlParam {
/** Map ID. */
mapid?: string;
/** 版本号. */
version?: string;
/** Layer name. */
layer?: string;
/** File ID. */
fileid?: string;
}
/**
* 更新地图参数
*/
export interface IUpdateMapParam extends IOpenMapBaseParam {
/** 是否删除老版本(缺省: false ). */
deleteOldVersion?: boolean;
}
/**
* 更新样式接口
*/
export interface IUpdateStyle {
/** Map ID (empty for current). */
mapid?: string;
/** Map version (empty uses current). */
version?: string;
/** Style name. */
name?: string;
/** Layer indices to turn on, e.g. [0,1,3]. */
layeron?: string | number[];
/** Layer indices to turn off, e.g. [2,4]. */
layeroff?: string | number[];
/** 地图裁剪范围，范围如[x1,y1,x2,y2].如果只有数字的话，表示是缩放系数 */
clipbounds?: [number, number, number, number] | number;
/** Color. */
backcolor?: number;
/** Line width [1,1,1,1,0] for levels 1-5 on/off. Empty for original. */
lineweight?: string | number[];
/** Expression (supports JS or expression syntax). */
expression?: string;
}
/**
* wms服务url地址接口
*/
export interface IWmsTileUrl {
/** 地图ID(为空时采用当前打开的mapid)， 为数组时表时同时请求多个. */
mapid?: string | string[];
/** Map version (empty uses current). */
version?: string | string[];
/** Layer name (empty for current). */
layers?: string | string[];
/** 范围，缺省{bbox-epsg-3857}. (如果要获取地图cad一个范围的wms数据无需任何坐标转换，将此范围填cad范围,srs,crs,mapbounds填为空).*/
bbox?: string;
/** 当前坐标系,缺省(EPSG:3857). */
srs?: string;
/** cad图的坐标系，为空的时候由元数据坐标系决定. 也可直接输入proj4字符串*/
crs?: string | string[];
/** 地理真实范围，如有值时,srs将不起作用 */
mapbounds?: string;
/** Width. */
width?: number;
/** Height. */
height?: number;
/** Whether transparent. */
transparent?: boolean;
/** 不透明时的背景颜色，默认为白色。格式必须为rgb(r,g,b)或rgba(r,g,b,a),a不透明应该是255. */
backgroundColor?: string;
/** Four params (dx, dy, scale, rotate); optional coordinate correction */
fourParameter?: string | string[];
/** Use inverse of four params above, default false */
isInverseFourParamter?: boolean | boolean[];
/** 是否是矢量瓦片. */
mvt?: boolean;
/** 是否考虑旋转，在不同坐标系中转换是需要考虑。默认自动考虑是否需要旋转. */
useImageRotate?: boolean;
/** 旋转时图像处理算法. 1或2,默认自动选择（旋转时有用）*/
imageProcessAlg?: number;
/** 当前互联网底图地图类型 WGS84(84坐标，如天地图，osm), GCJ02(火星坐标，如高德，腾讯地图)， BD09LL(百度经纬度坐标，如百度地图)， BD09MC(百度墨卡托米制坐标，如百度地图)*/
webMapType?: "WGS84" | "GCJ02" | "BD09LL" | "BD09MC";
}
/**
* 工作区（工作区主要用来对图纸进行分类管理。不同工作区的图纸存在的位置不同，查看不同工作区的图纸，需要切换到相应工作区才能查看）
*/
export interface IWorkspace {
/** 工作区名称(英文名称，不要有特殊字符，用于做为键值和路由). */
name: string;
/** 工作区别名(可以是中文). */
alias?: string;
/** 工作区目录，如果是相对于工作区路径的一个路径或绝对路径，如为空的话，则用工作区名称做为工作目录. */
workDir?: string;
/** 是否公开（不公开的话，无法通过获取工作区功能来获取到此工作区信息）. */
isPublic?: boolean;
/** 是否禁用全文搜索. 默认false */
DisableFullSearch?: boolean;
}
export const kebabCase: (s: any) => any;
export interface KeyframeOptions {
to: V | V[];
from?: V;
duration?: number;
ease?: Easing | Easing[];
offset?: number[];
}
export function keyframes