diff --git a/types/amap-js-api/amap-js-api-tests.ts b/types/amap-js-api/amap-js-api-tests.ts
new file mode 100644
index 0000000000..ee7a2ac583
--- /dev/null
+++ b/types/amap-js-api/amap-js-api-tests.ts
@@ -0,0 +1,3376 @@
+/**
+ * preset.ts
+ */
+
+declare const map: AMap.Map;
+declare const lnglat: AMap.LngLat;
+declare const size: AMap.Size;
+declare const lnglatTuple: [number, number];
+declare const pixel: AMap.Pixel;
+declare const markerShape: AMap.MarkerShape;
+declare const icon: AMap.Icon;
+declare const bounds: AMap.Bounds;
+declare const div: HTMLDivElement;
+declare const lang: AMap.Lang;
+declare const domEle: HTMLElement;
+declare const canvasEle: HTMLCanvasElement;
+declare const imgEle: HTMLImageElement;
+
+declare const circle: AMap.Circle;
+declare const marker: AMap.Marker;
+declare const layer: AMap.Layer;
+declare const tileLayer: AMap.TileLayer;
+declare const massMarksLayer: AMap.MassMarks;
+
+// declare const videoLayer: AMap.VideoLayer;
+// declare const buildings: AMap.Buildings;
+// declare const canvasLayer: AMap.CanvasLayer;
+// declare const flexible: AMap.TileLayer.Flexible;
+// declare const imageLayer: AMap.ImageLayer;
+// declare const tileLayerGroup: AMap.LayerGroup<AMap.TileLayer>;
+// declare const layerGroup: AMap.LayerGroup;
+// declare const trafficLayer: AMap.TileLayer.Traffic;
+// declare const bezierCurve: AMap.BezierCurve;
+// declare const contextMenu: AMap.ContextMenu;
+// declare const polyline: AMap.Polyline;
+// declare const polygon: AMap.Polygon;
+
+/**
+ * arryBounds.ts
+ */
+
+// $ExpectType ArrayBounds
+const testArrayBounds = new AMap.ArrayBounds([lnglat, lnglat, lnglat]);
+
+// $ExpectType LngLat[]
+testArrayBounds.bounds;
+
+// $ExpectType boolean
+testArrayBounds.contains(lnglat);
+
+// $ExpectType Bounds
+testArrayBounds.toBounds();
+
+// $ExpectType LngLat
+testArrayBounds.getCenter();
+
+/**
+ * bounds.ts
+ */
+
+// $ExpectType Bounds
+const testBounds = new AMap.Bounds(lnglat, lnglat);
+
+// $ExpectType boolean
+testBounds.contains(lnglat);
+// $ExpectType boolean
+testBounds.contains(lnglatTuple);
+
+// $ExpectType LngLat
+testBounds.getCenter();
+
+// $ExpectType LngLat
+testBounds.getSouthWest();
+
+// $ExpectType LngLat
+testBounds.getSouthEast();
+
+// $ExpectType LngLat
+testBounds.getNorthEast();
+
+// $ExpectType LngLat
+testBounds.getNorthWest();
+
+// $ExpectType string
+testBounds.toString();
+
+/**
+ * browser.ts
+ */
+
+const brwoser = AMap.Browser;
+
+// $ExpectType string
+brwoser.ua;
+
+// $ExpectType boolean
+brwoser.mobile;
+
+const plat: 'android' | 'ios' | 'windows' | 'mac' | 'other' = brwoser.plat;
+
+// $ExpectType boolean
+brwoser.mac;
+
+// $ExpectType boolean
+brwoser.windows;
+
+// $ExpectType boolean
+brwoser.ios;
+
+// $ExpectType boolean
+brwoser.iPad;
+
+// $ExpectType boolean
+brwoser.iPhone;
+
+// $ExpectType boolean
+brwoser.android;
+
+// $ExpectType boolean
+brwoser.android23;
+
+// $ExpectType boolean
+brwoser.chrome;
+
+// $ExpectType boolean
+brwoser.firefox;
+
+// $ExpectType boolean
+brwoser.safari;
+
+// $ExpectType boolean
+brwoser.wechat;
+
+// $ExpectType boolean
+brwoser.uc;
+
+// $ExpectType boolean
+brwoser.qq;
+
+// $ExpectType boolean
+brwoser.ie;
+
+// $ExpectType boolean
+brwoser.ie6;
+
+// $ExpectType boolean
+brwoser.ie7;
+
+// $ExpectType boolean
+brwoser.ie8;
+
+// $ExpectType boolean
+brwoser.ie9;
+
+// $ExpectType boolean
+brwoser.ie10;
+
+// $ExpectType boolean
+brwoser.ie11;
+
+// $ExpectType boolean
+brwoser.edge;
+
+// $ExpectType boolean
+brwoser.ielt9;
+
+// $ExpectType boolean
+brwoser.baidu;
+
+// $ExpectType boolean
+brwoser.isLocalStorage;
+
+// $ExpectType boolean
+brwoser.isGeolocation;
+
+// $ExpectType boolean
+brwoser.mobileWebkit;
+
+// $ExpectType boolean
+brwoser.mobileWebkit3d;
+
+// $ExpectType boolean
+brwoser.mobileOpera;
+
+// $ExpectType boolean
+brwoser.retina;
+
+// $ExpectType boolean
+brwoser.touch;
+
+// $ExpectType boolean
+brwoser.msPointer;
+
+// $ExpectType boolean
+brwoser.pointer;
+
+// $ExpectType boolean
+brwoser.webkit;
+
+// $ExpectType boolean
+brwoser.ie3d;
+
+// $ExpectType boolean
+brwoser.webkit3d;
+
+// $ExpectType boolean
+brwoser.gecko3d;
+
+// $ExpectType boolean
+brwoser.opera3d;
+
+// $ExpectType boolean
+brwoser.any3d;
+
+// $ExpectType boolean
+brwoser.isCanvas;
+
+// $ExpectType boolean
+brwoser.isSvg;
+
+// $ExpectType boolean
+brwoser.isVML;
+
+// $ExpectType boolean
+brwoser.isWorker;
+
+// $ExpectType boolean
+brwoser.isWebsocket;
+
+// $ExpectType boolean
+brwoser.isWebGL();
+
+/**
+ * convert-from.ts
+ */
+
+declare const convertType: 'baidu' | 'mapbar' | 'gps' | null;
+// $ExpectType void
+AMap.convertFrom(lnglat, convertType, (status, result) => {
+    const temp: 'complete' | 'error' = status;
+    if (typeof result !== 'string') {
+        // $ExpectType string
+        result.info;
+        // $ExpectType LngLat[]
+        result.locations;
+    } else {
+        // $ExpectType string
+        result;
+    }
+});
+// $ExpectType void
+AMap.convertFrom([lnglat], null, () => { });
+// $ExpectType void
+AMap.convertFrom(lnglatTuple, null, () => { });
+// $ExpectType void
+AMap.convertFrom([lnglatTuple], null, () => { });
+
+/**
+ * dom-util.ts
+ */
+
+const domUtil = AMap.DomUtil;
+
+// $ExpectType Size
+domUtil.getViewport(div);
+
+// $ExpectType Pixel
+domUtil.getViewportOffset(div);
+
+// $ExpectType HTMLDivElement
+domUtil.create('div');
+// $ExpectType HTMLAnchorElement
+domUtil.create('a');
+// $ExpectType HTMLDivElement
+domUtil.create('div', div);
+// $ExpectType HTMLDivElement
+domUtil.create('div', div, 'className');
+
+// $ExpectType void
+domUtil.setClass(div);
+// $ExpectType void
+domUtil.setClass(div, 'className');
+
+// $ExpectType boolean
+domUtil.hasClass(div, 'className');
+
+// $ExpectType void
+domUtil.removeClass(div, 'className');
+
+// $ExpectType void
+domUtil.setOpacity(div, 1);
+
+// $ExpectType void
+domUtil.rotate(div, 10);
+// $ExpectType void
+domUtil.rotate(div, 10, { x: 10, y: 10 });
+
+const util2: typeof AMap.DomUtil = domUtil.setCss(div, { textAlign: 'left' });
+// $ExpectError
+domUtil.setCss(div, { textAlign: 10 });
+
+// $ExpectType void
+domUtil.empty(div);
+
+// $ExpectType void
+domUtil.remove(div);
+
+/**
+ * event.ts
+ */
+
+// $ExpectType Map
+map.on('hotspotclick', (event: AMap.Map.EventMap['hotspotclick']) => {
+    // $ExpectType "hotspotclick"
+    event.type;
+    // $ExpectType string
+    event.id;
+    // $ExpectType LngLat
+    event.lnglat;
+});
+
+// $ExpectType EventListener<0>
+AMap.event.addDomListener(div, 'click', event => {
+    // $ExpectType number
+    event.clientX;
+});
+
+// $ExpectType EventListener<1>
+AMap.event.addListener(map, 'hotspotclick', function(event: AMap.Map.EventMap['hotspotclick']) {
+    // $ExpectType "hotspotclick"
+    event.type;
+    // $ExpectType string
+    event.id;
+    // $ExpectType LngLat
+    event.lnglat;
+    // $ExpectType number
+    this.test;
+}, { test: 1 });
+AMap.event.addListener(map, 'click', (event: AMap.Map.EventMap['click']) => {
+    // $ExpectType "click"
+    event.type;
+    // $ExpectType LngLat
+    event.lnglat;
+    // $ExpectType Map
+    event.target;
+});
+
+// $ExpectType EventListener<1>
+const eventListener = AMap.event.addListenerOnce(map, 'hotspotclick', function(event: AMap.Map.EventMap['hotspotclick']) {
+    // $ExpectType "hotspotclick"
+    event.type;
+    // $ExpectType string
+    event.id;
+    // $ExpectType LngLat
+    event.lnglat;
+    // $ExpectType number
+    this.test;
+}, { test: 1 });
+
+// $ExpectType void
+AMap.event.removeListener(eventListener);
+
+// $ExpectType void
+AMap.event.trigger(map, 'click', {
+    lnglat,
+    pixel,
+    target: map
+});
+// $ExpectType void
+AMap.event.trigger(map, 'hotspotclick', {
+    lnglat,
+    name: 'name',
+    id: 'id',
+    isIndoorPOI: true
+});
+// $ExpectType void
+AMap.event.trigger(map, 'complete');
+
+/**
+ * geometry-util.ts
+ */
+
+{
+    const point = lnglat;
+    const pointTuple = lnglatTuple;
+    const line = [point];
+    const lineTuple = [pointTuple];
+    const ring = [point];
+    const ringTuple = [pointTuple];
+    const polygon = [ring];
+    const polygonTuple = [ringTuple];
+    const geometryUtil = AMap.GeometryUtil;
+
+    // $ExpectType number
+    geometryUtil.distance(point, point);
+    // $ExpectType number
+    geometryUtil.distance(pointTuple, pointTuple);
+    // $ExpectType number
+    geometryUtil.distance(point, line);
+    // $ExpectType number
+    geometryUtil.distance(pointTuple, lineTuple);
+
+    // $ExpectType number
+    geometryUtil.ringArea(ring);
+    // $ExpectType number
+    geometryUtil.ringArea(ringTuple);
+
+    // $ExpectType boolean
+    geometryUtil.isClockwise(ring);
+    // $ExpectType boolean
+    geometryUtil.isClockwise(ringTuple);
+
+    // $ExpectType number
+    geometryUtil.distanceOfLine(line);
+    // $ExpectType number
+    geometryUtil.distanceOfLine(lineTuple);
+
+    // $ExpectType [number, number][]
+    geometryUtil.ringRingClip(ring, ring);
+    // $ExpectType [number, number][]
+    geometryUtil.ringRingClip(ringTuple, ringTuple);
+
+    // $ExpectType boolean
+    geometryUtil.doesRingRingIntersect(ring, ring);
+    // $ExpectType boolean
+    geometryUtil.doesRingRingIntersect(ringTuple, ringTuple);
+
+    // $ExpectType boolean
+    geometryUtil.doesLineRingIntersect(line, ring);
+    // $ExpectType boolean
+    geometryUtil.doesLineRingIntersect(lineTuple, ringTuple);
+
+    // $ExpectType boolean
+    geometryUtil.doesLineLineIntersect(line, line);
+    // $ExpectType boolean
+    geometryUtil.doesLineLineIntersect(lineTuple, lineTuple);
+
+    // $ExpectType boolean
+    geometryUtil.doesSegmentPolygonIntersect(point, point, polygon);
+    // $ExpectType boolean
+    geometryUtil.doesSegmentPolygonIntersect(pointTuple, pointTuple, polygonTuple);
+
+    // $ExpectType boolean
+    geometryUtil.doesSegmentRingIntersect(point, point, ring);
+    // $ExpectType boolean
+    geometryUtil.doesSegmentRingIntersect(pointTuple, pointTuple, ringTuple);
+
+    // $ExpectType boolean
+    geometryUtil.doesSegmentLineIntersect(point, point, line);
+    // $ExpectType boolean
+    geometryUtil.doesSegmentLineIntersect(pointTuple, pointTuple, lineTuple);
+
+    // $ExpectType boolean
+    geometryUtil.doesSegmentsIntersect(point, point, point, point);
+    // $ExpectType boolean
+    geometryUtil.doesSegmentsIntersect(pointTuple, pointTuple, pointTuple, pointTuple);
+
+    // $ExpectType boolean
+    geometryUtil.isPointInRing(point, ring);
+    // $ExpectType boolean
+    geometryUtil.isPointInRing(pointTuple, ringTuple);
+
+    // $ExpectType boolean
+    geometryUtil.isRingInRing(ring, ring);
+    // $ExpectType boolean
+    geometryUtil.isRingInRing(ringTuple, ringTuple);
+
+    // $ExpectType boolean
+    geometryUtil.isPointInPolygon(point, polygon);
+    // $ExpectType boolean
+    geometryUtil.isPointInPolygon(pointTuple, polygonTuple);
+
+    // $ExpectType [number, number][]
+    geometryUtil.makesureClockwise(lineTuple);
+
+    // $ExpectType [number, number][]
+    geometryUtil.makesureAntiClockwise(lineTuple);
+
+    // $ExpectType [number, number]
+    geometryUtil.closestOnSegment(point, point, point);
+    // $ExpectType [number, number]
+    geometryUtil.closestOnSegment(pointTuple, pointTuple, pointTuple);
+
+    // $ExpectType [number, number]
+    geometryUtil.closestOnSegment(point, point, point);
+    // $ExpectType [number, number]
+    geometryUtil.closestOnSegment(pointTuple, pointTuple, pointTuple);
+
+    // $ExpectType [number, number]
+    geometryUtil.closestOnLine(point, line);
+    // $ExpectType [number, number]
+    geometryUtil.closestOnLine(pointTuple, lineTuple);
+
+    // $ExpectType number
+    geometryUtil.distanceToSegment(point, point, point);
+    // $ExpectType number
+    geometryUtil.distanceToSegment(pointTuple, pointTuple, pointTuple);
+
+    // $ExpectType number
+    geometryUtil.distanceToLine(point, line);
+    // $ExpectType number
+    geometryUtil.distanceToLine(pointTuple, lineTuple);
+
+    // $ExpectType boolean
+    geometryUtil.isPointOnSegment(point, point, point);
+    // $ExpectType boolean
+    geometryUtil.isPointOnSegment(point, point, point, 1);
+    // $ExpectType boolean
+    geometryUtil.isPointOnSegment(pointTuple, pointTuple, pointTuple);
+    // $ExpectType boolean
+    geometryUtil.isPointOnSegment(pointTuple, pointTuple, pointTuple, 1);
+
+    // $ExpectType boolean
+    geometryUtil.isPointOnLine(point, line);
+    // $ExpectType boolean
+    geometryUtil.isPointOnLine(point, line, 1);
+    // $ExpectType boolean
+    geometryUtil.isPointOnLine(pointTuple, lineTuple);
+    // $ExpectType boolean
+    geometryUtil.isPointOnLine(pointTuple, lineTuple, 1);
+
+    // $ExpectType boolean
+    geometryUtil.isPointOnRing(point, ring);
+    // $ExpectType boolean
+    geometryUtil.isPointOnRing(point, ring, 1);
+    // $ExpectType boolean
+    geometryUtil.isPointOnRing(pointTuple, ringTuple);
+    // $ExpectType boolean
+    geometryUtil.isPointOnRing(pointTuple, ringTuple, 1);
+
+    // $ExpectType boolean
+    geometryUtil.isPointOnPolygon(point, polygon);
+    // $ExpectType boolean
+    geometryUtil.isPointOnPolygon(point, polygon, 1);
+    // $ExpectType boolean
+    geometryUtil.isPointOnPolygon(pointTuple, polygonTuple);
+    // $ExpectType boolean
+    geometryUtil.isPointOnPolygon(pointTuple, polygonTuple, 1);
+}
+
+/**
+ * lnglat.ts
+ */
+
+// $ExpectType LngLat
+new AMap.LngLat(114, 22);
+// $ExpectType LngLat
+const testLnglat = new AMap.LngLat(113, 21);
+
+// $ExpectType LngLat
+testLnglat.offset(1, 2);
+
+// $ExpectType number
+testLnglat.distance(testLnglat);
+// $ExpectType number
+testLnglat.distance([testLnglat]);
+
+// $ExpectType number
+testLnglat.getLng();
+
+// $ExpectType number
+testLnglat.getLat();
+
+// $ExpectType boolean
+testLnglat.equals(testLnglat);
+
+// $ExpectType string
+testLnglat.toString();
+
+// $ExpectType LngLat
+testLnglat.add(testLnglat);
+// $ExpectType LngLat
+testLnglat.add(testLnglat, true);
+
+// $ExpectType LngLat
+testLnglat.subtract(testLnglat);
+// $ExpectType LngLat
+testLnglat.subtract(testLnglat, true);
+
+// $ExpectType LngLat
+testLnglat.divideBy(1);
+// $ExpectType LngLat
+testLnglat.divideBy(1, true);
+
+// $ExpectType LngLat
+testLnglat.multiplyBy(1);
+// $ExpectType LngLat
+testLnglat.multiplyBy(1, true);
+
+/**
+ * map.ts
+ */
+
+// $ExpectType Map
+new AMap.Map('map');
+// $ExpectType Map
+new AMap.Map(div);
+
+// $ExpectType Map
+new AMap.Map(div, {});
+
+// $ExpectType Map
+const testMap = new AMap.Map(div, {
+    layers: [tileLayer],
+    zoom: 15,
+    center: [1, 2],
+    labelzIndex: 110,
+    zooms: [5, 15],
+    lang: 'zh_cn',
+    defaultCursor: 'default',
+    crs: 'EPSG4326',
+    animateEnable: true,
+    isHotspot: false,
+    defaultLayer: tileLayer,
+    rotateEnable: true,
+    resizeEnable: true,
+    showIndoorMap: true,
+    // indoorMap, // TODO
+    expandZoomRange: true,
+    dragEnable: true,
+    zoomEnable: true,
+    doubleClickZoom: true,
+    keyboardEnable: true,
+    jogEnable: true,
+    scrollWheel: true,
+    touchZoom: true,
+    mapStyle: '',
+    features: ['road'],
+    showBuildingBlock: true,
+    skyColor: '#fff',
+    preloadMode: true,
+    mask: [[1, 2], [2, 3], [3, 4]]
+});
+
+// $ExpectType number
+testMap.getZoom();
+
+// $ExpectType Layer[]
+testMap.getLayers();
+
+// $ExpectType LngLat
+testMap.getCenter();
+
+// $ExpectType HTMLElement | null
+testMap.getContainer();
+
+testMap.getCity(city => {
+    // $ExpectType string
+    city.city;
+    // $ExpectType string
+    city.citycode;
+    // $ExpectType string
+    city.district;
+    // $ExpectType string | never[]
+    city.province;
+});
+
+// $ExpectType Bounds
+testMap.getBounds();
+
+// $ExpectType number
+testMap.getLabelzIndex();
+
+// $ExpectType Lang
+testMap.getLang();
+
+// $ExpectType Size
+testMap.getSize();
+
+// $ExpectType number
+testMap.getRotation();
+
+// $ExpectType Status
+const mapStatus = testMap.getStatus();
+// $ExpectType boolean
+mapStatus.animateEnable;
+// $ExpectType boolean
+mapStatus.doubleClickZoom;
+// $ExpectType boolean
+mapStatus.dragEnable;
+// $ExpectType boolean
+mapStatus.isHotspot;
+// $ExpectType boolean
+mapStatus.jogEnable;
+// $ExpectType boolean
+mapStatus.keyboardEnable;
+// $ExpectType boolean
+mapStatus.pitchEnable;
+// $ExpectType boolean
+mapStatus.resizeEnable;
+// $ExpectType boolean
+mapStatus.rotateEnable;
+// $ExpectType boolean
+mapStatus.scrollWheel;
+// $ExpectType boolean
+mapStatus.touchZoom;
+// $ExpectType boolean
+mapStatus.zoomEnable;
+
+// $ExpectType string
+testMap.getDefaultCursor();
+
+// $ExpectType number
+testMap.getResolution();
+
+// $ExpectType number
+testMap.getScale();
+// $ExpectType number
+testMap.getScale(1);
+
+// $ExpectType void
+testMap.setZoom(1);
+
+// $ExpectType void
+testMap.setLabelzIndex(1);
+
+// $ExpectType void
+testMap.setLayers([tileLayer]);
+
+// $ExpectType void
+testMap.setCenter(lnglat);
+// $ExpectType void
+testMap.setCenter([1, 2]);
+
+// $ExpectType void
+testMap.setZoomAndCenter(13, lnglat);
+// $ExpectType void
+testMap.setZoomAndCenter(13, [1, 2]);
+
+// $ExpectType void
+testMap.setCity('city', (coord, zoom) => {
+    // $ExpectType string
+    coord[0];
+    // $ExpectType string
+    coord[1];
+    // $ExpectType number
+    zoom;
+});
+
+// $ExpectType Bounds
+testMap.setBounds(bounds);
+
+// $ExpectType void
+testMap.setLimitBounds(bounds);
+
+// $ExpectType void
+testMap.clearLimitBounds();
+
+// $ExpectType void
+testMap.setLang('zh_cn');
+
+// $ExpectType void
+testMap.setRotation(1);
+
+// $ExpectType void
+testMap.setStatus({});
+// $ExpectType void
+testMap.setStatus({
+    animateEnable: true,
+    doubleClickZoom: true,
+    dragEnable: true,
+    isHotspot: true,
+    jogEnable: true,
+    keyboardEnable: true,
+    pitchEnable: false,
+    resizeEnable: false,
+    rotateEnable: false,
+    scrollWheel: true,
+    touchZoom: true,
+    zoomEnable: true
+});
+
+// $ExpectType void
+testMap.setDefaultCursor('default');
+
+// $ExpectType void
+testMap.zoomIn();
+
+// $ExpectType void
+testMap.zoomOut();
+
+// $ExpectType void
+testMap.panTo([1, 2]);
+// $ExpectType void
+testMap.panTo(lnglat);
+
+// $ExpectType void
+testMap.panBy(1, 2);
+
+// $ExpectType void
+testMap.clearMap();
+
+// $ExpectType Map
+testMap.plugin('plugin name', () => { });
+// $ExpectType Map
+testMap.plugin(['plugin name'], () => { });
+
+// $ExpectType void
+testMap.clearInfoWindow();
+
+// $ExpectType LngLat
+testMap.pixelToLngLat(pixel);
+// $ExpectType LngLat
+testMap.pixelToLngLat(pixel, 1);
+
+// $ExpectType Pixel
+testMap.lnglatToPixel(lnglat);
+// $ExpectType Pixel
+testMap.lnglatToPixel(lnglat, 1);
+
+// $ExpectType LngLat
+testMap.containerToLngLat(pixel);
+
+// $ExpectType Pixel
+testMap.lngLatToContainer(lnglat);
+// $ExpectType Pixel
+testMap.lnglatTocontainer(lnglat);
+
+// $ExpectType void
+testMap.setMapStyle('');
+// $ExpectType string
+testMap.getMapStyle();
+
+// $ExpectType void
+testMap.setFeatures('all');
+// $ExpectType void
+testMap.setFeatures(['bg']);
+
+const feature: 'all' | 'bg' | 'point' | 'road' | 'building' | AMap.Map.Feature[] = testMap.getFeatures();
+
+// $ExpectType void
+testMap.setDefaultLayer(tileLayer);
+
+// $ExpectType void
+testMap.setPitch(1);
+// $ExpectType number
+testMap.getPitch();
+
+// $ExpectType ViewMode
+testMap.getViewMode_();
+
+// $ExpectType Pixel
+testMap.lngLatToGeodeticCoord(lnglat);
+// $ExpectType Pixel
+testMap.lngLatToGeodeticCoord(lnglatTuple);
+
+// $ExpectType LngLat
+testMap.geodeticCoordToLngLat(pixel);
+
+// $ExpectType void
+testMap.destroy();
+
+declare function dblClickHandler(this: AMap.Map, event: AMap.Map.EventMap['dblclick']): void;
+
+// $ExpectType Map
+testMap.on('click', (event: AMap.Map.EventMap['click']) => {
+    // $ExpectType "click"
+    event.type;
+    // $ExpectType Pixel
+    event.pixel;
+    // $ExpectType LngLat
+    event.lnglat;
+    // $ExpectType Map
+    event.target;
+});
+// $ExpectType Map
+testMap.on('dblclick', dblClickHandler);
+// $ExpectType Map
+testMap.on('complete', (event: AMap.Map.EventMap['complete']) => {
+    // $ExpectType "complete"
+    event.type;
+    // $ExpectError
+    event.value;
+});
+// $ExpectType Map
+testMap.on('hotspotclick', (event: AMap.Map.EventMap['hotspotclick']) => {
+    // $ExpectType string
+    event.id;
+    // $ExpectType LngLat
+    event.lnglat;
+    // $ExpectType string
+    event.name;
+    // $ExpectType "hotspotclick"
+    event.type;
+});
+// $ExpectType Map
+testMap.on('custom', (event: AMap.Event<'custom', { test: string }>) => {
+    // $ExpectType "custom"
+    event.type;
+    // $ExpectType string
+    event.test;
+});
+
+// $ExpectType Map
+testMap.off('dblclick', dblClickHandler);
+// $ExpectType Map
+testMap.off('click', 'mv');
+
+// $ExpectType Map
+testMap.emit('click', {
+    target: testMap,
+    lnglat,
+    pixel
+});
+
+testMap.emit('complete');
+// $ExpectType Map
+testMap.emit('hotspotclick', {
+    lnglat,
+    name: '123',
+    id: '123',
+    isIndoorPOI: true
+});
+// $ExpectType Map
+testMap.emit('custom', {
+    test: 1
+});
+// $ExpectType Map
+testMap.emit('custom', undefined);
+
+/**
+ * pixel.ts
+ */
+
+// $ExpectType Pixel
+new AMap.Pixel(10, 20);
+// $ExpectType Pixel
+const testPixel = new AMap.Pixel(10, 20);
+
+// $ExpectType number
+testPixel.getX();
+
+// $ExpectType number
+testPixel.getY();
+
+// $ExpectType boolean
+testPixel.equals(testPixel);
+
+// $ExpectType string
+testPixel.toString();
+
+// $ExpectType Pixel
+testPixel.add({ x: 1, y: 2 });
+// $ExpectType Pixel
+testPixel.add({ x: 1, y: 2 }, false);
+
+// $ExpectType Pixel
+testPixel.round();
+
+// $ExpectType Pixel
+testPixel.floor();
+
+// $ExpectType number
+testPixel.length();
+
+// $ExpectType number | null
+testPixel.direction();
+
+// $ExpectType Pixel
+testPixel.toFixed();
+// $ExpectType Pixel
+testPixel.toFixed(2);
+
+/**
+ * size.ts
+ */
+
+// $ExpectType Size
+const testSize = new AMap.Size(10, 20);
+
+// $ExpectType number
+testSize.getHeight();
+
+// $ExpectType number
+testSize.getWidth();
+
+// $ExpectType string
+testSize.toString();
+
+// $ExpectType boolean
+testSize.contains({ x: 10, y: 10 });
+
+/**
+ * util.ts
+ */
+
+const util = AMap.Util;
+
+// $ExpectType string
+util.colorNameToHex('colorName');
+
+// $ExpectType string
+util.rgbHex2Rgba('rgbHex');
+
+// $ExpectType string
+util.argbHex2Rgba('argbHex');
+
+// $ExpectType boolean
+util.isEmpty({});
+// $ExpectError
+util.isEmpty(1);
+
+// $ExpectType number[]
+util.deleteItemFromArray([1], 1);
+
+// $ExpectType number[]
+util.deleteItemFromArrayByIndex([1], 1);
+
+// $ExpectType number
+util.indexOf([1], 1);
+// $ExpectError
+util.indexOf([1], '1');
+
+// $ExpectType number
+util.format(1);
+// $ExpectType number
+util.format(1, 1);
+
+declare const value1: number | number[];
+// $ExpectType boolean
+util.isArray(value1);
+if (util.isArray(value1)) {
+    // $ExpectType number[]
+    value1;
+} else {
+    // $ExpectType number
+    value1;
+}
+
+declare const value2: number | HTMLElement;
+// $ExpectType boolean
+util.isDOM(value2);
+if (util.isDOM(value2)) {
+    // $ExpectType HTMLElement
+    value2;
+} else {
+    // $ExpectType number
+    value2;
+}
+
+// $ExpectType boolean
+util.includes([1], 1);
+// $ExpectError
+util.includes([1], '1');
+
+// $ExpectType number
+util.requestIdleCallback(() => { });
+// $ExpectType number
+const idleCallbackHandle = util.requestIdleCallback(() => { }, { timeout: 1 });
+
+// $ExpectType void
+util.cancelIdleCallback(idleCallbackHandle);
+
+// $ExpectType number
+util.requestAnimFrame(() => { });
+// $ExpectType number
+const animFrameHandle = util.requestAnimFrame(function() {
+    // $ExpectType number
+    this.test;
+}, { test: 1 });
+
+// $ExpectType void
+util.cancelAnimFrame(animFrameHandle);
+
+/**
+ * view2d.ts
+ */
+
+// $ExpectType View2D
+new AMap.View2D();
+// $ExpectType View2D
+new AMap.View2D({});
+
+// $ExpectType View2D
+new AMap.View2D({
+    center: [1, 2],
+    rotation: 1,
+    zoom: 10,
+    crs: 'EPGS3395'
+});
+
+// $ExpectType View2D
+const testView2d = new AMap.View2D({
+    center: lnglat
+});
+
+// $ExpectType View2D
+testView2d.on('complete', () => { });
+
+/**
+ * layer/buildings.ts
+ */
+
+// $ExpectType Buildings
+new AMap.Buildings();
+// $ExpectType Buildings
+new AMap.Buildings();
+// $ExpectType Buildings
+const testBuildings = new AMap.Buildings({
+    zooms: [1, 18],
+    opacity: 0.8,
+    heightFactor: 1,
+    visible: true,
+    zIndex: 10,
+    map
+});
+
+testBuildings.setStyle({
+    hideWithoutStyle: false,
+    areas: [
+        {
+            visible: true,
+            rejectTexture: true,
+            color1: 'ffffff00',
+            color2: 'ffffcc00',
+            path: [[1, 2]]
+        },
+        {
+            visible: true,
+            rejectTexture: true,
+            color1: 'ffffff00',
+            color2: 'ffffcc00',
+            path: [lnglat]
+        },
+        {
+            color1: 'ff99ff00',
+            path: [lnglat]
+        },
+    ]
+});
+
+/**
+ * layer/canvasLayer.ts
+ */
+
+// $ExpectType CanvasLayer
+new AMap.CanvasLayer({
+    map,
+    bounds,
+    visible: true,
+    zooms: [1, 2],
+    opacity: 1
+});
+
+// $ExpectType CanvasLayer
+new AMap.CanvasLayer();
+// $ExpectType CanvasLayer
+new AMap.CanvasLayer({});
+// $ExpectType CanvasLayer
+const testCanvasLayer = new AMap.CanvasLayer({
+    bounds
+});
+
+// $ExpectType void
+testCanvasLayer.setMap(null);
+// $ExpectType void
+testCanvasLayer.setMap(map);
+
+// $ExpectType Map | null | undefined
+testCanvasLayer.getMap();
+
+// $ExpectType void
+testCanvasLayer.show();
+
+// $ExpectType void
+testCanvasLayer.hide();
+
+// $ExpectType number
+testCanvasLayer.getzIndex();
+
+// $ExpectType void
+testCanvasLayer.setzIndex(10);
+
+// $ExpectType HTMLCanvasElement | null
+testCanvasLayer.getElement();
+
+// $ExpectType void
+testCanvasLayer.setCanvas(canvasEle);
+
+// $ExpectType HTMLCanvasElement | undefined
+testCanvasLayer.getCanvas();
+
+/**
+ * layer/flexible.ts
+ */
+
+// $ExpectType Flexible
+new AMap.TileLayer.Flexible();
+// $ExpectType Flexible
+new AMap.TileLayer.Flexible({});
+// $ExpectType Flexible
+const testFlexible = new AMap.TileLayer.Flexible({
+    createTile(x, y, z, success, fail) {
+        // $ExpectType number
+        x;
+        // $ExpectType number
+        y;
+        // $ExpectType number
+        z;
+        // $ExpectType void
+        success(imgEle);
+        // $ExpectType void
+        success(canvasEle);
+        // $ExpectType void
+        fail();
+    },
+    cacheSize: 10,
+    opacity: 1,
+    visible: true,
+    map,
+    zIndex: 1,
+    zooms: [1, 2]
+});
+
+// $ExpectType void
+testFlexible.setMap(null);
+// $ExpectType void
+testFlexible.setMap(map);
+
+// $ExpectType Map | null | undefined
+testFlexible.getMap();
+
+// $ExpectType void
+testFlexible.show();
+
+// $ExpectType void
+testFlexible.hide();
+
+// $ExpectType void
+testFlexible.setzIndex(10);
+
+// $ExpectType number
+testFlexible.getzIndex();
+
+/**
+ * layer/imageLayer.ts
+ */
+
+// $ExpectType ImageLayer
+new AMap.ImageLayer({
+    map,
+    bounds,
+    visible: true,
+    zooms: [1, 2],
+    opacity: 1
+});
+
+// $ExpectType ImageLayer
+new AMap.ImageLayer();
+// $ExpectType ImageLayer
+new AMap.ImageLayer({});
+// $ExpectType ImageLayer
+const testImageLayer = new AMap.ImageLayer({
+    bounds
+});
+
+// $ExpectType void
+testImageLayer.setMap(null);
+// $ExpectType void
+testImageLayer.setMap(map);
+
+// $ExpectType Map | null | undefined
+testImageLayer.getMap();
+
+// $ExpectType void
+testImageLayer.show();
+
+// $ExpectType void
+testImageLayer.hide();
+
+// $ExpectType number
+testImageLayer.getzIndex();
+
+// $ExpectType void
+testImageLayer.setzIndex(10);
+
+// $ExpectType HTMLImageElement | null
+testImageLayer.getElement();
+
+// $ExpectType void
+testImageLayer.setImageUrl('url');
+
+// $ExpectType string | undefined
+testImageLayer.getImageUrl();
+
+/**
+ * layer/layer.ts
+ */
+
+// $ExpectError
+new AMap.Layer();
+
+// $ExpectType HTMLDivElement | undefined
+layer.getContainer();
+
+// $ExpectType [number, number]
+layer.getZooms();
+
+// $ExpectType void
+layer.setOpacity(1);
+
+// $ExpectType number
+layer.getOpacity();
+
+// $ExpectType void
+layer.show();
+
+// $ExpectType void
+layer.hide();
+
+// $ExpectType void
+layer.setMap();
+// $ExpectType void
+layer.setMap(map);
+
+// $ExpectType void
+layer.setzIndex(1);
+
+// $ExpectType number
+layer.getzIndex();
+
+/**
+ * layer/layerGroup.ts
+ */
+
+// $ExpectError
+new AMap.LayerGroup();
+
+// $ExpectType LayerGroup<TileLayer>
+new AMap.LayerGroup(tileLayer);
+// $ExpectType LayerGroup<TileLayer>
+const testTileLayerGroup = new AMap.LayerGroup([tileLayer]);
+// $ExpectType LayerGroup<any>
+const testAnyLauerGroup = new AMap.LayerGroup<any>([]);
+
+// $ExpectType LayerGroup<TileLayer>
+testTileLayerGroup.addLayer(tileLayer);
+// $ExpectType LayerGroup<TileLayer>
+testTileLayerGroup.addLayer([tileLayer]);
+// $ExpectError
+testTileLayerGroup.addLayer(massMarksLayer);
+
+// $ExpectType TileLayer[]
+testTileLayerGroup.getLayers();
+
+// $ExpectType TileLayer | null
+testTileLayerGroup.getLayer(function(item, index, list) {
+    // $ExpectType TileLayer
+    item;
+    // $ExpectType number
+    index;
+    // $ExpectType TileLayer[]
+    list;
+    // $ExpectType null
+    this;
+
+    return true;
+});
+
+testTileLayerGroup.hasLayer(function(item, index, list) {
+    // $ExpectType TileLayer
+    item;
+    // $ExpectType number
+    index;
+    // $ExpectType TileLayer[]
+    list;
+    // $ExpectType null
+    this;
+
+    return true;
+});
+testTileLayerGroup.hasLayer(tileLayer);
+
+// $ExpectType LayerGroup<TileLayer>
+testTileLayerGroup.removeLayer(tileLayer);
+// $ExpectType LayerGroup<TileLayer>
+testTileLayerGroup.removeLayer([tileLayer]);
+
+// $ExpectType LayerGroup<TileLayer>
+testTileLayerGroup.clearLayers();
+
+testTileLayerGroup.eachLayer(function(item, index, list) {
+    // $ExpectType TileLayer
+    item;
+    // $ExpectType number
+    index;
+    // $ExpectType TileLayer[]
+    list;
+    // $ExpectType TileLayer
+    this;
+});
+testTileLayerGroup.eachLayer(function(item, index, list) {
+    // $ExpectType TileLayer
+    item;
+    // $ExpectType number
+    index;
+    // $ExpectType TileLayer[]
+    list;
+    // $ExpectType number
+    this.test;
+}, { test: 1 });
+
+// $ExpectType LayerGroup<TileLayer>
+testTileLayerGroup.setMap(map);
+
+// $ExpectType LayerGroup<TileLayer>
+testTileLayerGroup.hide();
+
+// $ExpectType LayerGroup<TileLayer>
+testTileLayerGroup.show();
+
+// $ExpectType LayerGroup<TileLayer>
+testTileLayerGroup.reload();
+
+// $ExpectType LayerGroup<TileLayer>
+testTileLayerGroup.setOptions({});
+
+// $ExpectType LayerGroup<TileLayer>
+testTileLayerGroup.setOptions({
+    tileSize: 256
+});
+// layerGruop.setOptions({
+//     // $ExpectError
+//     interval: 1
+// });
+
+testAnyLauerGroup.addLayer(tileLayer);
+
+testAnyLauerGroup.addLayer(massMarksLayer);
+
+testAnyLauerGroup.setOptions({
+    test: 1
+});
+
+/**
+ * layer/massMarks.ts
+ */
+
+const massMarksStyle1 = {
+    anchor: pixel,
+    url: '',
+    size,
+    rotation: 1
+};
+const massMarksStyle2 = {
+    anchor: pixel,
+    url: '',
+    size
+};
+const massMarksData1 = {
+    lnglat
+};
+
+interface MassMarksCustomData extends AMap.MassMarks.Data {
+    name: string;
+    id: string;
+}
+const massMarksMassMarksCustomData: MassMarksCustomData = {
+    lnglat: [1, 2],
+    style: 1,
+    name: '',
+    id: ''
+};
+
+// $ExpectError
+new AMap.MassMarks();
+// $ExpectError
+new AMap.MassMarks([], {});
+
+new AMap.MassMarks([], {
+    style: [massMarksStyle1, massMarksStyle2]
+});
+new AMap.MassMarks([massMarksData1], {
+    style: [massMarksStyle1, massMarksStyle2]
+});
+
+// $ExpectType MassMarks<MassMarksCustomData>
+const testMassMarks = new AMap.MassMarks<MassMarksCustomData>([massMarksMassMarksCustomData], {
+    style: [massMarksStyle1, massMarksStyle2]
+});
+
+// $ExpectType void
+testMassMarks.setStyle(massMarksStyle1);
+// $ExpectType void
+testMassMarks.setStyle([massMarksStyle1]);
+
+// $ExpectType Style | Style[]
+testMassMarks.getStyle();
+
+// $ExpectType void
+testMassMarks.setData('');
+
+// $ExpectError
+testMassMarks.setData(massMarksData1);
+// $ExpectError
+testMassMarks.setData(massMarksMassMarksCustomData);
+
+const massMarksCustomData = testMassMarks.getData()[0];
+// $ExpectType string
+massMarksCustomData.name;
+// $ExpectType string
+massMarksCustomData.id;
+// $ExpectType LngLat
+massMarksCustomData.lnglat;
+
+// $ExpectType void
+testMassMarks.clear();
+
+testMassMarks.on('click', (event: AMap.MassMarks.EventMap<typeof testMassMarks>['click']) => {
+    // $ExpectType "click"
+    event.type;
+
+    // $ExpectType MassMarksCustomData
+    event.data;
+
+    // $ExpectType MassMarks<MassMarksCustomData>
+    event.target;
+});
+
+/**
+ * layer/tileLayer.ts
+ */
+
+// $ExpectType TileLayer
+new AMap.TileLayer();
+
+// $ExpectType TileLayer
+new AMap.TileLayer({});
+
+// $ExpectType TileLayer
+const testTileLayer = new AMap.TileLayer({
+    map,
+    tileSize: 256,
+    tileUrl: '',
+    errorUrl: '',
+    getTileUrl: (x, y, z) => '',
+    zIndex: 1,
+    opacity: 0.1,
+    zooms: [3, 18],
+    detectRetina: true
+});
+
+// $ExpectType string[]
+testTileLayer.getTiles();
+
+// $ExpectType void
+testTileLayer.reload();
+
+// $ExpectType void
+testTileLayer.setTileUrl('');
+// $ExpectType void
+testTileLayer.setTileUrl((x, y, level) => {
+    // $ExpectType number
+    x;
+    // $ExpectType number
+    y;
+    // $ExpectType number
+    level;
+    return '';
+});
+
+// $ExpectType TileLayer
+testTileLayer.on('complete', () => { });
+
+testTileLayer.off('complete', () => { });
+
+testTileLayer.emit('complete');
+
+// $ExpectType Traffic
+const testTrafficLayer = new AMap.TileLayer.Traffic({});
+// $ExpectType Traffic
+new AMap.TileLayer.Traffic({
+    autoRefresh: true,
+    interval: 180
+});
+
+testTrafficLayer.on('complete', () => { });
+
+/**
+ * layer/videoLayer.ts
+ */
+
+// $ExpectType VideoLayer
+new AMap.VideoLayer({
+    map,
+    bounds,
+    visible: true,
+    zooms: [1, 2],
+    opacity: 1
+});
+
+// $ExpectType VideoLayer
+new AMap.VideoLayer();
+// $ExpectType VideoLayer
+new AMap.VideoLayer({});
+// $ExpectType VideoLayer
+const testVideoLayer = new AMap.VideoLayer({
+    bounds
+});
+
+// $ExpectType void
+testVideoLayer.setMap(null);
+// $ExpectType void
+testVideoLayer.setMap(map);
+
+// $ExpectType Map | null | undefined
+testVideoLayer.getMap();
+
+// $ExpectType void
+testVideoLayer.show();
+
+// $ExpectType void
+testVideoLayer.hide();
+
+// $ExpectType number
+testVideoLayer.getzIndex();
+
+// $ExpectType void
+testVideoLayer.setzIndex(10);
+
+// $ExpectType HTMLVideoElement | null
+testVideoLayer.getElement();
+
+// $ExpectType void
+testVideoLayer.setVideoUrl('url');
+
+// $ExpectType string | string[] | undefined
+testVideoLayer.getVideoUrl();
+
+/**
+ * layer/wms.ts
+ */
+
+// $ExpectType WMS
+new AMap.TileLayer.WMS({
+    url: 'url',
+    params: {}
+});
+// $ExpectType WMS
+const testWms = new AMap.TileLayer.WMS({
+    url: 'url',
+    blend: true,
+    params: {
+        VERSION: 'version',
+        LAYERS: 'layers',
+        STYLES: 'styles',
+        FORMAT: 'format',
+        TRANSPARENT: 'TRUE',
+        BGCOLOR: '#000',
+        EXCEPTIONS: 'exceptions',
+        TIME: 'time',
+        ELEVATION: 'elevation'
+    },
+    zooms: [1, 2],
+    tileSize: 256,
+    opacity: 1,
+    zIndex: 10,
+    visible: true
+});
+
+// $ExpectType void
+testWms.setMap(map);
+// $ExpectType void
+testWms.setMap(null);
+
+// $ExpectType Map | null | undefined
+testWms.getMap();
+
+// $ExpectType void
+testWms.show();
+
+// $ExpectType void
+testWms.hide();
+
+// $ExpectType void
+testWms.setzIndex(10);
+
+// $ExpectType number
+testWms.getzIndex();
+
+// $ExpectType void
+testWms.setUrl('url');
+
+// $ExpectType string
+testWms.getUrl();
+
+// $ExpectType void
+testWms.setParams({
+    VERSION: 'version',
+    LAYERS: 'layers',
+    STYLES: 'styles',
+    FORMAT: 'format',
+    TRANSPARENT: 'TRUE',
+    BGCOLOR: '#000',
+    EXCEPTIONS: 'exceptions',
+    TIME: 'time',
+    ELEVATION: 'elevation'
+});
+
+{
+    const params = testWms.getParams();
+    // $ExpectType string | undefined
+    params.VERSION;
+    // $ExpectType string | undefined
+    params.LAYERS;
+    // $ExpectType string | undefined
+    params.STYLES;
+    // $ExpectType string | undefined
+    params.FORMAT;
+    // $ExpectType "TRUE" | "FALSE" | undefined
+    params.TRANSPARENT;
+    // $ExpectType string | undefined
+    params.BGCOLOR;
+    // $ExpectType string | undefined
+    params.EXCEPTIONS;
+    // $ExpectType string | undefined
+    params.TIME;
+    // $ExpectType string | undefined
+    params.ELEVATION;
+}
+
+/**
+ * layer/wmts.ts
+ */
+
+// $ExpectType WMTS
+new AMap.TileLayer.WMTS({
+    url: 'url',
+    params: {}
+});
+// $ExpectType WMTS
+const testWmts = new AMap.TileLayer.WMTS({
+    url: 'url',
+    blend: true,
+    tileSize: 256,
+    zooms: [1, 2],
+    opacity: 1,
+    zIndex: 10,
+    visible: true,
+    params: {
+        Version: 'version',
+        Layer: 'layers',
+        Style: 'style',
+        Format: 'format'
+    }
+});
+
+// $ExpectType void
+testWmts.setMap(map);
+// $ExpectType void
+testWmts.setMap(null);
+
+// $ExpectType Map | null | undefined
+testWmts.getMap();
+
+// $ExpectType void
+testWmts.show();
+
+// $ExpectType void
+testWmts.hide();
+
+// $ExpectType void
+testWmts.setzIndex(10);
+
+// $ExpectType number
+testWmts.getzIndex();
+
+// $ExpectType void
+testWmts.setUrl('url');
+
+// $ExpectType string
+testWmts.getUrl();
+
+// $ExpectType void
+testWmts.setParams({
+    Version: 'version',
+    Layer: 'layers',
+    Style: 'style',
+    Format: 'format'
+});
+
+{
+    const params = testWmts.getParams();
+    // $ExpectType string | undefined
+    params.Version;
+    // $ExpectType string | undefined
+    params.Layer;
+    // $ExpectType string | undefined
+    params.Style;
+    // $ExpectType string | undefined
+    params.Format;
+}
+
+/**
+ * overlay/bezierCurve.ts
+ */
+
+interface BezierCurveExtraData {
+    test: number;
+}
+
+const bezierCurvePath = [
+    [1, 2, 3, 4],
+    [1, 2, 3],
+    [
+        [1, 2, 3],
+        [1, 2]
+    ],
+    [1, 2]
+];
+
+// $ExpectError
+new AMap.BezierCurve();
+// $ExpectError
+new AMap.BezierCurve({});
+// $ExpectType BezierCurve<BezierCurveExtraData>
+const testBezierCurve = new AMap.BezierCurve<BezierCurveExtraData>({
+    map,
+    path: bezierCurvePath,
+    strokeColor: '#FF0000',
+    strokeOpacity: 0.6,
+    strokeWeight: 10,
+    strokeStyle: 'dashed',
+    strokeDasharray: [1, 5],
+    zIndex: 10,
+    bubble: false,
+    showDir: true,
+    cursor: 'pointer',
+    isOutline: true,
+    outlineColor: '#00FF00',
+    borderWeight: 2
+});
+
+// $ExpectType void
+testBezierCurve.setPath(bezierCurvePath);
+
+// $ExpectType void
+testBezierCurve.setPath(bezierCurvePath);
+
+// $ExpectType void
+testBezierCurve.setOptions({});
+testBezierCurve.setOptions({
+    map,
+    path: bezierCurvePath,
+    strokeColor: '#FF0000',
+    strokeOpacity: 0.6,
+    strokeWeight: 10,
+    strokeStyle: 'dashed',
+    strokeDasharray: [1, 5],
+    zIndex: 10,
+    bubble: false,
+    showDir: true,
+    cursor: 'pointer',
+    isOutline: true,
+    outlineColor: '#00FF00',
+    borderWeight: 2
+});
+
+{
+    const options = testBezierCurve.getOptions();
+
+    // $ExpectType number | undefined
+    options.borderWeight;
+    // $ExpectType boolean | undefined
+    options.bubble;
+    // $ExpectType boolean | undefined
+    options.clickable;
+    // $ExpectType string | undefined
+    options.dirColor;
+    // $ExpectType string | undefined
+    options.dirImg;
+    // $ExpectType {} | BezierCurveExtraData | undefined
+    options.extData;
+    // $ExpectType boolean | undefined
+    options.geodesic;
+    // $ExpectType boolean | undefined
+    options.isOutline;
+    // $ExpectType "round" | "butt" | "square" | undefined
+    options.lineCap;
+    // $ExpectType "miter" | "round" | "bevel" | undefined
+    options.lineJoin;
+    // $ExpectType Map | undefined
+    options.map;
+    // $ExpectType string | undefined
+    options.outlineColor;
+    // $ExpectType (LngLat & { controlPoints: LngLat[]; })[] | undefined
+    options.path;
+    // $ExpectType boolean | undefined
+    options.showDir;
+    // $ExpectType string | undefined
+    options.strokeColor;
+    // $ExpectType number[] | undefined
+    options.strokeDasharray;
+    // $ExpectType number | undefined
+    options.strokeOpacity;
+    // $ExpectType "dashed" | "solid" | undefined
+    options.strokeStyle;
+    // $ExpectType number | undefined
+    options.strokeWeight;
+    // $ExpectType number | undefined
+    options.zIndex;
+}
+
+// $ExpectType number
+testBezierCurve.getLength();
+
+// $ExpectType Bounds | null
+testBezierCurve.getBounds();
+
+// $ExpectType void
+testBezierCurve.show();
+
+// $ExpectType void
+testBezierCurve.hide();
+
+// $ExpectType void
+testBezierCurve.setMap(null);
+testBezierCurve.setMap(map);
+
+// $ExpectType void
+testBezierCurve.setExtData({ test: 1 });
+// $ExpectError
+testBezierCurve.setExtData({ test: '123' });
+
+// $ExpectType {} | BezierCurveExtraData
+testBezierCurve.getExtData();
+
+testBezierCurve.on('click', (event: AMap.BezierCurve.EventMap<typeof testBezierCurve>['click']) => {
+    // $ExpectType "click"
+    event.type;
+    // $ExpectType LngLat
+    event.lnglat;
+    // $ExpectType BezierCurve<BezierCurveExtraData>
+    event.target;
+});
+
+testBezierCurve.on('show', (event: AMap.BezierCurve.EventMap<typeof testBezierCurve>['show']) => {
+    // $ExpectType "show"
+    event.type;
+    // $ExpectType BezierCurve<BezierCurveExtraData>
+    event.target;
+});
+
+testBezierCurve.on('options', (event: AMap.BezierCurve.EventMap<typeof testBezierCurve>['options']) => {
+    // $ExpectType "options"
+    event.type;
+    // $ExpectError
+    event.target;
+});
+
+/**
+ * overlay/circle.ts
+ */
+
+interface CircleExtraData {
+    test: number;
+}
+
+// $ExpectType Circle<any>
+new AMap.Circle();
+new AMap.Circle({});
+// $ExpectType Circle<CircleExtraData>
+const testCircle = new AMap.Circle<CircleExtraData>({
+    map,
+    zIndex: 10,
+    center: lnglat,
+    bubble: true,
+    cursor: 'pointer',
+    radius: 1000,
+    strokeColor: '#FF0000',
+    strokeOpcity: 0.8,
+    strokeWeight: 3,
+    fillColor: '#00FF00',
+    fillOpacity: 0.5,
+    strokeStyle: 'dashed',
+    extData: { test: 1 },
+    strokeDasharray: [2, 4]
+});
+
+// $ExpectType void
+testCircle.setCenter(lnglat);
+// $ExpectType void
+testCircle.setCenter(lnglatTuple);
+
+// $ExpectType LngLat | undefined
+testCircle.getCenter();
+
+// $ExpectType Bounds | null
+testCircle.getBounds();
+
+// $ExpectType void
+testCircle.setRadius(100);
+
+// $ExpectType number
+testCircle.getRadius();
+
+// $ExpectType void
+testCircle.setOptions({});
+testCircle.setOptions({
+    map,
+    zIndex: 10,
+    center: lnglat,
+    bubble: true,
+    cursor: 'pointer',
+    radius: 1000,
+    strokeColor: '#FF0000',
+    strokeOpcity: 0.8,
+    strokeWeight: 3,
+    fillColor: '#00FF00',
+    fillOpacity: 0.5,
+    strokeStyle: 'dashed',
+    extData: { test: 1 },
+    strokeDasharray: [2, 4]
+});
+
+{
+    const options = testCircle.getOptions();
+    // $ExpectType boolean | undefined
+    options.bubble;
+    // $ExpectType LngLat | undefined
+    options.center;
+    // $ExpectType boolean | undefined
+    options.clickable;
+    // $ExpectType {} | CircleExtraData | undefined
+    options.extData;
+    // $ExpectType string | undefined
+    options.fillColor;
+    // $ExpectType number | undefined
+    options.fillOpacity;
+    // $ExpectType "miter" | "round" | "bevel" | undefined
+    options.lineJoin;
+    // $ExpectType Map | undefined
+    options.map;
+    // $ExpectType LngLat[] | undefined
+    options.path;
+    // $ExpectType number | undefined
+    options.radius;
+    // $ExpectType string | undefined
+    options.strokeColor;
+    // $ExpectType number[] | undefined
+    options.strokeDasharray;
+    // $ExpectType number | undefined
+    options.strokeOpacity;
+    // $ExpectType "dashed" | "solid" | undefined
+    options.strokeStyle;
+    // $ExpectType number | undefined
+    options.strokeWeight;
+    // $ExpectType string | undefined
+    options.texture;
+    // $ExpectType number | undefined
+    options.zIndex;
+}
+
+// $ExpectType Bounds | null
+testCircle.getBounds();
+
+// $ExpectType void
+testCircle.hide();
+
+// $ExpectType void
+testCircle.show();
+
+// $ExpectType void
+testCircle.setMap(null);
+// $ExpectType void
+testCircle.setMap(map);
+
+// $ExpectType void
+testCircle.setExtData({ test: 2 });
+// $ExpectError
+testCircle.setExtData({ test: '1' });
+
+// $ExpectType {} | CircleExtraData
+testCircle.getExtData();
+
+// $ExpectType boolean
+testCircle.contains(lnglat);
+// $ExpectType boolean
+testCircle.contains(lnglatTuple);
+
+testCircle.on('click', (event: AMap.Circle.EventMap<typeof testCircle>['click']) => {
+    // $ExpectType "click"
+    event.type;
+    // $ExpectType Circle<CircleExtraData>
+    event.target;
+});
+
+testCircle.on('setCenter', (event: AMap.Circle.EventMap<typeof testCircle>['setCenter']) => {
+    // $ExpectType "setCenter"
+    event.type;
+    // $ExpectError
+    event.target;
+});
+
+testCircle.on('change', (event: AMap.Circle.EventMap<typeof testCircle>['change']) => {
+    // $ExpectType "change"
+    event.type;
+    // $ExpectType Circle<CircleExtraData>
+    event.target;
+});
+
+/**
+ * overlay/contextMenu.ts
+ */
+
+interface ContextMenuExtraData {
+    test: number;
+}
+// $ExpectType ContextMenu<any>
+new AMap.ContextMenu();
+// $ExpectType ContextMenu<any>
+new AMap.ContextMenu({});
+// $ExpectType ContextMenu<ContextMenuExtraData>
+const testContextMenu = new AMap.ContextMenu<ContextMenuExtraData>({
+    content: '<div>content</div>',
+});
+
+// $ExpectType void
+testContextMenu.addItem('item', function() {
+    // $ExpectType HTMLLIElement
+    this;
+});
+// $ExpectType void
+testContextMenu.addItem('item', () => { }, 1);
+
+// $ExpectType void
+testContextMenu.removeItem('item', () => {});
+
+// $ExpectType void
+testContextMenu.open(map, lnglatTuple);
+// $ExpectType void
+testContextMenu.open(map, lnglat);
+
+// $ExpectType void
+testContextMenu.close();
+
+testContextMenu.on('items', (event: AMap.ContextMenu.EventMap<typeof testContextMenu>['items']) => {
+    // $ExpectType "items"
+    event.type;
+});
+
+testContextMenu.on('open', (event: AMap.ContextMenu.EventMap<typeof testContextMenu>['open']) => {
+    // $ExpectType "open"
+    event.type;
+    // $ExpectType ContextMenu<ContextMenuExtraData>
+    event.target;
+});
+
+/**
+ * overlay/ellipse.ts
+ */
+
+interface EllipseExtraData {
+    test: number;
+}
+// $ExpectType Ellipse<any>
+new AMap.Ellipse();
+// $ExpectType Ellipse<any>
+new AMap.Ellipse({});
+// $ExpectType Ellipse<EllipseExtraData>
+const testEllipse = new AMap.Ellipse<EllipseExtraData>({
+    map,
+    zIndex: 10,
+    center: lnglat,
+    radius: [10000, 15000],
+    bubble: false,
+    cursor: 'pointer',
+    strokeColor: '#FF0000',
+    strokeOpacity: 0.8,
+    strokeWeight: 2,
+    fillColor: '#0000FF',
+    fillOpacity: 0.5,
+    strokeStyle: 'dashed',
+    extData: { test: 1 },
+    strokeDasharray: [1, 5]
+});
+
+// $ExpectType LngLat | undefined
+testEllipse.getCenter();
+
+// $ExpectType void
+testEllipse.setCenter(lnglat);
+// $ExpectType void
+testEllipse.setCenter(lnglatTuple);
+
+// $ExpectType Bounds | null
+testEllipse.getBounds();
+
+// $ExpectType void
+testEllipse.setOptions({
+    map,
+    zIndex: 10,
+    center: lnglat,
+    radius: [10000, 15000],
+    bubble: false,
+    cursor: 'pointer',
+    strokeColor: '#FF0000',
+    strokeOpacity: 0.8,
+    strokeWeight: 2,
+    fillColor: '#0000FF',
+    fillOpacity: 0.5,
+    strokeStyle: 'dashed',
+    extData: { test: 1 },
+    strokeDasharray: [1, 5]
+});
+
+{
+    const options = testEllipse.getOptions();
+
+    // $ExpectType boolean | undefined
+    options.bubble;
+    // $ExpectType LngLat | undefined
+    options.center;
+    // $ExpectType boolean | undefined
+    options.clickable;
+    // $ExpectType {} | EllipseExtraData | undefined
+    options.extData;
+    // $ExpectType string | undefined
+    options.fillColor;
+    // $ExpectType number | undefined
+    options.fillOpacity;
+    // $ExpectType "miter" | "round" | "bevel" | undefined
+    options.lineJoin;
+    // $ExpectType Map | undefined
+    options.map;
+    // $ExpectType LngLat[] | undefined
+    options.path;
+    // $ExpectType [number, number] | undefined
+    options.radius;
+    // $ExpectType string | undefined
+    options.strokeColor;
+    // $ExpectType number[] | undefined
+    options.strokeDasharray;
+    // $ExpectType number | undefined
+    options.strokeOpacity;
+    // $ExpectType "dashed" | "solid" | undefined
+    options.strokeStyle;
+    // $ExpectType number | undefined
+    options.strokeWeight;
+    // $ExpectType string | undefined
+    options.texture;
+    // $ExpectType number | undefined
+    options.zIndex;
+}
+
+// $ExpectType void
+testEllipse.hide();
+
+// $ExpectType void
+testEllipse.show();
+
+// $ExpectType void
+testEllipse.setMap(null);
+// $ExpectType void
+testEllipse.setMap(map);
+
+// $ExpectType void
+testEllipse.setExtData({ test: 2 });
+// $ExpectType {} | EllipseExtraData
+testEllipse.getExtData();
+
+// $ExpectType boolean
+testEllipse.contains(lnglat);
+// $ExpectType boolean
+testEllipse.contains(lnglatTuple);
+
+/**
+ * overlay/geoJSON.ts
+ */
+
+interface GeoJSONExtraData {
+    test: number;
+}
+
+const geoJSONObject: AMap.GeoJSON.GeoJSONObject[] = [
+    {
+        type: 'Feature',
+        properties: {},
+        geometry: {
+            type: 'Point',
+            coordinates: lnglatTuple
+        }
+    },
+    {
+        type: 'Feature',
+        properties: { test: 1 },
+        geometry: {
+            type: 'LineString',
+            coordinates: [lnglatTuple, lnglatTuple]
+        }
+    }
+];
+
+// $ExpectType GeoJSON<any>
+new AMap.GeoJSON();
+// $ExpectType GeoJSON<any>
+new AMap.GeoJSON({});
+// $ExpectType GeoJSON<GeoJSONExtraData>
+const testGeoJSON = new AMap.GeoJSON<GeoJSONExtraData>({
+    geoJSON: geoJSONObject,
+    getMarker(obj, lnglat) {
+        // $ExpectType GeoJSONObject
+        obj;
+        // $ExpectType LngLat
+        lnglat;
+        return marker;
+    },
+    getPolyline(obj, lnglats) {
+        // $ExpectType GeoJSONObject
+        obj;
+        // $ExpectType LngLat[]
+        lnglats;
+        return testPolyline;
+    },
+    getPolygon(obj, lnglats) {
+        // $ExpectType GeoJSONObject
+        obj;
+        // $ExpectType LngLat[]
+        lnglats;
+        return testPolygon;
+    },
+    coordsToLatLng(coord) {
+        // $ExpectType LngLat
+        coord;
+        return coord;
+    }
+});
+
+// $ExpectType void
+testGeoJSON.importData(geoJSONObject);
+
+// $ExpectType GeoJSON<GeoJSONExtraData>
+testGeoJSON.removeOverlay(marker);
+// $ExpectType GeoJSON<GeoJSONExtraData>
+testGeoJSON.removeOverlay([marker]);
+
+// $ExpectType boolean
+testGeoJSON.hasOverlay(marker);
+// $ExpectType boolean
+testGeoJSON.hasOverlay(m => m === marker);
+
+// $ExpectType GeoJSON<GeoJSONExtraData>
+testGeoJSON.addOverlay(marker);
+// $ExpectType GeoJSON<GeoJSONExtraData>
+testGeoJSON.addOverlay([marker]);
+
+// $ExpectType GeoJSONObject[]
+testGeoJSON.toGeoJSON();
+
+// $ExpectType GeoJSON<GeoJSONExtraData>
+testGeoJSON.setMap(null);
+// $ExpectType GeoJSON<GeoJSONExtraData>
+testGeoJSON.setMap(map);
+
+// $ExpectType GeoJSON<GeoJSONExtraData>
+testGeoJSON.hide();
+
+// $ExpectType GeoJSON<GeoJSONExtraData>
+testGeoJSON.show();
+
+testGeoJSON.on('click', (event: AMap.MapsEvent<'click', AMap.Overlay>) => {
+    // $ExpectType "click"
+    event.type;
+    // $ExpectType Overlay<any>
+    event.target;
+});
+
+/**
+ * overlay/icon.ts
+ */
+
+// $ExpectType Icon
+new AMap.Icon();
+// $ExpectType Icon
+new AMap.Icon({});
+// $ExpectType Icon
+new AMap.Icon({
+    size,
+    imageOffset: pixel,
+    image: 'image uri',
+    imageSize: size
+});
+// $ExpectType Icon
+const testIcon = new AMap.Icon({
+    size: [1, 2],
+    imageOffset: pixel,
+    image: 'image uri',
+    imageSize: [1, 2]
+});
+
+// $ExpectType Size
+testIcon.getImageSize();
+
+// $ExpectType void
+testIcon.setImageSize(size);
+// $ExpectType void
+testIcon.setImageSize([1, 2]);
+
+/**
+ * overlay/infoWindow.ts
+ */
+
+interface InfoWindowExtraData {
+    test: number;
+}
+
+// $ExpectType InfoWindow<any>
+new AMap.InfoWindow();
+// $ExpectType InfoWindow<any>
+new AMap.InfoWindow({});
+// $ExpectType InfoWindow<InfoWindowExtraData>
+const testInfoWindow = new AMap.InfoWindow<InfoWindowExtraData>({
+    isCustom: false,
+    autoMove: false,
+    closeWhenClickMap: false,
+    content: 'content',
+    size: [100, 100],
+    offset: new AMap.Pixel(10, 10),
+    position: lnglat,
+    showShadow: true
+});
+
+// $ExpectType void
+testInfoWindow.open(map);
+// $ExpectType void
+testInfoWindow.open(map, lnglat);
+// $ExpectType void
+testInfoWindow.open(map, lnglatTuple);
+
+// $ExpectType void
+testInfoWindow.close();
+
+// $ExpectType boolean
+testInfoWindow.getIsOpen();
+
+// $ExpectType void
+testInfoWindow.setContent('content');
+// $ExpectType void
+testInfoWindow.setContent(div);
+
+// $ExpectType string | HTMLElement | undefined
+testInfoWindow.getContent();
+
+// $ExpectType void
+testInfoWindow.setPosition(lnglat);
+// $ExpectType void
+testInfoWindow.setPosition(lnglatTuple);
+
+// $ExpectType LngLat | undefined
+testInfoWindow.getPosition();
+
+// $ExpectType Size | undefined
+testInfoWindow.getSize();
+
+testInfoWindow.on('change', (event: AMap.InfoWindow.EventMap<typeof testInfoWindow>['change']) => {
+    // $ExpectType "change"
+    event.type;
+    // $ExpectType InfoWindow<InfoWindowExtraData>
+    event.target;
+});
+
+testInfoWindow.on('close', (event: AMap.InfoWindow.EventMap<typeof testInfoWindow>['close']) => {
+    // $ExpectType "close"
+    event.type;
+    // $ExpectType InfoWindow<InfoWindowExtraData>
+    event.target;
+});
+
+testInfoWindow.on('open', (event: AMap.InfoWindow.EventMap<typeof testInfoWindow>['open']) => {
+    // $ExpectType "open"
+    event.type;
+    // $ExpectType InfoWindow<InfoWindowExtraData>
+    event.target;
+});
+
+/**
+ * overlay/marker.ts
+ */
+
+interface MarkerExtraData {
+    test: number;
+}
+
+// $ExpectType Marker<MarkerExtraData>
+new AMap.Marker<MarkerExtraData>();
+// $ExpectType Marker<any>
+new AMap.Marker();
+// $ExpectType Marker<any>
+new AMap.Marker({});
+// $ExpectType Marker<MarkerExtraData>
+export const testMarker = new AMap.Marker<MarkerExtraData>({
+    map,
+    position: lnglat,
+    offset: pixel,
+    icon: 'iconUrl',
+    content: 'htmlString',
+    topWhenClick: true,
+    raiseOnDrag: true,
+    cursor: 'default',
+    visible: true,
+    zIndex: 10,
+    angle: 10,
+    autoRotation: true,
+    animation: 'AMAP_ANIMATION_BOUNCE',
+    shadow: icon,
+    title: '123',
+    clickable: true,
+    shape: markerShape,
+    extData: {
+        test: 123
+    }
+});
+
+// $ExpectType void
+testMarker.markOnAMAP({
+    name: '123',
+    position: [1, 2]
+});
+// $ExpectType void
+testMarker.markOnAMAP();
+// $ExpectType void
+testMarker.markOnAMAP({});
+// $ExpectType void
+testMarker.markOnAMAP({
+    position: [1, 2],
+    name: '123'
+});
+
+// $ExpectType Pixel
+testMarker.getOffset();
+
+// $ExpectType void
+testMarker.setOffset(pixel);
+
+// $ExpectType void
+testMarker.setAnimation('AMAP_ANIMATION_BOUNCE');
+
+// $ExpectType AnimationName
+testMarker.getAnimation();
+
+// $ExpectType void
+testMarker.setClickable(true);
+
+// $ExpectType boolean
+testMarker.getClickable();
+
+// $ExpectType LngLat | undefined
+testMarker.getPosition();
+
+// $ExpectType void
+testMarker.setPosition(lnglat);
+
+// $ExpectType void
+testMarker.setAngle(0);
+
+// $ExpectType void
+testMarker.setLabel();
+// $ExpectType void
+testMarker.setLabel({});
+// $ExpectType void
+testMarker.setLabel({
+    content: 'label content',
+    offset: pixel
+});
+
+// $ExpectType Label | undefined
+testMarker.getLabel();
+
+// $ExpectType number
+testMarker.getAngle();
+
+// $ExpectType void
+testMarker.setzIndex(100);
+
+// $ExpectType number
+testMarker.getzIndex();
+
+// $ExpectType void
+testMarker.setIcon('icon uri');
+// $ExpectType void
+testMarker.setIcon(icon);
+
+// $ExpectType string | Icon | undefined
+testMarker.getIcon();
+
+// $ExpectType void
+testMarker.setDraggable(true);
+
+// $ExpectType boolean
+testMarker.getDraggable();
+
+// $ExpectType void
+testMarker.setCursor('default');
+
+// $ExpectType void
+testMarker.setContent('content');
+// $ExpectType void
+testMarker.setContent(domEle);
+
+// $ExpectType string | HTMLElement
+testMarker.getContent();
+
+// $ExpectType void
+testMarker.moveAlong([lnglat], 100);
+// $ExpectError
+testMarker.moveAlong([[1, 2]], 100);
+// $ExpectType void
+testMarker.moveAlong([lnglat], 100, t => t, false);
+
+// $ExpectType void
+testMarker.moveTo(lnglat, 100);
+// $ExpectType void
+testMarker.moveTo([1, 2], 100);
+// $ExpectType void
+testMarker.moveTo([1, 2], 100, t => t);
+
+// $ExpectType void
+testMarker.stopMove();
+
+// $ExpectType boolean
+testMarker.pauseMove();
+
+// $ExpectType boolean
+testMarker.resumeMove();
+
+// $ExpectType void
+testMarker.setMap(map);
+
+// $ExpectType void
+testMarker.setTitle('title');
+// $ExpectError
+testMarker.setTitle();
+
+// $ExpectType string | undefined
+testMarker.getTitle();
+
+// $ExpectType void
+testMarker.setTop(true);
+
+// $ExpectType boolean
+testMarker.getTop();
+
+// $ExpectType void
+testMarker.setShadow();
+// $ExpectType void
+testMarker.setShadow(icon);
+// $ExpectType void
+testMarker.setShadow('shadow url');
+
+// $ExpectType string | Icon | undefined
+testMarker.getShadow();
+
+// $ExpectType void
+testMarker.setShape();
+// $ExpectType void
+testMarker.setShape(markerShape);
+
+// $ExpectType MarkerShape | undefined
+testMarker.getShape();
+
+testMarker.on('click', (event: AMap.Marker.EventMap<typeof testMarker>['click']) => {
+    // $ExpectType {} | MarkerExtraData
+    event.target.getExtData();
+});
+
+/**
+ * overlay/markerShape.ts
+ */
+
+// $ExpectType MarkerShape
+new AMap.MarkerShape({
+    type: 'circle',
+    coords: [1, 1, 1]
+});
+// $ExpectType MarkerShape
+new AMap.MarkerShape({
+    type: 'rect',
+    coords: [1, 1, 1, 2]
+});
+// $ExpectType MarkerShape
+new AMap.MarkerShape({
+    type: 'poly',
+    coords: [1, 2, 3, 4, 5]
+});
+
+// $ExpectError
+new AMap.MarkerShape({
+    type: 'circle',
+    coords: [1, 1]
+});
+// $ExpectError
+new AMap.MarkerShape({
+    type: 'rect',
+    coords: [1, 1, 1, 2, 2]
+});
+
+/**
+ * overlay/overlay.ts
+ */
+
+interface OverlayExtraData {
+    test: number;
+}
+declare const testOverlay: AMap.Overlay<OverlayExtraData>;
+
+// $ExpectType void
+testOverlay.show();
+
+// $ExpectType void
+testOverlay.hide();
+
+// $ExpectType Map | null | undefined
+testOverlay.getMap();
+
+// $ExpectType void
+testOverlay.setMap(map);
+// $ExpectType void
+testOverlay.setMap(null);
+
+// $ExpectError
+testOverlay.setExtData({ any: 123 });
+
+// $ExpectError OverlayExtraData
+testOverlay.getExtData();
+
+/**
+ * overlay/overlayGroup.ts
+ */
+
+// $ExpectType OverlayGroup<Overlay<any>, any>
+const testOverlayGroup2 = new AMap.OverlayGroup();
+// $ExpectType OverlayGroup<Marker<any>, any>
+new AMap.OverlayGroup<AMap.Marker, any>(marker);
+// $ExpectType OverlayGroup<Marker<any>, any>
+const testOverlayGroup = new AMap.OverlayGroup<AMap.Marker>([marker]);
+
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.addOverlay(marker);
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.addOverlay([marker]);
+// $ExpectError
+testOverlayGroup.addOverlay([testCircle]);
+
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.addOverlays(marker);
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.addOverlays([marker]);
+
+// $ExpectType Marker<any>[]
+testOverlayGroup.getOverlays();
+
+// $ExpectType boolean
+testOverlayGroup.hasOverlay(marker);
+// $ExpectType boolean
+testOverlayGroup.hasOverlay(o => o === marker);
+
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.removeOverlay(marker);
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.removeOverlay([marker]);
+
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.removeOverlays(marker);
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.removeOverlays([marker]);
+
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.clearOverlays();
+
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.eachOverlay(function(overlay, index, overlays) {
+    // $ExpectType Marker<any>
+    overlay;
+    // $ExpectType number
+    index;
+    // $ExpectType Marker<any>[]
+    overlays;
+    // $ExpectType Marker<any>
+    this;
+});
+
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.setMap(null);
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.setMap(map);
+
+// $ExpectType OverlayGroup<Overlay<any>, any>
+testOverlayGroup2.setOptions({
+    test: 1
+});
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.setOptions({
+    map,
+    position: lnglat,
+    offset: pixel,
+    icon: 'iconUrl',
+    content: 'htmlString',
+    topWhenClick: true,
+    raiseOnDrag: true,
+    cursor: 'default',
+    visible: true,
+    zIndex: 10,
+    angle: 10,
+    autoRotation: true,
+    animation: 'AMAP_ANIMATION_BOUNCE',
+    shadow: icon,
+    title: '123',
+    clickable: true,
+    shape: markerShape,
+    extData: {
+        test: 123
+    }
+});
+
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.show();
+
+// $ExpectType OverlayGroup<Marker<any>, any>
+testOverlayGroup.hide();
+
+testOverlayGroup.on('click', (event: AMap.MapsEvent<'click', AMap.Overlay>) => {
+    // $ExpectType "click"
+    event.type;
+    // $ExpectType Overlay<any>
+    event.target;
+});
+
+/**
+ * overlay/polygon.ts
+ */
+
+interface PolygonExtraData {
+    test: number;
+}
+
+const polygonPath1 = [lnglatTuple, lnglatTuple, lnglatTuple, lnglatTuple, lnglatTuple];
+const polygonPath2 = [lnglat, lnglat, lnglat, lnglat, lnglat];
+
+// $ExpectType Polygon<any>
+new AMap.Polygon();
+// $ExpectType Polygon<any>
+new AMap.Polygon({});
+// $ExpectType Polygon<PolygonExtraData>
+const testPolygon = new AMap.Polygon<PolygonExtraData>({
+    map,
+    zIndex: 10,
+    bubble: true,
+    cursor: 'pointer',
+    strokeColor: '#00FF00',
+    strokeOpacity: 0.3,
+    strokeWeight: 5,
+    fillColor: '#0000FF',
+    fillOpacity: 0.5,
+    draggable: true,
+    extData: { test: 1 },
+    strokeStyle: 'dashed',
+    strokeDasharray: [2, 4],
+    path: polygonPath1
+});
+
+// $ExpectType void
+testPolygon.setPath(polygonPath1);
+// $ExpectType void
+testPolygon.setPath(polygonPath2);
+// $ExpectType void
+testPolygon.setPath([polygonPath1, polygonPath2]);
+
+// $ExpectType LngLat[] | LngLat[][]
+testPolygon.getPath();
+
+// $ExpectType void
+testPolygon.setOptions({
+    map,
+    zIndex: 10,
+    bubble: true,
+    cursor: 'pointer',
+    strokeColor: '#00FF00',
+    strokeOpacity: 0.8,
+    strokeWeight: 5,
+    fillColor: '#0000FF',
+    fillOpacity: 0.5,
+    draggable: true,
+    extData: { test: 1 },
+    strokeStyle: 'dashed',
+    strokeDasharray: [4, 2],
+    path: [polygonPath2, polygonPath1]
+});
+
+{
+    const options = testPolygon.getOptions();
+    // $ExpectType boolean | undefined
+    options.bubble;
+    // $ExpectType boolean | undefined
+    options.clickable;
+    // $ExpectType {} | PolygonExtraData | undefined
+    options.extData;
+    // $ExpectType string | undefined
+    options.fillColor;
+    // $ExpectType number | undefined
+    options.fillOpacity;
+    // $ExpectType "miter" | "round" | "bevel" | undefined
+    options.lineJoin;
+    // $ExpectType Map | undefined
+    options.map;
+    // $ExpectType LngLat[] | LngLat[][] | undefined
+    options.path;
+    // $ExpectType string | undefined
+    options.strokeColor;
+    // $ExpectType number[] | undefined
+    options.strokeDasharray;
+    // $ExpectType number | undefined
+    options.strokeOpacity;
+    // $ExpectType "dashed" | "solid" | undefined
+    options.strokeStyle;
+    // $ExpectType number | undefined
+    options.strokeWeight;
+    // $ExpectType string | undefined
+    options.texture;
+    // $ExpectType number | undefined
+    options.zIndex;
+}
+
+// $ExpectType Bounds | null
+testPolygon.getBounds();
+
+// $ExpectType number
+testPolygon.getArea();
+
+// $ExpectType void
+testPolygon.setMap(null);
+// $ExpectType void
+testPolygon.setMap(map);
+
+// $ExpectType void
+testPolygon.setExtData({ test: 1 });
+
+// $ExpectType {} | PolygonExtraData
+testPolygon.getExtData();
+
+// $ExpectType boolean
+testPolygon.contains(lnglat);
+// $ExpectType boolean
+testPolygon.contains(lnglatTuple);
+
+testPolygon.on('click', (event: AMap.Polygon.EventMap<typeof testPolygon>['click']) => {
+    // $ExpectType "click"
+    event.type;
+    // $ExpectType Polygon<PolygonExtraData>
+    event.target;
+});
+
+/**
+ * overlay/polyline.ts
+ */
+
+interface PolylineExtraData {
+    test: number;
+}
+
+// $ExpectType Polyline<any>
+new AMap.Polyline();
+// $ExpectType Polyline<any>
+new AMap.Polyline({});
+// $ExpectType Polyline<PolylineExtraData>
+const testPolyline = new AMap.Polyline<PolylineExtraData>({
+    map,
+    zIndex: 10,
+    bubble: true,
+    cursor: 'default',
+    geodesic: true,
+    isOutline: true,
+    borderWeight: 1,
+    outlineColor: '#AA0000',
+    path: [lnglat],
+    strokeColor: '#0000AA',
+    strokeOpacity: 0.5,
+    strokeWeight: 10,
+    strokeStyle: 'dashed',
+    strokeDasharray: [20, 10, 20],
+    lineJoin: 'bevel',
+    lineCap: 'butt',
+    draggable: true,
+    extData: { test: 1 },
+    showDir: true
+});
+// Polyline<PolylineExtraData>
+
+// $ExpectType void
+testPolyline.setPath([lnglat]);
+// $ExpectType void
+testPolyline.setPath([lnglatTuple]);
+
+// $ExpectType void
+testPolyline.setOptions({});
+// $ExpectType void
+testPolyline.setOptions({
+    map,
+    zIndex: 10,
+    bubble: true,
+    cursor: 'default',
+    geodesic: true,
+    isOutline: true,
+    borderWeight: 1,
+    outlineColor: '#AA0000',
+    path: [lnglat, lnglat],
+    strokeColor: '#0000AA',
+    strokeOpacity: 0.5,
+    strokeWeight: 10,
+    strokeStyle: 'dashed',
+    strokeDasharray: [20, 10, 20],
+    lineJoin: 'bevel',
+    lineCap: 'butt',
+    draggable: true,
+    extData: { test: 1 },
+    showDir: true
+});
+
+{
+    const options = testPolyline.getOptions();
+    // $ExpectType number | undefined
+    options.borderWeight;
+    // $ExpectType boolean | undefined
+    options.bubble;
+    // $ExpectType boolean | undefined
+    options.clickable;
+    // $ExpectType string | undefined
+    options.dirColor;
+    // $ExpectType string | undefined
+    options.dirImg;
+    // $ExpectType {} | PolylineExtraData | undefined
+    options.extData;
+    // $ExpectType boolean | undefined
+    options.geodesic;
+    // $ExpectType boolean | undefined
+    options.isOutline;
+    // $ExpectType "round" | "butt" | "square" | undefined
+    options.lineCap;
+    // $ExpectType "miter" | "round" | "bevel" | undefined
+    options.lineJoin;
+    // $ExpectType Map | undefined
+    options.map;
+    // $ExpectType string | undefined
+    options.outlineColor;
+    // $ExpectType LngLat[] | undefined
+    options.path;
+    // $ExpectType boolean | undefined
+    options.showDir;
+    // $ExpectType string | undefined
+    options.strokeColor;
+    // $ExpectType number[] | undefined
+    options.strokeDasharray;
+    // $ExpectType number | undefined
+    options.strokeOpacity;
+    // $ExpectType "dashed" | "solid" | undefined
+    options.strokeStyle;
+    // $ExpectType number | undefined
+    options.strokeWeight;
+    // $ExpectType number | undefined
+    options.zIndex;
+}
+
+// $ExpectType number
+testPolyline.getLength();
+
+// $ExpectType Bounds | null
+testPolyline.getBounds();
+
+// $ExpectType void
+testPolyline.hide();
+
+// $ExpectType void
+testPolyline.show();
+
+// $ExpectType void
+testPolyline.setMap(null);
+// $ExpectType void
+testPolyline.setMap(map);
+
+// $ExpectType void
+testPolyline.setExtData({ test: 1 });
+
+// $ExpectType {} | PolylineExtraData
+testPolyline.getExtData();
+
+testPolyline.on('click', (event: AMap.Polyline.EventMap<typeof testPolyline>['click']) => {
+    // $ExpectType "click"
+    event.type;
+    // $ExpectType Polyline<PolylineExtraData>
+    event.target;
+});
+
+/**
+ * overlay/rectangle.ts
+ */
+
+interface RectangleExtraData {
+    test: number;
+}
+
+// $ExpectType Rectangle<any>
+new AMap.Rectangle();
+// $ExpectType Rectangle<any>
+new AMap.Rectangle({});
+// $ExpectType Rectangle<RectangleExtraData>
+const testRectangle = new AMap.Rectangle<RectangleExtraData>({
+    map,
+    zIndex: 10,
+    bounds,
+    bubble: false,
+    cursor: 'pointer',
+    strokeColor: '#00FF00',
+    strokeOpacity: 0.8,
+    strokeWeight: 2,
+    fillColor: '#0000FF',
+    fillOpacity: 0.5,
+    strokeStyle: 'solid',
+    extData: { test: 1 },
+    strokeDasharray: [1, 5]
+});
+
+// $ExpectType Bounds | undefined
+testRectangle.getBounds();
+
+// $ExpectType void
+testRectangle.setBounds(bounds);
+
+// $ExpectType void
+testRectangle.setOptions({});
+// $ExpectType void
+testRectangle.setOptions({
+    map,
+    zIndex: 10,
+    bounds,
+    bubble: false,
+    cursor: 'pointer',
+    strokeColor: '#00FF00',
+    strokeOpacity: 0.8,
+    strokeWeight: 2,
+    fillColor: '#0000FF',
+    fillOpacity: 0.5,
+    strokeStyle: 'solid',
+    extData: { test: 1 },
+    strokeDasharray: [1, 5]
+});
+
+{
+    const options = testRectangle.getOptions();
+    // $ExpectType Bounds | undefined
+    options.bounds;
+    // $ExpectType boolean | undefined
+    options.bubble;
+    // $ExpectType boolean | undefined
+    options.clickable;
+    // $ExpectType {} | RectangleExtraData | undefined
+    options.extData;
+    // $ExpectType string | undefined
+    options.fillColor;
+    // $ExpectType number | undefined
+    options.fillOpacity;
+    // $ExpectType "miter" | "round" | "bevel" | undefined
+    options.lineJoin;
+    // $ExpectType Map | undefined
+    options.map;
+    // $ExpectType LngLat[] | undefined
+    options.path;
+    // $ExpectType string | undefined
+    options.strokeColor;
+    // $ExpectType number[] | undefined
+    options.strokeDasharray;
+    // $ExpectType number | undefined
+    options.strokeOpacity;
+    // $ExpectType "dashed" | "solid" | undefined
+    options.strokeStyle;
+    // $ExpectType number | undefined
+    options.strokeWeight;
+    // $ExpectType string | undefined
+    options.texture;
+    // $ExpectType number | undefined
+    options.zIndex;
+}
+
+// $ExpectType void
+testRectangle.hide();
+
+// $ExpectType void
+testRectangle.show();
+
+// $ExpectType void
+testRectangle.setExtData({test: 2});
+
+// $ExpectType {} | RectangleExtraData
+testRectangle.getExtData();
+
+// $ExpectType boolean
+testRectangle.contains(lnglat);
+// $ExpectType boolean
+testRectangle.contains(lnglatTuple);
+
+testRectangle.on('click', (event: AMap.Rectangle.EventMap<typeof testRectangle>['click']) => {
+    // $ExpectType "click"
+    event.type;
+    // $ExpectType Rectangle<RectangleExtraData>
+    event.target;
+});
+
+testRectangle.on('setBounds', (event: AMap.Rectangle.EventMap<typeof testRectangle>['setBounds']) => {
+    // $ExpectType "setBounds"
+    event.type;
+    // $ExpectError
+    event.target;
+});
+
+/**
+ * overlay/text.ts
+ */
+
+interface TextExtraData {
+    test: number;
+}
+
+// $ExpectType Text<any>
+new AMap.Text();
+// $ExpectType Text<any>
+new AMap.Text({});
+// $ExpectType Text<TextExtraData>
+const testText = new AMap.Text<TextExtraData>({
+    text: 'content',
+    textAlign: 'center',
+    verticalAlign: 'top',
+    map,
+    position: lnglat,
+    offset: pixel,
+    topWhenClick: true,
+    bubble: true,
+    draggable: true,
+    raiseOnDrag: true,
+    cursor: 'default',
+    visible: true,
+    zIndex: 100,
+    angle: 45,
+    autoRotation: true,
+    animation: 'AMAP_ANIMATION_BOUNCE',
+    shadow: 'https://webapi.amap.com/theme/v1.3/markers/0.png',
+    title: 'title',
+    clickable: true,
+    extData: { test: 1 }
+});
+
+// $ExpectType string
+testText.getText();
+
+// $ExpectType void
+testText.setText('123');
+
+// $ExpectType void
+testText.setStyle({
+    background: 'red',
+    width: '200px'
+});
+
+// $ExpectType void
+testText.markOnAMAP({
+    name: '123',
+    position: lnglatTuple
+});
+
+// $ExpectType Pixel
+testText.getOffset();
+
+// $ExpectType void
+testText.setOffset(pixel);
+
+// $ExpectType void
+testText.setAnimation('AMAP_ANIMATION_BOUNCE');
+
+// $ExpectType AnimationName
+testText.getAnimation();
+
+// $ExpectType void
+testText.setClickable(true);
+
+// $ExpectType boolean
+testText.getClickable();
+
+// $ExpectType LngLat | undefined
+testText.getPosition();
+
+// $ExpectType void
+testText.setAngle(10);
+
+// $ExpectType number
+testText.getAngle();
+
+// $ExpectType void
+testText.setzIndex(1);
+
+// $ExpectType number
+testText.getzIndex();
+
+// $ExpectType void
+testText.setDraggable(true);
+
+// $ExpectType boolean
+testText.getDraggable();
+
+// $ExpectType void
+testText.hide();
+
+// $ExpectType void
+testText.show();
+
+// $ExpectType void
+testText.setCursor('default');
+
+// $ExpectType void
+testText.moveAlong([lnglat], 100);
+
+// $ExpectType void
+testText.moveAlong([lnglat], 100);
+// $ExpectError
+testText.moveAlong([[1, 2]], 100);
+// $ExpectType void
+testText.moveAlong([lnglat], 100, t => t, false);
+
+// $ExpectType void
+testText.moveTo(lnglat, 100);
+// $ExpectType void
+testText.moveTo([1, 2], 100);
+// $ExpectType void
+testText.moveTo([1, 2], 100, t => t);
+
+// $ExpectType void
+testText.stopMove();
+
+// $ExpectType boolean
+testText.pauseMove();
+
+// $ExpectType boolean
+testText.resumeMove();
+
+// $ExpectType void
+testText.setMap(map);
+
+// $ExpectType void
+testText.setTitle('title');
+// $ExpectError
+testText.setTitle();
+
+// $ExpectType string | undefined
+testText.getTitle();
+
+// $ExpectType void
+testText.setTop(true);
+
+// $ExpectType boolean
+testText.getTop();
+
+// $ExpectType void
+testText.setShadow();
+// $ExpectType void
+testText.setShadow(icon);
+// $ExpectType void
+testText.setShadow('shadow url');
+
+// $ExpectType void
+testText.setExtData({test: 1});
+
+// $ExpectType {} | TextExtraData
+testText.getExtData();
+
+testText.on('click', (event: AMap.Text.EventMap<typeof testText>['click']) => {
+    // $ExpectType "click"
+    event.type;
+    // $ExpectType Text<TextExtraData>
+    event.target;
+});
diff --git a/types/amap-js-api/array-bounds.d.ts b/types/amap-js-api/array-bounds.d.ts
new file mode 100644
index 0000000000..419d8e4b1d
--- /dev/null
+++ b/types/amap-js-api/array-bounds.d.ts
@@ -0,0 +1,10 @@
+declare namespace AMap {
+    class ArrayBounds {
+        constructor(bounds: LocationValue[]);
+        bounds: LngLat[];
+        contains(point: LocationValue): boolean;
+        // internal
+        toBounds(): Bounds;
+        getCenter(): LngLat;
+    }
+}
diff --git a/types/amap-js-api/bounds.d.ts b/types/amap-js-api/bounds.d.ts
new file mode 100644
index 0000000000..63e880fe65
--- /dev/null
+++ b/types/amap-js-api/bounds.d.ts
@@ -0,0 +1,12 @@
+declare namespace AMap {
+    class Bounds {
+        constructor(southWest: LngLat, northEast: LngLat);
+        contains(point: LocationValue): boolean;
+        getCenter(): LngLat;
+        getSouthWest(): LngLat;
+        getSouthEast(): LngLat;
+        getNorthEast(): LngLat;
+        getNorthWest(): LngLat;
+        toString(): string;
+    }
+}
diff --git a/types/amap-js-api/browser.d.ts b/types/amap-js-api/browser.d.ts
new file mode 100644
index 0000000000..71bfaa8fea
--- /dev/null
+++ b/types/amap-js-api/browser.d.ts
@@ -0,0 +1,51 @@
+declare namespace AMap {
+    namespace Browser {
+        const ua: string;
+        const mobile: boolean;
+        const plat: 'android' | 'ios' | 'windows' | 'mac' | 'other';
+        const mac: boolean;
+        const windows: boolean;
+        const ios: boolean;
+        const iPad: boolean;
+        const iPhone: boolean;
+        const android: boolean;
+        const android23: boolean;
+        const chrome: boolean;
+        const firefox: boolean;
+        const safari: boolean;
+        const wechat: boolean;
+        const uc: boolean;
+        const qq: boolean;
+        const ie: boolean;
+        const ie6: boolean;
+        const ie7: boolean;
+        const ie8: boolean;
+        const ie9: boolean;
+        const ie10: boolean;
+        const ie11: boolean;
+        const edge: boolean;
+        const ielt9: boolean;
+        const baidu: boolean;
+        const isLocalStorage: boolean;
+        const isGeolocation: boolean;
+        const mobileWebkit: boolean;
+        const mobileWebkit3d: boolean;
+        const mobileOpera: boolean;
+        const retina: boolean;
+        const touch: boolean;
+        const msPointer: boolean;
+        const pointer: boolean;
+        const webkit: boolean;
+        const ie3d: boolean;
+        const webkit3d: boolean;
+        const gecko3d: boolean;
+        const opera3d: boolean;
+        const any3d: boolean;
+        const isCanvas: boolean;
+        const isSvg: boolean;
+        const isVML: boolean;
+        const isWorker: boolean;
+        const isWebsocket: boolean;
+        function isWebGL(): boolean;
+    }
+}
diff --git a/types/amap-js-api/common.d.ts b/types/amap-js-api/common.d.ts
new file mode 100644
index 0000000000..3d51dc719e
--- /dev/null
+++ b/types/amap-js-api/common.d.ts
@@ -0,0 +1,22 @@
+declare namespace AMap {
+    type SizeValue = Size | [number, number];
+    type LocationValue = LngLat | [number, number];
+    type Lang = 'zh_cn' | 'en' | 'zh_en';
+
+    type Event<N extends string = string, V = undefined> = { type: N } &
+        (V extends HTMLElement ? { value: V }
+            : V extends object ? V
+            : V extends undefined ? {}
+            : { value: V });
+    type MapsEvent<N extends string, I> = Event<N, {
+        lnglat: LngLat;
+        pixel: Pixel;
+        target: I
+    }>;
+
+    type StrokeLineJoin = 'miter' | 'round' | 'bevel';
+    type StrokeLineCap = 'butt' | 'round' | 'square';
+    type StrokeStyle = 'dashed' | 'solid';
+
+    type AnimationName = 'AMAP_ANIMATION_NONE' | 'AMAP_ANIMATION_DROP' | 'AMAP_ANIMATION_BOUNCE';
+}
diff --git a/types/amap-js-api/convert-from.d.ts b/types/amap-js-api/convert-from.d.ts
new file mode 100644
index 0000000000..9fe1f1e76d
--- /dev/null
+++ b/types/amap-js-api/convert-from.d.ts
@@ -0,0 +1,15 @@
+declare namespace AMap {
+    namespace convertFrom {
+        interface Result {
+            info: string; // 'ok'
+            locations: LngLat[];
+        }
+        type Type = 'gps' | 'baidu' | 'mapbar';
+        type SearchStatus = 'complete' | 'error';
+    }
+    function convertFrom(
+        lnglat: LocationValue | LocationValue[],
+        type: convertFrom.Type | null,
+        callback: (status: convertFrom.SearchStatus, result: string | convertFrom.Result) => void
+    ): void;
+}
diff --git a/types/amap-js-api/dom-util.d.ts b/types/amap-js-api/dom-util.d.ts
new file mode 100644
index 0000000000..d83a2ca69a
--- /dev/null
+++ b/types/amap-js-api/dom-util.d.ts
@@ -0,0 +1,31 @@
+declare namespace AMap {
+    namespace DomUtil {
+        function getViewport(dom: HTMLElement): Size;
+
+        function getViewportOffset(dom: HTMLElement): Pixel;
+
+        function create<K extends keyof HTMLElementTagNameMap>(
+            tagName: K,
+            parent?: HTMLElement,
+            className?: string
+        ): HTMLElementTagNameMap[K];
+
+        function setClass(dom: HTMLElement, className?: string): void;
+
+        function hasClass(dom: HTMLElement, className: string): boolean;
+
+        function addClass(dom: HTMLElement, className: string): void;
+
+        function removeClass(dom: HTMLElement, className: string): void;
+
+        function setOpacity(dom: HTMLElement, opacity: number): void;
+
+        function rotate(dom: HTMLElement, deg: number, origin?: { x: number, y: number }): void;
+
+        function setCss(dom: HTMLElement | HTMLElement[], style: Partial<CSSStyleDeclaration>): typeof DomUtil; // this
+
+        function empty(dom: HTMLElement): void;
+
+        function remove(dom: HTMLElement): void;
+    }
+}
diff --git a/types/amap-js-api/event.d.ts b/types/amap-js-api/event.d.ts
new file mode 100644
index 0000000000..d8ff5753c9
--- /dev/null
+++ b/types/amap-js-api/event.d.ts
@@ -0,0 +1,59 @@
+declare namespace AMap {
+    abstract class EventEmitter {
+        on<E extends Event, C = this>(
+            eventName: string,
+            // tslint:disable-next-line:no-unnecessary-generics
+            handler: (this: C, event: E) => void,
+            context?: C,
+            once?: boolean,
+            unshift?: boolean
+        ): this;
+
+        off<E extends Event, C = this>(
+            eventName: string,
+            // tslint:disable-next-line
+            handler: ((this: C, event: E) => void) | 'mv',
+            context?: C
+        ): this;
+
+        emit(eventName: string, data?: any): this;
+    }
+
+    namespace event {
+        interface EventListener<T extends 0 | 1> {
+            type: T;
+        }
+
+        function addDomListener<N extends keyof HTMLElementTagNameMap, E extends keyof HTMLElementEventMap, C = HTMLElementTagNameMap[N]>(
+            // tslint:disable-next-line: no-unnecessary-generics
+            instance: HTMLElementTagNameMap[N],
+            eventName: E,
+            handler: (this: C, event: HTMLElementEventMap[E]) => void,
+            context?: C
+        ): EventListener<0>;
+
+        function addListener<I extends EventEmitter, E extends Event, C = I>(
+            // tslint:disable-next-line: no-unnecessary-generics
+            instance: I,
+            eventName: string,
+            // tslint:disable-next-line: no-unnecessary-generics
+            handler: (this: C, event: E) => void,
+            // tslint:disable-next-line: no-unnecessary-generics
+            context?: C
+        ): EventListener<1>;
+
+        function addListenerOnce<I extends EventEmitter, E extends Event, C = I>(
+            // tslint:disable-next-line: no-unnecessary-generics
+            instance: I,
+            eventName: string,
+            // tslint:disable-next-line: no-unnecessary-generics
+            handler: (this: C, event: E) => void,
+            // tslint:disable-next-line: no-unnecessary-generics
+            context?: C
+        ): EventListener<1>;
+
+        function removeListener(listener: EventListener<0 | 1>): void;
+
+        function trigger(instance: EventEmitter, eventName: string, data?: any): void;
+    }
+}
diff --git a/types/amap-js-api/geometry-util.d.ts b/types/amap-js-api/geometry-util.d.ts
new file mode 100644
index 0000000000..03f6800088
--- /dev/null
+++ b/types/amap-js-api/geometry-util.d.ts
@@ -0,0 +1,122 @@
+declare namespace AMap {
+    namespace GeometryUtil {
+        function distance(
+            point1: LocationValue,
+            point2: LocationValue | LocationValue[]
+        ): number;
+
+        function ringArea(ring: LocationValue[]): number;
+
+        function isClockwise(path: LocationValue[]): boolean;
+
+        function distanceOfLine(line: LocationValue[]): number;
+
+        function ringRingClip(
+            ring1: LocationValue[],
+            ring2: LocationValue[]
+        ): Array<[number, number]>;
+
+        function doesRingRingIntersect(
+            ring1: LocationValue[],
+            ring2: LocationValue[]
+        ): boolean;
+
+        function doesLineRingIntersect(
+            line: LocationValue[],
+            ring: LocationValue[]
+        ): boolean;
+
+        function doesLineLineIntersect(
+            line1: LocationValue[],
+            line2: LocationValue[]
+        ): boolean;
+
+        function doesSegmentPolygonIntersect(
+            point1: LocationValue,
+            point2: LocationValue,
+            polygon: LocationValue[][]
+        ): boolean;
+
+        function doesSegmentRingIntersect(
+            point1: LocationValue,
+            point2: LocationValue,
+            ring: LocationValue[]
+        ): boolean;
+
+        function doesSegmentLineIntersect(
+            point1: LocationValue,
+            point2: LocationValue,
+            line: LocationValue[]
+        ): boolean;
+
+        function doesSegmentsIntersect(
+            point1: LocationValue,
+            point2: LocationValue,
+            point3: LocationValue,
+            point4: LocationValue
+        ): boolean;
+
+        function isPointInRing(point: LocationValue, ring: LocationValue[]): boolean;
+
+        function isRingInRing(ring1: LocationValue[], ring2: LocationValue[]): boolean;
+
+        function isPointInPolygon(point: LocationValue, polygon: LocationValue[][]): boolean;
+
+        function makesureClockwise(path: Array<[number, number]>): Array<[number, number]>;
+
+        function makesureAntiClockwise(path: Array<[number, number]>): Array<[number, number]>;
+
+        function closestOnSegment(
+            point1: LocationValue,
+            point2: LocationValue,
+            point3: LocationValue
+        ): [number, number];
+
+        function closestOnLine(point: LocationValue, line: LocationValue[]): [number, number];
+
+        function distanceToSegment(
+            point1: LocationValue,
+            point2: LocationValue,
+            point3: LocationValue
+        ): number;
+
+        function distanceToLine(point: LocationValue, line: LocationValue[]): number;
+
+        function isPointOnSegment(
+            point1: LocationValue,
+            point2: LocationValue,
+            point3: LocationValue,
+            tolerance?: number
+        ): boolean;
+
+        function isPointOnLine(
+            point: LocationValue,
+            line: LocationValue[],
+            tolerance?: number
+        ): boolean;
+
+        function isPointOnRing(
+            point: LocationValue,
+            ring: LocationValue[],
+            tolerance?: number
+        ): boolean;
+
+        function isPointOnPolygon(
+            point: LocationValue,
+            polygon: LocationValue[][],
+            tolerance?: number
+        ): boolean;
+
+        function doesPolygonPolygonIntersect(
+            polygon1: LocationValue[],
+            polygon2: LocationValue[]
+        ): boolean;
+
+        function distanceToPolygon(point: LocationValue, polygon: LocationValue[]): number;
+
+        function triangulateShape(
+            shape1: LngLat[] | Pixel[] | [number, number],
+            shape2: LngLat[] | Pixel[] | [number, number]
+        ): number[];
+    }
+}
diff --git a/types/amap-js-api/index.d.ts b/types/amap-js-api/index.d.ts
new file mode 100644
index 0000000000..5b8c1a5b94
--- /dev/null
+++ b/types/amap-js-api/index.d.ts
@@ -0,0 +1,48 @@
+// Type definitions for non-npm package amap-js-api 1.4
+// Project: https://lbs.amap.com/api/javascript-api/summary
+// Definitions by: breeze9527 <https://github.com/breeze9527>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+/// <reference path="array-bounds.d.ts" />
+/// <reference path="bounds.d.ts" />
+/// <reference path="browser.d.ts" />
+/// <reference path="common.d.ts" />
+/// <reference path="convert-from.d.ts" />
+/// <reference path="dom-util.d.ts" />
+/// <reference path="event.d.ts" />
+/// <reference path="geometry-util.d.ts" />
+/// <reference path="lngLat.d.ts" />
+/// <reference path="map.d.ts" />
+/// <reference path="pixel.d.ts" />
+/// <reference path="size.d.ts" />
+/// <reference path="type-util.d.ts" />
+/// <reference path="util.d.ts" />
+/// <reference path="view2D.d.ts" />
+/// <reference path="layer/building.d.ts" />
+/// <reference path="layer/flexible.d.ts" />
+/// <reference path="layer/layer.d.ts" />
+/// <reference path="layer/layerGroup.d.ts" />
+/// <reference path="layer/massMarks.d.ts" />
+/// <reference path="layer/mediaLayer.d.ts" />
+/// <reference path="layer/tileLayer.d.ts" />
+/// <reference path="layer/wms.d.ts" />
+/// <reference path="layer/wmts.d.ts" />
+/// <reference path="overlay/bezierCurve.d.ts" />
+/// <reference path="overlay/circle.d.ts" />
+/// <reference path="overlay/circleMarker.d.ts" />
+/// <reference path="overlay/contextMenu.d.ts" />
+/// <reference path="overlay/ellipse.d.ts" />
+/// <reference path="overlay/geoJSON.d.ts" />
+/// <reference path="overlay/icon.d.ts" />
+/// <reference path="overlay/infoWindow.d.ts" />
+/// <reference path="overlay/marker.d.ts" />
+/// <reference path="overlay/markerShape.d.ts" />
+/// <reference path="overlay/overlay.d.ts" />
+/// <reference path="overlay/overlayGroup.d.ts" />
+/// <reference path="overlay/pathOverlay.d.ts" />
+/// <reference path="overlay/polygon.d.ts" />
+/// <reference path="overlay/polyline.d.ts" />
+/// <reference path="overlay/rectangle.d.ts" />
+/// <reference path="overlay/shapeOverlay.d.ts" />
+/// <reference path="overlay/text.d.ts" />
diff --git a/types/amap-js-api/layer/building.d.ts b/types/amap-js-api/layer/building.d.ts
new file mode 100644
index 0000000000..30dd7c4092
--- /dev/null
+++ b/types/amap-js-api/layer/building.d.ts
@@ -0,0 +1,30 @@
+declare namespace AMap {
+    namespace Buildings {
+        interface Options extends Layer.Options {
+            zooms?: [number, number];
+            opacity?: number;
+            heightFactor?: number;
+            visible?: boolean;
+            zIndex?: number;
+            // inner
+            merge?: boolean;
+            sort?: boolean;
+        }
+        interface AreaStyle {
+            color1: string;
+            path: LocationValue[];
+            color2?: string;
+            visible?: boolean;
+            rejectTexture?: boolean;
+        }
+        interface Style {
+            hideWithoutStyle?: boolean;
+            areas: AreaStyle[];
+        }
+    }
+
+    class Buildings extends Layer {
+        constructor(opts?: Buildings.Options);
+        setStyle(style: Buildings.Style): void;
+    }
+}
diff --git a/types/amap-js-api/layer/flexible.d.ts b/types/amap-js-api/layer/flexible.d.ts
new file mode 100644
index 0000000000..bdb4001a7c
--- /dev/null
+++ b/types/amap-js-api/layer/flexible.d.ts
@@ -0,0 +1,20 @@
+declare namespace AMap {
+    namespace TileLayer {
+        namespace Flexible {
+            interface Options extends TileLayer.Options {
+                createTile?(
+                    x: number,
+                    y: number,
+                    z: number,
+                    success: (tile: HTMLImageElement | HTMLCanvasElement) => void,
+                    fail: () => void
+                ): void;
+                cacheSize?: number;
+                visible?: boolean;
+            }
+        }
+        class Flexible extends TileLayer {
+            constructor(options?: Flexible.Options);
+        }
+    }
+}
diff --git a/types/amap-js-api/layer/layer.d.ts b/types/amap-js-api/layer/layer.d.ts
new file mode 100644
index 0000000000..8f35d949fd
--- /dev/null
+++ b/types/amap-js-api/layer/layer.d.ts
@@ -0,0 +1,20 @@
+declare namespace AMap {
+    namespace Layer {
+        interface Options {
+            map?: Map;
+        }
+    }
+
+    abstract class Layer extends EventEmitter {
+        getContainer(): HTMLDivElement | undefined;
+        getZooms(): [number, number];
+        setOpacity(alpha: number): void;
+        getOpacity(): number;
+        show(): void;
+        hide(): void;
+        setMap(map?: Map | null): void;
+        getMap(): Map | null | undefined;
+        setzIndex(index: number): void;
+        getzIndex(): number;
+    }
+}
diff --git a/types/amap-js-api/layer/layerGroup.d.ts b/types/amap-js-api/layer/layerGroup.d.ts
new file mode 100644
index 0000000000..4cc463eef7
--- /dev/null
+++ b/types/amap-js-api/layer/layerGroup.d.ts
@@ -0,0 +1,21 @@
+declare namespace AMap {
+    class LayerGroup<L = any> extends Layer {
+        constructor(layers: L | L[]);
+        addLayer(layer: L | L[]): this;
+        addLayers(layers: L | L[]): this;
+        getLayers(): L[];
+        getLayer(finder: (this: null, item: L, index: number, list: L[]) => boolean): L | null;
+        hasLayer(layer: L | ((this: null, item: L, index: number, list: L[]) => boolean)): boolean;
+        removeLayer(layer: L | L[]): this;
+        removeLayers(layer: L | L[]): this;
+        clearLayers(): this;
+        eachLayer<C = L>(iterator: (this: C, layer: L, index: number, list: L[]) => void, context?: C): void;
+
+        // overwrite
+        setMap(map?: Map): this;
+        hide(): this;
+        show(): this;
+        reload(): this;
+        setOptions(options: any): this;
+    }
+}
diff --git a/types/amap-js-api/layer/massMarks.d.ts b/types/amap-js-api/layer/massMarks.d.ts
new file mode 100644
index 0000000000..1ab5464a5b
--- /dev/null
+++ b/types/amap-js-api/layer/massMarks.d.ts
@@ -0,0 +1,47 @@
+declare namespace AMap {
+    namespace MassMarks {
+        interface EventMap<I = MassMarks> {
+            click: UIEvent<'click', I>;
+            dblclick: UIEvent<'dblclick', I>;
+            mousedown: UIEvent<'mousedown', I>;
+            mouseup: UIEvent<'mouseup', I>;
+            mouseover: UIEvent<'mouseover', I>;
+            mouseout: UIEvent<'mouseout', I>;
+            touchstart: UIEvent<'touchstart', I>;
+            touchend: UIEvent<'touchend', I>;
+        }
+
+        interface Style {
+            anchor: Pixel;
+            url: string;
+            size: Size;
+            rotation?: number;
+        }
+
+        type UIEvent<N extends string, I> = Event<N, {
+            target: I;
+            data: I extends MassMarks<infer D> ? D : Data;
+        }>;
+
+        interface Options extends Layer.Options {
+            zIndex?: number;
+            cursor?: string;
+            alwayRender?: boolean;
+            style: Style | Style[];
+            // rejectMapMask
+        }
+        interface Data {
+            lnglat: LocationValue;
+            style?: number;
+        }
+    }
+
+    class MassMarks<D extends MassMarks.Data = MassMarks.Data> extends Layer {
+        constructor(data: D[] | string, opts: MassMarks.Options);
+        setStyle(style: MassMarks.Style | MassMarks.Style[]): void;
+        getStyle(): MassMarks.Style | MassMarks.Style[];
+        setData(data: D[] | string): void;
+        getData(): Array<Pick<D, Exclude<keyof D, 'lnglat'>> & { lnglat: LngLat }>;
+        clear(): void;
+    }
+}
diff --git a/types/amap-js-api/layer/mediaLayer.d.ts b/types/amap-js-api/layer/mediaLayer.d.ts
new file mode 100644
index 0000000000..a38f5ba025
--- /dev/null
+++ b/types/amap-js-api/layer/mediaLayer.d.ts
@@ -0,0 +1,35 @@
+declare namespace AMap {
+    namespace MediaLayer {
+        interface Options extends Layer.Options {
+            bounds?: Bounds;
+            visible?: boolean;
+            zooms?: [number, number];
+            opacity?: number;
+        }
+    }
+
+    abstract class MediaLayer<E extends HTMLElement> extends Layer {
+        constructor(options?: MediaLayer.Options);
+        setBounds(bounds: Bounds): void;
+        getBounds(): Bounds;
+        setOptions(options: Partial<MediaLayer.Options>): void;
+        getOptions(): Partial<MediaLayer.Options>;
+        getElement(): E | null;
+    }
+
+    class ImageLayer extends MediaLayer<HTMLImageElement> {
+        setImageUrl(url: string): void;
+        getImageUrl(): string | undefined;
+    }
+
+    class VideoLayer extends MediaLayer<HTMLVideoElement> {
+        setVideoUrl(source: string | string[]): void;
+        getVideoUrl(): string | string[] | undefined;
+    }
+
+    class CanvasLayer extends MediaLayer<HTMLCanvasElement> {
+        setCanvas(canvas: HTMLCanvasElement): void;
+        getCanvas(): HTMLCanvasElement | undefined;
+        reFresh(): void;
+    }
+}
diff --git a/types/amap-js-api/layer/tileLayer.d.ts b/types/amap-js-api/layer/tileLayer.d.ts
new file mode 100644
index 0000000000..7576a70664
--- /dev/null
+++ b/types/amap-js-api/layer/tileLayer.d.ts
@@ -0,0 +1,37 @@
+declare namespace AMap {
+    namespace TileLayer {
+        interface EventMap {
+            complete: Event<'complete'>;
+        }
+
+        interface Options extends Layer.Options {
+            tileSize?: number;
+            tileUrl?: string;
+            errorUrl?: string;
+            getTileUrl?: string | ((x: number, y: number, level: number) => string);
+            zIndex?: number;
+            opacity?: number;
+            zooms?: [number, number];
+            detectRetina?: boolean;
+        }
+        class Satellite extends TileLayer { }
+        class RoadNet extends TileLayer { }
+
+        namespace Traffic {
+            interface Options extends TileLayer.Options {
+                autoRefresh?: boolean;
+                interval?: number;
+            }
+        }
+        class Traffic extends TileLayer {
+            constructor(options?: Traffic.Options);
+        }
+    }
+
+    class TileLayer extends Layer {
+        constructor(options?: TileLayer.Options);
+        getTiles(): string[];
+        reload(): void;
+        setTileUrl(url: string | ((x: number, y: number, level: number) => string)): void;
+    }
+}
diff --git a/types/amap-js-api/layer/wms.d.ts b/types/amap-js-api/layer/wms.d.ts
new file mode 100644
index 0000000000..c4561ddf14
--- /dev/null
+++ b/types/amap-js-api/layer/wms.d.ts
@@ -0,0 +1,29 @@
+declare namespace AMap {
+    namespace TileLayer {
+        namespace WMS {
+            interface Params {
+                VERSION?: string;
+                LAYERS?: string;
+                STYLES?: string;
+                FORMAT?: string;
+                TRANSPARENT?: 'TRUE' | 'FALSE';
+                BGCOLOR?: string;
+                EXCEPTIONS?: string;
+                TIME?: string;
+                ELEVATION?: string;
+            }
+            interface Options extends Flexible.Options {
+                url: string;
+                params: Params;
+                blend?: boolean;
+            }
+        }
+        class WMS extends Flexible {
+            constructor(options: WMS.Options);
+            setUrl(url: string): void;
+            getUrl(): string;
+            setParams(params: WMS.Params): void;
+            getParams(): WMS.Params;
+        }
+    }
+}
diff --git a/types/amap-js-api/layer/wmts.d.ts b/types/amap-js-api/layer/wmts.d.ts
new file mode 100644
index 0000000000..5d85e5df48
--- /dev/null
+++ b/types/amap-js-api/layer/wmts.d.ts
@@ -0,0 +1,25 @@
+declare namespace AMap {
+    namespace TileLayer {
+        namespace WMTS {
+            interface Params {
+                Version?: string;
+                Layer?: string;
+                Style?: string;
+                Format?: string;
+            }
+            interface Options extends Flexible.Options {
+                url: string;
+                params: Params;
+                blend?: boolean;
+            }
+        }
+
+        class WMTS extends Flexible {
+            constructor(options: WMTS.Options);
+            setUrl(url: string): void;
+            getUrl(): string;
+            setParams(params: WMTS.Params): void;
+            getParams(): WMTS.Params;
+        }
+    }
+}
diff --git a/types/amap-js-api/lngLat.d.ts b/types/amap-js-api/lngLat.d.ts
new file mode 100644
index 0000000000..4247002b2b
--- /dev/null
+++ b/types/amap-js-api/lngLat.d.ts
@@ -0,0 +1,17 @@
+declare namespace AMap {
+    class LngLat {
+        constructor(lng: number, lat: number, noAutofix?: boolean);
+        offset(east: number, north: number): LngLat;
+        distance(lnglat: LngLat | LngLat[]): number;
+        getLng(): number;
+        getLat(): number;
+        equals(lnglat: LngLat): boolean;
+        toString(): string;
+
+        // internal
+        add(lnglat: LngLat, noAutofix?: boolean): LngLat;
+        subtract(lnglat: LngLat, noAutofix?: boolean): LngLat;
+        divideBy(num: number, noAutofix?: boolean): LngLat;
+        multiplyBy(num: number, noAutofix?: boolean): LngLat;
+    }
+}
diff --git a/types/amap-js-api/map.d.ts b/types/amap-js-api/map.d.ts
new file mode 100644
index 0000000000..46edc68577
--- /dev/null
+++ b/types/amap-js-api/map.d.ts
@@ -0,0 +1,187 @@
+declare namespace AMap {
+    namespace Map {
+        type Feature = 'bg' | 'point' | 'road' | 'building';
+        type ViewMode = '2D' | '3D';
+        interface Options {
+            view?: View2D;
+            layers?: Layer[];
+            zoom?: number;
+            center?: LocationValue;
+            labelzIndex?: number;
+            zooms?: [number, number];
+            lang?: Lang;
+            defaultCursor?: string;
+            crs?: 'EPSG3857' | 'EPSG3395' | 'EPSG4326';
+            animateEnable?: boolean;
+            isHotspot?: boolean;
+            defaultLayer?: TileLayer;
+            rotateEnable?: boolean;
+            resizeEnable?: boolean;
+            showIndoorMap?: boolean;
+            expandZoomRange?: boolean;
+            dragEnable?: boolean;
+            zoomEnable?: boolean;
+            doubleClickZoom?: boolean;
+            keyboardEnable?: boolean;
+            jogEnable?: boolean;
+            scrollWheel?: boolean;
+            touchZoom?: boolean;
+            touchZoomCenter?: number;
+            mapStyle?: string;
+            features?: Feature[] | 'all' | Feature;
+            showBuildingBlock?: boolean;
+            viewMode?: ViewMode;
+            pitch?: number;
+            pitchEnable?: boolean;
+            buildingAnimation?: boolean;
+            skyColor?: string;
+            preloadMode?: boolean;
+            mask?: Array<[number, number]> | Array<Array<[number, number]>> | Array<Array<Array<[number, number]>>>;
+            maxPitch?: number;
+            rotation?: number;
+            forceVector?: boolean;
+
+            // internal
+            baseRender?: 'vw' | 'd' | 'dv' | 'v';
+            overlayRender?: 'c' | 'd';
+            showLabel?: boolean;
+            gridMapForeign?: boolean;
+            logoUrl?: string;
+            logoUrlRetina?: string;
+            copyright?: string;
+            turboMode?: boolean;
+            workerMode?: boolean;
+            // continuousZoomEnable?: boolean;
+            // showFog: boolean;
+            // yaw: number;
+            // scale: number;
+            // detectRetina: number;
+        }
+        interface Status {
+            animateEnable: boolean;
+            doubleClickZoom: boolean;
+            dragEnable: boolean;
+            isHotspot: boolean;
+            jogEnable: boolean;
+            keyboardEnable: boolean;
+            pitchEnable: boolean;
+            resizeEnable: boolean;
+            rotateEnable: boolean;
+            scrollWheel: boolean;
+            touchZoom: boolean;
+            zoomEnable: boolean;
+        }
+        type HotspotEvent<N extends string> = Event<N, {
+            lnglat: LngLat;
+            name: string;
+            id: string;
+            // internal
+            isIndoorPOI: boolean;
+        }>;
+        interface EventMap {
+            click: MapsEvent<'click', Map>;
+            dblclick: MapsEvent<'dblclick', Map>;
+            rightclick: MapsEvent<'rightclick', Map>;
+            rdblclick: MapsEvent<'rdblclick', Map>;
+            mouseup: MapsEvent<'mouseup', Map>;
+            mousedown: MapsEvent<'mousedown', Map>;
+            mousemove: MapsEvent<'mousemove', Map>;
+            mousewheel: MapsEvent<'mousewheel', Map>;
+            mouseover: MapsEvent<'mouseover', Map>;
+            mouseout: MapsEvent<'mouseout', Map>;
+            touchstart: MapsEvent<'touchstart', Map>;
+            touchmove: MapsEvent<'touchmove', Map>;
+            touchend: MapsEvent<'touchend', Map>;
+            contextmenu: MapsEvent<'contextmenu', Map>;
+
+            hotspotclick: HotspotEvent<'hotspotclick'>;
+            hotspotover: HotspotEvent<'hotspotover'>;
+            hotspotout: HotspotEvent<'hotspotout'>;
+
+            complete: Event<'complete'>;
+            mapmove: Event<'mapmove'>;
+            movestart: Event<'movestart'>;
+            moveend: Event<'moveend'>;
+            zoomchange: Event<'zoomchange'>;
+            zoomstart: Event<'zoomstart'>;
+            zoomend: Event<'zoomend'>;
+            dragstart: Event<'dragstart'>;
+            dragging: Event<'dragging'>;
+            dragend: Event<'dragend'>;
+            resize: Event<'resize'>;
+        }
+    }
+
+    class Map extends EventEmitter {
+        constructor(container: string | HTMLElement, opts?: Map.Options);
+        poiOnAMAP(obj: { id: string; location?: LocationValue; name?: string }): void;
+        detailOnAMAP(obj: { id: string; location?: LocationValue; name?: string }): void;
+        getZoom(): number;
+        getLayers(): Layer[];
+        getCenter(): LngLat;
+        getContainer(): HTMLElement | null;
+        getCity(callback: (cityData: {
+            city: string;
+            citycode: string;
+            district: string;
+            province: string | never[]; // province is empty array when getCity fail
+        }) => void): void;
+        getBounds(): Bounds;
+        getLabelzIndex(): number;
+        getLimitBounds(): Bounds;
+        getLang(): Lang;
+        getSize(): Size;
+        getRotation(): number;
+        getStatus(): Map.Status;
+        getDefaultCursor(): string;
+        getResolution(point?: LocationValue): number;
+        getScale(dpi?: number): number;
+        setZoom(level: number): void;
+        setLabelzIndex(index: number): void;
+        setLayers(layers: Layer[]): void;
+        add(overlay: Overlay | Overlay[]): void;
+        remove(overlay: Overlay | Overlay[]): void;
+        getAllOverlays(type?: 'marker' | 'circle' | 'polyline' | 'polygon'): Overlay[];
+        setCenter(center: LocationValue): void;
+        setZoomAndCenter(zoomLevel: number, center: LocationValue): void;
+        setCity(city: string, callback: (this: this, coord: [string, string], zoom: number) => void): void;
+        setBounds(bound: Bounds): Bounds;
+        setLimitBounds(bound: Bounds): void;
+        clearLimitBounds(): void;
+        setLang(lang: Lang): void;
+        setRotation(rotation: number): void;
+        setStatus(status: Partial<Map.Status>): void;
+        setDefaultCursor(cursor: string): void;
+        zoomIn(): void;
+        zoomOut(): void;
+        panTo(position: LocationValue): void;
+        panBy(x: number, y: number): void;
+        setFitView(
+            overlayList?: Overlay | Overlay[],
+            immediately?: boolean,
+            avoid?: [number, number, number, number],
+            maxZoom?: number
+        ): Bounds | false | undefined;
+        clearMap(): void;
+        destroy(): void;
+        plugin(name: string | string[], callback: () => void): this;
+        addControl(control: {}): void; // TODO
+        removeControl(control: {}): void; // TODO
+        clearInfoWindow(): void;
+        pixelToLngLat(pixel: Pixel, level?: number): LngLat;
+        lnglatToPixel(lnglat: LocationValue, level?: number): Pixel;
+        containerToLngLat(pixel: Pixel): LngLat;
+        lngLatToContainer(lnglat: LocationValue): Pixel;
+        lnglatTocontainer(lnglat: LocationValue): Pixel;
+        setMapStyle(style: string): void;
+        getMapStyle(): string;
+        setFeatures(feature: Map.Feature | Map.Feature[] | 'all'): void;
+        getFeatures(): Map.Feature | Map.Feature[] | 'all';
+        setDefaultLayer(layer: TileLayer): void;
+        setPitch(pitch: number): void;
+        getPitch(): number;
+        getViewMode_(): Map.ViewMode;
+        lngLatToGeodeticCoord(lnglat: LocationValue): Pixel;
+        geodeticCoordToLngLat(pixel: Pixel): LngLat;
+    }
+}
diff --git a/types/amap-js-api/overlay/bezierCurve.d.ts b/types/amap-js-api/overlay/bezierCurve.d.ts
new file mode 100644
index 0000000000..5778cb72a6
--- /dev/null
+++ b/types/amap-js-api/overlay/bezierCurve.d.ts
@@ -0,0 +1,22 @@
+declare namespace AMap {
+    namespace BezierCurve {
+        interface EventMap<I = BezierCurve> extends Polyline.EventMap<I> { }
+        type Options<ExtraData = any> = Merge<Polyline.Options<ExtraData>, {
+            // internal
+            path: Array<Array<number | string | Array<string | number>>>;
+            tolerance?: number;
+            interpolateNumLimit?: [number | number];
+        }>;
+
+        interface GetOptionsResult<ExtraData = any> extends Polyline.GetOptionsResult<ExtraData> {
+            path: Array<LngLat & { controlPoints: LngLat[] }>;
+        }
+    }
+    class BezierCurve<ExtraData = any> extends Polyline<ExtraData> {
+        constructor(options: BezierCurve.Options<ExtraData>);
+        getOptions(): Partial<BezierCurve.GetOptionsResult<ExtraData>>;
+        // internal
+        getInterpolateLngLats(): LngLat[];
+        getSerializedPath(): number[][];
+    }
+}
diff --git a/types/amap-js-api/overlay/circle.d.ts b/types/amap-js-api/overlay/circle.d.ts
new file mode 100644
index 0000000000..2a1cbd9020
--- /dev/null
+++ b/types/amap-js-api/overlay/circle.d.ts
@@ -0,0 +1,49 @@
+declare namespace AMap {
+    namespace Circle {
+        interface EventMap<I = Circle> extends ShapeOverlay.EventMap<I> {
+            setCenter: Event<'setCenter'>;
+            setRadius: Event<'setRadius'>;
+        }
+
+        interface Options<ExtraData = any> {
+            map?: Map;
+            zIndex?: number;
+            center?: LocationValue;
+            bubble?: boolean;
+            cursor?: string;
+            radius?: number;
+            strokeColor?: string;
+            strokeOpcity?: number;
+            strokeWeight?: number;
+            fillColor?: string;
+            fillOpacity?: number;
+            strokeStyle?: StrokeStyle;
+            extData?: ExtraData;
+            strokeDasharray?: number[];
+
+            // internal
+            visible?: boolean;
+            unit?: 'meter' | 'px'; // 'might be typo'
+        }
+
+        type GetOptionsResult<ExtraData = any> = Merge<Polygon.GetOptionsResult<ExtraData>, {
+            path: LngLat[];
+            center: LngLat;
+            radius: number;
+        }>;
+    }
+
+    class Circle<ExtraData = any> extends ShapeOverlay<ExtraData> {
+        constructor(options?: Circle.Options<ExtraData>);
+        setCenter(center: LocationValue, preventEvent?: boolean): void;
+        getCenter(): LngLat | undefined;
+        getBounds(): Bounds | null;
+        setRadius(radius: number, preventEvent?: boolean): void;
+        getRadius(): number;
+        setOptions(options?: Circle.Options<ExtraData>): void;
+        getOptions(): Partial<Circle.GetOptionsResult<ExtraData>>;
+        contains(point: LocationValue): boolean;
+        // internal
+        getPath(count?: number): LngLat[];
+    }
+}
diff --git a/types/amap-js-api/overlay/circleMarker.d.ts b/types/amap-js-api/overlay/circleMarker.d.ts
new file mode 100644
index 0000000000..13e4162f46
--- /dev/null
+++ b/types/amap-js-api/overlay/circleMarker.d.ts
@@ -0,0 +1,4 @@
+declare namespace AMap {
+    // tslint:disable-next-line;
+    class CircleMarker<ExtraData = any> extends Circle<ExtraData> {}
+}
diff --git a/types/amap-js-api/overlay/contextMenu.d.ts b/types/amap-js-api/overlay/contextMenu.d.ts
new file mode 100644
index 0000000000..72c7fc2852
--- /dev/null
+++ b/types/amap-js-api/overlay/contextMenu.d.ts
@@ -0,0 +1,23 @@
+declare namespace AMap {
+    namespace ContextMenu {
+        interface Options {
+            content?: string | HTMLElement;
+            // internal
+            visible?: boolean;
+        }
+
+        interface EventMap<I> {
+            items: Event<'items'>;
+            open: Event<'open', { target: I }>;
+            close: Event<'close', { target: I }>;
+        }
+    }
+
+    class ContextMenu<ExtraData = any> extends Overlay<ExtraData> {
+        constructor(options?: ContextMenu.Options);
+        addItem(text: string, fn: (this: HTMLLIElement) => void, num?: number): void;
+        removeItem(test: string, fn: (this: HTMLLIElement) => void): void;
+        open(map: Map, position: LocationValue): void;
+        close(): void;
+    }
+}
diff --git a/types/amap-js-api/overlay/ellipse.d.ts b/types/amap-js-api/overlay/ellipse.d.ts
new file mode 100644
index 0000000000..55feaf3112
--- /dev/null
+++ b/types/amap-js-api/overlay/ellipse.d.ts
@@ -0,0 +1,27 @@
+declare namespace AMap {
+    namespace Ellipse {
+        interface EventMap<I = Ellipse> extends ShapeOverlay.EventMap<I> {
+            setPath: Event<'setPath'>;
+            setCenter: Event<'setCenter'>;
+        }
+
+        interface Options<ExtraData = any> extends Polygon.Options<ExtraData> {
+            center?: LocationValue;
+            radius?: [number, number];
+        }
+        type GetOptionsResult<ExtraData = any> = Merge<Circle.GetOptionsResult<ExtraData>, {
+            radius: [number, number];
+        }>;
+    }
+
+    class Ellipse<ExtraData = any> extends Polygon<ExtraData> {
+        constructor(options?: Ellipse.Options<ExtraData>);
+        getCenter(): LngLat | undefined;
+        setCenter(center: LocationValue, preventEvent?: boolean): void;
+        setOptions(options: Ellipse.Options<ExtraData>): void;
+
+        // internal
+        setRadius(radius: [number, number], preventEvent?: boolean): void;
+        getRadius(): [number, number];
+    }
+}
diff --git a/types/amap-js-api/overlay/geoJSON.d.ts b/types/amap-js-api/overlay/geoJSON.d.ts
new file mode 100644
index 0000000000..75098a59f0
--- /dev/null
+++ b/types/amap-js-api/overlay/geoJSON.d.ts
@@ -0,0 +1,43 @@
+declare namespace AMap {
+    namespace GeoJSON {
+        type Geometry = {
+            type: 'Point';
+            coordinates: [number, number];
+        } | {
+            type: 'MultiPoint' | 'LineString' | 'Polygon';
+            coordinates: Array<[number, number]>;
+        } | {
+            type: 'MultiLineString' | 'MultiPolygon';
+            coordinates: Array<Array<[number, number]>>;
+        } | {
+            type: 'GeometryCollection';
+            geometries: Geometry[];
+        };
+
+        type GeoJSONObject = {
+            type: 'Feature';
+            properties: any;
+            geometry: Geometry;
+        } | {
+            type: 'FeatureCollection',
+            properties: any;
+            features: GeoJSONObject[];
+        };
+        interface Options {
+            geoJSON?: GeoJSONObject | GeoJSONObject[];
+            getMarker?(obj: GeoJSONObject, lnglat: LngLat): Marker;
+            getPolyline?(obj: GeoJSONObject, lnglats: LngLat[]): Polyline;
+            getPolygon?(obj: GeoJSONObject, lnglats: LngLat[]): Polygon;
+            coordsToLatLng?(lnglat: LngLat): LngLat;
+
+            // internal
+            coordsToLatLngs?(lnglats: LngLat[]): LngLat[];
+        }
+    }
+
+    class GeoJSON<ExtraData = any> extends OverlayGroup<Overlay, ExtraData> {
+        constructor(options?: GeoJSON.Options);
+        importData(obj: GeoJSON.GeoJSONObject | GeoJSON.GeoJSONObject[]): void;
+        toGeoJSON(): GeoJSON.GeoJSONObject[];
+    }
+}
diff --git a/types/amap-js-api/overlay/icon.d.ts b/types/amap-js-api/overlay/icon.d.ts
new file mode 100644
index 0000000000..be300feef3
--- /dev/null
+++ b/types/amap-js-api/overlay/icon.d.ts
@@ -0,0 +1,16 @@
+declare namespace AMap {
+    namespace Icon {
+        interface Options {
+            size?: SizeValue;
+            imageOffset?: Pixel;
+            image?: string;
+            imageSize?: SizeValue;
+        }
+    }
+
+    class Icon extends EventEmitter {
+        constructor(options?: Icon.Options);
+        setImageSize(size: SizeValue): void;
+        getImageSize(): Size;
+    }
+}
diff --git a/types/amap-js-api/overlay/infoWindow.d.ts b/types/amap-js-api/overlay/infoWindow.d.ts
new file mode 100644
index 0000000000..54bedd95a8
--- /dev/null
+++ b/types/amap-js-api/overlay/infoWindow.d.ts
@@ -0,0 +1,37 @@
+declare namespace AMap {
+    namespace InfoWindow {
+        interface EventMap<I> {
+            change: Event<'change', { target: I }>;
+            open: Event<'open', { target: I }>;
+            close: Event<'close', { target: I }>;
+        }
+
+        interface Options<ExtraData = any> extends Overlay.Options<ExtraData> {
+            isCustom?: boolean;
+            autoMove?: boolean;
+            closeWhenClickMap?: boolean;
+            content?: string | HTMLElement;
+            size?: SizeValue;
+            offset?: Pixel;
+            position?: LocationValue;
+            showShadow?: boolean;
+            // internal
+            height?: number;
+        }
+    }
+
+    class InfoWindow<ExtraData = any> extends Overlay<ExtraData> {
+        constructor(options?: InfoWindow.Options);
+        open(map: Map, position?: LocationValue): void;
+        close(): void;
+        getIsOpen(): boolean;
+        setContent(content: string | HTMLElement): void;
+        getContent(): string | HTMLElement | undefined;
+        setPosition(lnglat: LocationValue): void;
+        getPosition(): LngLat | undefined;
+        setSize(size: SizeValue): void;
+        getSize(): Size | undefined;
+        // internal
+        setOffset(offset: Pixel): void;
+    }
+}
diff --git a/types/amap-js-api/overlay/marker.d.ts b/types/amap-js-api/overlay/marker.d.ts
new file mode 100644
index 0000000000..e24ce7be8f
--- /dev/null
+++ b/types/amap-js-api/overlay/marker.d.ts
@@ -0,0 +1,103 @@
+declare namespace AMap {
+    namespace Marker {
+        interface EventMap<I = Marker> {
+            click: MapsEvent<'click', I>;
+            dblclick: MapsEvent<'dblclick', I>;
+            rightclick: MapsEvent<'rightclick', I>;
+            mousemove: MapsEvent<'mousemove', I>;
+            mouseover: MapsEvent<'mouseover', I>;
+            mouseout: MapsEvent<'mouseout', I>;
+            mousedown: MapsEvent<'mousedown', I>;
+            mouseup: MapsEvent<'mouseup', I>;
+            dragstart: MapsEvent<'dragstart', I>;
+            dragging: MapsEvent<'dragging', I>;
+            dragend: MapsEvent<'dragend', I>;
+            moving: Event<'moving', { passwdPath: LngLat[]; }>;
+            moveend: Event<'moveend'>;
+            movealong: Event<'movealong'>;
+            touchstart: MapsEvent<'touchstart', I>;
+            touchmove: MapsEvent<'touchmove', I>;
+            touchend: MapsEvent<'touchend', I>;
+        }
+
+        interface Label {
+            content?: string;
+            offset?: Pixel;
+        }
+
+        interface Options<ExtraData = any> extends Overlay.Options<ExtraData> {
+            position?: LocationValue;
+            offset?: Pixel;
+            icon?: string | Icon;
+            content?: string | HTMLElement;
+            topWhenClick?: boolean;
+            bubble?: boolean;
+            draggable?: boolean;
+            raiseOnDrag?: boolean;
+            cursor?: string;
+            visible?: boolean;
+            zIndex?: number;
+            angle?: number;
+            autoRotation?: boolean;
+            animation?: AnimationName;
+            shadow?: Icon | string;
+            title?: string;
+            shape?: MarkerShape;
+            label?: Label;
+            zooms?: [number, number];
+
+            // internal
+            topWhenMouseOver?: boolean;
+            height?: number;
+        }
+    }
+
+    class Marker<ExtraData = any> extends Overlay<ExtraData> {
+        constructor(options?: Marker.Options<ExtraData>);
+        markOnAMAP(obj?: { name?: string, position?: LocationValue }): void;
+        getOffset(): Pixel;
+        setOffset(offset: Pixel): void;
+        setAnimation(animate: AnimationName, prevent?: boolean): void;
+        getAnimation(): AnimationName;
+        setClickable(cilckable: boolean): void;
+        getClickable(): boolean;
+        getPosition(): LngLat | undefined;
+        setPosition(position: LocationValue): void;
+        setAngle(angle: number): void;
+        setLabel(label?: Marker.Label): void;
+        getLabel(): Marker.Label | undefined;
+        getAngle(): number;
+        setzIndex(index: number): void;
+        getzIndex(): number;
+        setIcon(content: string | Icon): void;
+        getIcon(): string | Icon | undefined;
+        setDraggable(draggable: boolean): void;
+        getDraggable(): boolean;
+        setCursor(cursor: string): void;
+        setContent(content: string | HTMLElement): void;
+        getContent(): string | HTMLElement;
+        moveAlong(
+            path: LngLat[],
+            speed: number,
+            timingFunction?: (t: number) => number,
+            circleable?: boolean
+        ): void;
+        moveTo(
+            path: LocationValue,
+            speed: number,
+            timingFunction?: (t: number) => number
+        ): void;
+        stopMove(): void;
+        pauseMove(): boolean;
+        resumeMove(): boolean;
+        setMap(map: null | Map): void;
+        setTitle(title: string): void;
+        getTitle(): string | undefined;
+        setTop(isTop: boolean): void;
+        getTop(): boolean;
+        setShadow(icon?: Icon | string): void;
+        getShadow(): Icon | undefined | string;
+        setShape(shape?: MarkerShape): void;
+        getShape(): MarkerShape | undefined;
+    }
+}
diff --git a/types/amap-js-api/overlay/markerShape.d.ts b/types/amap-js-api/overlay/markerShape.d.ts
new file mode 100644
index 0000000000..f0d6c39bac
--- /dev/null
+++ b/types/amap-js-api/overlay/markerShape.d.ts
@@ -0,0 +1,21 @@
+declare namespace AMap {
+    namespace MarkerShape {
+        interface CircleOptions {
+            type: 'circle';
+            coords: [number, number, number];
+        }
+        interface PolyOptions {
+            type: 'poly';
+            coords: number[];
+        }
+        interface RectOptions {
+            type: 'rect';
+            coords: [number, number, number, number];
+        }
+        type Options = CircleOptions | PolyOptions | RectOptions;
+    }
+
+    class MarkerShape extends EventEmitter {
+        constructor(options: MarkerShape.Options);
+    }
+}
diff --git a/types/amap-js-api/overlay/overlay.d.ts b/types/amap-js-api/overlay/overlay.d.ts
new file mode 100644
index 0000000000..1726b39c3e
--- /dev/null
+++ b/types/amap-js-api/overlay/overlay.d.ts
@@ -0,0 +1,37 @@
+declare namespace AMap {
+    namespace Overlay {
+        interface EventMap<I> {
+            touchstart: MapsEvent<'touchstart', I>;
+            touchmove: MapsEvent<'touchmove', I>;
+            touchend: MapsEvent<'touchend', I>;
+            click: MapsEvent<'click', I>;
+            rightclick: MapsEvent<'rightclick', I>;
+            dblclick: MapsEvent<'dblclick', I>;
+            mousemove: MapsEvent<'mousemove', I>;
+            mouseover: MapsEvent<'mouseover', I>;
+            mousedown: MapsEvent<'mousedown', I>;
+            mouseup: MapsEvent<'mouseup', I>;
+        }
+        interface Options<ExtraData = any> {
+            map?: Map;
+            cursor?: string;
+            extData?: ExtraData;
+            bubble?: boolean;
+            clickable?: boolean;
+            draggable?: boolean;
+        }
+    }
+    abstract class Overlay<ExtraData = any> extends EventEmitter {
+        constructor(options?: Overlay.Options);
+        show(): void;
+        hide(): void;
+        getMap(): Map | null | undefined;
+        setMap(map: Map | null): void;
+        setExtData(extData: ExtraData): void;
+        getExtData(): ExtraData | {};
+
+        // internal
+        setHeight(height?: number | string): void;
+        getHeight(): number | string;
+    }
+}
diff --git a/types/amap-js-api/overlay/overlayGroup.d.ts b/types/amap-js-api/overlay/overlayGroup.d.ts
new file mode 100644
index 0000000000..d397505b04
--- /dev/null
+++ b/types/amap-js-api/overlay/overlayGroup.d.ts
@@ -0,0 +1,30 @@
+type ReferOverlayOptions<O> =
+    O extends AMap.BezierCurve ? AMap.BezierCurve.Options
+    : O extends AMap.Polyline ? AMap.Polyline.Options
+    : O extends AMap.Circle ? AMap.Circle.Options
+    : O extends AMap.Ellipse ? AMap.Ellipse.Options
+    : O extends AMap.Polygon ? AMap.Polygon.Options
+    : O extends AMap.Text ? AMap.Text.Options
+    : O extends AMap.Marker ? AMap.Marker.Options
+    : O extends AMap.Rectangle ? AMap.Rectangle.Options
+    : any;
+
+declare namespace AMap {
+    class OverlayGroup<O extends Overlay = Overlay, ExtraData = any> extends Overlay<ExtraData> {
+        constructor(overlays?: O | O[]);
+        addOverlay(overlay: O | O[]): this;
+        addOverlays(overlay: O | O[]): this;
+        getOverlays(): O[];
+        hasOverlay(overlay: O | ((this: null, item: O, index: number, list: O[]) => boolean)): boolean;
+        removeOverlay(overlay: O | O[]): this;
+        removeOverlays(overlay: O | O[]): this;
+        clearOverlays(): this;
+        eachOverlay<C = O>(iterator: (this: C, overlay: O, index: number, overlays: O[]) => void, context?: C): this;
+        setMap(map: null | Map): this;
+        setOptions(options: ReferOverlayOptions<O>): this;
+        show(): this;
+        hide(): this;
+
+        getOverlay(finder: ((this: null, item: O, index: number, list: O[]) => boolean) | O): O | null;
+    }
+}
diff --git a/types/amap-js-api/overlay/pathOverlay.d.ts b/types/amap-js-api/overlay/pathOverlay.d.ts
new file mode 100644
index 0000000000..de21aa35a7
--- /dev/null
+++ b/types/amap-js-api/overlay/pathOverlay.d.ts
@@ -0,0 +1,20 @@
+declare namespace AMap {
+    namespace PathOverlay {
+        interface EventMap<I = PathOverlay> extends ShapeOverlay.EventMap<I> { }
+        interface Options<ExtraData = any> extends Overlay.Options<ExtraData> {
+            visible?: boolean;
+            zIndex?: number;
+            strokeColor?: string;
+            strokeOpacity?: number;
+            strokeWeight?: number;
+            strokeStyle?: StrokeStyle;
+            strokeDasharray?: number[];
+            lineJoin?: StrokeLineJoin;
+            lineCap?: StrokeLineCap;
+        }
+    }
+    abstract class PathOverlay<ExtraData = any> extends ShapeOverlay<ExtraData> {
+        constructor(options?: PathOverlay.Options<ExtraData>);
+        getBounds(): Bounds | (this extends Rectangle ? undefined : null);
+    }
+}
diff --git a/types/amap-js-api/overlay/polygon.d.ts b/types/amap-js-api/overlay/polygon.d.ts
new file mode 100644
index 0000000000..8792e0e135
--- /dev/null
+++ b/types/amap-js-api/overlay/polygon.d.ts
@@ -0,0 +1,32 @@
+declare namespace AMap {
+    namespace Polygon {
+        interface EventMap<I = Polygon> extends PathOverlay.EventMap<I> { }
+        interface Options<ExtraData = any> extends PathOverlay.Options<ExtraData> {
+            path?: LocationValue[] | LocationValue[][];
+            fillColor?: string;
+            fillOpacity?: number;
+        }
+
+        interface GetOptionsResult<ExtraData = any> extends ShapeOverlay.GetOptionsResult<ExtraData> {
+            fillColor: string;
+            fillOpacity: number;
+            path: LngLat[] | LngLat[][];
+            lineJoin: StrokeLineJoin;
+            texture: string;
+        }
+    }
+
+    class Polygon<ExtraData = any> extends PathOverlay<ExtraData> {
+        constructor(options?: Polygon.Options<ExtraData>);
+        setPath(path: LocationValue[] | LocationValue[][]): void;
+        getPath(): LngLat[] | LngLat[][];
+        setOptions(options: Polygon.Options<ExtraData>): void;
+        getOptions(): Partial<
+            this extends Omit<Ellipse, keyof Polygon> ? Ellipse.GetOptionsResult<ExtraData> :
+            this extends Omit<Rectangle, keyof Polygon> ? Rectangle.GetOptionsResult<ExtraData> :
+            Polygon.GetOptionsResult<ExtraData>
+        >;
+        getArea(): number;
+        contains(point: LocationValue): boolean;
+    }
+}
diff --git a/types/amap-js-api/overlay/polyline.d.ts b/types/amap-js-api/overlay/polyline.d.ts
new file mode 100644
index 0000000000..207279b208
--- /dev/null
+++ b/types/amap-js-api/overlay/polyline.d.ts
@@ -0,0 +1,46 @@
+declare namespace AMap {
+    namespace Polyline {
+        interface EventMap<I = Polyline> extends PathOverlay.EventMap<I> { }
+        interface GetOptionsResult<ExtraData = any> extends ShapeOverlay.GetOptionsResult<ExtraData> {
+            isOutline: boolean;
+            outlineColor: string;
+            geodesic: boolean;
+            path: LngLat[];
+            lineJoin: StrokeLineJoin;
+            lineCap: StrokeLineCap;
+            borderWeight: number;
+            showDir: boolean;
+            dirColor: string;
+            dirImg: string;
+        }
+
+        interface Options<ExtraData = any> extends PathOverlay.Options<ExtraData> {
+            isOutline?: boolean;
+            outlineColor?: string;
+            geodesic?: boolean;
+            dirColor?: string;
+            borderWeight?: number;
+            showDir?: boolean;
+            // internal
+            path?: LocationValue[];
+        }
+    }
+
+    class Polyline<ExtraData = any> extends PathOverlay<ExtraData> {
+        constructor(options?: BezierCurve.Options<ExtraData> | Polyline.Options<ExtraData>);
+        setPath(
+            path: this extends Omit<BezierCurve, keyof Polyline> ?
+                Array<Array<number | string | Array<string | number>>>
+                : LocationValue[]
+        ): void;
+        getPath(): this extends Omit<BezierCurve, keyof Polyline> ?
+            Array<LngLat & { controlPoints: LngLat[] }>
+            : LngLat[];
+        getLength(): number;
+        setOptions(options: this extends Omit<BezierCurve, keyof Polyline> ?
+            Partial<BezierCurve.Options<ExtraData>>
+            : Polyline.Options<ExtraData>
+        ): void;
+        getOptions(): Partial<Polyline.GetOptionsResult<ExtraData>>;
+    }
+}
diff --git a/types/amap-js-api/overlay/rectangle.d.ts b/types/amap-js-api/overlay/rectangle.d.ts
new file mode 100644
index 0000000000..259e2072de
--- /dev/null
+++ b/types/amap-js-api/overlay/rectangle.d.ts
@@ -0,0 +1,21 @@
+declare namespace AMap {
+    namespace Rectangle {
+        interface EventMap<I = Rectangle> extends Polygon.EventMap<I> {
+            setBounds: Event<'setBounds'>;
+        }
+
+        interface Options<ExtraData = any> extends Polygon.Options<ExtraData> {
+            bounds?: Bounds;
+        }
+        type GetOptionsResult<ExtraData = any> = Merge<Polygon.GetOptionsResult<ExtraData>, {
+            path: LngLat[];
+            bounds: Bounds;
+            texture: string;
+        }>;
+    }
+    class Rectangle<ExtraData = any> extends Polygon<ExtraData> {
+        constructor(options?: Rectangle.Options<ExtraData>);
+        setBounds(bounds: Bounds, preventEvent?: boolean): void;
+        setOptions(options: Partial<Rectangle.Options>): void;
+    }
+}
diff --git a/types/amap-js-api/overlay/shapeOverlay.d.ts b/types/amap-js-api/overlay/shapeOverlay.d.ts
new file mode 100644
index 0000000000..b8f239aac1
--- /dev/null
+++ b/types/amap-js-api/overlay/shapeOverlay.d.ts
@@ -0,0 +1,30 @@
+declare namespace AMap {
+    namespace ShapeOverlay {
+        interface EventMap<I = ShapeOverlay> extends Overlay.EventMap<I> {
+            show: Event<'show', { target: I }>;
+            hide: Event<'hide', { target: I }>;
+            options: Event<'options'>;
+            change: Event<'change', { target: I }>;
+        }
+        interface GetOptionsResult<ExtraData = any> {
+            map: Map;
+            zIndex: number;
+            strokeColor: string;
+            strokeOpacity: number;
+            strokeWeight: number;
+            strokeStyle: StrokeStyle;
+            strokeDasharray: number[];
+            extData: ExtraData | {};
+            bubble: boolean;
+            clickable: boolean;
+        }
+    }
+    abstract class ShapeOverlay<ExtraData = any> extends Overlay<ExtraData> {
+        abstract setOptions(options: {}): void;
+        abstract getOptions(): {};
+        getzIndex(): number;
+        setzIndex(zIndex: number): void;
+        getVisible(): boolean;
+        setDraggable(draggable: boolean): void;
+    }
+}
diff --git a/types/amap-js-api/overlay/text.d.ts b/types/amap-js-api/overlay/text.d.ts
new file mode 100644
index 0000000000..db15ae08ce
--- /dev/null
+++ b/types/amap-js-api/overlay/text.d.ts
@@ -0,0 +1,19 @@
+declare namespace AMap {
+    namespace Text {
+        type TextAlign = 'left' | 'right' | 'center';
+        type VerticalAlign = 'top' | 'middle' | 'bottom';
+        interface EventMap<I = Text> extends Marker.EventMap<I> { }
+        interface Options extends Marker.Options {
+            text?: string;
+            textAlign?: TextAlign;
+            verticalAlign?: VerticalAlign;
+        }
+    }
+
+    class Text<ExtraData = any> extends Marker<ExtraData> {
+        constructor(options?: Text.Options);
+        getText(): string;
+        setText(text: string): void;
+        setStyle(style: object): void;
+    }
+}
diff --git a/types/amap-js-api/pixel.d.ts b/types/amap-js-api/pixel.d.ts
new file mode 100644
index 0000000000..fab4605b7a
--- /dev/null
+++ b/types/amap-js-api/pixel.d.ts
@@ -0,0 +1,17 @@
+declare namespace AMap {
+    class Pixel {
+        constructor(x: number, y: number, round?: boolean);
+        getX(): number;
+        getY(): number;
+        equals(point: Pixel): boolean;
+        toString(): string;
+
+        // internal
+        add(offset: {x: number; y: number}, round?: boolean): Pixel;
+        round(): Pixel;
+        floor(): Pixel;
+        length(): number;
+        direction(): null | number;
+        toFixed(decimals?: number): this;
+    }
+}
diff --git a/types/amap-js-api/size.d.ts b/types/amap-js-api/size.d.ts
new file mode 100644
index 0000000000..12a1e25423
--- /dev/null
+++ b/types/amap-js-api/size.d.ts
@@ -0,0 +1,10 @@
+declare namespace AMap {
+    class Size {
+        constructor(width: number, height: number);
+        getWidth(): number;
+        getHeight(): number;
+        toString(): string;
+        // internal
+        contains(size: { x: number; y: number }): boolean;
+    }
+}
diff --git a/types/amap-js-api/tsconfig.json b/types/amap-js-api/tsconfig.json
new file mode 100644
index 0000000000..a26facba9e
--- /dev/null
+++ b/types/amap-js-api/tsconfig.json
@@ -0,0 +1,66 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noEmit": true,
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "array-bounds.d.ts",
+        "bounds.d.ts",
+        "browser.d.ts",
+        "common.d.ts",
+        "convert-from.d.ts",
+        "dom-util.d.ts",
+        "event.d.ts",
+        "geometry-util.d.ts",
+        "index.d.ts",
+        "layer/building.d.ts",
+        "layer/flexible.d.ts",
+        "layer/layer.d.ts",
+        "layer/layerGroup.d.ts",
+        "layer/massMarks.d.ts",
+        "layer/mediaLayer.d.ts",
+        "layer/tileLayer.d.ts",
+        "layer/wms.d.ts",
+        "layer/wmts.d.ts",
+        "lngLat.d.ts",
+        "map.d.ts",
+        "overlay/bezierCurve.d.ts",
+        "overlay/circle.d.ts",
+        "overlay/circleMarker.d.ts",
+        "overlay/contextMenu.d.ts",
+        "overlay/ellipse.d.ts",
+        "overlay/geoJSON.d.ts",
+        "overlay/icon.d.ts",
+        "overlay/infoWindow.d.ts",
+        "overlay/marker.d.ts",
+        "overlay/markerShape.d.ts",
+        "overlay/overlay.d.ts",
+        "overlay/overlayGroup.d.ts",
+        "overlay/pathOverlay.d.ts",
+        "overlay/polygon.d.ts",
+        "overlay/polyline.d.ts",
+        "overlay/rectangle.d.ts",
+        "overlay/shapeOverlay.d.ts",
+        "overlay/text.d.ts",
+        "pixel.d.ts",
+        "size.d.ts",
+        "type-util.d.ts",
+        "util.d.ts",
+        "view2D.d.ts",
+        "amap-js-api-tests.ts"
+    ]
+}
diff --git a/types/amap-js-api/tslint.json b/types/amap-js-api/tslint.json
new file mode 100644
index 0000000000..f93cf8562a
--- /dev/null
+++ b/types/amap-js-api/tslint.json
@@ -0,0 +1,3 @@
+{
+    "extends": "dtslint/dt.json"
+}
diff --git a/types/amap-js-api/type-util.d.ts b/types/amap-js-api/type-util.d.ts
new file mode 100644
index 0000000000..1ced3d69c1
--- /dev/null
+++ b/types/amap-js-api/type-util.d.ts
@@ -0,0 +1,12 @@
+type Omit<T, E extends keyof T> = {
+    [K in Exclude<keyof T, E>]: T[K]
+};
+
+type OptionalKey<T> = { [K in keyof T]-?: undefined extends T[K] ? K : never }[keyof T];
+// type OmitUndefined<M> = Omit<M, { [K in keyof M]: M[K] extends undefined ? K : never }[keyof M]>;
+// type PickUndefined<M> = Omit<M, keyof OmitUndefined<M>>;
+
+type Merge<O, T> =
+    { [K in Exclude<keyof O, keyof T | OptionalKey<O>>]-?: O[K]; } &
+    { [K in Extract<Exclude<keyof O, keyof T>, OptionalKey<O>>]?: O[K]; } &
+    T;
diff --git a/types/amap-js-api/util.d.ts b/types/amap-js-api/util.d.ts
new file mode 100644
index 0000000000..70b48c31d1
--- /dev/null
+++ b/types/amap-js-api/util.d.ts
@@ -0,0 +1,37 @@
+declare namespace AMap {
+    namespace Util {
+        function colorNameToHex(colorName: string): string;
+
+        function rgbHex2Rgba(hex: string): string;
+
+        function argbHex2Rgba(hex: string): string;
+
+        function isEmpty(obj: object): boolean;
+
+        function deleteItemFromArray<T = any>(array: T[], item: T): T[];
+
+        function deleteItemFromArrayByIndex<T = any>(array: T[], index: number): T[];
+
+        function indexOf<T = any>(array: T[], item: T): number;
+
+        function format(floatNumber: number, digits?: number): number;
+
+        function isArray(data: any): data is any[];
+
+        function isDOM(data: any): data is HTMLElement;
+
+        function includes<T = any>(array: T[], item: T): boolean;
+
+        function requestIdleCallback(callback: (...args: any[]) => any, options?: { timeout?: number }): number;
+
+        function cancelIdleCallback(handle: number): void;
+
+        function requestAnimFrame<C = undefined>(callback: (this: C, ...args: any[]) => any, context?: C): number;
+
+        function cancelAnimFrame(handle: number): void;
+
+        function color2RgbaArray(color: string | number[]): [number, number, number, number];
+
+        function color2Rgba(color: string | number[]): string;
+    }
+}
diff --git a/types/amap-js-api/view2D.d.ts b/types/amap-js-api/view2D.d.ts
new file mode 100644
index 0000000000..d662b4c50e
--- /dev/null
+++ b/types/amap-js-api/view2D.d.ts
@@ -0,0 +1,13 @@
+declare namespace AMap {
+    namespace View2D {
+        interface Options {
+            center?: LocationValue;
+            rotation?: number;
+            zoom?: number;
+            crs?: 'EPGS3857' | 'EPGS3395' | 'EPGS4326';
+        }
+    }
+    class View2D extends EventEmitter {
+        constructor(options?: View2D.Options);
+    }
+}