@mappable-world/mappable-types 0.0.20 → 0.0.22

package/imperative/MMapFeature/types.d.ts

@@ -1,4 +1,4 @@
-import type { LineStringGeometry, Margin, MultiLineStringGeometry, MultiPolygonGeometry, PointGeometry, PolygonGeometry } from "../../common/types";
+import type { LineStringGeometry, Margin, MultiLineStringGeometry, MultiPolygonGeometry, PointGeometry, PolygonGeometry, LngLat } from "../../common/types";
 export interface DraggableProps<Callback> {
     /** Feature can be draggable */
     draggable?: boolean;
@@ -32,13 +32,37 @@ export interface BlockingProps {
          */
     blockBehaviors?: boolean;
 }
+export interface MapEvent {
+    /** [x, y] */
+    screenCoordinates: [
+        number,
+        number
+    ];
+    coordinates: LngLat;
+    stopPropagation: () => void;
+}
 export interface FeatureClickEvents {
     /** Double click handler */
-    onDoubleClick?: (event: MouseEvent) => void;
+    onDoubleClick?: (event: MouseEvent, mapEvent: MapEvent) => void;
     /** Click handler */
-    onClick?: (event: MouseEvent) => void;
+    onClick?: (event: MouseEvent, mapEvent: MapEvent) => void;
     /** Fast click handler */
-    onFastClick?: (event: MouseEvent) => void;
+    onFastClick?: (event: MouseEvent, mapEvent: MapEvent) => void;
 }
 export type Geometry = PolygonGeometry | MultiPolygonGeometry | LineStringGeometry | MultiLineStringGeometry | PointGeometry;
+/**
+ * Feature drag event handler.
+ * ```typescript
+ * function onDragEvent(type, coordinates) => {
+ *    console.log('Event:', type, coordinates);
+ * };
+ * const feature = new MMapFeature({
+ *   geometry: {...},
+ *   draggable: true,
+ *   onDragStart: onDragEvent.bind(null, 'dragStart'),
+ *   onDragMove: onDragEvent.bind(null, 'dragMove'),
+ *   onDragEnd: onDragEvent.bind(null, 'dragEnd'),
+ * });
+ * ```
+ */
 export type MMapFeatureEventHandler = (coordinates: Geometry['coordinates']) => void | false;

package/imperative/MMapHotspot/index.d.ts

@@ -1,7 +1,21 @@
 import type { GenericGeometry, LngLat } from "../../common/types";
 /**
+ * Some active area on the map that can be clicked.
  * This is not a real MMapEntity, it cannot be added to the map.
  * But you can check it by `instance of` in MMapListener handlers
+ * For example, in [custom layers](https://mappable.world/docs/js-api/dg/concepts/custom-layers.html) you can pass an object of this type in the `findObjectInPosition` method
+ * Or just listen to the `onEventName` event and check the object:
+ * ```javascript
+ * const map = new mappable.MMap(document.getElementById('map-root'), {...});
+ * map.addChild(new mappable.MMapListener({
+ *   layer: 'any',
+ *   onClick: (object) => {
+ *      if (object instanceof mappable.MMapHotspot) {
+ *          console.log('Hotspot clicked', object);
+ *      }
+ *   }
+ * }))
+ * ```
  */
 declare class MMapHotspot {
     private static _uid;

package/imperative/MMapListener/index.d.ts

@@ -15,6 +15,8 @@ export interface DomEvent {
 type HandlerEntity<TType extends string, TEntity> = {
     type: TType;
     entity: TEntity;
+    layer: string;
+    source: string;
 };
 export type DomEventHandlerObject = HandlerEntity<"feature", MMapFeature> | HandlerEntity<"marker", MMapMarker> | HandlerEntity<"hotspot", MMapHotspot> | undefined;
 interface TileLayerState {
@@ -105,7 +107,7 @@ type MMapListenerProps = DomEventsProps | NullablePartial<MapEvents> | NullableP
  *
  * map.addChild(mapListener);
  * ```
- * @see [More about events](https://mappable.world/docs/jsapi/dg/concepts/events.html)
+ * @see [More about events](https://mappable.world/docs/js-api/dg/concepts/events.html)
  */
 declare class MMapListener extends MMapEntity<MMapListenerProps> {
     private _domHandlers;

package/imperative/MMapMarker/index.d.ts

@@ -98,9 +98,9 @@ declare class MMapMarker extends MMapGroupEntity<MMapMarkerProps, DefaultProps>
         onDragMove?: MMapMarkerEventHandler | undefined;
         blockEvents?: boolean | undefined;
         blockBehaviors?: boolean | undefined;
-        onDoubleClick?: ((event: MouseEvent) => void) | undefined;
-        onClick?: ((event: MouseEvent) => void) | undefined;
-        onFastClick?: ((event: MouseEvent) => void) | undefined;
+        onDoubleClick?: ((event: MouseEvent, mapEvent: import("../MMapFeature/types").MapEvent) => void) | undefined;
+        onClick?: ((event: MouseEvent, mapEvent: import("../MMapFeature/types").MapEvent) => void) | undefined;
+        onFastClick?: ((event: MouseEvent, mapEvent: import("../MMapFeature/types").MapEvent) => void) | undefined;
         markerElement?: HTMLElement | undefined;
         children?: import("react").ReactNode;
         ref?: import("react").Ref<import("../Entities").GenericEntity<{
@@ -144,10 +144,10 @@ declare class MMapMarker extends MMapGroupEntity<MMapMarkerProps, DefaultProps>
     }>>;
     readonly element: HTMLElement;
     private _destroyDomCtx?;
-    constructor(props: MMapMarkerProps, element?: HTMLElement);
-    private __feature;
+    private __feature?;
     get properties(): Record<string, unknown> | undefined;
     get coordinates(): LngLat;
+    constructor(props: MMapMarkerProps, element?: HTMLElement);
     _onAttach(): void;
     _onDetach(): void;
     protected _onUpdate({ coordinates, zIndex, ...props }: Partial<MMapMarkerProps>): void;

package/imperative/MMapReactContainer/index.d.ts

@@ -1,9 +1,18 @@
 import { MMapContainer, MMapContainerProps, MMapContainerPropsImpl } from "../MMapContainer";
-/** @deprecated Use MMapContainerPropsImpl instead */
+/**
+ * @deprecated Use {@link MMapContainerPropsImpl} instead
+ * @private
+ */
 type MMapReactContainerPropsImpl<TContext> = MMapContainerPropsImpl<TContext>;
-/** @deprecated Use MMapContainerProps instead */
+/**
+ * @deprecated Use {@link MMapContainerProps} instead
+ * @private
+ */
 type MMapReactContainerProps<TContext> = MMapContainerProps<TContext>;
-/** @deprecated Use MMapContainer instead */
+/**
+ * @deprecated Use {@link MMapContainer} instead
+ * @private
+ */
 declare class MMapReactContainer extends MMapContainer {
 }
 export { MMapReactContainer, MMapReactContainerPropsImpl, MMapReactContainerProps };

package/imperative/MMapScaleControl/index.d.ts

@@ -1,5 +1,11 @@
 import { MMapComplexEntity } from "../MMapEnities";
+/**
+ * Types of measurement units that scale control can display.
+ */
 export type UnitType = "imperial" | "metric" | "nautical";
+/**
+ * Properties for [[MMapScaleControl]]
+ */
 type MMapScaleControlProps = {
     /** Maximum width of scale line in pixels */
     maxWidth?: number;
@@ -11,6 +17,22 @@ declare const defaultProps: Readonly<{
     unit: "metric";
 }>;
 type DefaultProps = typeof defaultProps;
+/**
+ * A control that shows the map scale in different units of measurement.
+ * @example Add scale control to the lower left part of the map:
+ * ```js
+ * const scaleControl = new MMapScaleControl({});
+ * const controls = new MMapControls({position: 'bottom left'}, [scaleControl]);
+ * map.addChild(controls)
+ * ```
+ * Alternatively, you can show the integrated scale control on the map by `showScaleInCopyrights` props:
+ * ```js
+ * const map = new MMap(document.getElementById('map-root'), {
+ *   showScaleInCopyrights: true,
+ *   location: {center: [37.622504, 55.753215], zoom: 10}
+ * });
+ * ```
+ */
 declare class MMapScaleControl extends MMapComplexEntity<MMapScaleControlProps, DefaultProps> {
     static defaultProps: Readonly<{
         maxWidth: 74;

package/imperative/MMapTileDataSource/index.d.ts

@@ -3,7 +3,7 @@ import { MMapEntity } from "../MMapEnities";
 /**
  * MMapTileDataSource props
  */
-type MMapTileDataSourceProps = {
+interface MMapTileDataSourceProps {
     /** Data source id */
     id: string;
     /** Min and max zoom for tiles */
@@ -18,7 +18,7 @@ type MMapTileDataSourceProps = {
     raster?: RasterTileDataSourceDescription;
     /** Data source copyrights */
     copyrights?: string[];
-};
+}
 /**
  * Create map tile data source.
  *
@@ -50,7 +50,6 @@ type MMapTileDataSourceProps = {
  */
 declare class MMapTileDataSource extends MMapEntity<MMapTileDataSourceProps> {
     private _id;
-    private _unwatchVectorContext?;
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(props: Partial<MMapTileDataSourceProps>): void;

package/imperative/ThemeContext.d.ts

@@ -1,6 +1,12 @@
 import { Context } from "./Entities";
 /**
- * Sets map theme
+ * Map theme. Affects the colors of the map controls and background.
+ * ```typescript
+ * const map = new mappable.MMap({
+ *    location: {center: [55.751574, 37.573856], zoom: 9},
+ *    theme: 'dark'
+ * });
+ * ```
  */
 export type MMapTheme = "light" | "dark";
 export type MMapThemeContext = {

package/imperative/TypeContext.d.ts

@@ -0,0 +1,9 @@
+import { Context } from "./Entities";
+export type MMapType = string;
+export type MMapTypeContext = {
+    type?: MMapType;
+};
+/**
+ * Selects one of predefined map style modes optimized for particular use case.
+ */
+export declare const TypeContext: Context<MMapTypeContext>;

package/imperative/config.d.ts

@@ -1,11 +1,36 @@
+/**
+ * All possible apikeys for http-services.
+ */
 interface Apikeys {
     suggest?: string;
     router?: string;
     search?: string;
 }
+/**
+ * Configuration object for whole API.
+ * For example, it can be used to set experiments or apikeys.
+ * ```js
+ * mappable.getDefaultConfig().setApikeys({search: "YOUR_SEARCH_API_KEY"})`.
+ * ```
+ */
 export declare class Config {
     readonly description: string;
+    /**
+     * Set experiments for map.
+     */
     setExperiments(experiments: Record<string, boolean>): void;
+    /**
+     * Set apikeys for http-services.
+     * ```js
+     * mappable.getDefaultConfig().setApikeys({search: "YOUR_SEARCH_API_KEY"})`.
+     * ```
+     */
     setApikeys(apikeys: Apikeys): void;
 }
+/**
+ * Returns default config object.
+ * ```js
+ * mappable.getDefaultConfig().setApikeys({suggest: "YOUR_SUGGEST_API_KEY"})`.
+ * ```
+ */
 export declare function getDefaultConfig(): Config;

package/imperative/fetchConfig.d.ts

@@ -5,6 +5,8 @@ import { Config } from "./config";
 export type FetchConfigOptions = {
     /** Language */
     lang: string;
+    /** Data provider */
+    dataProvider?: string;
     /** Signal to abort request */
     signal?: AbortSignal;
 };
@@ -13,6 +15,6 @@ export type FetchConfigOptions = {
  *
  * @param {FetchConfigOptions} options Request options
  * @param {Config} config Current config
- * @returns {Promise<Config>} config for map construction
+ * @returns {Promise<Config>} Config for map construction
  */
 export declare function fetchConfig(options: FetchConfigOptions, config?: Config | undefined): Promise<Config>;

package/imperative/index.d.ts

@@ -1,6 +1,8 @@
-import * as projections_ from "./utils/projections";
+import * as projections_ from "./projections";
 export { MMap, MMapProps, MMapCenterLocation, MMapZoomLocation, MMapBoundsLocation, MMapCenterZoomLocation, MMapLocationRequest, MMapCameraRequest } from "./MMap";
 export { MMapThemeContext, ThemeContext, MMapTheme } from "./ThemeContext";
+export { MMapTypeContext, TypeContext, MMapType } from "./TypeContext";
+export { MMapContextProvider, MMapContextProviderProps } from "./MMapContextProvider";
 export { MMapCopyrightsPosition } from "./MMapCopyrights";
 export { MMapEntity, MMapComplexEntity, MMapGroupEntity, MMapContext } from "./MMapEnities";
 export { MMapDefaultFeaturesLayer, MMapDefaultFeaturesLayerProps } from "./MMapDefaultFeaturesLayer";

package/imperative/{utils/projections → projections}/web-mercator.d.ts

@@ -1,11 +1,9 @@
-import type { Projection, LngLat, WorldCoordinates } from "../../../common/types";
+import type { Projection, LngLat, WorldCoordinates } from "../../common/types";
 /**
- * @class Mercator projection onto a sphere.
- * Used by many mapping services, in particular OpenStreetMap.
- * @name projection.webMercator
- * @augments Projection
- * @static
- * @example
+ * @private
+ * Mercator projection onto a sphere.
+ * Used by many mapping services, in particular OpenStreetMap
+ *
  * ```js
  * // Create a map in the web Mercator projection
  * const map = new mappable.MMap(document.getElementById('MMapsID'), {

package/modules/layers-extra/MMapCarparksLayer.d.ts

@@ -0,0 +1,50 @@
+import { optionsKeyVuefy, MMapComplexEntity, MMapLayerProps } from "../../imperative";
+import type { CustomVuefyOptions } from "../vuefy";
+type MMapCarparksLayerType = "ground" | "icons";
+type MMapCarparksLayerProps = {
+    /** Should show layer. Default is true */
+    visible?: boolean;
+    /** Name for source */
+    source?: string;
+    /** Layers parameters */
+    layers?: Partial<Record<MMapCarparksLayerType, Partial<MMapLayerProps>>>;
+};
+declare const defaultProps: {
+    visible: boolean;
+    source: string;
+    updateTime: number;
+    layers: {
+        ground: {
+            zIndex: number;
+        };
+        icons: {
+            zIndex: number;
+        };
+    };
+};
+type DefaultProps = typeof defaultProps;
+declare class MMapCarparksLayer extends MMapComplexEntity<MMapCarparksLayerProps, DefaultProps> {
+    static defaultProps: {
+        visible: boolean;
+        source: string;
+        updateTime: number;
+        layers: {
+            ground: {
+                zIndex: number;
+            };
+            icons: {
+                zIndex: number;
+            };
+        };
+    };
+    static [optionsKeyVuefy]: CustomVuefyOptions<MMapCarparksLayer>;
+    private _coverageSubscription?;
+    private _unwatchThemeContext?;
+    private _dataSource?;
+    private _layers;
+    protected _onAttach(): void;
+    private _getTileDataSourceProps;
+    protected _onUpdate(): void;
+    protected _onDetach(): void;
+}
+export { MMapCarparksLayer, MMapCarparksLayerProps };

package/modules/layers-extra/MMapPanoramaLayer.d.ts

@@ -0,0 +1,52 @@
+import type { CustomVuefyOptions } from "../vuefy";
+import { optionsKeyVuefy } from "../../imperative/wrappers";
+import { MMapComplexEntity } from "../../imperative/MMapEnities";
+import { MMapLayerProps } from "../../imperative/MMapLayer";
+type MMapPanoramaLayerType = "ground" | "icons";
+type MMapPanoramaLayerProps = {
+    /** Should show layer. Default is true */
+    visible?: boolean;
+    /** Name for source */
+    source?: string;
+    /** Layers parameters */
+    layers?: Partial<Record<MMapPanoramaLayerType, Partial<MMapLayerProps>>>;
+};
+declare const defaultProps: {
+    visible: boolean;
+    source: string;
+    layers: {
+        ground: {
+            zIndex: number;
+        };
+        icons: {
+            zIndex: number;
+        };
+    };
+    updateTime: number;
+};
+type DefaultProps = typeof defaultProps;
+declare class MMapPanoramaLayer extends MMapComplexEntity<MMapPanoramaLayerProps, DefaultProps> {
+    static defaultProps: {
+        visible: boolean;
+        source: string;
+        layers: {
+            ground: {
+                zIndex: number;
+            };
+            icons: {
+                zIndex: number;
+            };
+        };
+        updateTime: number;
+    };
+    private _dataSource?;
+    private _layers;
+    private _coverageSubscription?;
+    private _unwatchThemeContext?;
+    static [optionsKeyVuefy]: CustomVuefyOptions<MMapPanoramaLayer>;
+    protected _onAttach(): void;
+    private _getTileDataSourceProps;
+    protected _onDetach(): void;
+    protected _onUpdate(): void;
+}
+export { MMapPanoramaLayer, MMapPanoramaLayerProps };

package/modules/layers-extra/MMapTrafficEventsLayer.d.ts

@@ -0,0 +1,58 @@
+import { MMapComplexEntity } from "../../imperative/MMapEnities";
+import { MMapLayerProps } from "../../imperative/MMapLayer";
+import type { CustomVuefyOptions } from "../vuefy";
+import { optionsKeyVuefy } from "../../imperative/wrappers";
+type MMapTrafficEventsLayerType = "ground" | "icons" | "labels";
+type MMapTrafficEventsLayerProps = {
+    /** Should show layer. Default is true */
+    visible?: boolean;
+    /** Name for source */
+    source?: string;
+    /** Layers parameters */
+    layers?: Partial<Record<MMapTrafficEventsLayerType, Partial<MMapLayerProps>>>;
+};
+declare const defaultProps: {
+    visible: boolean;
+    source: string;
+    updateTime: number;
+    layers: {
+        ground: {
+            zIndex: number;
+        };
+        icons: {
+            zIndex: number;
+        };
+        labels: {
+            zIndex: number;
+        };
+    };
+};
+type DefaultProps = typeof defaultProps;
+declare class MMapTrafficEventsLayer extends MMapComplexEntity<MMapTrafficEventsLayerProps, DefaultProps> {
+    static defaultProps: {
+        visible: boolean;
+        source: string;
+        updateTime: number;
+        layers: {
+            ground: {
+                zIndex: number;
+            };
+            icons: {
+                zIndex: number;
+            };
+            labels: {
+                zIndex: number;
+            };
+        };
+    };
+    private _dataSource?;
+    private _layers;
+    private _coverageSubscription?;
+    private _unwatchThemeContext?;
+    static [optionsKeyVuefy]: CustomVuefyOptions<MMapTrafficEventsLayer>;
+    protected _onAttach(): void;
+    private _getTileDataSourceProps;
+    protected _onUpdate(): void;
+    protected _onDetach(): void;
+}
+export { MMapTrafficEventsLayer, MMapTrafficEventsLayerProps };

package/modules/layers-extra/MMapTrafficLayer.d.ts

@@ -0,0 +1,36 @@
+import { MMapComplexEntity } from "../../imperative/MMapEnities";
+import type { CustomVuefyOptions } from "../vuefy";
+import { optionsKeyVuefy } from "../../imperative/wrappers";
+type MMapTrafficLayerProps = {
+    /** Should show layer. Default is true */
+    visible?: boolean;
+    /** Layer z-index */
+    zIndex?: number;
+    /** Name for source */
+    source?: string;
+};
+declare const defaultProps: Readonly<{
+    visible: true;
+    source: "mappable-traffic-layer";
+    zIndex: 1000;
+    updateTime: number;
+}>;
+type DefaultProps = typeof defaultProps;
+declare class MMapTrafficLayer extends MMapComplexEntity<MMapTrafficLayerProps, DefaultProps> {
+    static defaultProps: Readonly<{
+        visible: true;
+        source: "mappable-traffic-layer";
+        zIndex: 1000;
+        updateTime: number;
+    }>;
+    private _dataSource?;
+    private _layer?;
+    private _coverageSubscription?;
+    private _unwatchThemeContext?;
+    static [optionsKeyVuefy]: CustomVuefyOptions<MMapTrafficLayer>;
+    protected _onAttach(): void;
+    private _getTileDataSourceProps;
+    protected _onUpdate(props: Partial<MMapTrafficLayerProps>): void;
+    protected _onDetach(): void;
+}
+export { MMapTrafficLayer, MMapTrafficLayerProps };

package/modules/layers-extra/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./MMapTrafficLayer";
+export * from "./MMapTrafficEventsLayer";
+export * from "./MMapCarparksLayer";
+export * from "./MMapPanoramaLayer";

package/modules/layers-extra/utils.d.ts

@@ -0,0 +1 @@
+export declare function transformUrlTemplate(urlTemplate: string, locale: string, version?: string): string;

package/modules/ruler/EventsBlockerLayer.d.ts

@@ -0,0 +1,10 @@
+import { MMapComplexEntity } from "../../imperative/MMapEnities";
+type EventBlockerLayerProps = {
+    zIndex: number;
+};
+declare class EventBlockerLayer extends MMapComplexEntity<EventBlockerLayerProps> {
+    private _layer;
+    constructor(props: EventBlockerLayerProps);
+    protected _onUpdate(props: Partial<EventBlockerLayerProps>): void;
+}
+export { EventBlockerLayer, EventBlockerLayerProps };

package/modules/ruler/MMapRuler.d.ts

@@ -0,0 +1,66 @@
+import { MMapComplexEntity, MMapEntity } from "../../imperative";
+import { optionsKeyVuefy, overrideKeyReactify, overrideKeyVuefy } from "../../imperative/wrappers";
+import { RenderPointCommonArgs, MMapRulerCommon, MMapRulerCommonProps } from "./MMapRulerCommon";
+export type MMapRulerProps = Omit<MMapRulerCommonProps, "point"> & {
+    point: (params: RenderPointArgs) => MMapEntity<RenderPointArgs>;
+};
+export type RenderPointArgs = RenderPointCommonArgs;
+declare const defaultProps: Readonly<{}>;
+export declare class MMapRuler extends MMapComplexEntity<MMapRulerProps, typeof defaultProps> {
+    static defaultProps: Readonly<{}>;
+    static [optionsKeyVuefy]: import("../vuefy").CustomVuefyOptions<MMapRulerCommon, {
+        type: import("./MMapRulerCommon").RulerType;
+        source?: string | undefined;
+        geometry: import("./MMapRulerCommon").RulerGeometry;
+        zIndex?: number | undefined;
+        onUpdate?: import("./MMapRulerCommon").UpdateCommonFn | undefined;
+        points: import("../../common/types/lng-lat").LngLat[];
+        editable?: boolean | undefined;
+        onUpdateStart?: import("./MMapRulerCommon").UpdateStartFn | undefined;
+        onUpdateEnd?: import("./MMapRulerCommon").UpdateEndFn | undefined;
+    }>;
+    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapRulerCommon, import("react").ForwardRefExoticComponent<{
+        type: import("./MMapRulerCommon").RulerType;
+        source?: string | undefined;
+        geometry: import("./MMapRulerCommon").RulerGeometry;
+        zIndex?: number | undefined;
+        onUpdate?: import("./MMapRulerCommon").UpdateCommonFn | undefined;
+        points: import("../../common/types/lng-lat").LngLat[];
+        editable?: boolean | undefined;
+        onUpdateStart?: import("./MMapRulerCommon").UpdateStartFn | undefined;
+        onUpdateEnd?: import("./MMapRulerCommon").UpdateEndFn | undefined;
+        point: (params: RenderPointCommonArgs) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+        previewPoint: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+        ref?: import("react").Ref<MMapEntity<{
+            type: import("./MMapRulerCommon").RulerType;
+            source?: string | undefined;
+            geometry: import("./MMapRulerCommon").RulerGeometry;
+            zIndex?: number | undefined;
+            onUpdate?: import("./MMapRulerCommon").UpdateCommonFn | undefined;
+            points: import("../../common/types/lng-lat").LngLat[];
+            editable?: boolean | undefined;
+            onUpdateStart?: import("./MMapRulerCommon").UpdateStartFn | undefined;
+            onUpdateEnd?: import("./MMapRulerCommon").UpdateEndFn | undefined;
+            point: (params: RenderPointCommonArgs) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+            previewPoint: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+        }, {}>> | undefined;
+        key?: import("react").Key | null | undefined;
+    }>>;
+    static [overrideKeyVuefy]: import("../vuefy").CustomVuefyFn<MMapRulerCommon, {
+        type: import("./MMapRulerCommon").RulerType;
+        source?: string | undefined;
+        geometry: import("./MMapRulerCommon").RulerGeometry;
+        zIndex?: number | undefined;
+        onUpdate?: import("./MMapRulerCommon").UpdateCommonFn | undefined;
+        points: import("../../common/types/lng-lat").LngLat[];
+        editable?: boolean | undefined;
+        onUpdateStart?: import("./MMapRulerCommon").UpdateStartFn | undefined;
+        onUpdateEnd?: import("./MMapRulerCommon").UpdateEndFn | undefined;
+    }>;
+    private _rulerCommon;
+    private _previewPointWrapper;
+    constructor(props: MMapRulerProps);
+    protected _onUpdate(): void;
+    private _renderPoints;
+}
+export {};