tg-map-vue3 3.9.9 → 4.0.1

package/dist/src/components/TgMap.vue.d.ts

@@ -1,10 +1,5 @@
+import { BuildInMapTypeId, GestureHandlingOptions, LatLng, MapType, TgMapType, type AbstractMap, type AbstractMapEventMap, type BaseMap, type MapStyle, type StringEnumValue } from 'tg-map-core';
 import { type PropType } from 'vue';
-import { LatLng } from '../map/lat-lng';
-import { TgMapType } from '../map/map-factory';
-import type { AbstractMap, AbstractMapEventMap } from '../map/map/map';
-import { GestureHandlingOptions, type MapStyle } from '../map/map/map-options';
-import { BuildInMapTypeId, MapType } from '../map/map/map-type';
-import { type StringEnumValue } from '../utils/mapped-types';
 import { type EventEmits } from '../utils/vue-utils';
 type TgMapEmits = {
     load: AbstractMap;
@@ -16,6 +11,92 @@ type TgMapEmits = {
     'update:map-type-id': string;
     'update:last-center': LatLng;
 };
+export declare const tgMapProps: {
+    /** type没做响应式, 但外部可以把type作为tg-map的key, 让type修改时完全重建tg-map */
+    type: {
+        type: PropType<StringEnumValue<typeof TgMapType>>;
+        default: TgMapType;
+    };
+    /**
+     * 当对该属性使用双向绑定时, 改变center将触发update:center又反过来触发center改变, 最终导致无限循环...
+     * 当前通过setCenter()时判断center是否有改变来避免该问题, 但为了避免可能存在的问题, 另外设计了如下机制:
+     * - :center-sync-delay="300": 延时同步center, 防止center的值更新过快
+     * - :current-center.sync="currentCenter": 实时获取center的值
+     * - :last-center.sync="center": 获取tg-map销毁时的最后的center的值, 使用这种方式可以做到type切换时保留中心点位置
+     * @see AbstractMapEventMap.center-changed
+     */
+    center: {
+        type: PropType<LatLng>;
+        required: true;
+    };
+    /**
+     * 同步center的延时
+     * @default 300
+     * @see center
+     */
+    centerSyncDelay: {
+        type: PropType<number>;
+        default: number;
+    };
+    /**
+     * 仅用来获取center的值, 需要设置center的值请使用`center`属性
+     * @see center
+     * @deprecated 用的太少, 故maptalks未实现该属性, 要实时获取中心点, 请将{@link centerSyncDelay}设为0
+     */
+    currentCenter: {
+        type: PropType<LatLng>;
+    };
+    /**
+     * 仅用于获取tg-map销毁时的最后的center的值
+     * @see center
+     * @deprecated 用的太少, 故maptalks未实现该属性
+     */
+    lastCenter: {
+        type: PropType<LatLng>;
+    };
+    zoom: {
+        type: PropType<number>;
+        required: true;
+    };
+    /**
+     * 该属性不会响应式更新, 要让它立即生效, 请参考{@link file://./../views/map/InfoDemo.vue#L3}
+     * @see MapOptions.infoWindowMode
+     */
+    infoWindowMode: {
+        type: PropType<"single" | "multi">;
+    };
+    gestureHandling: {
+        type: PropType<StringEnumValue<typeof GestureHandlingOptions>>;
+    };
+    minZoom: {
+        type: PropType<number>;
+    };
+    maxZoom: {
+        type: PropType<number>;
+    };
+    mapStyle: {
+        type: PropType<MapStyle>;
+    };
+    mapTypeId: {
+        type: PropType<StringEnumValue<typeof BuildInMapTypeId>>;
+    };
+    /** 地图类型对象, 优先级比mapTypeId高 */
+    mapType: {
+        type: PropType<any>;
+    };
+    hideLogo: {
+        type: PropType<boolean>;
+    };
+    onLoad: import("vue").Prop<import("tg-map-core").EventCallback<AbstractMap>>;
+    'onUpdate:center': import("vue").Prop<import("tg-map-core").EventCallback<LatLng>>;
+    'onUpdate:current-center': import("vue").Prop<import("tg-map-core").EventCallback<LatLng>>;
+    'onUpdate:last-center': import("vue").Prop<import("tg-map-core").EventCallback<LatLng>>;
+    'onUpdate:map-type': import("vue").Prop<import("tg-map-core").EventCallback<MapType>>;
+    'onUpdate:map-type-id': import("vue").Prop<import("tg-map-core").EventCallback<string>>;
+    'onUpdate:zoom': import("vue").Prop<import("tg-map-core").EventCallback<number>>;
+    onError: import("vue").Prop<import("tg-map-core").EventCallback<any>>;
+};
+export type TgMapEventEmits = EventEmits<AbstractMapEventMap & TgMapEmits>;
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     /** type没做响应式, 但外部可以把type作为tg-map的key, 让type修改时完全重建tg-map */
     type: {
@@ -29,7 +110,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
      * - :current-center.sync="currentCenter": 实时获取center的值
      * - :last-center.sync="center": 获取tg-map销毁时的最后的center的值, 使用这种方式可以做到type切换时保留中心点位置
      * @see AbstractMapEventMap.center-changed
-     * */
+     */
     center: {
         type: PropType<LatLng>;
         required: true;
@@ -46,13 +127,15 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     /**
      * 仅用来获取center的值, 需要设置center的值请使用`center`属性
      * @see center
-     * */
+     * @deprecated 用的太少, 故maptalks未实现该属性, 要实时获取中心点, 请将{@link centerSyncDelay}设为0
+     */
     currentCenter: {
         type: PropType<LatLng>;
     };
     /**
      * 仅用于获取tg-map销毁时的最后的center的值
      * @see center
+     * @deprecated 用的太少, 故maptalks未实现该属性
      */
     lastCenter: {
         type: PropType<LatLng>;
@@ -90,14 +173,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     hideLogo: {
         type: PropType<boolean>;
     };
-    onLoad: import("vue").Prop<import("./index.ts").EventCallback<AbstractMap>>;
-    'onUpdate:center': import("vue").Prop<import("./index.ts").EventCallback<LatLng>>;
-    'onUpdate:current-center': import("vue").Prop<import("./index.ts").EventCallback<LatLng>>;
-    'onUpdate:last-center': import("vue").Prop<import("./index.ts").EventCallback<LatLng>>;
-    'onUpdate:map-type': import("vue").Prop<import("./index.ts").EventCallback<MapType>>;
-    'onUpdate:map-type-id': import("vue").Prop<import("./index.ts").EventCallback<string>>;
-    'onUpdate:zoom': import("vue").Prop<import("./index.ts").EventCallback<number>>;
-    onError: import("vue").Prop<import("./index.ts").EventCallback<any>>;
+    onLoad: import("vue").Prop<import("tg-map-core").EventCallback<AbstractMap>>;
+    'onUpdate:center': import("vue").Prop<import("tg-map-core").EventCallback<LatLng>>;
+    'onUpdate:current-center': import("vue").Prop<import("tg-map-core").EventCallback<LatLng>>;
+    'onUpdate:last-center': import("vue").Prop<import("tg-map-core").EventCallback<LatLng>>;
+    'onUpdate:map-type': import("vue").Prop<import("tg-map-core").EventCallback<MapType>>;
+    'onUpdate:map-type-id': import("vue").Prop<import("tg-map-core").EventCallback<string>>;
+    'onUpdate:zoom': import("vue").Prop<import("tg-map-core").EventCallback<number>>;
+    onError: import("vue").Prop<import("tg-map-core").EventCallback<any>>;
 }>, {
     attrs: import("vue").ComputedRef<{
         binds: Record<string, unknown>;
@@ -106,7 +189,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     }>;
     centerSyncTimeoutId: TimeoutId | undefined;
 }, {
-    map: AbstractMap | undefined;
+    map: BaseMap | undefined;
     isDestroyed: boolean;
 }, {
     propsJson(): string;
@@ -123,7 +206,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
      * - :current-center.sync="currentCenter": 实时获取center的值
      * - :last-center.sync="center": 获取tg-map销毁时的最后的center的值, 使用这种方式可以做到type切换时保留中心点位置
      * @see AbstractMapEventMap.center-changed
-     * */
+     */
     center: {
         type: PropType<LatLng>;
         required: true;
@@ -140,13 +223,15 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     /**
      * 仅用来获取center的值, 需要设置center的值请使用`center`属性
      * @see center
-     * */
+     * @deprecated 用的太少, 故maptalks未实现该属性, 要实时获取中心点, 请将{@link centerSyncDelay}设为0
+     */
     currentCenter: {
         type: PropType<LatLng>;
     };
     /**
      * 仅用于获取tg-map销毁时的最后的center的值
      * @see center
+     * @deprecated 用的太少, 故maptalks未实现该属性
      */
     lastCenter: {
         type: PropType<LatLng>;
@@ -184,39 +269,39 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     hideLogo: {
         type: PropType<boolean>;
     };
-    onLoad: import("vue").Prop<import("./index.ts").EventCallback<AbstractMap>>;
-    'onUpdate:center': import("vue").Prop<import("./index.ts").EventCallback<LatLng>>;
-    'onUpdate:current-center': import("vue").Prop<import("./index.ts").EventCallback<LatLng>>;
-    'onUpdate:last-center': import("vue").Prop<import("./index.ts").EventCallback<LatLng>>;
-    'onUpdate:map-type': import("vue").Prop<import("./index.ts").EventCallback<MapType>>;
-    'onUpdate:map-type-id': import("vue").Prop<import("./index.ts").EventCallback<string>>;
-    'onUpdate:zoom': import("vue").Prop<import("./index.ts").EventCallback<number>>;
-    onError: import("vue").Prop<import("./index.ts").EventCallback<any>>;
+    onLoad: import("vue").Prop<import("tg-map-core").EventCallback<AbstractMap>>;
+    'onUpdate:center': import("vue").Prop<import("tg-map-core").EventCallback<LatLng>>;
+    'onUpdate:current-center': import("vue").Prop<import("tg-map-core").EventCallback<LatLng>>;
+    'onUpdate:last-center': import("vue").Prop<import("tg-map-core").EventCallback<LatLng>>;
+    'onUpdate:map-type': import("vue").Prop<import("tg-map-core").EventCallback<MapType>>;
+    'onUpdate:map-type-id': import("vue").Prop<import("tg-map-core").EventCallback<string>>;
+    'onUpdate:zoom': import("vue").Prop<import("tg-map-core").EventCallback<number>>;
+    onError: import("vue").Prop<import("tg-map-core").EventCallback<any>>;
 }>> & Readonly<{
-    onClick?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
-    onDblclick?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
-    onMousedown?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
-    onMouseup?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
-    onMouseout?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
-    onMouseover?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
-    "onCenter-changed"?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
-    onRightclick?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
-    onContextmenu?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
-    onDragstart?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
-    onDrag?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
-    onDragend?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
-    onMousemove?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
-    onTilesloaded?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
-    "onZoom-changed"?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
-    "onMap-type-changed"?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
-    onError?: ((event: any) => any) | undefined;
     onLoad?: ((event: AbstractMap) => any) | undefined;
+    onError?: ((event: any) => any) | undefined;
     "onUpdate:center"?: ((event: LatLng) => any) | undefined;
     "onUpdate:current-center"?: ((event: LatLng) => any) | undefined;
     "onUpdate:zoom"?: ((event: number) => any) | undefined;
     "onUpdate:map-type"?: ((event: MapType) => any) | undefined;
     "onUpdate:map-type-id"?: ((event: string) => any) | undefined;
     "onUpdate:last-center"?: ((event: LatLng) => any) | undefined;
+    onClick?: ((event: import("tg-map-core").Tg.MouseEvent) => any) | undefined;
+    onDblclick?: ((event: import("tg-map-core").Tg.MouseEvent) => any) | undefined;
+    onRightclick?: ((event: import("tg-map-core").Tg.MouseEvent) => any) | undefined;
+    onContextmenu?: ((event: import("tg-map-core").Tg.MouseEvent) => any) | undefined;
+    onDragstart?: ((event: import("tg-map-core").Tg.Event) => any) | undefined;
+    onDrag?: ((event: import("tg-map-core").Tg.Event) => any) | undefined;
+    onDragend?: ((event: import("tg-map-core").Tg.Event) => any) | undefined;
+    onMouseover?: ((event: import("tg-map-core").Tg.MouseEvent) => any) | undefined;
+    onMouseout?: ((event: import("tg-map-core").Tg.MouseEvent) => any) | undefined;
+    onMousedown?: ((event: import("tg-map-core").Tg.MouseEvent) => any) | undefined;
+    onMousemove?: ((event: import("tg-map-core").Tg.MouseEvent) => any) | undefined;
+    onMouseup?: ((event: import("tg-map-core").Tg.MouseEvent) => any) | undefined;
+    onTilesloaded?: ((event: import("tg-map-core").Tg.Event) => any) | undefined;
+    "onCenter-changed"?: ((event: import("tg-map-core").Tg.Event) => any) | undefined;
+    "onZoom-changed"?: ((event: import("tg-map-core").Tg.Event) => any) | undefined;
+    "onMap-type-changed"?: ((event: import("tg-map-core").Tg.Event) => any) | undefined;
 }>, {
     type: StringEnumValue<typeof TgMapType>;
     centerSyncDelay: number;
@@ -625,20 +710,1729 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             getEngine: () => H.map.render.p2d.RenderEngine;
             addEventListener: (type: string, handler: EventListenerOrEventListenerObject, opt_capture?: boolean, opt_scope?: any) => void;
             removeEventListener: (type: string, handler: EventListenerOrEventListenerObject, opt_capture?: boolean, opt_scope?: any) => void;
+        } | {
+            addControl: (control: {
+                options: import("maptalks").ControlOptionsType;
+                onAdd(): void;
+                onRemove(): void;
+                buildOn(map?: import("maptalks").Map): HTMLElement;
+                addTo(map: import("maptalks").Map): /*elided*/ any;
+                update(): /*elided*/ any;
+                getMap(): import("maptalks").Map;
+                getPosition(): import("maptalks").DomPositionType;
+                setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                getContainerPoint(): import("maptalks").Point;
+                getContainer(): HTMLElement;
+                getDOM(): HTMLElement;
+                show(): /*elided*/ any;
+                hide(): /*elided*/ any;
+                isVisible(): boolean;
+                remove(): /*elided*/ any;
+                onConfig(conf: import("maptalks").ClassOptions): void;
+                _eventMap?: Record<string, {
+                    handler: import("maptalks").HandlerFn;
+                    context: any;
+                }[]>;
+                _eventParent?: any;
+                _eventTarget?: any;
+                on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                addEventListener(...args: any[]): any;
+                once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                removeEventListener(...args: any[]): any;
+                listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                getListeningEvents(): string[];
+                copyEventListeners(target: any): any;
+                fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                _clearListeners(eventType: string): void;
+                _clearAllListeners(): void;
+                _setEventParent(parent: any): any;
+                _setEventTarget(target: any): any;
+                _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                proxyOptions(): /*elided*/ any;
+                callInitHooks(): /*elided*/ any;
+                _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                config(conf?: string | import("maptalks").ClassOptions, value?: any): import("maptalks").ClassOptions | /*elided*/ any;
+            }) => import("maptalks").Map;
+            removeControl: (control: {
+                options: import("maptalks").ControlOptionsType;
+                onAdd(): void;
+                onRemove(): void;
+                buildOn(map?: import("maptalks").Map): HTMLElement;
+                addTo(map: import("maptalks").Map): /*elided*/ any;
+                update(): /*elided*/ any;
+                getMap(): import("maptalks").Map;
+                getPosition(): import("maptalks").DomPositionType;
+                setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                getContainerPoint(): import("maptalks").Point;
+                getContainer(): HTMLElement;
+                getDOM(): HTMLElement;
+                show(): /*elided*/ any;
+                hide(): /*elided*/ any;
+                isVisible(): boolean;
+                remove(): /*elided*/ any;
+                onConfig(conf: import("maptalks").ClassOptions): void;
+                _eventMap?: Record<string, {
+                    handler: import("maptalks").HandlerFn;
+                    context: any;
+                }[]>;
+                _eventParent?: any;
+                _eventTarget?: any;
+                on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                addEventListener(...args: any[]): any;
+                once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                removeEventListener(...args: any[]): any;
+                listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                getListeningEvents(): string[];
+                copyEventListeners(target: any): any;
+                fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                _clearListeners(eventType: string): void;
+                _clearAllListeners(): void;
+                _setEventParent(parent: any): any;
+                _setEventTarget(target: any): any;
+                _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                proxyOptions(): /*elided*/ any;
+                callInitHooks(): /*elided*/ any;
+                _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                config(conf?: string | import("maptalks").ClassOptions, value?: any): import("maptalks").ClassOptions | /*elided*/ any;
+            }) => import("maptalks").Map;
+            VERSION: string;
+            isMap: boolean;
+            centerAltitude: number;
+            width: number;
+            height: number;
+            CanvasClass: any;
+            cameraCenterDistance: number;
+            options: {
+                pitch?: number | undefined;
+                bearing?: number | undefined;
+                baseLayer?: {
+                    map: /*elided*/ any;
+                    parent: any;
+                    options: {
+                        attribution?: string | undefined;
+                        minZoom?: number | undefined;
+                        maxZoom?: number | undefined;
+                        visible?: boolean | undefined;
+                        opacity?: number | undefined;
+                        zIndex?: number | undefined;
+                        globalCompositeOperation?: string | undefined;
+                        renderer?: "canvas" | "gl" | "gpu" | "dom" | null | undefined;
+                        debugOutline?: string | undefined;
+                        cssFilter?: string | undefined;
+                        forceRenderOnMoving?: boolean | undefined;
+                        forceRenderOnZooming?: boolean | undefined;
+                        forceRenderOnRotating?: boolean | undefined;
+                        collision?: boolean | undefined;
+                        collisionScope?: "layer" | "map" | undefined;
+                        hitDetect?: boolean | undefined;
+                        canvas?: HTMLCanvasElement | undefined;
+                        mask?: any;
+                        drawImmediate?: boolean | undefined;
+                        geometryEvents?: boolean | undefined;
+                        geometryEventTolerance?: number | undefined;
+                        maskClip?: boolean | undefined;
+                    };
+                    getLayers?: (() => import("maptalks").Layer[]) | undefined;
+                    load: () => import("maptalks").Layer;
+                    getId: () => string;
+                    setId: (id: string) => import("maptalks").Layer;
+                    addTo: (map: import("maptalks").Map) => import("maptalks").Layer;
+                    setZIndex: (zIndex: number) => import("maptalks").Layer;
+                    getZIndex: () => number;
+                    getMinZoom: () => number;
+                    getMaxZoom: () => number;
+                    getOpacity: () => number;
+                    setOpacity: (op: number) => import("maptalks").Layer;
+                    isCanvasRender: () => boolean;
+                    getMap: () => import("maptalks").Map;
+                    getProjection: () => import("maptalks").CommonProjectionType;
+                    bringToFront: () => import("maptalks").Layer;
+                    bringToBack: () => import("maptalks").Layer;
+                    show: () => import("maptalks").Layer;
+                    hide: () => import("maptalks").Layer;
+                    isVisible: () => boolean;
+                    remove: () => import("maptalks").Layer;
+                    getMask: () => import("maptalks").Marker | import("maptalks").MultiPolygon | import("maptalks").Polygon;
+                    setMask: (mask: import("maptalks").Polygon | import("maptalks").MultiPolygon | import("maptalks").Marker) => import("maptalks").Layer;
+                    removeMask: () => import("maptalks").Layer;
+                    onLoad: () => boolean;
+                    onLoadEnd: () => void;
+                    isLoaded: () => boolean;
+                    getCollisionIndex: () => import("maptalks").CollisionIndex;
+                    clearCollisionIndex: () => import("maptalks").Layer;
+                    getRenderer: () => any;
+                    onConfig: (conf: {
+                        [key: string]: any;
+                    }) => void;
+                    onAdd: () => void;
+                    onRendererCreate: () => void;
+                    onCanvasCreate: () => void;
+                    onRemove: () => void;
+                    toJSON: (options?: any) => import("maptalks").LayerJSONType;
+                    identify: (_coordinate: import("maptalks").Coordinate, _options: import("maptalks").LayerIdentifyOptionsType) => void;
+                    identifyAtPoint: (_containerPoint: import("maptalks").Point, _options: import("maptalks").LayerIdentifyOptionsType) => void;
+                    _jsonType?: string | undefined;
+                    getJSONType: () => string;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]> | undefined;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on: (eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+                    addEventListener: (...args: any[]) => any;
+                    once: (eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+                    off: (eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+                    removeEventListener: (...args: any[]) => any;
+                    listens: (eventType: string, handler?: import("maptalks").HandlerFn, context?: any) => number;
+                    getListeningEvents: () => string[];
+                    copyEventListeners: (target: any) => any;
+                    fire: (eventType: string, param?: import("maptalks").BaseEventParamsType) => any;
+                    _wrapOnceHandler: (evtType: string, handler: import("maptalks").HandlerFn, context?: any) => (...args: any[]) => void;
+                    _switch: (to: string, eventRecords: import("maptalks").EventRecords, context?: any) => any;
+                    _clearListeners: (eventType: string) => void;
+                    _clearAllListeners: () => void;
+                    _setEventParent: (parent: any) => any;
+                    _setEventTarget: (target: any) => any;
+                    _fire: (eventType: string, param: import("maptalks").BaseEventParamsType) => any;
+                    proxyOptions: () => import("maptalks").Layer;
+                    callInitHooks: () => import("maptalks").Layer;
+                    _setOptions: (options: import("maptalks").ClassOptions) => import("maptalks").Layer;
+                    setOptions: (options: import("maptalks").ClassOptions) => import("maptalks").Layer;
+                    config: (conf?: string | import("maptalks").ClassOptions, value?: any) => import("maptalks").Layer | import("maptalks").ClassOptions;
+                } | undefined;
+                layers?: {
+                    map: /*elided*/ any;
+                    parent: any;
+                    options: {
+                        attribution?: string | undefined;
+                        minZoom?: number | undefined;
+                        maxZoom?: number | undefined;
+                        visible?: boolean | undefined;
+                        opacity?: number | undefined;
+                        zIndex?: number | undefined;
+                        globalCompositeOperation?: string | undefined;
+                        renderer?: "canvas" | "gl" | "gpu" | "dom" | null | undefined;
+                        debugOutline?: string | undefined;
+                        cssFilter?: string | undefined;
+                        forceRenderOnMoving?: boolean | undefined;
+                        forceRenderOnZooming?: boolean | undefined;
+                        forceRenderOnRotating?: boolean | undefined;
+                        collision?: boolean | undefined;
+                        collisionScope?: "layer" | "map" | undefined;
+                        hitDetect?: boolean | undefined;
+                        canvas?: HTMLCanvasElement | undefined;
+                        mask?: any;
+                        drawImmediate?: boolean | undefined;
+                        geometryEvents?: boolean | undefined;
+                        geometryEventTolerance?: number | undefined;
+                        maskClip?: boolean | undefined;
+                    };
+                    getLayers?: (() => import("maptalks").Layer[]) | undefined;
+                    load: () => import("maptalks").Layer;
+                    getId: () => string;
+                    setId: (id: string) => import("maptalks").Layer;
+                    addTo: (map: import("maptalks").Map) => import("maptalks").Layer;
+                    setZIndex: (zIndex: number) => import("maptalks").Layer;
+                    getZIndex: () => number;
+                    getMinZoom: () => number;
+                    getMaxZoom: () => number;
+                    getOpacity: () => number;
+                    setOpacity: (op: number) => import("maptalks").Layer;
+                    isCanvasRender: () => boolean;
+                    getMap: () => import("maptalks").Map;
+                    getProjection: () => import("maptalks").CommonProjectionType;
+                    bringToFront: () => import("maptalks").Layer;
+                    bringToBack: () => import("maptalks").Layer;
+                    show: () => import("maptalks").Layer;
+                    hide: () => import("maptalks").Layer;
+                    isVisible: () => boolean;
+                    remove: () => import("maptalks").Layer;
+                    getMask: () => import("maptalks").Marker | import("maptalks").MultiPolygon | import("maptalks").Polygon;
+                    setMask: (mask: import("maptalks").Polygon | import("maptalks").MultiPolygon | import("maptalks").Marker) => import("maptalks").Layer;
+                    removeMask: () => import("maptalks").Layer;
+                    onLoad: () => boolean;
+                    onLoadEnd: () => void;
+                    isLoaded: () => boolean;
+                    getCollisionIndex: () => import("maptalks").CollisionIndex;
+                    clearCollisionIndex: () => import("maptalks").Layer;
+                    getRenderer: () => any;
+                    onConfig: (conf: {
+                        [key: string]: any;
+                    }) => void;
+                    onAdd: () => void;
+                    onRendererCreate: () => void;
+                    onCanvasCreate: () => void;
+                    onRemove: () => void;
+                    toJSON: (options?: any) => import("maptalks").LayerJSONType;
+                    identify: (_coordinate: import("maptalks").Coordinate, _options: import("maptalks").LayerIdentifyOptionsType) => void;
+                    identifyAtPoint: (_containerPoint: import("maptalks").Point, _options: import("maptalks").LayerIdentifyOptionsType) => void;
+                    _jsonType?: string | undefined;
+                    getJSONType: () => string;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]> | undefined;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on: (eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+                    addEventListener: (...args: any[]) => any;
+                    once: (eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+                    off: (eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+                    removeEventListener: (...args: any[]) => any;
+                    listens: (eventType: string, handler?: import("maptalks").HandlerFn, context?: any) => number;
+                    getListeningEvents: () => string[];
+                    copyEventListeners: (target: any) => any;
+                    fire: (eventType: string, param?: import("maptalks").BaseEventParamsType) => any;
+                    _wrapOnceHandler: (evtType: string, handler: import("maptalks").HandlerFn, context?: any) => (...args: any[]) => void;
+                    _switch: (to: string, eventRecords: import("maptalks").EventRecords, context?: any) => any;
+                    _clearListeners: (eventType: string) => void;
+                    _clearAllListeners: () => void;
+                    _setEventParent: (parent: any) => any;
+                    _setEventTarget: (target: any) => any;
+                    _fire: (eventType: string, param: import("maptalks").BaseEventParamsType) => any;
+                    proxyOptions: () => import("maptalks").Layer;
+                    callInitHooks: () => import("maptalks").Layer;
+                    _setOptions: (options: import("maptalks").ClassOptions) => import("maptalks").Layer;
+                    setOptions: (options: import("maptalks").ClassOptions) => import("maptalks").Layer;
+                    config: (conf?: string | import("maptalks").ClassOptions, value?: any) => import("maptalks").Layer | import("maptalks").ClassOptions;
+                }[] | undefined;
+                draggable?: boolean | undefined;
+                dragPan?: boolean | undefined;
+                dragPanEasing?: import("maptalks").EasingType | undefined;
+                dragRotate?: boolean | undefined;
+                dragPitch?: boolean | undefined;
+                dragRotatePitch?: boolean | undefined;
+                touchGesture?: boolean | undefined;
+                touchZoom?: boolean | undefined;
+                touchRotate?: boolean | undefined;
+                touchPitch?: boolean | undefined;
+                touchZoomRotate?: boolean | undefined;
+                doubleClickZoom?: boolean | undefined;
+                scrollWheelZoom?: boolean | undefined;
+                geometryEvents?: boolean | undefined;
+                control?: boolean | undefined;
+                attribution?: boolean | {
+                    content?: (string | HTMLElement) | undefined;
+                    custom?: boolean | undefined;
+                    position?: string | {
+                        top?: number | string | undefined;
+                        bottom?: number | string | undefined;
+                        left?: number | string | undefined;
+                        right?: number | string | undefined;
+                    } | undefined;
+                    cssName?: (string | Array<string>) | undefined;
+                } | undefined;
+                zoomControl?: boolean | undefined;
+                scaleControl?: boolean | undefined;
+                overviewControl?: boolean | undefined;
+                fog?: boolean | undefined;
+                fogColor?: any;
+                devicePixelRatio?: number | undefined;
+                heightFactor?: number | undefined;
+                originLatitudeForAltitude?: number | undefined;
+                viewHistory?: boolean | undefined;
+                viewHistoryCount?: number | undefined;
+                seamlessZoom?: boolean | undefined;
+                maxVisualPitch?: number | undefined;
+                maxPitch?: number | undefined;
+                centerCross?: boolean | undefined;
+                zoomable?: boolean | undefined;
+                zoomInCenter?: boolean | undefined;
+                zoomOrigin?: Array<number> | undefined;
+                zoomAnimation?: boolean | undefined;
+                zoomAnimationDuration?: number | undefined;
+                tileBackgroundLimitPerFrame?: number | undefined;
+                panAnimation?: boolean | undefined;
+                panAnimationDuration?: number | undefined;
+                rotateAnimation?: boolean | undefined;
+                rotateAnimationDuration?: number | undefined;
+                enableInfoWindow?: boolean | undefined;
+                hitDetect?: boolean | undefined;
+                hitDetectLimit?: number | undefined;
+                fpsOnInteracting?: number | undefined;
+                layerCanvasLimitOnInteracting?: number | undefined;
+                maxZoom?: number | undefined;
+                minZoom?: number | undefined;
+                maxExtent?: {
+                    _clazz: typeof import("maptalks").Coordinate | typeof import("maptalks").Point;
+                    _dirty: boolean;
+                    projection: any;
+                    xmin: import("maptalks").WithNull<number>;
+                    xmax: import("maptalks").WithNull<number>;
+                    ymin: import("maptalks").WithNull<number>;
+                    ymax: import("maptalks").WithNull<number>;
+                    pxmin: number;
+                    pxmax: number;
+                    pymin: number;
+                    pymax: number;
+                    left?: number | undefined;
+                    right?: number | undefined;
+                    top?: number | undefined;
+                    bottom?: number | undefined;
+                    antiMeridian?: boolean | undefined;
+                    _initialize: {
+                        (p1: import("maptalks").WithNull<import("maptalks").ExtentLike>): void;
+                        (p1: import("maptalks").PositionType, p2: import("maptalks").PositionType): void;
+                        (p1: number, p2: number, p3: number, p4: number): void;
+                    };
+                    _add: {
+                        (p: import("maptalks").Extent): import("maptalks").Extent;
+                        (p: import("maptalks").PointExtent): import("maptalks").Extent;
+                        (p: import("maptalks").PositionType): import("maptalks").Extent;
+                        (p: number[]): import("maptalks").Extent;
+                    };
+                    add: {
+                        (p: import("maptalks").Extent): import("maptalks").Extent;
+                        (p: import("maptalks").PointExtent): import("maptalks").Extent;
+                        (p: import("maptalks").PositionType): import("maptalks").Extent;
+                        (p: number[]): import("maptalks").Extent;
+                    };
+                    _scale: (s: number) => import("maptalks").Extent;
+                    _sub: {
+                        (p: [number, number]): import("maptalks").Extent;
+                        (p: import("maptalks").PositionType): import("maptalks").Extent;
+                        (p: import("maptalks").Extent | import("maptalks").PointExtent): import("maptalks").Extent;
+                    };
+                    _substract: {
+                        (p: [number, number]): import("maptalks").Extent;
+                        (p: import("maptalks").PositionType): import("maptalks").Extent;
+                        (p: import("maptalks").Extent | import("maptalks").PointExtent): import("maptalks").Extent;
+                    };
+                    sub: {
+                        (p: [number, number]): import("maptalks").Extent;
+                        (p: import("maptalks").PositionType): import("maptalks").Extent;
+                        (p: import("maptalks").Extent | import("maptalks").PointExtent): import("maptalks").Extent;
+                    };
+                    substract: {
+                        (p: [number, number]): import("maptalks").Extent;
+                        (p: import("maptalks").PositionType): import("maptalks").Extent;
+                        (p: import("maptalks").Extent | import("maptalks").PointExtent): import("maptalks").Extent;
+                    };
+                    round: () => import("maptalks").PointExtent | import("maptalks").Extent;
+                    _round: () => import("maptalks").Extent;
+                    getMin: {
+                        (out?: import("maptalks").Point): import("maptalks").Point;
+                        (out?: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                    };
+                    getMax: {
+                        (out?: import("maptalks").Point): import("maptalks").Point;
+                        (out?: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                    };
+                    getCenter: (out?: import("maptalks").PositionType) => import("maptalks").PositionType;
+                    isValid: () => boolean;
+                    equals: (ext2: import("maptalks").Extent | import("maptalks").PointExtent) => boolean;
+                    intersects: (ext2: import("maptalks").Extent | import("maptalks").PointExtent) => boolean;
+                    within: (extent: import("maptalks").Extent | import("maptalks").PointExtent) => boolean;
+                    contains: (c: import("maptalks").CoordinateLike) => boolean;
+                    getWidth: () => number;
+                    getHeight: () => number;
+                    getSize: () => import("maptalks").Size;
+                    set: (xmin: import("maptalks").WithNull<number>, ymin: import("maptalks").WithNull<number>, xmax: import("maptalks").WithNull<number>, ymax: import("maptalks").WithNull<number>) => import("maptalks").Extent;
+                    __combine: (extent: import("maptalks").PositionType | import("maptalks").Extent | import("maptalks").PointExtent) => number[];
+                    _combine: (extent: import("maptalks").PositionType | import("maptalks").Extent | import("maptalks").PointExtent) => import("maptalks").Extent;
+                    combine: (extent: import("maptalks").PositionType | import("maptalks").Extent | import("maptalks").PointExtent) => any;
+                    intersection: (extent: import("maptalks").Extent | import("maptalks").PointExtent) => any;
+                    expand: (distance: number | import("maptalks").Size) => import("maptalks").PointExtent | import("maptalks").Extent;
+                    _expand: (distance: number | import("maptalks").Size) => import("maptalks").Extent;
+                    toJSON: () => import("maptalks").JsonExtent;
+                    toArray: (out?: import("maptalks").PositionType[]) => import("maptalks").PositionType[];
+                    toString: () => string;
+                    copy: () => import("maptalks").PointExtent | import("maptalks").Extent;
+                    convertTo: {
+                        (fn: (p: import("maptalks").Point) => import("maptalks").Point, out?: import("maptalks").Extent | import("maptalks").PointExtent): import("maptalks").Extent | import("maptalks").PointExtent;
+                        (fn: (p: import("maptalks").Coordinate) => import("maptalks").Coordinate, out?: import("maptalks").Extent | import("maptalks").PointExtent): import("maptalks").Extent | import("maptalks").PointExtent;
+                    };
+                    _project: (ext: import("maptalks").Extent | import("maptalks").PointExtent) => void;
+                } | undefined;
+                limitExtentOnMaxExtent?: boolean | undefined;
+                fixCenterOnResize?: boolean | undefined;
+                checkSize?: boolean | undefined;
+                checkSizeInterval?: number | undefined;
+                renderer?: (import("maptalks").MapRendererType | import("maptalks").MapRendererType[]) | undefined;
+                cascadePitches?: Array<number> | undefined;
+                renderable?: boolean | undefined;
+                clickTimeThreshold?: number | undefined;
+                stopRenderOnOffscreen?: boolean | undefined;
+                preventWheelScroll?: boolean | undefined;
+                preventTouch?: boolean | undefined;
+                supportPluginEvent?: boolean | undefined;
+                switchDragButton?: boolean | undefined;
+                mousemoveThrottleTime?: number | undefined;
+                mousemoveThrottleEnable?: boolean | undefined;
+                maxFPS?: number | undefined;
+                debug?: boolean | undefined;
+                spatialReference?: {
+                    projection: string | {
+                        code: string;
+                        is: (code: string) => boolean;
+                        project: ((p: import("maptalks").Coordinate) => import("maptalks").Coordinate) & ((lnglat: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate);
+                        unproject: ((p: import("maptalks").Coordinate) => import("maptalks").Coordinate) & ((pLnglat: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate);
+                        projectCoords: (coordinates: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][], antiMeridian?: boolean) => import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                        unprojectCoords: (projCoords: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][]) => import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                        isSphere: () => boolean;
+                        isOutSphere: (pcoord: import("maptalks").Coordinate) => boolean;
+                        wrapCoord: (pcoord: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        getCircum: () => Record<string, number>;
+                        getSphereExtent: () => import("maptalks").Extent;
+                        rad: number;
+                        metersPerDegree: number;
+                        maxLatitude: number;
+                        measure: string;
+                        sphere: {
+                            radius: number;
+                            measureLenBetween: (c1: import("maptalks").CoordsLike, c2: import("maptalks").CoordsLike, ignoreAltitude?: boolean) => number;
+                            measureArea: (coordinates: import("maptalks").CoordsLike[]) => number;
+                            locate: (c: import("maptalks").CoordsLike, xDist: number, yDist: number, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                            _locate: (c: import("maptalks").Coordinate, xDist: number, yDist: number) => import("maptalks").WithNull<import("maptalks").Coordinate>;
+                            rotate: (c: import("maptalks").CoordsLike, pivot: import("maptalks").Coordinate, angle: number) => import("maptalks").Coordinate;
+                            _rotate: (c: import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number) => import("maptalks").Coordinate;
+                        };
+                        measureLenBetween: (c1: import("maptalks").CoordsLike, c2: import("maptalks").CoordsLike) => number;
+                        measureArea: (coordinates: import("maptalks").Coordinate[]) => number;
+                        _locate: (c: import("maptalks").CoordsLike, xDist: number, yDist: number) => any;
+                        locate: (c: import("maptalks").CoordsLike, xDist: number, yDist: number, out?: import("maptalks").Coordinate) => any;
+                        _rotate: (c: import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number) => any;
+                        rotate: (c: import("maptalks").CoordsLike, pivot: import("maptalks").Coordinate, angle: number) => any;
+                        measureLength: (c1: import("maptalks").Coordinate, c2: import("maptalks").Coordinate) => number;
+                    } | {
+                        code: string;
+                        is: (code: string) => boolean;
+                        project: ((p: import("maptalks").Coordinate) => import("maptalks").Coordinate) & ((p: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate);
+                        unproject: ((p: import("maptalks").Coordinate) => import("maptalks").Coordinate) & ((p: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate);
+                        projectCoords: (coordinates: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][], antiMeridian?: boolean) => import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                        unprojectCoords: (projCoords: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][]) => import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                        isSphere: () => boolean;
+                        isOutSphere: (pcoord: import("maptalks").Coordinate) => boolean;
+                        wrapCoord: (pcoord: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        getCircum: () => Record<string, number>;
+                        getSphereExtent: () => import("maptalks").Extent;
+                        aliases: string[];
+                        measure: string;
+                        sphere: {
+                            radius: number;
+                            measureLenBetween: (c1: import("maptalks").CoordsLike, c2: import("maptalks").CoordsLike, ignoreAltitude?: boolean) => number;
+                            measureArea: (coordinates: import("maptalks").CoordsLike[]) => number;
+                            locate: (c: import("maptalks").CoordsLike, xDist: number, yDist: number, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                            _locate: (c: import("maptalks").Coordinate, xDist: number, yDist: number) => import("maptalks").WithNull<import("maptalks").Coordinate>;
+                            rotate: (c: import("maptalks").CoordsLike, pivot: import("maptalks").Coordinate, angle: number) => import("maptalks").Coordinate;
+                            _rotate: (c: import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number) => import("maptalks").Coordinate;
+                        };
+                        measureLenBetween: (c1: import("maptalks").CoordsLike, c2: import("maptalks").CoordsLike) => number;
+                        measureArea: (coordinates: import("maptalks").Coordinate[]) => number;
+                        _locate: (c: import("maptalks").CoordsLike, xDist: number, yDist: number) => any;
+                        locate: (c: import("maptalks").CoordsLike, xDist: number, yDist: number, out?: import("maptalks").Coordinate) => any;
+                        _rotate: (c: import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number) => any;
+                        rotate: (c: import("maptalks").CoordsLike, pivot: import("maptalks").Coordinate, angle: number) => any;
+                        measureLength: (c1: import("maptalks").Coordinate, c2: import("maptalks").Coordinate) => number;
+                    } | {
+                        code: string;
+                        is: (code: string) => boolean;
+                        project: (p: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        unproject: (p: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        projectCoords: (coordinates: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][], antiMeridian?: boolean) => import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                        unprojectCoords: (projCoords: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][]) => import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                        isSphere: () => boolean;
+                        isOutSphere: (pcoord: import("maptalks").Coordinate) => boolean;
+                        wrapCoord: (pcoord: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        getCircum: () => Record<string, number>;
+                        getSphereExtent: () => import("maptalks").Extent;
+                        aliases: string[];
+                        centralMeridian: number;
+                        create: (params: Partial<import("maptalks").EPSG9807ProjectionParams>) => {
+                            code: string;
+                            is(code: string): boolean;
+                            project(p: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                            unproject(p: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                            projectCoords(coordinates: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][], antiMeridian?: boolean): import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                            unprojectCoords(projCoords: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][]): import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                            isSphere(): boolean;
+                            isOutSphere(pcoord: import("maptalks").Coordinate): boolean;
+                            wrapCoord(pcoord: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                            getCircum(): Record<string, number>;
+                            getSphereExtent(): import("maptalks").Extent;
+                        } & {
+                            code: string;
+                            aliases: string[];
+                            centralMeridian: number;
+                            project: (p: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                            unproject: (p: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        } & {
+                            measure: string;
+                            sphere: {
+                                radius: number;
+                                measureLenBetween(c1: import("maptalks").CoordinateJson | import("maptalks").Coordinate, c2: import("maptalks").CoordinateJson | import("maptalks").Coordinate, ignoreAltitude?: boolean): number;
+                                measureArea(coordinates: (import("maptalks").CoordinateJson | import("maptalks").Coordinate)[]): number;
+                                locate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, xDist: number, yDist: number, out?: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                                _locate(c: import("maptalks").Coordinate, xDist: number, yDist: number): import("maptalks").Coordinate;
+                                rotate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number): import("maptalks").Coordinate;
+                                _rotate(c: import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number): import("maptalks").Coordinate;
+                            };
+                            measureLenBetween(c1: import("maptalks").CoordinateJson | import("maptalks").Coordinate, c2: import("maptalks").CoordinateJson | import("maptalks").Coordinate): number;
+                            measureArea(coordinates: import("maptalks").Coordinate[]): number;
+                            _locate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, xDist: number, yDist: number): any;
+                            locate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, xDist: number, yDist: number, out?: import("maptalks").Coordinate): any;
+                            _rotate(c: import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number): any;
+                            rotate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number): any;
+                        } & {
+                            measureLength: (c1: import("maptalks").Coordinate, c2: import("maptalks").Coordinate) => number;
+                        };
+                    } | {
+                        code: string;
+                        is: (code: string) => boolean;
+                        project: ((p: import("maptalks").Coordinate) => import("maptalks").Coordinate) & ((p: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate);
+                        unproject: ((p: import("maptalks").Coordinate) => import("maptalks").Coordinate) & ((p: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate);
+                        projectCoords: (coordinates: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][], antiMeridian?: boolean) => import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                        unprojectCoords: (projCoords: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][]) => import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                        isSphere: () => boolean;
+                        isOutSphere: (pcoord: import("maptalks").Coordinate) => boolean;
+                        wrapCoord: (pcoord: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        getCircum: () => Record<string, number>;
+                        getSphereExtent: () => import("maptalks").Extent;
+                        measure: string;
+                        sphere: {
+                            radius: number;
+                            measureLenBetween: (c1: import("maptalks").CoordsLike, c2: import("maptalks").CoordsLike, ignoreAltitude?: boolean) => number;
+                            measureArea: (coordinates: import("maptalks").CoordsLike[]) => number;
+                            locate: (c: import("maptalks").CoordsLike, xDist: number, yDist: number, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                            _locate: (c: import("maptalks").Coordinate, xDist: number, yDist: number) => import("maptalks").WithNull<import("maptalks").Coordinate>;
+                            rotate: (c: import("maptalks").CoordsLike, pivot: import("maptalks").Coordinate, angle: number) => import("maptalks").Coordinate;
+                            _rotate: (c: import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number) => import("maptalks").Coordinate;
+                        };
+                        measureLenBetween: (c1: import("maptalks").CoordsLike, c2: import("maptalks").CoordsLike) => number;
+                        measureArea: (coordinates: import("maptalks").CoordsLike[]) => number;
+                        _locate: (c: import("maptalks").Coordinate, xDist: number, yDist: number) => any;
+                        locate: (c: import("maptalks").CoordsLike, xDist: number, yDist: number, out?: import("maptalks").Coordinate) => any;
+                        _rotate: (c: import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number) => any;
+                        rotate: (c: import("maptalks").CoordsLike, pivot: import("maptalks").Coordinate, angle: number) => any;
+                        measureLength: (c1: import("maptalks").Coordinate, c2: import("maptalks").Coordinate) => number;
+                        EARTHRADIUS: number;
+                        MCBAND: number[];
+                        LLBAND: number[];
+                        MC2LL: number[][];
+                        LL2MC: number[][];
+                        convertMC2LL: (cB: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        convertLL2MC: (T: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        convertor: (cC: import("maptalks").Coordinate, cD: number, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        toRadians: (T: number) => number;
+                        toDegrees: (T: number) => number;
+                        getRange: (cC: number, cB: number, T: number) => number;
+                        getLoop: (cC: number, cB: number, T: number) => number;
+                    } | {
+                        code: string;
+                        is: (code: string) => boolean;
+                        project: (p: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        unproject: (p: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        projectCoords: (coordinates: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][], antiMeridian?: boolean) => import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                        unprojectCoords: (projCoords: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][]) => import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                        isSphere: () => boolean;
+                        isOutSphere: (pcoord: import("maptalks").Coordinate) => boolean;
+                        wrapCoord: (pcoord: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        getCircum: () => Record<string, number>;
+                        getSphereExtent: () => import("maptalks").Extent;
+                        aliases: string[] & any[];
+                        centralMeridian: number;
+                        create: ((params: Partial<import("maptalks").EPSG9807ProjectionParams>) => {
+                            code: string;
+                            is(code: string): boolean;
+                            project(p: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                            unproject(p: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                            projectCoords(coordinates: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][], antiMeridian?: boolean): import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                            unprojectCoords(projCoords: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][]): import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                            isSphere(): boolean;
+                            isOutSphere(pcoord: import("maptalks").Coordinate): boolean;
+                            wrapCoord(pcoord: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                            getCircum(): Record<string, number>;
+                            getSphereExtent(): import("maptalks").Extent;
+                        } & {
+                            code: string;
+                            aliases: string[];
+                            centralMeridian: number;
+                            project: (p: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                            unproject: (p: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        } & {
+                            measure: string;
+                            sphere: {
+                                radius: number;
+                                measureLenBetween(c1: import("maptalks").CoordinateJson | import("maptalks").Coordinate, c2: import("maptalks").CoordinateJson | import("maptalks").Coordinate, ignoreAltitude?: boolean): number;
+                                measureArea(coordinates: (import("maptalks").CoordinateJson | import("maptalks").Coordinate)[]): number;
+                                locate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, xDist: number, yDist: number, out?: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                                _locate(c: import("maptalks").Coordinate, xDist: number, yDist: number): import("maptalks").Coordinate;
+                                rotate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number): import("maptalks").Coordinate;
+                                _rotate(c: import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number): import("maptalks").Coordinate;
+                            };
+                            measureLenBetween(c1: import("maptalks").CoordinateJson | import("maptalks").Coordinate, c2: import("maptalks").CoordinateJson | import("maptalks").Coordinate): number;
+                            measureArea(coordinates: import("maptalks").Coordinate[]): number;
+                            _locate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, xDist: number, yDist: number): any;
+                            locate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, xDist: number, yDist: number, out?: import("maptalks").Coordinate): any;
+                            _rotate(c: import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number): any;
+                            rotate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number): any;
+                        } & {
+                            measureLength: (c1: import("maptalks").Coordinate, c2: import("maptalks").Coordinate) => number;
+                        }) & ((params: Partial<import("maptalks").UTMProjectionParams>) => {
+                            code: string;
+                            is(code: string): boolean;
+                            project(p: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                            unproject(p: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                            projectCoords(coordinates: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][], antiMeridian?: boolean): import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                            unprojectCoords(projCoords: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][]): import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                            isSphere(): boolean;
+                            isOutSphere(pcoord: import("maptalks").Coordinate): boolean;
+                            wrapCoord(pcoord: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                            getCircum(): Record<string, number>;
+                            getSphereExtent(): import("maptalks").Extent;
+                        } & {
+                            code: string;
+                            aliases: string[];
+                            centralMeridian: number;
+                            project: (p: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                            unproject: (p: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        } & {
+                            measure: string;
+                            sphere: {
+                                radius: number;
+                                measureLenBetween(c1: import("maptalks").CoordinateJson | import("maptalks").Coordinate, c2: import("maptalks").CoordinateJson | import("maptalks").Coordinate, ignoreAltitude?: boolean): number;
+                                measureArea(coordinates: (import("maptalks").CoordinateJson | import("maptalks").Coordinate)[]): number;
+                                locate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, xDist: number, yDist: number, out?: import("maptalks").Coordinate): import("maptalks").Coordinate;
+                                _locate(c: import("maptalks").Coordinate, xDist: number, yDist: number): import("maptalks").Coordinate;
+                                rotate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number): import("maptalks").Coordinate;
+                                _rotate(c: import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number): import("maptalks").Coordinate;
+                            };
+                            measureLenBetween(c1: import("maptalks").CoordinateJson | import("maptalks").Coordinate, c2: import("maptalks").CoordinateJson | import("maptalks").Coordinate): number;
+                            measureArea(coordinates: import("maptalks").Coordinate[]): number;
+                            _locate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, xDist: number, yDist: number): any;
+                            locate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, xDist: number, yDist: number, out?: import("maptalks").Coordinate): any;
+                            _rotate(c: import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number): any;
+                            rotate(c: import("maptalks").CoordinateJson | import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number): any;
+                        } & {
+                            measureLength: (c1: import("maptalks").Coordinate, c2: import("maptalks").Coordinate) => number;
+                        });
+                    } | {
+                        code: string;
+                        is: (code: string) => boolean;
+                        project: ((p: import("maptalks").Coordinate) => import("maptalks").Coordinate) & ((p: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate);
+                        unproject: ((p: import("maptalks").Coordinate) => import("maptalks").Coordinate) & ((p: import("maptalks").Coordinate, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate);
+                        projectCoords: (coordinates: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][], antiMeridian?: boolean) => import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                        unprojectCoords: (projCoords: import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][]) => import("maptalks").Coordinate[] | import("maptalks").Coordinate[][] | import("maptalks").Coordinate[][][];
+                        isSphere: () => boolean;
+                        isOutSphere: (pcoord: import("maptalks").Coordinate) => boolean;
+                        wrapCoord: (pcoord: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+                        getCircum: () => Record<string, number>;
+                        getSphereExtent: () => import("maptalks").Extent;
+                        measure: string;
+                        measureLenBetween: (c1: import("maptalks").Coordinate | import("maptalks").CoordinateJson, c2: import("maptalks").Coordinate | import("maptalks").CoordinateJson, ignoreAltitude?: boolean) => number;
+                        measureArea: (coordinates: (import("maptalks").Coordinate | import("maptalks").CoordinateJson)[]) => number;
+                        locate: (c: import("maptalks").Coordinate | import("maptalks").CoordinateJson, xDist: number, yDist: number, out?: import("maptalks").Coordinate) => any;
+                        _locate: (c: import("maptalks").Coordinate, xDist: number, yDist: number) => import("maptalks").WithNull<import("maptalks").Coordinate>;
+                        rotate: (c: import("maptalks").Coordinate | import("maptalks").CoordinateJson, pivot: import("maptalks").Coordinate, angle: number) => any;
+                        _rotate: (c: import("maptalks").Coordinate, pivot: import("maptalks").Coordinate, angle: number) => import("maptalks").Coordinate;
+                        measureLength: (c1: import("maptalks").Coordinate, c2: import("maptalks").Coordinate) => number;
+                    };
+                    resolutions?: number[] | undefined;
+                    fullExtent?: {
+                        top: number;
+                        left: number;
+                        bottom: number;
+                        right: number;
+                    } | {
+                        xmin: number;
+                        xmax: number;
+                        ymin: number;
+                        ymax: number;
+                    } | undefined;
+                } | undefined;
+                autoPanAtEdge?: boolean | undefined;
+                boxZoom?: boolean | undefined;
+                boxZoomSymbol?: {
+                    markerType: string;
+                    markerLineWidth: number;
+                    markerLineColor: string;
+                    markerLineDasharray: Array<number>;
+                    markerFillOpacity: number;
+                    markerFill: string;
+                    markerWidth: number;
+                    markerHeight: number;
+                } | undefined;
+                onlyVisibleGeometryEvents?: boolean | undefined;
+                compassControl?: boolean | undefined;
+                layerSwitcherControl?: boolean | undefined;
+                navControl?: boolean | undefined;
+                resetControl?: boolean | undefined;
+                cameraFarUndergroundInMeter?: number | undefined;
+                onlyWebGL1?: boolean | undefined;
+                preserveDrawingBuffer?: boolean | undefined;
+                forceRedrawPerFrame?: boolean | undefined;
+                extensions?: string[] | undefined;
+                optionalExtensions?: string[] | undefined;
+            };
+            JSON_VERSION: "1.0";
+            attributionControl?: {
+                buildOn: () => HTMLDivElement;
+                getContent: () => string | HTMLElement;
+                setContent: (content: string | HTMLElement) => {
+                    buildOn(): HTMLDivElement;
+                    getContent(): string | HTMLElement;
+                    setContent(content: string | HTMLElement): /*elided*/ any;
+                    onAdd(): void;
+                    onRemove(): void;
+                    options: import("maptalks").ControlOptionsType & import("maptalks").AttributionOptionsTypeSpec;
+                    addTo(map: import("maptalks").Map): /*elided*/ any;
+                    update(): /*elided*/ any;
+                    getMap(): import("maptalks").Map;
+                    getPosition(): import("maptalks").DomPositionType;
+                    setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                    getContainerPoint(): import("maptalks").Point;
+                    getContainer(): HTMLElement;
+                    getDOM(): HTMLElement;
+                    show(): /*elided*/ any;
+                    hide(): /*elided*/ any;
+                    isVisible(): boolean;
+                    remove(): /*elided*/ any;
+                    onConfig(conf: import("maptalks").ClassOptions): void;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]>;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    addEventListener(...args: any[]): any;
+                    once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    removeEventListener(...args: any[]): any;
+                    listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                    getListeningEvents(): string[];
+                    copyEventListeners(target: any): any;
+                    fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                    _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                    _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                    _clearListeners(eventType: string): void;
+                    _clearAllListeners(): void;
+                    _setEventParent(parent: any): any;
+                    _setEventTarget(target: any): any;
+                    _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                    proxyOptions(): /*elided*/ any;
+                    callInitHooks(): /*elided*/ any;
+                    _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    config(conf?: string | import("maptalks").ClassOptions, value?: any): /*elided*/ any | import("maptalks").ClassOptions;
+                };
+                onAdd: () => void;
+                onRemove: () => void;
+                options: {
+                    position?: string | {
+                        top?: number | string | undefined;
+                        bottom?: number | string | undefined;
+                        left?: number | string | undefined;
+                        right?: number | string | undefined;
+                    } | undefined;
+                    cssName?: (string | Array<string>) | undefined;
+                    content?: (string | HTMLElement) | undefined;
+                    custom?: boolean | undefined;
+                };
+                addTo: (map: import("maptalks").Map) => {
+                    buildOn(): HTMLDivElement;
+                    getContent(): string | HTMLElement;
+                    setContent(content: string | HTMLElement): /*elided*/ any;
+                    onAdd(): void;
+                    onRemove(): void;
+                    options: import("maptalks").ControlOptionsType & import("maptalks").AttributionOptionsTypeSpec;
+                    addTo(map: import("maptalks").Map): /*elided*/ any;
+                    update(): /*elided*/ any;
+                    getMap(): import("maptalks").Map;
+                    getPosition(): import("maptalks").DomPositionType;
+                    setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                    getContainerPoint(): import("maptalks").Point;
+                    getContainer(): HTMLElement;
+                    getDOM(): HTMLElement;
+                    show(): /*elided*/ any;
+                    hide(): /*elided*/ any;
+                    isVisible(): boolean;
+                    remove(): /*elided*/ any;
+                    onConfig(conf: import("maptalks").ClassOptions): void;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]>;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    addEventListener(...args: any[]): any;
+                    once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    removeEventListener(...args: any[]): any;
+                    listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                    getListeningEvents(): string[];
+                    copyEventListeners(target: any): any;
+                    fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                    _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                    _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                    _clearListeners(eventType: string): void;
+                    _clearAllListeners(): void;
+                    _setEventParent(parent: any): any;
+                    _setEventTarget(target: any): any;
+                    _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                    proxyOptions(): /*elided*/ any;
+                    callInitHooks(): /*elided*/ any;
+                    _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    config(conf?: string | import("maptalks").ClassOptions, value?: any): /*elided*/ any | import("maptalks").ClassOptions;
+                };
+                update: () => {
+                    buildOn(): HTMLDivElement;
+                    getContent(): string | HTMLElement;
+                    setContent(content: string | HTMLElement): /*elided*/ any;
+                    onAdd(): void;
+                    onRemove(): void;
+                    options: import("maptalks").ControlOptionsType & import("maptalks").AttributionOptionsTypeSpec;
+                    addTo(map: import("maptalks").Map): /*elided*/ any;
+                    update(): /*elided*/ any;
+                    getMap(): import("maptalks").Map;
+                    getPosition(): import("maptalks").DomPositionType;
+                    setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                    getContainerPoint(): import("maptalks").Point;
+                    getContainer(): HTMLElement;
+                    getDOM(): HTMLElement;
+                    show(): /*elided*/ any;
+                    hide(): /*elided*/ any;
+                    isVisible(): boolean;
+                    remove(): /*elided*/ any;
+                    onConfig(conf: import("maptalks").ClassOptions): void;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]>;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    addEventListener(...args: any[]): any;
+                    once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    removeEventListener(...args: any[]): any;
+                    listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                    getListeningEvents(): string[];
+                    copyEventListeners(target: any): any;
+                    fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                    _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                    _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                    _clearListeners(eventType: string): void;
+                    _clearAllListeners(): void;
+                    _setEventParent(parent: any): any;
+                    _setEventTarget(target: any): any;
+                    _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                    proxyOptions(): /*elided*/ any;
+                    callInitHooks(): /*elided*/ any;
+                    _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    config(conf?: string | import("maptalks").ClassOptions, value?: any): /*elided*/ any | import("maptalks").ClassOptions;
+                };
+                getMap: () => import("maptalks").Map;
+                getPosition: () => import("maptalks").DomPositionType;
+                setPosition: (position: import("maptalks").ControlPositionType) => {
+                    buildOn(): HTMLDivElement;
+                    getContent(): string | HTMLElement;
+                    setContent(content: string | HTMLElement): /*elided*/ any;
+                    onAdd(): void;
+                    onRemove(): void;
+                    options: import("maptalks").ControlOptionsType & import("maptalks").AttributionOptionsTypeSpec;
+                    addTo(map: import("maptalks").Map): /*elided*/ any;
+                    update(): /*elided*/ any;
+                    getMap(): import("maptalks").Map;
+                    getPosition(): import("maptalks").DomPositionType;
+                    setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                    getContainerPoint(): import("maptalks").Point;
+                    getContainer(): HTMLElement;
+                    getDOM(): HTMLElement;
+                    show(): /*elided*/ any;
+                    hide(): /*elided*/ any;
+                    isVisible(): boolean;
+                    remove(): /*elided*/ any;
+                    onConfig(conf: import("maptalks").ClassOptions): void;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]>;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    addEventListener(...args: any[]): any;
+                    once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    removeEventListener(...args: any[]): any;
+                    listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                    getListeningEvents(): string[];
+                    copyEventListeners(target: any): any;
+                    fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                    _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                    _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                    _clearListeners(eventType: string): void;
+                    _clearAllListeners(): void;
+                    _setEventParent(parent: any): any;
+                    _setEventTarget(target: any): any;
+                    _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                    proxyOptions(): /*elided*/ any;
+                    callInitHooks(): /*elided*/ any;
+                    _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    config(conf?: string | import("maptalks").ClassOptions, value?: any): /*elided*/ any | import("maptalks").ClassOptions;
+                };
+                getContainerPoint: () => import("maptalks").Point;
+                getContainer: () => HTMLElement;
+                getDOM: () => HTMLElement;
+                show: () => {
+                    buildOn(): HTMLDivElement;
+                    getContent(): string | HTMLElement;
+                    setContent(content: string | HTMLElement): /*elided*/ any;
+                    onAdd(): void;
+                    onRemove(): void;
+                    options: import("maptalks").ControlOptionsType & import("maptalks").AttributionOptionsTypeSpec;
+                    addTo(map: import("maptalks").Map): /*elided*/ any;
+                    update(): /*elided*/ any;
+                    getMap(): import("maptalks").Map;
+                    getPosition(): import("maptalks").DomPositionType;
+                    setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                    getContainerPoint(): import("maptalks").Point;
+                    getContainer(): HTMLElement;
+                    getDOM(): HTMLElement;
+                    show(): /*elided*/ any;
+                    hide(): /*elided*/ any;
+                    isVisible(): boolean;
+                    remove(): /*elided*/ any;
+                    onConfig(conf: import("maptalks").ClassOptions): void;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]>;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    addEventListener(...args: any[]): any;
+                    once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    removeEventListener(...args: any[]): any;
+                    listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                    getListeningEvents(): string[];
+                    copyEventListeners(target: any): any;
+                    fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                    _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                    _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                    _clearListeners(eventType: string): void;
+                    _clearAllListeners(): void;
+                    _setEventParent(parent: any): any;
+                    _setEventTarget(target: any): any;
+                    _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                    proxyOptions(): /*elided*/ any;
+                    callInitHooks(): /*elided*/ any;
+                    _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    config(conf?: string | import("maptalks").ClassOptions, value?: any): /*elided*/ any | import("maptalks").ClassOptions;
+                };
+                hide: () => {
+                    buildOn(): HTMLDivElement;
+                    getContent(): string | HTMLElement;
+                    setContent(content: string | HTMLElement): /*elided*/ any;
+                    onAdd(): void;
+                    onRemove(): void;
+                    options: import("maptalks").ControlOptionsType & import("maptalks").AttributionOptionsTypeSpec;
+                    addTo(map: import("maptalks").Map): /*elided*/ any;
+                    update(): /*elided*/ any;
+                    getMap(): import("maptalks").Map;
+                    getPosition(): import("maptalks").DomPositionType;
+                    setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                    getContainerPoint(): import("maptalks").Point;
+                    getContainer(): HTMLElement;
+                    getDOM(): HTMLElement;
+                    show(): /*elided*/ any;
+                    hide(): /*elided*/ any;
+                    isVisible(): boolean;
+                    remove(): /*elided*/ any;
+                    onConfig(conf: import("maptalks").ClassOptions): void;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]>;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    addEventListener(...args: any[]): any;
+                    once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    removeEventListener(...args: any[]): any;
+                    listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                    getListeningEvents(): string[];
+                    copyEventListeners(target: any): any;
+                    fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                    _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                    _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                    _clearListeners(eventType: string): void;
+                    _clearAllListeners(): void;
+                    _setEventParent(parent: any): any;
+                    _setEventTarget(target: any): any;
+                    _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                    proxyOptions(): /*elided*/ any;
+                    callInitHooks(): /*elided*/ any;
+                    _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    config(conf?: string | import("maptalks").ClassOptions, value?: any): /*elided*/ any | import("maptalks").ClassOptions;
+                };
+                isVisible: () => boolean;
+                remove: () => {
+                    buildOn(): HTMLDivElement;
+                    getContent(): string | HTMLElement;
+                    setContent(content: string | HTMLElement): /*elided*/ any;
+                    onAdd(): void;
+                    onRemove(): void;
+                    options: import("maptalks").ControlOptionsType & import("maptalks").AttributionOptionsTypeSpec;
+                    addTo(map: import("maptalks").Map): /*elided*/ any;
+                    update(): /*elided*/ any;
+                    getMap(): import("maptalks").Map;
+                    getPosition(): import("maptalks").DomPositionType;
+                    setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                    getContainerPoint(): import("maptalks").Point;
+                    getContainer(): HTMLElement;
+                    getDOM(): HTMLElement;
+                    show(): /*elided*/ any;
+                    hide(): /*elided*/ any;
+                    isVisible(): boolean;
+                    remove(): /*elided*/ any;
+                    onConfig(conf: import("maptalks").ClassOptions): void;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]>;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    addEventListener(...args: any[]): any;
+                    once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    removeEventListener(...args: any[]): any;
+                    listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                    getListeningEvents(): string[];
+                    copyEventListeners(target: any): any;
+                    fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                    _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                    _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                    _clearListeners(eventType: string): void;
+                    _clearAllListeners(): void;
+                    _setEventParent(parent: any): any;
+                    _setEventTarget(target: any): any;
+                    _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                    proxyOptions(): /*elided*/ any;
+                    callInitHooks(): /*elided*/ any;
+                    _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    config(conf?: string | import("maptalks").ClassOptions, value?: any): /*elided*/ any | import("maptalks").ClassOptions;
+                };
+                onConfig: (conf: import("maptalks").ClassOptions) => void;
+                _eventMap?: Record<string, {
+                    handler: import("maptalks").HandlerFn;
+                    context: any;
+                }[]> | undefined;
+                _eventParent?: any;
+                _eventTarget?: any;
+                on: (eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+                addEventListener: (...args: any[]) => any;
+                once: (eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+                off: (eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+                removeEventListener: (...args: any[]) => any;
+                listens: (eventType: string, handler?: import("maptalks").HandlerFn, context?: any) => number;
+                getListeningEvents: () => string[];
+                copyEventListeners: (target: any) => any;
+                fire: (eventType: string, param?: import("maptalks").BaseEventParamsType) => any;
+                _wrapOnceHandler: (evtType: string, handler: import("maptalks").HandlerFn, context?: any) => (...args: any[]) => void;
+                _switch: (to: string, eventRecords: import("maptalks").EventRecords, context?: any) => any;
+                _clearListeners: (eventType: string) => void;
+                _clearAllListeners: () => void;
+                _setEventParent: (parent: any) => any;
+                _setEventTarget: (target: any) => any;
+                _fire: (eventType: string, param: import("maptalks").BaseEventParamsType) => any;
+                proxyOptions: () => {
+                    buildOn(): HTMLDivElement;
+                    getContent(): string | HTMLElement;
+                    setContent(content: string | HTMLElement): /*elided*/ any;
+                    onAdd(): void;
+                    onRemove(): void;
+                    options: import("maptalks").ControlOptionsType & import("maptalks").AttributionOptionsTypeSpec;
+                    addTo(map: import("maptalks").Map): /*elided*/ any;
+                    update(): /*elided*/ any;
+                    getMap(): import("maptalks").Map;
+                    getPosition(): import("maptalks").DomPositionType;
+                    setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                    getContainerPoint(): import("maptalks").Point;
+                    getContainer(): HTMLElement;
+                    getDOM(): HTMLElement;
+                    show(): /*elided*/ any;
+                    hide(): /*elided*/ any;
+                    isVisible(): boolean;
+                    remove(): /*elided*/ any;
+                    onConfig(conf: import("maptalks").ClassOptions): void;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]>;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    addEventListener(...args: any[]): any;
+                    once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    removeEventListener(...args: any[]): any;
+                    listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                    getListeningEvents(): string[];
+                    copyEventListeners(target: any): any;
+                    fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                    _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                    _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                    _clearListeners(eventType: string): void;
+                    _clearAllListeners(): void;
+                    _setEventParent(parent: any): any;
+                    _setEventTarget(target: any): any;
+                    _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                    proxyOptions(): /*elided*/ any;
+                    callInitHooks(): /*elided*/ any;
+                    _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    config(conf?: string | import("maptalks").ClassOptions, value?: any): /*elided*/ any | import("maptalks").ClassOptions;
+                };
+                callInitHooks: () => {
+                    buildOn(): HTMLDivElement;
+                    getContent(): string | HTMLElement;
+                    setContent(content: string | HTMLElement): /*elided*/ any;
+                    onAdd(): void;
+                    onRemove(): void;
+                    options: import("maptalks").ControlOptionsType & import("maptalks").AttributionOptionsTypeSpec;
+                    addTo(map: import("maptalks").Map): /*elided*/ any;
+                    update(): /*elided*/ any;
+                    getMap(): import("maptalks").Map;
+                    getPosition(): import("maptalks").DomPositionType;
+                    setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                    getContainerPoint(): import("maptalks").Point;
+                    getContainer(): HTMLElement;
+                    getDOM(): HTMLElement;
+                    show(): /*elided*/ any;
+                    hide(): /*elided*/ any;
+                    isVisible(): boolean;
+                    remove(): /*elided*/ any;
+                    onConfig(conf: import("maptalks").ClassOptions): void;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]>;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    addEventListener(...args: any[]): any;
+                    once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    removeEventListener(...args: any[]): any;
+                    listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                    getListeningEvents(): string[];
+                    copyEventListeners(target: any): any;
+                    fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                    _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                    _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                    _clearListeners(eventType: string): void;
+                    _clearAllListeners(): void;
+                    _setEventParent(parent: any): any;
+                    _setEventTarget(target: any): any;
+                    _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                    proxyOptions(): /*elided*/ any;
+                    callInitHooks(): /*elided*/ any;
+                    _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    config(conf?: string | import("maptalks").ClassOptions, value?: any): /*elided*/ any | import("maptalks").ClassOptions;
+                };
+                _setOptions: (options: import("maptalks").ClassOptions) => {
+                    buildOn(): HTMLDivElement;
+                    getContent(): string | HTMLElement;
+                    setContent(content: string | HTMLElement): /*elided*/ any;
+                    onAdd(): void;
+                    onRemove(): void;
+                    options: import("maptalks").ControlOptionsType & import("maptalks").AttributionOptionsTypeSpec;
+                    addTo(map: import("maptalks").Map): /*elided*/ any;
+                    update(): /*elided*/ any;
+                    getMap(): import("maptalks").Map;
+                    getPosition(): import("maptalks").DomPositionType;
+                    setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                    getContainerPoint(): import("maptalks").Point;
+                    getContainer(): HTMLElement;
+                    getDOM(): HTMLElement;
+                    show(): /*elided*/ any;
+                    hide(): /*elided*/ any;
+                    isVisible(): boolean;
+                    remove(): /*elided*/ any;
+                    onConfig(conf: import("maptalks").ClassOptions): void;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]>;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    addEventListener(...args: any[]): any;
+                    once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    removeEventListener(...args: any[]): any;
+                    listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                    getListeningEvents(): string[];
+                    copyEventListeners(target: any): any;
+                    fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                    _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                    _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                    _clearListeners(eventType: string): void;
+                    _clearAllListeners(): void;
+                    _setEventParent(parent: any): any;
+                    _setEventTarget(target: any): any;
+                    _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                    proxyOptions(): /*elided*/ any;
+                    callInitHooks(): /*elided*/ any;
+                    _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    config(conf?: string | import("maptalks").ClassOptions, value?: any): /*elided*/ any | import("maptalks").ClassOptions;
+                };
+                setOptions: (options: import("maptalks").ClassOptions) => {
+                    buildOn(): HTMLDivElement;
+                    getContent(): string | HTMLElement;
+                    setContent(content: string | HTMLElement): /*elided*/ any;
+                    onAdd(): void;
+                    onRemove(): void;
+                    options: import("maptalks").ControlOptionsType & import("maptalks").AttributionOptionsTypeSpec;
+                    addTo(map: import("maptalks").Map): /*elided*/ any;
+                    update(): /*elided*/ any;
+                    getMap(): import("maptalks").Map;
+                    getPosition(): import("maptalks").DomPositionType;
+                    setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                    getContainerPoint(): import("maptalks").Point;
+                    getContainer(): HTMLElement;
+                    getDOM(): HTMLElement;
+                    show(): /*elided*/ any;
+                    hide(): /*elided*/ any;
+                    isVisible(): boolean;
+                    remove(): /*elided*/ any;
+                    onConfig(conf: import("maptalks").ClassOptions): void;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]>;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    addEventListener(...args: any[]): any;
+                    once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    removeEventListener(...args: any[]): any;
+                    listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                    getListeningEvents(): string[];
+                    copyEventListeners(target: any): any;
+                    fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                    _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                    _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                    _clearListeners(eventType: string): void;
+                    _clearAllListeners(): void;
+                    _setEventParent(parent: any): any;
+                    _setEventTarget(target: any): any;
+                    _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                    proxyOptions(): /*elided*/ any;
+                    callInitHooks(): /*elided*/ any;
+                    _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    config(conf?: string | import("maptalks").ClassOptions, value?: any): /*elided*/ any | import("maptalks").ClassOptions;
+                };
+                config: (conf?: string | import("maptalks").ClassOptions, value?: any) => {
+                    buildOn(): HTMLDivElement;
+                    getContent(): string | HTMLElement;
+                    setContent(content: string | HTMLElement): /*elided*/ any;
+                    onAdd(): void;
+                    onRemove(): void;
+                    options: import("maptalks").ControlOptionsType & import("maptalks").AttributionOptionsTypeSpec;
+                    addTo(map: import("maptalks").Map): /*elided*/ any;
+                    update(): /*elided*/ any;
+                    getMap(): import("maptalks").Map;
+                    getPosition(): import("maptalks").DomPositionType;
+                    setPosition(position: import("maptalks").ControlPositionType): /*elided*/ any;
+                    getContainerPoint(): import("maptalks").Point;
+                    getContainer(): HTMLElement;
+                    getDOM(): HTMLElement;
+                    show(): /*elided*/ any;
+                    hide(): /*elided*/ any;
+                    isVisible(): boolean;
+                    remove(): /*elided*/ any;
+                    onConfig(conf: import("maptalks").ClassOptions): void;
+                    _eventMap?: Record<string, {
+                        handler: import("maptalks").HandlerFn;
+                        context: any;
+                    }[]>;
+                    _eventParent?: any;
+                    _eventTarget?: any;
+                    on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    addEventListener(...args: any[]): any;
+                    once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                    removeEventListener(...args: any[]): any;
+                    listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                    getListeningEvents(): string[];
+                    copyEventListeners(target: any): any;
+                    fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                    _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                    _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                    _clearListeners(eventType: string): void;
+                    _clearAllListeners(): void;
+                    _setEventParent(parent: any): any;
+                    _setEventTarget(target: any): any;
+                    _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                    proxyOptions(): /*elided*/ any;
+                    callInitHooks(): /*elided*/ any;
+                    _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                    config(conf?: string | import("maptalks").ClassOptions, value?: any): /*elided*/ any | import("maptalks").ClassOptions;
+                } | import("maptalks").ClassOptions;
+            } | undefined;
+            isLoaded: () => boolean;
+            getContainer: () => HTMLCanvasElement | HTMLDivElement;
+            getSpatialReference: () => import("maptalks").SpatialReference;
+            setSpatialReference: (ref: import("maptalks").SpatialReferenceType) => import("maptalks").Map;
+            onConfig: (conf: {
+                [key: string]: any;
+            }) => import("maptalks").Map;
+            getProjection: () => import("maptalks").ProjectionType;
+            getFullExtent: () => import("maptalks").Extent;
+            setCursor: (cursor: string) => import("maptalks").Map;
+            resetCursor: () => import("maptalks").Map;
+            getCenter: () => import("maptalks").Coordinate;
+            setCenter: (center: import("maptalks").Coordinate, padding?: import("maptalks").MapPaddingType) => import("maptalks").Map;
+            getSize: () => import("maptalks").Size;
+            getContainerExtent: () => import("maptalks").PointExtent;
+            getExtent: () => import("maptalks").Extent;
+            getProjExtent: () => import("maptalks").Extent;
+            getPrjExtent: () => import("maptalks").Extent;
+            getMaxExtent: () => import("maptalks").Extent;
+            setMaxExtent: (extent: import("maptalks").Extent) => import("maptalks").Map;
+            getZoom: () => number;
+            getZoomForScale: (scale: number, fromZoom?: number, isFraction?: boolean) => number;
+            getZoomFromRes: (res: number) => number;
+            setZoom: (zoom: number, options?: {
+                animation: boolean;
+            } | undefined) => import("maptalks").Map;
+            getMaxZoom: () => number;
+            setMaxZoom: (maxZoom: number) => import("maptalks").Map;
+            getMinZoom: () => number;
+            setMinZoom: (minZoom: number) => import("maptalks").Map;
+            getMaxNativeZoom: () => number;
+            getGLRes: () => number;
+            getGLScale: (zoom?: number) => number;
+            zoomIn: () => import("maptalks").Map;
+            zoomOut: () => import("maptalks").Map;
+            isZooming: () => boolean;
+            isInteracting: () => boolean;
+            setCenterAndZoom: (center: import("maptalks").Coordinate, zoom?: number) => import("maptalks").Map;
+            getFitZoom: (extent: import("maptalks").Extent, isFraction?: boolean, padding?: import("maptalks").MapPaddingType) => number;
+            getView: () => import("maptalks").MapViewType;
+            setView: (view: import("maptalks").MapViewType) => import("maptalks").Map;
+            getResolution: (zoom?: number) => number;
+            getScale: (zoom?: number) => number;
+            fitExtent: (extent: import("maptalks").ExtentLike, zoomOffset?: number, options?: import("maptalks").MapFitType, step?: ((frame: any) => void) | undefined) => import("maptalks").Map | {
+                options: import("maptalks").AnimationOptionsPrivateType;
+                playState: string;
+                ready: boolean;
+                finished: boolean;
+                target?: any;
+                duration: number;
+                currentTime: number;
+                startTime: number;
+                play(): /*elided*/ any;
+                pause(): /*elided*/ any;
+                cancel(): /*elided*/ any;
+                finish(): /*elided*/ any;
+                reverse(): void;
+            };
+            getBaseLayer: () => import("maptalks").Layer;
+            setBaseLayer: (baseLayer: import("maptalks").Layer) => import("maptalks").Map;
+            removeBaseLayer: () => import("maptalks").Map;
+            getLayers: (filter?: ((layer: import("maptalks").Layer) => boolean) | undefined) => Array<import("maptalks").Layer>;
+            getLayer: (id: string) => import("maptalks").Layer | null;
+            addLayer: (layers: import("maptalks").Layer | Array<import("maptalks").Layer>, ...otherLayers: Array<import("maptalks").Layer>) => import("maptalks").Map;
+            removeLayer: (layers: import("maptalks").Layer | Array<import("maptalks").Layer>) => import("maptalks").Map;
+            sortLayers: (layers: Array<import("maptalks").Layer>) => import("maptalks").Map;
+            toDataURL: (options?: import("maptalks").MapDataURLType) => string | null;
+            coordToPoint: (coordinate: import("maptalks").Coordinate, zoom?: number, out?: import("maptalks").Point) => import("maptalks").Point;
+            coordToPointAtRes: (coordinate: import("maptalks").Coordinate, res?: number, out?: import("maptalks").Point) => import("maptalks").Point;
+            pointToCoord: (point: import("maptalks").Point, zoom?: number, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+            pointAtResToCoord: (point: import("maptalks").Point, res?: number, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+            coordToViewPoint: (coordinate: import("maptalks").Coordinate, out?: import("maptalks").Point, altitude?: number) => import("maptalks").Point;
+            viewPointToCoord: (viewPoint: import("maptalks").Point, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+            coordToContainerPoint: (coordinate: import("maptalks").Coordinate, zoom?: number, out?: import("maptalks").Point) => import("maptalks").Point;
+            containerPointToCoord: (containerPoint: import("maptalks").Point, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+            containerPointToViewPoint: (containerPoint: import("maptalks").Point, out?: import("maptalks").Point) => import("maptalks").Point;
+            viewPointToContainerPoint: (viewPoint: import("maptalks").Point, out?: import("maptalks").Point) => import("maptalks").Point;
+            checkSize: (force?: boolean) => import("maptalks").Map;
+            locate: (coordinate: import("maptalks").Coordinate, dx: number, dy: number) => import("maptalks").Coordinate;
+            getMainPanel: () => HTMLDivElement | null;
+            getPanels: () => Record<string, import("maptalks").PanelDom>;
+            remove: () => import("maptalks").Map;
+            isRemoved: () => boolean;
+            isMoving: () => boolean;
+            onMoveStart: (param?: any) => void;
+            onMoving: (param: any) => void;
+            onMoveEnd: (param: any) => void;
+            onDragRotateStart: (param: any) => void;
+            onDragRotating: (param: any) => void;
+            onDragRotateEnd: (param: any) => void;
+            isDragRotating: () => boolean;
+            isOffscreen: (box: import("maptalks").PointExtent | Array<number>, viewportPadding?: number) => boolean;
+            getRenderer: () => any;
+            getDevicePixelRatio: () => number;
+            setDevicePixelRatio: (dpr: number) => import("maptalks").Map;
+            setContainerDomRect: (domRect: DOMRect) => void;
+            offsetPlatform: (offset?: import("maptalks").Point) => import("maptalks").Point;
+            getViewPoint: () => import("maptalks").Point;
+            toJSON: (options?: import("maptalks").MapOptionsType) => {
+                [key: string]: any;
+            };
+            isRotating: () => boolean;
+            animateTo: (view: import("maptalks").MapViewType, options?: import("maptalks").MapAnimationOptionsType, step?: ((frame: any) => void) | undefined) => {
+                options: import("maptalks").AnimationOptionsPrivateType;
+                playState: string;
+                ready: boolean;
+                finished: boolean;
+                target?: any;
+                duration: number;
+                currentTime: number;
+                startTime: number;
+                play(): /*elided*/ any;
+                pause(): /*elided*/ any;
+                cancel(): /*elided*/ any;
+                finish(): /*elided*/ any;
+                reverse(): void;
+            };
+            flyTo: (view: import("maptalks").MapViewType, options?: import("maptalks").MapAnimationOptionsType, step?: ((frame: any) => void) | undefined) => import("maptalks").Map;
+            isAnimating: () => boolean;
+            isFullScreen: () => boolean;
+            requestFullScreen: (dom?: HTMLDivElement) => import("maptalks").Map;
+            cancelFullScreen: () => import("maptalks").Map;
+            panTo: (coordinate: import("maptalks").Coordinate, options?: import("maptalks").MapAnimationOptionsType, step?: ((frame: any) => void) | undefined) => import("maptalks").Map;
+            panBy: (offset: import("maptalks").Point | Array<number>, options?: import("maptalks").MapAnimationOptionsType, step?: ((frame: any) => void) | undefined) => import("maptalks").Map;
+            computeLength: (coord1: import("maptalks").Coordinate, coord2: import("maptalks").Coordinate) => number;
+            computeGeometryLength: (geometry: import("maptalks").Geometry) => number;
+            computeGeometryArea: (geometry: import("maptalks").Geometry) => number;
+            identify: (opts: import("maptalks").identifyOptionsType, cb: import("maptalks").MapIdentifyCBType) => void;
+            identifyAtPoint: (opts: import("maptalks").identifyAtPointOptionsType, cb: import("maptalks").MapIdentifyCBType) => void;
+            onZoomStart: (nextZoom: number, origin?: import("maptalks").Point) => any;
+            onZooming: (nextZoom: number, origin?: import("maptalks").Point, startScale?: number) => any;
+            onZoomEnd: (nextZoom: number, origin?: import("maptalks").Point) => any;
+            cameraPosition: [number, number, number];
+            cameraLookAt: [number, number, number];
+            projViewMatrix: [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
+            getFov: () => number;
+            setFov: (fov: number) => import("maptalks").Map;
+            getBearing: () => number;
+            setBearing: (bearing: number) => import("maptalks").Map;
+            getPitch: () => number;
+            setPitch: (pitch: number) => import("maptalks").Map;
+            setCameraMovements: (frameOptions: Array<import("maptalks").MapViewType>, option?: {
+                autoRotate: boolean;
+            } | undefined) => any;
+            setCameraOrientation: (params: import("maptalks").MapViewType) => import("maptalks").Map;
+            setCameraPosition: (coordinate: import("maptalks").Coordinate) => any;
+            getFitZoomForCamera: (cameraPosition: [number, number, number], pitch: number) => any;
+            getFitZoomForAltitude: (altitude: number) => any;
+            isTransforming: () => boolean;
+            getFrustumAltitude: () => number;
+            updateCenterAltitude: () => any;
+            getContainerPointRay: (from: import("maptalks").Vector3, to: import("maptalks").Vector3, containerPoint: import("maptalks").Point, near?: number, far?: number) => any;
+            zoomToPreviousView: (options?: any) => import("maptalks").MapViewType;
+            hasPreviousView: () => boolean;
+            zoomToNextView: (options?: any) => import("maptalks").MapViewType;
+            hasNextView: () => boolean;
+            getViewHistory: () => Array<import("maptalks").MapViewType>;
+            getCollisionIndex: () => import("maptalks").CollisionIndex;
+            createCollisionIndex: () => import("maptalks").CollisionIndex;
+            clearCollisionIndex: () => import("maptalks").Map;
+            uiCollides: () => import("maptalks").Map;
+            coordinateToPoint: (coordinate: import("maptalks").Coordinate, zoom?: number, out?: import("maptalks").Point) => import("maptalks").Point;
+            coordinateToPointAtRes: (coordinate: import("maptalks").Coordinate, res?: number, out?: import("maptalks").Point) => import("maptalks").Point;
+            pointToCoordinate: (point: import("maptalks").Point, zoom?: number, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+            pointAtResToCoordinate: (point: import("maptalks").Point, res?: number, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+            coordinateToViewPoint: (coordinate: import("maptalks").Coordinate, out?: import("maptalks").Point, altitude?: number) => import("maptalks").Point;
+            viewPointToCoordinate: (viewPoint: import("maptalks").Point, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+            coordinateToContainerPoint: (coordinate: import("maptalks").Coordinate, zoom?: number, out?: import("maptalks").Point) => import("maptalks").Point;
+            coordinateToContainerPointAtRes: (coordinate: import("maptalks").Coordinate, res?: number, out?: import("maptalks").Point) => import("maptalks").Point;
+            coordinatesToContainerPoints: (coordinates: Array<import("maptalks").Coordinate>, zoom?: number) => Array<import("maptalks").Point>;
+            coordinatesToContainerPointsAtRes: (coordinates: Array<import("maptalks").Coordinate>, res?: number) => Array<import("maptalks").Point>;
+            containerPointToCoordinate: (containerPoint: import("maptalks").Point, out?: import("maptalks").Coordinate) => import("maptalks").Coordinate;
+            containerToExtent: (containerExtent: import("maptalks").PointExtent) => import("maptalks").Extent;
+            distanceToPixel: (xDist: number, yDist: number, zoom?: number) => import("maptalks").Size;
+            distanceToPoint: (xDist: number, yDist: number, zoom?: number, paramCenter?: import("maptalks").Coordinate) => import("maptalks").Point;
+            distanceToPointAtRes: (xDist: number, yDist: number, res?: number, paramCenter?: import("maptalks").Coordinate, out?: import("maptalks").Point) => import("maptalks").Point;
+            altitudeToPoint: (altitude: number, res?: number, originCenter?: import("maptalks").Coordinate) => number;
+            pointAtResToAltitude: (point: import("maptalks").Point, res?: number, originCenter?: import("maptalks").Coordinate) => number;
+            pixelToDistance: (width: number, height: number) => number;
+            pointToDistance: (dx: number, dy: number, zoom?: number) => number;
+            pointAtResToDistance: (dx: number, dy: number, res?: number, paramCenter?: import("maptalks").Coordinate) => number;
+            locateByPoint: (coordinate: import("maptalks").Coordinate, px: number, py: number) => import("maptalks").Coordinate;
+            get2DExtent: (zoom?: number, out?: import("maptalks").PointExtent) => import("maptalks").PointExtent;
+            get2DExtentAtRes: (res?: number, out?: import("maptalks").PointExtent) => import("maptalks").PointExtent;
+            pointToExtent: (extent2D: import("maptalks").PointExtent) => import("maptalks").Extent;
+            getViewPointFrameOffset: () => import("maptalks").Point | null;
+            viewPointToPrj: (viewPoint: import("maptalks").Point, out?: import("maptalks").Point) => import("maptalks").Point;
+            prjToContainerPoint: (pCoordinate: import("maptalks").Coordinate, zoom?: number, out?: import("maptalks").Point, altitude?: number) => import("maptalks").Point;
+            prjToContainerPointAtRes: (pCoordinate: import("maptalks").Coordinate, res?: number, out?: import("maptalks").Point, altitude?: number) => import("maptalks").Point;
+            prjToViewPoint: (pCoordinate: import("maptalks").Coordinate, out?: import("maptalks").Point, altitude?: number) => import("maptalks").Point;
+            viewPointToPoint: (viewPoint: import("maptalks").Point, zoom?: number, out?: import("maptalks").Point) => import("maptalks").Point;
+            pointToViewPoint: (point: import("maptalks").Point, zoom?: number, out?: import("maptalks").Point) => import("maptalks").Point;
+            _handlers?: {
+                target: any;
+                dom?: HTMLElement | undefined;
+                addHooks: () => void;
+                removeHooks: () => void;
+                enable: () => import("maptalks").Handler;
+                disable: () => import("maptalks").Handler;
+                enabled: () => boolean;
+                remove: () => void;
+                _eventMap?: Record<string, {
+                    handler: import("maptalks").HandlerFn;
+                    context: any;
+                }[]> | undefined;
+                _eventParent?: any;
+                _eventTarget?: any;
+                on: (eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+                addEventListener: (...args: any[]) => any;
+                once: (eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+                off: (eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+                removeEventListener: (...args: any[]) => any;
+                listens: (eventType: string, handler?: import("maptalks").HandlerFn, context?: any) => number;
+                getListeningEvents: () => string[];
+                copyEventListeners: (target: any) => any;
+                fire: (eventType: string, param?: import("maptalks").BaseEventParamsType) => any;
+                _wrapOnceHandler: (evtType: string, handler: import("maptalks").HandlerFn, context?: any) => (...args: any[]) => void;
+                _switch: (to: string, eventRecords: import("maptalks").EventRecords, context?: any) => any;
+                _clearListeners: (eventType: string) => void;
+                _clearAllListeners: () => void;
+                _setEventParent: (parent: any) => any;
+                _setEventTarget: (target: any) => any;
+                _fire: (eventType: string, param: import("maptalks").BaseEventParamsType) => any;
+            }[] | undefined;
+            addHandler: (name: any, handlerClass: any) => any;
+            removeHandler: (name: any) => any;
+            _clearHandlers: () => void;
+            _eventMap?: Record<string, {
+                handler: import("maptalks").HandlerFn;
+                context: any;
+            }[]> | undefined;
+            _eventParent?: any;
+            _eventTarget?: any;
+            on: (eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+            addEventListener: (...args: any[]) => any;
+            once: (eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+            off: (eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any) => any;
+            removeEventListener: (...args: any[]) => any;
+            listens: (eventType: string, handler?: import("maptalks").HandlerFn, context?: any) => number;
+            getListeningEvents: () => string[];
+            copyEventListeners: (target: any) => any;
+            fire: (eventType: string, param?: import("maptalks").BaseEventParamsType) => any;
+            _wrapOnceHandler: (evtType: string, handler: import("maptalks").HandlerFn, context?: any) => (...args: any[]) => void;
+            _switch: (to: string, eventRecords: import("maptalks").EventRecords, context?: any) => any;
+            _clearListeners: (eventType: string) => void;
+            _clearAllListeners: () => void;
+            _setEventParent: (parent: any) => any;
+            _setEventTarget: (target: any) => any;
+            _fire: (eventType: string, param: import("maptalks").BaseEventParamsType) => any;
+            proxyOptions: () => import("maptalks").Map;
+            callInitHooks: () => import("maptalks").Map;
+            _setOptions: (options: import("maptalks").ClassOptions) => import("maptalks").Map;
+            setOptions: (options: import("maptalks").ClassOptions) => import("maptalks").Map;
+            config: (conf?: string | import("maptalks").ClassOptions, value?: any) => import("maptalks").Map | import("maptalks").ClassOptions;
+            setMenu: (options: import("maptalks").MenuOptionsType) => import("maptalks").Map;
+            getMenu: () => {
+                options: import("maptalks").MenuOptionsType;
+                addTo(owner: import("maptalks").Geometry | import("maptalks").Map): any;
+                setItems(items: Array<import("maptalks").MenuItem>): /*elided*/ any;
+                getItems(): import("maptalks").MenuItem[];
+                buildOn(): HTMLElement;
+                getOffset(): import("maptalks").Point;
+                getTransformOrigin(): string;
+                getEvents(): {
+                    "_zoomstart _zoomend _movestart _dblclick _click": () => void;
+                };
+                onAdd(): void;
+                onRemove(): void;
+                onDomRemove(): void;
+                getOwnerEvents(): {
+                    [key: string]: () => void;
+                };
+                getMap(): import("maptalks").Map;
+                show(coordinate: import("maptalks").Coordinate): /*elided*/ any;
+                hide(): /*elided*/ any;
+                isVisible(): boolean;
+                remove(): /*elided*/ any;
+                getSize(): import("maptalks").Size;
+                getOwner(): import("maptalks").Map | import("maptalks").Geometry;
+                getDOM(): HTMLElement;
+                setZIndex(zIndex: number): /*elided*/ any;
+                getPosition(): import("maptalks").Point;
+                onGeometryPositionChange(param: any): void;
+                onMoving(): void;
+                onEvent(): void;
+                onZoomEnd(): void;
+                onResize(): void;
+                onDomSizeChange(): void;
+                isSupportZoomFilter(): boolean;
+                onConfig(config: Record<string, any>): /*elided*/ any;
+                _eventMap?: Record<string, {
+                    handler: import("maptalks").HandlerFn;
+                    context: any;
+                }[]>;
+                _eventParent?: any;
+                _eventTarget?: any;
+                on(eventsOn: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                addEventListener(...args: any[]): any;
+                once(eventTypes: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                off(eventsOff: string | import("maptalks").EventRecords, handler: import("maptalks").HandlerFn, context?: any): any;
+                removeEventListener(...args: any[]): any;
+                listens(eventType: string, handler?: import("maptalks").HandlerFn, context?: any): number;
+                getListeningEvents(): string[];
+                copyEventListeners(target: any): any;
+                fire(eventType: string, param?: import("maptalks").BaseEventParamsType): any;
+                _wrapOnceHandler(evtType: string, handler: import("maptalks").HandlerFn, context?: any): (...args: any[]) => void;
+                _switch(to: string, eventRecords: import("maptalks").EventRecords, context?: any): any;
+                _clearListeners(eventType: string): void;
+                _clearAllListeners(): void;
+                _setEventParent(parent: any): any;
+                _setEventTarget(target: any): any;
+                _fire(eventType: string, param: import("maptalks").BaseEventParamsType): any;
+                proxyOptions(): /*elided*/ any;
+                callInitHooks(): /*elided*/ any;
+                _setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                setOptions(options: import("maptalks").ClassOptions): /*elided*/ any;
+                config(conf?: string | import("maptalks").ClassOptions, value?: any): import("maptalks").ClassOptions | /*elided*/ any;
+            };
+            openMenu: (coordinate?: import("maptalks").Coordinate) => import("maptalks").Map;
+            setMenuItems: (items: Array<import("maptalks").MenuItem>) => import("maptalks").Map;
+            getMenuItems: () => Array<import("maptalks").MenuItem>;
+            closeMenu: () => import("maptalks").Map;
+            removeMenu: () => import("maptalks").Map;
         };
-        readonly coordType: import("./index.ts").CoordType;
+        readonly coordType: import("tg-map-core").CoordType;
         addEventListener: {
             <K extends keyof AbstractMapEventMap>(type: K, listener: (event: AbstractMapEventMap[K]) => void): void;
-            (type: string, listener: import("./index.ts").Tg.EventListener): void;
+            (type: string, listener: import("tg-map-core").Tg.EventListener): void;
         };
         removeEventListener: {
             <K extends keyof AbstractMapEventMap>(type: K, listener: (event: AbstractMapEventMap[K]) => void): void;
-            (type: string, listener: import("./index.ts").Tg.EventListener): void;
+            (type: string, listener: import("tg-map-core").Tg.EventListener): void;
         };
-        getLatestInfoWindow: () => import("./index.ts").InfoWindowOverlay | undefined;
-        setLatestInfoWindowInternal: (infoWindow: import("./index.ts").InfoWindowOverlay) => void;
-        fromContainerPointToLatLng: (point: import("./index.ts").Point) => LatLng;
-        fromLatLngToContainerPoint: (latLng: LatLng) => import("./index.ts").Point;
+        getLatestInfoWindow: () => import("tg-map-core").InfoWindowOverlay | undefined;
+        setLatestInfoWindowInternal: (infoWindow: import("tg-map-core").InfoWindowOverlay) => void;
+        fromContainerPointToLatLng: (point: import("tg-map-core").Point) => LatLng;
+        fromLatLngToContainerPoint: (latLng: LatLng) => import("tg-map-core").Point;
         setDefaultCursor: (cursor: import("csstype").Property.Cursor) => void;
         setDraggable: (draggable: boolean) => void;
         setDoubleClickZoom: (enable: boolean) => void;
@@ -650,40 +2444,40 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         setBuildInMapTypeId: (id: BuildInMapTypeId) => void;
         setMapType: (mapType: MapType) => void;
         getMapType: () => MapType;
-        addLayer: (layer: import("./index.ts").Layer) => void;
-        removeLayer: (layer: import("./index.ts").Layer) => void;
-        addOverlayMapType: (mapType: import("./index.ts").OverlayMapType) => void;
-        removeOverlayMapType: (mapType: import("./index.ts").OverlayMapType) => void;
+        addLayer: (layer: import("tg-map-core").Layer) => void;
+        removeLayer: (layer: import("tg-map-core").Layer) => void;
+        addOverlayMapType: (mapType: import("tg-map-core").OverlayMapType) => void;
+        removeOverlayMapType: (mapType: import("tg-map-core").OverlayMapType) => void;
         panTo: (position: LatLng) => void;
         panBy: (x: number, y: number) => void;
-        fitBounds: (bounds: import("./index.ts").LatLngBounds, padding?: import("./index.ts").Padding) => void;
-        getBounds: () => import("./index.ts").LatLngBounds;
-        addElementOverlay: (overlay: import("./index.ts").ElementOverlay) => void;
-        removeElementOverlay: (overlay: import("./index.ts").ElementOverlay) => void;
-        addOverlay: (overlay: import("./index.ts").Overlay) => void;
-        removeOverlay: (overlay: import("./index.ts").Overlay) => void;
-        createMarker: (options: import("./index.ts").MarkerOptions) => import("./index.ts").MarkerOverlay;
-        createMarkerClusterer: (options: import("./index.ts").MarkerClustererOptions) => import("./index.ts").MarkerClusterer;
-        createHeatmap: (options: import("./index.ts").HeatmapOptions) => import("./index.ts").Heatmap;
-        createAutocomplete: (options: import("./index.ts").AutocompleteOptions) => import("./index.ts").Autocomplete;
-        createSearchBox: (options: import("./index.ts").SearchBoxOptions) => import("./index.ts").SearchBox;
-        createPlacesService: (options: import("./index.ts").PlacesServiceOptions) => import("./index.ts").PlacesService;
-        createMapUrls: (options: import("./index.ts").MapUrlsOptions) => import("./index.ts").MapUrls;
-        createInfoWindow: (options: import("./index.ts").InfoWindowOptions) => import("./index.ts").InfoWindowOverlay;
-        createInfoBox: (options: import("./index.ts").InfoBoxOptions) => import("./index.ts").InfoBoxOverlay;
-        createPolyline: (options: import("./index.ts").PolylineOptions) => import("./index.ts").PolylineOverlay;
-        createPolygon: (options: import("./index.ts").PolygonOptions) => import("./index.ts").PolygonOverlay;
-        createRectangle: (options: import("./index.ts").RectangleOptions) => import("./index.ts").RectangleOverlay;
-        createCircle: (options: import("./index.ts").CircleOptions) => import("./index.ts").CircleOverlay;
-        createLabel: (options: import("../map/map/overlay/label.ts").LabelOptions) => import("../map/map/overlay/label.ts").LabelOverlay;
-        addCustomControl: (control: import("./index.ts").CustomControl) => void;
-        removeCustomControl: (control: import("./index.ts").CustomControl) => void;
-        createMapTypeControl: (options: import("./index.ts").MapTypeControlOptions) => import("./index.ts").MapTypeControl;
-        createZoomControl: (options: import("./index.ts").ZoomControlOptions) => import("./index.ts").ZoomControl;
-        createStreetViewControl: (options: import("./index.ts").StreetViewControlOptions) => import("./index.ts").StreetViewControl;
-        createScaleControl: (options: import("./index.ts").ScaleControlOptions) => import("./index.ts").ZoomControl;
-        addControl: (control: import("./index.ts").AbstractControl) => void;
-        removeControl: (control: import("./index.ts").AbstractControl) => void;
+        fitBounds: (bounds: import("tg-map-core").LatLngBounds, padding?: import("tg-map-core").Padding) => void;
+        getBounds: () => import("tg-map-core").LatLngBounds;
+        addElementOverlay: (overlay: import("tg-map-core").ElementOverlay) => void;
+        removeElementOverlay: (overlay: import("tg-map-core").ElementOverlay) => void;
+        addOverlay: (overlay: import("tg-map-core").Overlay) => void;
+        removeOverlay: (overlay: import("tg-map-core").Overlay) => void;
+        createMarker: (options: import("tg-map-core").MarkerOptions) => import("tg-map-core").MarkerOverlay;
+        createMarkerClusterer: (options: import("tg-map-core").MarkerClustererOptions) => import("tg-map-core").MarkerClusterer;
+        createHeatmap: (options: import("tg-map-core").HeatmapOptions) => import("tg-map-core").Heatmap;
+        createAutocomplete: (options: import("tg-map-core").AutocompleteOptions) => import("tg-map-core").Autocomplete;
+        createSearchBox: (options: import("tg-map-core").SearchBoxOptions) => import("tg-map-core").SearchBox;
+        createPlacesService: (options: import("tg-map-core").PlacesServiceOptions) => import("tg-map-core").PlacesService;
+        createMapUrls: (options: import("tg-map-core").MapUrlsOptions) => import("tg-map-core").MapUrls;
+        createInfoWindow: (options: import("tg-map-core").InfoWindowOptions) => import("tg-map-core").InfoWindowOverlay;
+        createInfoBox: (options: import("tg-map-core").InfoBoxOptions) => import("tg-map-core").InfoBoxOverlay;
+        createPolyline: (options: import("tg-map-core").PolylineOptions) => import("tg-map-core").PolylineOverlay;
+        createPolygon: (options: import("tg-map-core").PolygonOptions) => import("tg-map-core").PolygonOverlay;
+        createRectangle: (options: import("tg-map-core").RectangleOptions) => import("tg-map-core").RectangleOverlay;
+        createCircle: (options: import("tg-map-core").CircleOptions) => import("tg-map-core").CircleOverlay;
+        createLabel: (options: import("tg-map-core").LabelOptions) => import("tg-map-core").LabelOverlay;
+        addCustomControl: (control: import("tg-map-core").CustomControl) => void;
+        removeCustomControl: (control: import("tg-map-core").CustomControl) => void;
+        createMapTypeControl: (options: import("tg-map-core").MapTypeControlOptions) => import("tg-map-core").MapTypeControl;
+        createZoomControl: (options: import("tg-map-core").ZoomControlOptions) => import("tg-map-core").ZoomControl;
+        createStreetViewControl: (options: import("tg-map-core").StreetViewControlOptions) => import("tg-map-core").StreetViewControl;
+        createScaleControl: (options: import("tg-map-core").ScaleControlOptions) => import("tg-map-core").ZoomControl;
+        addControl: (control: import("tg-map-core").AbstractControl) => void;
+        removeControl: (control: import("tg-map-core").AbstractControl) => void;
         getZoom: () => number;
         setZoom: (zoom: number) => void;
     } | undefined>;