@cn-map/gaode-react 0.0.0 → 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,610 @@
+import { APIStatus, APIType, LoadStatus, LoaderOptions } from "@cn-map/gaode-jsapi-loader";
+import { FC, JSX, PropsWithChildren, ReactNode, Ref, RefObject } from "react";
+import { Accessor, AccessorLike, MapEventProps, Nullable } from "@cn-map/gaode-shared/types";
+/**
+ * 加载高德地图依赖的 Hook
+ * @param {APILoaderOptions} config - 加载高德地图API的配置项
+ * @param {boolean} [resetOnUnmount=false] - 组件卸载时是否重置全局 JSAPI 状态
+ */
+declare const useAPILoader: (config: APILoaderOptions, resetOnUnmount?: boolean) => readonly [Record<APIType, APIStatus>, Nullable<Error | Event>];
+interface APILoaderOptions extends Omit<LoaderOptions, "key"> {
+  /**
+   * key 密钥 您需先[申请密钥(ak)](https://lbs.amap.com/dev/key/app)
+   * - [开发文档说明地址](https://lbs.amap.com/api/javascript-api/guide/abc/prepare)
+   *
+   * 1. 首先，[注册开发者账号](https://lbs.amap.com/dev/id/newuser)，成为高德开放平台开发者
+   * 2. 登陆之后，在进入「应用管理」 页面「创建新应用」
+   * 3. 为应用[添加 Key](https://lbs.amap.com/dev/key/app)，「服务平台」一项请选择「 Web 端 ( JSAPI ) 」
+   *
+   */
+  apiKey: string;
+}
+interface APILoaderProps extends APILoaderOptions {
+  /**
+   * 组件卸载时是否重置全局 JSAPI 状态
+   *
+   * @default false
+   */
+  resetOnUnmount?: boolean;
+  children?: ReactNode | ((...args: ReturnType<typeof useAPILoader>) => ReactNode);
+}
+/**
+ * APILoader 用于加载高德地图依赖
+ */
+export declare const APILoader: ({ children, resetOnUnmount, ...config }: APILoaderProps) => JSX.Element;
+/**
+ * 获取当前API加载状态
+ * @param {APIType} type - 获取的API类型
+ * @return { APIStatus } - 返回指定类型的加载状态
+ */
+export declare function useAPIStatus(type: APIType): APIStatus;
+/**
+ * 获取当前API加载状态
+ * @return { Record<APIType, APIStatus> } - 返回所有类型的加载状态
+ */
+export declare function useAPIStatus(): Record<APIType, APIStatus>;
+interface ControlExtraInitOptions {
+  /**
+   * 地图对象
+   */
+  map?: AMap.Map;
+}
+type ControlBarEvents = MapEventProps<AMap.ControlBarEventType, AMap.ControlBar>;
+type ControlBarInitOptions = AMap.ControlBarOptions & ControlExtraInitOptions;
+type ControlBarProps = ControlBarInitOptions & ControlBarEvents & {
+  ref?: Ref<AMap.ControlBar>;
+};
+declare const ControlBar: FC<ControlBarProps>;
+type GeolocationEvents = MapEventProps<AMap.GeolocationEventType, AMap.Geolocation>;
+type GeolocationInitOptions = AMap.GeolocationOptions & ControlExtraInitOptions;
+type GeolocationProps = GeolocationInitOptions & GeolocationEvents & {
+  ref?: Ref<AMap.Geolocation>;
+};
+declare const Geolocation: FC<GeolocationProps>;
+type HawkEyeEvents = MapEventProps<AMap.HawkEyeEventType, AMap.HawkEye>;
+type HawkEyeInitOptions = AMap.HawkEyeOptions & ControlExtraInitOptions;
+type HawkEyeProps = HawkEyeInitOptions & HawkEyeEvents & {
+  ref?: Ref<AMap.HawkEye>;
+};
+declare const HawkEye: FC<HawkEyeProps>;
+type MapTypeEvents = MapEventProps<AMap.MapTypeEventType, AMap.MapType>;
+type MapTypeInitOptions = AMap.MapTypeOptions & ControlExtraInitOptions;
+type MapTypeProps = MapTypeInitOptions & MapTypeEvents & {
+  ref?: Ref<AMap.MapType>;
+};
+declare const MapType: FC<MapTypeProps>;
+type ScaleEvents = MapEventProps<AMap.ScaleEventType, AMap.Scale>;
+type ScaleInitOptions = AMap.ScaleOptions & ControlExtraInitOptions;
+type ScaleProps = ScaleInitOptions & ScaleEvents & {
+  ref?: Ref<AMap.Scale>;
+};
+declare const Scale: FC<ScaleProps>;
+type ToolBarEvents = MapEventProps<AMap.ToolBarEventType, AMap.ToolBar>;
+type ToolBarInitOptions = AMap.ToolBarOptions & ControlExtraInitOptions;
+type ToolBarProps = ToolBarInitOptions & ToolBarEvents & {
+  ref?: Ref<AMap.ToolBar>;
+};
+declare const ToolBar: FC<ToolBarProps>;
+declare function useLazyInit<T>(init: Accessor<T>): T;
+type BuildingsAttributes = Omit<BuildingsInitOptions, "map"> & {
+  /**
+   * 建筑物图层样式
+   */
+  style?: AMap.BuildingsStyleOptions;
+};
+type BuildingsEvents = MapEventProps<AMap.BuildingsEventType, AMap.Buildings>;
+type BuildingsInitOptions = AMap.BuildingsOptions;
+type BuildingsProps = BuildingsInitOptions & BuildingsAttributes & BuildingsEvents & {
+  ref?: Ref<AMap.Buildings>;
+};
+declare const Buildings: FC<BuildingsProps>;
+interface CommonProps {
+  className?: string;
+  style?: import("react").CSSProperties;
+}
+/**
+ * 目标
+ */
+type Target<T> = RefObject<T> | AccessorLike<T>;
+type CanvasLayerEvents = MapEventProps<AMap.CanvasLayerEventType, AMap.CanvasLayer>;
+type CanvasLayerInitOptions = Omit<AMap.CanvasLayerOptions, "canvas"> & {
+  /**
+   * 画布元素
+   */
+  canvas?: Target<HTMLCanvasElement>;
+};
+type CanvasLayerProps = CanvasLayerInitOptions & CanvasLayerEvents & {
+  ref?: Ref<AMap.CanvasLayer>;
+};
+declare const CanvasLayer: FC<CanvasLayerProps>;
+type CustomLayerEvents = MapEventProps<AMap.CustomLayerEventType, AMap.CustomLayer>;
+interface CustomLayerExtraInitOptions {
+  /**
+   * 画布元素/矢量图形元素
+   */
+  element: Target<HTMLCanvasElement | SVGSVGElement>;
+}
+type CustomLayerInitOptions = AMap.CustomLayerOptions & CustomLayerExtraInitOptions;
+type CustomLayerProps = CustomLayerInitOptions & CustomLayerEvents & {
+  ref?: Ref<AMap.CustomLayer>;
+};
+declare const CustomLayer: FC<CustomLayerProps>;
+type CountryEvents = MapEventProps<AMap.DistrictLayer.CountryEventType, AMap.DistrictLayer.Country>;
+type CountryInitOptions = AMap.DistrictLayer.CountryOptions;
+type CountryProps = CountryInitOptions & CountryEvents & {
+  ref?: Ref<AMap.DistrictLayer.Country>;
+};
+declare const Country: FC<CountryProps>;
+type DistrictLayerEvents = MapEventProps<AMap.DistrictLayerEventType, AMap.DistrictLayer>;
+type DistrictLayerInitOptions = AMap.DistrictLayerOptions;
+type DistrictLayerProps = DistrictLayerInitOptions & DistrictLayerEvents & {
+  ref?: Ref<AMap.DistrictLayer>;
+};
+declare const DistrictLayer: FC<DistrictLayerProps>;
+type ProvinceEvents = MapEventProps<AMap.DistrictLayer.ProvinceEventType, AMap.DistrictLayer.Province>;
+type ProvinceInitOptions = AMap.DistrictLayer.ProvinceOptions;
+type ProvinceProps = ProvinceInitOptions & ProvinceEvents & {
+  ref?: Ref<AMap.DistrictLayer.Province>;
+};
+declare const Province: FC<ProvinceProps>;
+type WorldEvents = MapEventProps<AMap.DistrictLayer.WorldEventType, AMap.DistrictLayer.World>;
+type WorldInitOptions = AMap.DistrictLayer.WorldOptions;
+type WorldProps = WorldInitOptions & WorldEvents & {
+  ref?: Ref<AMap.DistrictLayer.World>;
+};
+declare const World: FC<WorldProps>;
+type GLCustomLayerEvents = MapEventProps<AMap.GLCustomLayerEventType, AMap.GLCustomLayer>;
+type GLCustomLayerInitOptions = AMap.GLCustomLayerOptions;
+type GLCustomLayerProps = GLCustomLayerInitOptions & GLCustomLayerEvents & {
+  ref?: Ref<AMap.GLCustomLayer>;
+};
+declare const GLCustomLayer: FC<GLCustomLayerProps>;
+type HeatMapAttributes = AMap.HeatMapOptions & {
+  dataset?: AMap.HeatMapDataSet | AMap.HeatMapDataSetLive;
+};
+type HeatMapInitOptions = HeatMapAttributes & {
+  map?: AMap.Map;
+};
+type HeatMapProps = HeatMapInitOptions & {
+  ref?: Ref<AMap.HeatMap>;
+};
+declare const HeatMap: FC<HeatMapProps>;
+type ImageLayerEvents = MapEventProps<AMap.ImageLayerEventType, AMap.ImageLayer>;
+type ImageLayerInitOptions = AMap.ImageLayerOptions;
+type ImageLayerProps = ImageLayerInitOptions & ImageLayerEvents & {
+  ref?: Ref<AMap.ImageLayer>;
+};
+declare const ImageLayer: FC<ImageLayerProps>;
+type IndoorMapEvents = MapEventProps<AMap.IndoorMapEventType, AMap.IndoorMap>;
+interface IndoorMapExtraInitOptions {
+  /**
+   * 建筑物 POI ID
+   */
+  POIId?: string;
+  /**
+   * 楼层
+   */
+  floor?: number;
+}
+type IndoorMapInitOptions = AMap.IndoorMapOptions & IndoorMapExtraInitOptions;
+type IndoorMapProps = IndoorMapInitOptions & IndoorMapEvents & {
+  ref?: Ref<AMap.IndoorMap>;
+};
+declare const IndoorMap: FC<IndoorMapProps>;
+/**
+ * 获取LabelsLayer实例 hook
+ */
+export declare function useLabelsLayer(): AMap.LabelsLayer;
+type LabelsLayerEvents<ExtData = any> = MapEventProps<AMap.LabelsLayerEventType, AMap.LabelsLayer<ExtData>>;
+interface LabelsLayerExtraInitOptions<ExtData = any> {
+  /**
+   * 标注点集合
+   */
+  labelMarkers?: AMap.LabelMarker<ExtData>[];
+}
+type LabelsLayerInitOptions<ExtData = any> = AMap.LabelsLayerOptions & LabelsLayerExtraInitOptions<ExtData>;
+type LabelsLayerProps<ExtData = any> = PropsWithChildren<LabelsLayerInitOptions<ExtData> & LabelsLayerEvents<ExtData> & {
+  ref?: Ref<AMap.LabelsLayer<ExtData>>;
+}>;
+declare const LabelsLayer: <ExtData = any>({ ref, map: _map, children, labelMarkers, ...props }: LabelsLayerProps<ExtData>) => JSX.Element | null;
+type LayerGroupEvents = MapEventProps<AMap.LayerGroupEventType, AMap.LayerGroupLayer>;
+interface LayerGroupExtraInitOptions {
+  map?: AMap.Map;
+}
+type LayerGroupInitOptions = LayerGroupExtraInitOptions & LayerGroupEvents & {
+  visible?: boolean;
+  layers?: AMap.LayerGroupLayer[];
+};
+type LayerGroupProps = LayerGroupInitOptions & {
+  ref?: Ref<AMap.LayerGroup>;
+};
+declare const LayerGroup: FC<LayerGroupProps>;
+type MapboxEvents = MapEventProps<AMap.MapboxEventType, AMap.Mapbox>;
+type MapboxInitOptions = AMap.MapboxOptions;
+type MapboxProps = PropsWithChildren<MapboxInitOptions & MapboxEvents> & {
+  ref?: Ref<AMap.Mapbox>;
+};
+declare const Mapbox: FC<MapboxProps>;
+type MapboxVectorTileLayerEvents = MapEventProps<AMap.MapboxVectorTileLayerEventType, AMap.MapboxVectorTileLayer>;
+type MapboxVectorTileLayerInitOptions = AMap.MapboxVectorTileLayerOptions;
+type MapboxVectorTileLayerProps = MapboxVectorTileLayerInitOptions & MapboxVectorTileLayerEvents & {
+  ref?: Ref<AMap.MapboxVectorTileLayer>;
+};
+declare const MapboxVectorTileLayer: FC<MapboxVectorTileLayerProps>;
+type FlexibleEvents = MapEventProps<AMap.TileLayer.FlexibleEventType, AMap.TileLayer.Flexible>;
+type FlexibleInitOptions = AMap.TileLayer.FlexibleOptions;
+type FlexibleProps = FlexibleInitOptions & FlexibleEvents & {
+  ref?: Ref<AMap.TileLayer.Flexible>;
+};
+declare const Flexible: FC<FlexibleProps>;
+type MarkEvents = MapEventProps<AMap.TileLayer.MarkEventType, AMap.TileLayer.Mark>;
+type MarkInitOptions = AMap.TileLayer.MarkOptions;
+type MarkProps = MarkInitOptions & MarkEvents & {
+  ref?: Ref<AMap.TileLayer.Mark>;
+};
+declare const Mark: FC<MarkProps>;
+type RoadNetEvents = MapEventProps<AMap.TileLayer.RoadNetEventType, AMap.TileLayer.RoadNet>;
+type RoadNetInitOptions = AMap.TileLayer.RoadNetOptions;
+type RoadNetProps = RoadNetInitOptions & RoadNetEvents & {
+  ref?: Ref<AMap.TileLayer.RoadNet>;
+};
+declare const RoadNet: FC<RoadNetProps>;
+type SatelliteEvents = MapEventProps<AMap.TileLayer.SatelliteEventType, AMap.TileLayer.Satellite>;
+type SatelliteInitOptions = AMap.TileLayer.SatelliteOptions;
+type SatelliteProps = SatelliteInitOptions & SatelliteEvents & {
+  ref?: Ref<AMap.TileLayer.Satellite>;
+};
+declare const Satellite: FC<SatelliteProps>;
+type TileLayerEvents = MapEventProps<AMap.TileLayerEventType, AMap.TileLayer>;
+type TileLayerInitOptions = AMap.TileLayerOptions;
+type TileLayerProps = TileLayerInitOptions & TileLayerEvents & {
+  ref?: Ref<AMap.TileLayer>;
+};
+declare const TileLayer: FC<TileLayerProps>;
+type TrafficEvents = MapEventProps<AMap.TileLayer.TrafficEventType, AMap.TileLayer.Traffic>;
+type TrafficInitOptions = AMap.TileLayer.TrafficOptions;
+type TrafficProps = TrafficInitOptions & TrafficEvents & {
+  ref?: Ref<AMap.TileLayer.Traffic>;
+};
+declare const Traffic: FC<TrafficProps>;
+type WMSEvents = MapEventProps<AMap.TileLayer.WMSEventType, AMap.TileLayer.WMS>;
+type WMSInitOptions = AMap.TileLayer.WMSOptions;
+type WMSProps = WMSInitOptions & WMSEvents & {
+  ref?: Ref<AMap.TileLayer.WMS>;
+};
+declare const Wms: FC<WMSProps>;
+type WMTSEvents = MapEventProps<AMap.TileLayer.WMTSEventType, AMap.TileLayer.WMTS>;
+type WMTSInitOptions = AMap.TileLayer.WMTSOptions;
+type WMTSProps = WMTSInitOptions & WMTSEvents & {
+  ref?: Ref<AMap.TileLayer.WMTS>;
+};
+declare const Wmts: FC<WMTSProps>;
+/**
+ * 获取VectorLayer实例 hook
+ */
+export declare function useVectorLayer(): AMap.VectorLayer;
+type VectorLayerInitOptions = AMap.VectorLayerOptions;
+type VectorLayerProps<ExtData = any> = PropsWithChildren<VectorLayerInitOptions & {
+  ref?: Ref<AMap.VectorLayer<ExtData>>;
+}>;
+declare const VectorLayer: <ExtData = any>({ ref, map: _map, children, ...props }: VectorLayerProps<ExtData>) => JSX.Element;
+/**
+ * 获取地图实例 hook
+ */
+export declare function useMap(): Nullable<AMap.Map>;
+/**
+ * 获取合并props的地图实例
+ */
+export declare function useMapInstance(mapInProps?: Nullable<AMap.Map>): Nullable<AMap.Map>;
+type MapEvents = MapEventProps<AMap.MapEventType, AMap.Map>;
+interface MapContainer {
+  /**
+   * 地图容器元素 或 容器 id
+   */
+  container?: AccessorLike<HTMLDivElement> | string;
+}
+type SetOption = "center" | "zoom" | "rotation" | "pitch";
+interface MapSetOptions {
+  /**
+   * 镜头是否立即过渡到目标位置, 支持单独设置
+   */
+  immediately?: boolean | Partial<Record<SetOption, boolean>>;
+  /**
+   * 镜头动画时长，支持单独设置
+   */
+  duration?: number | Partial<Record<SetOption, number>>;
+}
+type MapInitOptions = AMap.MapOptions & MapContainer;
+type MapProps = PropsWithChildren<MapInitOptions & Partial<Pick<HTMLDivElement, "id">> & MapSetOptions & CommonProps & MapEvents & {
+  ref?: Ref<Nullable<AMap.Map>>;
+}>;
+declare const Map: FC<MapProps>;
+interface VectorOverlayExtraInitOptions {
+  /**
+   * 地图对象
+   */
+  map?: AMap.Map;
+  /**
+   * 是否可见
+   */
+  visible?: boolean;
+}
+type BezierCurveEvents<ExtData> = MapEventProps<AMap.BezierCurveEventType, AMap.BezierCurve<ExtData>>;
+type BezierCurveInitOptions<ExtData = any> = AMap.BezierCurveOptions<ExtData> & VectorOverlayExtraInitOptions;
+type BezierCurveProps<ExtData = any> = BezierCurveInitOptions<ExtData> & BezierCurveEvents<ExtData> & {
+  ref?: Ref<AMap.BezierCurve<ExtData>>;
+};
+declare const BezierCurve: <ExtData = any>({ ref, map: _map, ...props }: BezierCurveProps<ExtData>) => null;
+type CircleEvents<ExtData> = MapEventProps<AMap.CircleEventType, AMap.Circle<ExtData>>;
+type CircleInitOptions<ExtData = any> = AMap.CircleOptions<ExtData> & VectorOverlayExtraInitOptions;
+type CircleProps<ExtData = any> = CircleInitOptions<ExtData> & CircleEvents<ExtData> & {
+  ref?: Ref<AMap.Circle<ExtData>>;
+};
+declare const Circle: <ExtData = any>({ ref, map: _map, ...props }: CircleProps<ExtData>) => null;
+type CircleMarkerEvents<ExtData> = MapEventProps<AMap.CircleMarkerEventType, AMap.CircleMarker<ExtData>>;
+type CircleMarkerInitOptions<ExtData> = AMap.CircleMarkerOptions<ExtData> & VectorOverlayExtraInitOptions;
+type CircleMarkerProps<ExtData = any> = CircleMarkerInitOptions<ExtData> & CircleMarkerEvents<ExtData> & {
+  ref?: Ref<AMap.CircleMarker<ExtData>>;
+};
+declare const CircleMarker: <ExtData = any>({ ref, map: _map, ...props }: CircleMarkerProps<ExtData>) => null;
+type ContextMenuEvents = MapEventProps<AMap.ContextMenuEventType, AMap.ContextMenu>;
+type ContextMenuInitOptions = AMap.ContextMenuOptions;
+type ContextMenuProps = PropsWithChildren<ContextMenuInitOptions & ContextMenuEvents> & {
+  ref?: Ref<AMap.ContextMenu>;
+};
+declare const ContextMenu: FC<ContextMenuProps>;
+type MarkerEvents<ExtData> = MapEventProps<AMap.MarkerEventType, AMap.Marker<ExtData>>;
+interface MarkerExtraInitOptions {
+  /**
+   * 是否置顶
+   */
+  isTop?: boolean;
+}
+type MarkerInitOptions<ExtData> = AMap.MarkerOptions<ExtData> & MarkerExtraInitOptions;
+type MarkerProps<ExtData = any> = PropsWithChildren<MarkerInitOptions<ExtData> & MarkerEvents<ExtData> & {
+  ref?: Ref<AMap.Marker<ExtData>>;
+}>;
+declare const Marker: <ExtData = any>({ ref, map: _map, children, ...props }: MarkerProps<ExtData>) => JSX.Element | null;
+type ElasticMarkerEvents<ExtData> = MapEventProps<AMap.ElasticMarkerEventType, AMap.ElasticMarker<ExtData>>;
+type ElasticMarkerInitOptions<ExtData> = AMap.ElasticMarkerOptions<ExtData> & MarkerExtraInitOptions;
+type ElasticMarkerProps<ExtData = any> = ElasticMarkerInitOptions<ExtData> & ElasticMarkerEvents<ExtData> & {
+  ref?: Ref<AMap.ElasticMarker<ExtData>>;
+};
+declare const ElasticMarker: <ExtData = any>({ ref, map: _map, ...props }: ElasticMarkerProps<ExtData>) => JSX.Element | null;
+type EllipseEvents<ExtData> = MapEventProps<AMap.EllipseEventType, AMap.Ellipse<ExtData>>;
+type EllipseInitOptions<ExtData = any> = AMap.EllipseOptions<ExtData> & VectorOverlayExtraInitOptions;
+type EllipseProps<ExtData = any> = EllipseInitOptions<ExtData> & EllipseEvents<ExtData> & {
+  ref?: Ref<AMap.Ellipse<ExtData>>;
+};
+declare const Ellipse: <ExtData = any>({ ref, map: _map, ...props }: EllipseProps<ExtData>) => null;
+type IndexClusterEvents = MapEventProps<AMap.IndexClusterEventType, AMap.IndexCluster>;
+interface IndexClusterExtraInitOptions {
+  /**
+   * 点标记聚合数据项
+   */
+  data: AMap.IndexClusterDataOptions[];
+  /**
+   * 地图对象
+   */
+  map?: AMap.Map;
+}
+type IndexClusterInitOptions = AMap.IndexClusterOptions & IndexClusterExtraInitOptions;
+type IndexClusterProps = IndexClusterInitOptions & IndexClusterEvents & {
+  ref?: Ref<AMap.IndexCluster>;
+};
+declare const IndexCluster: FC<IndexClusterProps>;
+type InfoWindowEvents<ExtData> = MapEventProps<AMap.InfoWindowEventType, AMap.InfoWindow<ExtData>>;
+type InfoWindowInitOptions<ExtData = any> = AMap.InfoWindowOptions<ExtData>;
+type InfoWindowProps<ExtData = any> = PropsWithChildren<InfoWindowInitOptions<ExtData> & InfoWindowEvents<ExtData> & {
+  ref?: Ref<AMap.InfoWindow<ExtData>>;
+}>;
+declare const InfoWindow: <ExtData = any>({ ref, map: _map, children, ...props }: InfoWindowProps<ExtData>) => JSX.Element | null;
+type LabelMarkerEvents<ExtData> = MapEventProps<AMap.LabelMarkerEventType, AMap.LabelMarker<ExtData>>;
+interface LabelMarkerExtraInitOptions {
+  /**
+   * 是否置顶
+   */
+  isTop?: boolean;
+}
+type LabelMarkerInitOptions<ExtData = any> = AMap.LabelMarkerOptions<ExtData> & LabelMarkerExtraInitOptions;
+type LabelMarkerProps<ExtData = any> = LabelMarkerInitOptions<ExtData> & LabelMarkerEvents<ExtData> & {
+  ref?: Ref<AMap.LabelMarker<ExtData>>;
+};
+declare const LabelMarker: <ExtData = any>({ ref, ...props }: LabelMarkerProps<ExtData>) => null;
+type MarkerClusterEvents = MapEventProps<AMap.MarkerClusterEventType, AMap.MarkerCluster>;
+interface MarkerClusterExtraInitOptions {
+  /**
+   * 点标记聚合数据项
+   */
+  data: AMap.MarkerClusterDataOptions[];
+  /**
+   * 地图对象
+   */
+  map?: AMap.Map;
+}
+type MarkerClusterInitOptions = AMap.MarkerClusterOptions & MarkerClusterExtraInitOptions;
+type MarkerClusterProps = MarkerClusterInitOptions & MarkerClusterEvents & {
+  ref?: Ref<AMap.MarkerCluster>;
+};
+declare const MarkerCluster: FC<MarkerClusterProps>;
+type MassMarksEvents = MapEventProps<AMap.MassMarksEventType, AMap.MassMarks>;
+interface MassMarksExtraInitOptions {
+  /**
+   * 海量点数据参数
+   */
+  data: AMap.MassMarksDataOptions[];
+  /**
+   * 地图对象
+   */
+  map?: AMap.Map;
+}
+type MassMarksInitOptions = AMap.MassMarksOptions & MassMarksExtraInitOptions;
+type MassMarksProps = MassMarksInitOptions & MassMarksEvents & {
+  ref?: Ref<AMap.MassMarks>;
+};
+declare const MassMarks: FC<MassMarksProps>;
+type OverlayGroupEvents<ExtData> = MapEventProps<AMap.OverlayGroupEventType, AMap.OverlayGroupOverlay<ExtData>>;
+type OverlayGroupInitOptions<ExtData> = {
+  /**
+   * 覆盖物集合
+   */
+  overlays?: AMap.OverlayGroupOverlay<ExtData>[];
+} & VectorOverlayExtraInitOptions & OverlayGroupEvents<ExtData>;
+type OverlayGroupProps<ExtData = any> = OverlayGroupInitOptions<ExtData> & {
+  ref?: Ref<AMap.OverlayGroup<ExtData>>;
+};
+declare const OverlayGroup: <ExtData = any>({ ref, visible, map: _map, overlays, ...props }: OverlayGroupProps<ExtData>) => null;
+type PolygonEvents<ExtData> = MapEventProps<AMap.PolygonEventType, AMap.Polygon<ExtData>>;
+type PolygonInitOptions<ExtData = any> = AMap.PolygonOptions<ExtData> & VectorOverlayExtraInitOptions;
+type PolygonProps<ExtData = any> = PolygonInitOptions<ExtData> & PolygonEvents<ExtData> & {
+  ref?: Ref<AMap.Polygon<ExtData>>;
+};
+declare const Polygon: <ExtData = any>({ ref, map: _map, ...props }: PolygonProps<ExtData>) => null;
+type PolylineEvents<ExtData> = MapEventProps<AMap.PolylineEventType, AMap.Polyline<ExtData>>;
+type PolylineInitOptions<ExtData = any> = AMap.PolylineOptions<ExtData> & VectorOverlayExtraInitOptions;
+type PolylineProps<ExtData = any> = PolylineInitOptions<ExtData> & PolylineEvents<ExtData> & {
+  ref?: Ref<AMap.Polyline<ExtData>>;
+};
+declare const Polyline: <ExtData = any>({ ref, map: _map, ...props }: PolylineProps<ExtData>) => null;
+type RectangleEvents<ExtData> = MapEventProps<AMap.RectangleEventType, AMap.Rectangle<ExtData>>;
+type RectangleInitOptions<ExtData = any> = AMap.RectangleOptions<ExtData> & VectorOverlayExtraInitOptions;
+type RectangleProps<ExtData = any> = RectangleInitOptions<ExtData> & RectangleEvents<ExtData> & {
+  ref?: Ref<AMap.Rectangle<ExtData>>;
+};
+declare const Rectangle: <ExtData = any>({ ref, map: _map, ...props }: RectangleProps<ExtData>) => null;
+type TextEvents<ExtData> = MapEventProps<AMap.TextEventType, AMap.Text<ExtData>>;
+type TextInitOptions<ExtData> = AMap.TextOptions<ExtData> & MarkerExtraInitOptions;
+type TextProps<ExtData = any> = PropsWithChildren<TextInitOptions<ExtData> & TextEvents<ExtData> & {
+  ref?: Ref<AMap.Text<ExtData>>;
+}>;
+declare const Text: <ExtData = any>({ ref, map: _map, children, ...props }: TextProps<ExtData>) => JSX.Element | null;
+type BezierCurveEditorEvents = MapEventProps<AMap.BezierCurveEditorEventType, AMap.BezierCurveEditor>;
+interface BezierCurveEditorExtraInitOptions {
+  /**
+   * 地图对象
+   */
+  map?: AMap.Map;
+  /**
+   * 要编辑的贝塞尔曲线对象
+   */
+  target?: Target<Nullable<AMap.BezierCurve>>;
+}
+type BezierCurveEditorInitOptions = AMap.BezierCurveEditorOptions & BezierCurveEditorExtraInitOptions;
+type BezierCurveEditorProps = BezierCurveEditorInitOptions & BezierCurveEditorEvents & {
+  ref?: Ref<Nullable<AMap.BezierCurveEditor>>;
+};
+declare const BezierCurveEditor: FC<BezierCurveEditorProps>;
+type CircleEditorEvents = MapEventProps<AMap.CircleEditorEventType, AMap.CircleEditor>;
+interface CircleEditorExtraInitOptions {
+  /**
+   * 地图对象
+   */
+  map?: AMap.Map;
+  /**
+   * 要编辑的圆对象
+   */
+  target?: Target<Nullable<AMap.Circle>>;
+}
+type CircleEditorInitOptions = AMap.CircleEditorOptions & CircleEditorExtraInitOptions;
+type CircleEditorProps = CircleEditorInitOptions & CircleEditorEvents & {
+  ref?: Ref<Nullable<AMap.CircleEditor>>;
+};
+declare const CircleEditor: FC<CircleEditorProps>;
+type EllipseEditorEvents = MapEventProps<AMap.EllipseEditorEventType, AMap.EllipseEditor>;
+interface EllipseEditorExtraInitOptions {
+  /**
+   * 地图对象
+   */
+  map?: AMap.Map;
+  /**
+   * 要编辑的椭圆对象
+   */
+  target?: Target<Nullable<AMap.Ellipse>>;
+}
+type EllipseEditorInitOptions = AMap.EllipseEditorOptions & EllipseEditorExtraInitOptions;
+type EllipseEditorProps = EllipseEditorInitOptions & EllipseEditorEvents & {
+  ref?: Ref<Nullable<AMap.EllipseEditor>>;
+};
+declare const EllipseEditor: FC<EllipseEditorProps>;
+type MouseToolEvents = MapEventProps<AMap.MouseToolEventType, AMap.MouseTool>;
+interface MouserToolExtraInitOptions {
+  /**
+   * 地图对象
+   */
+  map?: AMap.Map;
+  /**
+   * 是否在卸载时清除绘制的图形
+   */
+  clearOnClose?: boolean;
+}
+type MouseToolInitOptions = AMap.MouseToolOptions & MouserToolExtraInitOptions;
+type MouseToolProps = MouseToolInitOptions & MouseToolEvents & {
+  ref?: Ref<Nullable<AMap.MouseTool>>;
+};
+declare const MouseTool: FC<MouseToolProps>;
+type PolygonEditorEvents = MapEventProps<AMap.PolygonEditorEventType, AMap.PolygonEditor>;
+interface PolygonEditorExtraInitOptions {
+  /**
+   * 地图对象
+   */
+  map?: AMap.Map;
+  /**
+   * 要编辑的多边形对象
+   */
+  target?: Target<Nullable<AMap.Polygon>>;
+}
+type PolygonEditorInitOptions = AMap.PolygonEditorOptions & PolygonEditorExtraInitOptions;
+type PolygonEditorProps = PolygonEditorInitOptions & PolygonEditorEvents & {
+  ref?: Ref<Nullable<AMap.PolygonEditor>>;
+};
+declare const PolygonEditor: FC<PolygonEditorProps>;
+type PolylineEditorEvents = MapEventProps<AMap.PolylineEditorEventType, AMap.PolylineEditor>;
+interface PolylineEditorExtraInitOptions {
+  /**
+   * 地图对象
+   */
+  map?: AMap.Map;
+  /**
+   * 要编辑的折线对象
+   */
+  target?: Target<Nullable<AMap.Polyline>>;
+}
+type PolylineEditorInitOptions = AMap.PolylineEditorOptions & PolylineEditorExtraInitOptions;
+type PolylineEditorProps = PolylineEditorInitOptions & PolylineEditorEvents & {
+  ref?: Ref<Nullable<AMap.PolylineEditor>>;
+};
+declare const PolylineEditor: FC<PolylineEditorProps>;
+type RangingToolEvents = MapEventProps<AMap.RangingToolEventType, AMap.RangingTool>;
+interface RangingToolExtraInitOptions {
+  /**
+   * 地图对象
+   */
+  map?: AMap.Map;
+}
+type RangingToolInitOptions = AMap.RangingToolOptions & RangingToolExtraInitOptions;
+type RangingToolProps = RangingToolInitOptions & RangingToolEvents & {
+  ref?: Ref<Nullable<AMap.RangingTool>>;
+};
+declare const RangingTool: FC<RangingToolProps>;
+type RectangleEditorEvents = MapEventProps<AMap.RectangleEditorEventType, AMap.RectangleEditor>;
+interface RectangleEditorExtraInitOptions {
+  /**
+   * 地图对象
+   */
+  map?: AMap.Map;
+  /**
+   * 要编辑的矩形对象
+   */
+  target?: Target<Nullable<AMap.Rectangle>>;
+}
+type RectangleEditorInitOptions = AMap.RectangleEditorOptions & RectangleEditorExtraInitOptions;
+type RectangleEditorProps = RectangleEditorInitOptions & RectangleEditorEvents & {
+  ref?: Ref<Nullable<AMap.RectangleEditor>>;
+};
+declare const RectangleEditor: FC<RectangleEditorProps>;
+export declare function splitProps<T extends object, K1 extends keyof T>(props: T, ...keys: [K1[]]): [Pick<T, K1>, Omit<T, K1>];
+export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T>(props: T, ...keys: [K1[], K2[]]): [Pick<T, K1>, Pick<T, K2>, Omit<T, K1 | K2>];
+export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T, K3 extends keyof T>(props: T, ...keys: [K1[], K2[], K3[]]): [Pick<T, K1>, Pick<T, K2>, Pick<T, K3>, Omit<T, K1 | K2 | K3>];
+export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T, K3 extends keyof T, K4 extends keyof T>(props: T, ...keys: [K1[], K2[], K3[], K4[]]): [Pick<T, K1>, Pick<T, K2>, Pick<T, K3>, Pick<T, K4>, Omit<T, K1 | K2 | K3 | K4>];
+export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T, K3 extends keyof T, K4 extends keyof T, K5 extends keyof T>(props: T, ...keys: [K1[], K2[], K3[], K4[], K5[]]): [Pick<T, K1>, Pick<T, K2>, Pick<T, K3>, Pick<T, K4>, Pick<T, K5>, Omit<T, K1 | K2 | K3 | K4 | K5>];
+export { type APILoaderOptions, type APILoaderProps, BezierCurve, BezierCurveEditor, type BezierCurveEditorProps, type BezierCurveProps, Buildings as BuildingLayer, Buildings, type BuildingsProps, CanvasLayer, type CanvasLayerProps, Circle, CircleEditor, type CircleEditorProps, CircleMarker, type CircleMarkerProps, type CircleProps, ContextMenu, type ContextMenuProps, ControlBar, type ControlBarProps, Country, type CountryProps, CustomLayer, type CustomLayerProps, DistrictLayer, type DistrictLayerProps, ElasticMarker, type ElasticMarkerProps, Ellipse, EllipseEditor, type EllipseEditorProps, type EllipseProps, Flexible, type FlexibleProps, GLCustomLayer, type GLCustomLayerProps, Geolocation, type GeolocationProps, HawkEye, type HawkEyeProps, HeatMap, type HeatMapProps, ImageLayer, type ImageLayerProps, IndexCluster, type IndexClusterProps, IndoorMap, type IndoorMapProps, InfoWindow, type InfoWindowProps, LabelMarker, type LabelMarkerProps, LabelsLayer, type LabelsLayerProps, LayerGroup, type LayerGroupProps, LoadStatus, Map, type MapContainer, type MapEvents, type MapProps, type MapSetOptions, MapType, type MapTypeProps, Mapbox, type MapboxProps, MapboxVectorTileLayer, type MapboxVectorTileLayerProps, Mark, type MarkProps, Marker, MarkerCluster, type MarkerClusterProps, type MarkerProps, MassMarks, type MassMarksProps, MouseTool, type MouseToolProps, OverlayGroup, type OverlayGroupProps, Polygon, PolygonEditor, type PolygonEditorProps, type PolygonProps, Polyline, PolylineEditor, type PolylineEditorProps, type PolylineProps, Province, type ProvinceProps, RangingTool, type RangingToolProps, Rectangle, RectangleEditor, type RectangleEditorProps, type RectangleProps, RoadNet, type RoadNetProps, Satellite, type SatelliteProps, Scale, type ScaleProps, Text, type TextProps, TileLayer, type TileLayerProps, ToolBar, type ToolBarProps, Traffic, type TrafficProps, VectorLayer, type VectorLayerProps, Wms as WMS, type WMSProps, Wmts as WMTS, type WMTSProps, World, type WorldProps, useAPILoader, useLazyInit };