@mappable-world/mappable-types 0.0.20 → 0.0.22

package/common/types/bounds.d.ts

@@ -8,10 +8,10 @@ export type GenericBounds<T> = [
     T
 ];
 /**
- * Rectangle bounded by bottom-left and top-right coordinates
+ * Rectangle bounded by top-left and bottom-right coordinates
  */
 export type LngLatBounds = GenericBounds<LngLat>;
 /**
- * Rectangle bounded by bottom-left and top-right world coordinates
+ * Rectangle bounded by top-left and bottom-right world coordinates
  */
 export type WorldBounds = GenericBounds<WorldCoordinates>;

package/common/types/data-source-description.d.ts

@@ -122,11 +122,19 @@ interface VectorTileDataSourceDescription {
     meshRequestWithCredentials?: boolean;
     glyphRequestWithCredentials?: boolean;
     richModelRequestWithCredentials?: boolean;
+    indoorPlanRequestWithCredentials?: boolean;
+    styleRequestWithCredentials?: boolean;
+    fontListRequestWithCredentials?: boolean;
+    fontObjectRequestWithCredentials?: boolean;
     tileRequestHeaders?: Record<string, string>;
     iconRequestHeaders?: Record<string, string>;
     glyphRequestHeaders?: Record<string, string>;
     meshRequestHeaders?: Record<string, string>;
     richModelRequestHeaders?: Record<string, string>;
+    indoorPlanRequestHeaders?: Record<string, string>;
+    styleRequestHeaders?: Record<string, string>;
+    fontListRequestHeaders?: Record<string, string>;
+    fontObjectRequestHeaders?: Record<string, string>;
     priority: VectorDataSourcePriority;
     collisionPriority?: VectorObjectsCollisionPriority;
     requestTileSize?: VectorTileSize;

package/common/types/layer-implementation.d.ts

@@ -15,7 +15,9 @@ interface LayerImplementationRenderProps {
     size: PixelCoordinates;
 }
 interface RasterLayerImplementationRenderProps extends LayerImplementationRenderProps {
-    camera: Camera;
+    camera: Camera & {
+        fov: number;
+    };
     worlds: WorldOffset[];
 }
 interface RasterLayerImplementation {
@@ -39,7 +41,9 @@ interface RasterLayerImplementationConstructor {
     new (props: RasterLayerImplementationConstructorProps): RasterLayerImplementation;
 }
 interface VectorLayerImplementationRenderProps extends LayerImplementationRenderProps {
-    camera: Camera;
+    camera: Camera & {
+        fov: number;
+    };
     worlds: {
         lookAt: Vec2;
         viewProjMatrix: Matrix4;

package/imperative/DomContext.d.ts

@@ -18,8 +18,8 @@ export declare function createDomContext(containerEntity: GenericComplexEntity<u
 /**
  * Hook for providing DOM context in entity
  * @param entity - Entity to provide the DomContext
- * @param element - Dom element that is passed to DomContext
- * @param container - Inner DOM element that is passed to the DOMContext
+ * @param element - DOM element to attach
+ * @param container - DOM element to provide to descendants in new DomContext
  * @returns Function that detaches the DOM element and DomContext from the entity
  */
 export declare function useDomContext(entity: GenericComplexEntity<unknown>, element: Element, container: Element | null): DomDetach;

package/imperative/Entities.d.ts

@@ -9,6 +9,7 @@ declare class ContextProvider<T> {
     consume(): T | undefined;
     provide(nextContext: T): void;
 }
+export declare const __implEntityKeepOldPropValue: {};
 type WithDefaults<Props, DefaultProps extends Partial<Props>> = Props & {
     [K in keyof DefaultProps]: K extends keyof Props ? NonNullable<Props[K]> : never;
 };

package/imperative/MMap/index.d.ts

@@ -6,29 +6,51 @@ import { Config } from "../config";
 import { MMapTheme } from "../ThemeContext";
 import { overrideKeyReactify } from "../wrappers";
 /**
- * Sets map center.
+ * Sets map center. In this case, the zoom of the map remains unchanged.
+ * ```javascript
+ * map.update({
+ *   location: {center: [-0.118092, 51.509865]}
+ * });
+ * ```
  */
 export type MMapCenterLocation = {
     center: LngLat;
 };
 /**
- * Sets map zoom.
+ * Sets map zoom. In this case, the center of the map remains unchanged.
+ * ```javascript
+ * map.update({
+ *    location: {zoom: 10}
+ * });
+ * ```
  */
 export type MMapZoomLocation = {
     zoom: number;
 };
 /**
- * Sets map bounds.
+ * Calculate the center and zoom by specifying the coordinates of the top left and bottom right corners of the map.
+ * In this case, the center of the map will be in the center of the rectangle described at the given coordinates.
+ * If the map have an aspect ratio different from this rectangle, the rectangle will be inscribed in height and the map will be centered in width.
+ * ```javascript
+ * map.update({
+ *     location: {bounds: [[-0.118092, 51.509865], [-0.118092, 51.509865]]}
+ * });
+ * ```
  */
 export type MMapBoundsLocation = {
     bounds: LngLatBounds;
 };
 /**
  * Sets map center and zoom. Combination of MMapCenterLocation and MMapZoomLocation
+ * ```javascript
+ * map.update({
+ *  location: {center: [-0.118092, 51.509865], zoom: 10}
+ * });
+ * ```
  */
 export type MMapCenterZoomLocation = MMapCenterLocation & MMapZoomLocation;
 /**
- * Sets map center and zoom or bounds. Combination of @mixes MMapZoomLocation and MMapBoundsLocation
+ * Union type for describing the position of the map through the center and zoom or through the bounds of the map
  */
 export type MMapLocation = MMapCenterZoomLocation & Partial<MMapBoundsLocation>;
 /**
@@ -41,7 +63,27 @@ export type MMapCamera = {
     azimuth?: number;
 };
 /**
- * Describes how to change current map location. Change can be instantenious or animated if duration property is set.
+ * Describes how to change current map location. Change can be instantaneous or animated if duration property is set.
+ * ```javascript
+ * map.update({
+ *  location: {
+ *      center: [-0.118092, 51.509865], // Center of the map
+ *      zoom: 10, // Zoom level
+ *      duration: 200, // Animation of moving map will take 200 milliseconds
+ *      easing: 'ease-in-out' // Animation easing function
+ *  }
+ * });
+ * ```
+ * or just change center of the map
+ * ```javascript
+ * map.update({
+ *  location: {
+ *     center: [-0.118092, 51.509865], // Center of the map
+ *     duration: 200, // Animation of moving map will take 200 milliseconds
+ *     easing: 'linear' // Animation easing function
+ *  }
+ * })';
+ * ```
  */
 export type MMapLocationRequest = (MMapBoundsLocation | MMapCenterLocation | MMapZoomLocation | MMapCenterZoomLocation) & {
     /** Animation duration */
@@ -49,6 +91,17 @@ export type MMapLocationRequest = (MMapBoundsLocation | MMapCenterLocation | MMa
     /** Animation easing function */
     easing?: EasingFunctionDescription;
 };
+/**
+ * Describes how to change current camera position. Change can be instantaneous or animated if duration property is set.
+ * ```javascript
+ * map.update({camera: {
+ *      tilt: 45 * (Math.PI / 180), // 45 degrees
+ *      azimuth: 30 * (Math.PI / 180) // 30 degrees
+ *      duration: 200, // Animation of moving camera will take 200 milliseconds
+ *      easing: 'ease-in-out'
+ *  }});
+ * ```
+ */
 export type MMapCameraRequest = MMapCamera & {
     /** Animation duration */
     duration?: number;
@@ -56,7 +109,24 @@ export type MMapCameraRequest = MMapCamera & {
     easing?: EasingFunctionDescription;
 };
 /**
- * MMap props
+ * Map settings. Allow to set map mode, behaviors, margin, zoom rounding, zoom range, restrict map area, theme and other settings.
+ * ```javascript
+ * const map = new MMap(document.getElementById('map-root'), {
+ *    className: 'custom-map',
+ *    location: {center: [-0.118092, 51.509865], zoom: 10},
+ *    camera: {tilt: 45 * (Math.PI / 180), azimuth: 30 * (Math.PI / 180)}
+ *    mode: 'raster',
+ *    behaviors: ['drag', 'scrollZoom', 'dblClick', 'mouseRotate', 'mouseTilt'],
+ *    margin: [0, 100, 0, 0],
+ *    theme: 'light'
+ * });
+ * ```
+ * But required only `location` prop.
+ * ```javascript
+ * const map = new MMap(document.getElementById('map-root'), {
+ *   location: {center: [-0.118092, 51.509865], zoom: 10}
+ * });
+ * ```
  */
 export type MMapProps = {
     /** Map container css class name */
@@ -131,7 +201,7 @@ type DefaultProps = typeof defaultProps;
  * ```javascript
  * const map = new MMap(
  *     document.getElementById('map-root'),
- *     {location: {center: [37.622504, 55.753215], zoom: 10}}
+ *     {location: {center: [-0.118092, 51.509865], zoom: 10}}
  * );
  * // add default Mappable scheme layer
  * map.addChild(new MMapDefaultSchemeLayer());
@@ -200,8 +270,8 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
     private __abortVectorLoad?;
     private _layers;
     private _copyrights;
-    private _coverage;
     private _isDestroyed;
+    private _isVectorLoading;
     constructor(rootContainer: HTMLElement, props: MMapProps, children?: MMapEntity<unknown>[]);
     readonly children: MMapEntity<unknown>[];
     addChild(child: MMapEntity<unknown>, index?: number): this;

package/imperative/MMap/projection.d.ts

@@ -1,2 +1,2 @@
-import { WebMercator } from "../utils/projections/web-mercator";
+import { WebMercator } from "../projections/web-mercator";
 export declare const projection: WebMercator;

package/imperative/MMapCollection/index.d.ts

@@ -1,3 +1,21 @@
 import { MMapGroupEntity } from "../MMapEnities";
+/**
+ * MMapCollection is a collection of MMapEntity objects.
+ * Allow adding or removing [[MMapEntity]] objects.
+ * ```typescript
+ * const collection = new MMapCollection({});
+ * const markerElement = document.createElement('div');
+ * markerElement.className = 'marker';
+ *
+ * for (let i = 0; i < 10_000; i++) {
+ *  collection.addChild(new MMapMarker({
+ *    coordinates: [Math.random() * 180, Math.random() * 180]
+ *  }, markerElement.cloneNode(true)));
+ * }
+ *
+ * map.addChild(collection); // Add collection to the map
+ * map.removeChild(collection); // Remove all markers from the map
+ * ```
+ */
 export declare class MMapCollection extends MMapGroupEntity<{}> {
 }

package/imperative/MMapContainer/index.d.ts

@@ -17,6 +17,20 @@ declare const defaultProps: {
 };
 type DefaultProps = typeof defaultProps;
 type ComputedMMapContainerProps<TContext> = MMapContainerProps<TContext> & MMapContainerPropsImpl<TContext>;
+/**
+ * Allow adding or removing [[MMapEntity]] objects or usual DOM elements inside the MMap.
+ * ```tsx
+ * const container = <MMapContainer>
+ *     <MMapMarker coordinates={[55.76, 37.64]}><div className="point"></div></MMapMarker>
+ *     <div>Some text</div>
+ * </MMapContainer>;
+ *
+ * ReactDOM.render(<MMap>{container}</MMap, document.getElementById('root'));
+ * ```
+ * In this example, the `container` variable contains a `MMapContainer` object with two children: `MMapMarker` and `div`.
+ * - `MMapMarker` is a MMapEntity
+ * - `div` is a usual DOM element
+ */
 declare class MMapContainer extends MMapGroupEntity<ComputedMMapContainerProps<unknown>, DefaultProps> {
     static defaultProps: {
         tagName: string;

package/imperative/MMapContextProvider/index.d.ts

@@ -0,0 +1,50 @@
+import { MMapGroupEntity } from "../MMapEnities";
+import type { Context } from "../Entities";
+/**
+ * MMapContextProvider props
+ */
+export type MMapContextProviderProps<T> = {
+    /** Context that will receive the provided value */
+    context: Context<T>;
+    /** Value to be provided in the context. */
+    value: T;
+};
+/**
+ * Context provider for MMap, allowing to inject a context and its value.
+ *
+ * ```javascript
+ * const mapContextProvider = new MMapContextProvider({context: SomeMapContext, value: {your: 'value'}});
+ * map.addChild(mapContextProvider);
+ * ```
+ * And define context consumer:
+ * ```ts
+ * class SomeContextConsumer extends mappable.MMapEntity<{}> {
+ *    constructor() {
+ *        super({});
+ *    }
+ *
+ *    _onAttach() {
+ *      const value = this._consumeContext(SomeMapContext);
+ *      console.log(value); // {your: 'value'}
+ *    }
+ * }
+ * ```
+ * When adding nested containers, the context will be available in them:
+ * ```ts
+ * mapContextProvider.addChild(new SomeContextConsumer());
+ * ```
+ * But the most important thing is that the context can be passed at any nesting level:
+ * ```tsx
+ * <MMapContextProvider context={SomeMapContext} value={{your: 'value'}}>
+ *     <MMapContainer>
+ *         <MMapContainer>
+ *             <SomeContextConsumer />
+ *         <MMapContainer>
+ *     </MMapContainer>
+ * </MMapContextProvider>
+ * ```
+ */
+export declare class MMapContextProvider<T> extends MMapGroupEntity<MMapContextProviderProps<T>> {
+    protected _onAttach(): void;
+    protected _onUpdate({ value }: Partial<MMapContextProviderProps<T>>): void;
+}

package/imperative/MMapControl/MMapControl.d.ts

@@ -50,9 +50,10 @@ export declare class MMapControl extends MMapGroupEntity<MMapControlProps, Defau
         key?: import("react").Key | null | undefined;
     }>>;
     private _element?;
+    private _innerElement?;
     private _detachDom?;
     private _unwatchThemeContext?;
-    constructor(props?: MMapControlProps);
+    constructor(props?: MMapControlProps, element?: HTMLElement);
     protected _createDom(): HTMLElement;
     protected _onAttach(): void;
     protected _onUpdate(props: Partial<MMapControlProps>): void;

package/imperative/MMapControl/MMapControlButton.d.ts

@@ -1,7 +1,18 @@
 import { MMapComplexEntity, MMapGroupEntity } from "../MMapEnities";
 import { overrideKeyReactify } from "../wrappers";
 /**
- * MMapControlButton props
+ * Properties for [[MMapControlCommonButton]]
+ * ```typescript
+ * const button = new MMapControlCommonButton({
+ *   text: 'Click me!',
+ *   disabled: false,
+ *   color: 'black',
+ *   background: 'white',
+ *   onClick: () => {
+ *      console.log('Button clicked');
+ *   }
+ * });
+ * ```
  */
 export type MMapControlCommonButtonProps = {
     /** On click handler */
@@ -20,7 +31,19 @@ export type MMapControlCommonButtonProps = {
 export type MMapControlButtonProps = MMapControlCommonButtonProps;
 /** @module MMapControlButton */
 /**
- * Default control button.
+ * Default control button. Can be used as a base for custom controls.
+ * ```javascript
+ * const map = new mappable.MMap(document.getElementById('map-root'), {...});
+ * const controls = new mappable.MMapControls({position: 'bottom right'});
+ * const button = new mappable.MMapControlCommonButton({
+ *    text: 'Click me!',
+ *    onClick: () => {
+ *      console.log('Button clicked');
+ *    }
+ * });
+ * controls.addChild(button);
+ * ```
+ * More about controls: [Mappable Maps API controls](https://mappable.world/docs/js-api/dg/concepts/controls/index.html)
  */
 export declare class MMapControlCommonButton extends MMapGroupEntity<MMapControlCommonButtonProps> {
     private _element?;
@@ -48,7 +71,7 @@ export declare class MMapControlCommonButton extends MMapGroupEntity<MMapControl
  * map.addChild(controls);
  * ```
  *
- * @see https://mappable.world/docs/jsapi/dg/concepts/controls/about.html
+ * @see <https://mappable.world/docs/js-api/dg/concepts/controls/index.html>
  */
 export declare class MMapControlButton extends MMapComplexEntity<MMapControlButtonProps> {
     static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapControlButton, import("react").ForwardRefExoticComponent<{

package/imperative/MMapControls/index.d.ts

@@ -49,7 +49,7 @@ export declare class MMapControls extends MMapGroupEntity<MMapControlsProps> {
     private _detachDom?;
     constructor(props: MMapControlsProps, children?: MMapEntity<unknown>[]);
     protected _onAttach(): void;
-    protected _onUpdate(): void;
+    protected _onUpdate(diffProps: Partial<MMapControlsProps>): void;
     protected _onDetach(): void;
 }
 export {};

package/imperative/MMapCopyrights/index.d.ts

@@ -1,4 +1,13 @@
 import { MMapGroupEntity } from "../MMapEnities";
+/**
+ * Copyrights position on the map container. By default, 'bottom right'.
+ * For example, 'top left' or 'bottom right'
+ * ```javascript
+ * const map = new mappable.MMap(document.getElementById('map-root'), {
+ *  copyrightsPosition: 'top left'
+ * });
+ * ```
+ */
 type MMapCopyrightsPosition = "top left" | "top right" | "bottom left" | "bottom right";
 type MMapCopyrightsProps = {
     /** Position of copyright on the map */
@@ -20,35 +29,25 @@ declare class MMapCopyrights extends MMapGroupEntity<MMapCopyrightsProps, Defaul
         position: MMapCopyrightsPosition;
         showScale: false;
     }>;
-    private _boxElement;
+    private _containerElement;
     private _copyrightsTextElement;
-    private _linkElement;
+    private _agreementLinkElement;
     private _logoElement;
     private _copyrightsContainer;
     private _scaleElement;
     private _scaleControl;
-    private _mapWidth;
     private _copyrights;
-    private _fixedCopyrights;
-    private _userAgreementText;
-    private _userAgreementState;
-    private _unwatchMapContext?;
-    private _unwatchThemeContext?;
     private _detachDom?;
     constructor(props?: MMapCopyrightsProps);
     protected _onAttach(): void;
     protected _onUpdate(props: Partial<MMapCopyrightsProps>): void;
     protected _onDetach(): void;
     private _createDom;
-    private _syncDom;
-    private _syncMapWidth;
+    private _render;
     private _syncTheme;
-    private _setUserAgreementText;
-    private _setUserAgreementState;
-    private _setCopyrights;
-    private _setFixedCopyrights;
-    private _copyrightsChangeHandler;
-    private _adjustText;
+    private _applyCopyrights;
+    private _computeMaxWidth;
+    private _rearrange;
     private _toggleScaleControl;
 }
 export { MMapCopyrights, MMapCopyrightsPosition, MMapCopyrightsProps };

package/imperative/MMapDefaultSchemeLayer/index.d.ts

@@ -1,6 +1,16 @@
 import type { VectorCustomization } from "../../common/types";
 import { MMapLayerProps } from "../MMapLayer";
 import { MMapComplexEntity } from "../MMapEnities";
+/**
+ * Types of underlay layers available in the default scheme.
+ * Each layer is displayed on the map according to its zIndex.
+ * By default, layers are displayed in the following order:
+ * 1. ground
+ * 2. buildings
+ * 3. icons
+ * 4. labels
+ * @see https://mappable.world/docs/js-api/dg/concepts/general.html#source-prepared
+ */
 type MMapDefaultSchemeLayerType = "ground" | "buildings" | "icons" | "labels";
 /**
  * MMapDefaultSchemeLayer props
@@ -22,6 +32,18 @@ type MMapDefaultSchemeLayerProps = {
     source?: string;
     /** Layers parameters */
     layers?: Partial<Record<MMapDefaultSchemeLayerType, Partial<MMapLayerProps>>>;
+    /**
+         * Allow to clamp map zoom. If you want the layer to not lock zoom when it reaches
+         * its maximum value, you can set this field to false.
+         * This may be necessary, for example, when your own layers are working at scales greater than 21.
+         * ```js
+         * const defaultSchemeLayer = new MMapDefaultSchemeLayer({clampMapZoom: false});
+         * map.addChild(defaultSchemeLayer);
+         * ```
+         * See example https://mappable.world/docs/js-api/examples/cases/over-zoom.html
+         * @default true
+         */
+    clampMapZoom?: boolean;
 };
 declare const defaultProps: {
     visible: boolean;
@@ -45,8 +67,15 @@ declare const defaultProps: {
         type: string;
         zIndex: number;
     }>;
+    clampMapZoom: boolean;
 };
 type DefaultProps = typeof defaultProps;
+declare const MAP_TYPES: {
+    map: string;
+    admin: string;
+    driving: string;
+    transit: string;
+};
 /**
  * Map default layer to show mappable-world scheme on map.
  *
@@ -82,15 +111,17 @@ declare class MMapDefaultSchemeLayer extends MMapComplexEntity<MMapDefaultScheme
             type: string;
             zIndex: number;
         }>;
+        clampMapZoom: boolean;
     };
     private _dataSource?;
     private _layers;
     private _unwatchMapContext?;
     private _unwatchThemeContext?;
+    private _coverageSubscription?;
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(propsDiff: Partial<MMapDefaultSchemeLayerProps>): void;
-    private _getDataSourceDescription;
+    private _getTileDataSourceProps;
     private _updateTheme;
 }
-export { MMapDefaultSchemeLayer, MMapDefaultSchemeLayerProps };
+export { MMapDefaultSchemeLayer, MMapDefaultSchemeLayerProps, MAP_TYPES };

package/imperative/MMapEnities.d.ts

@@ -91,4 +91,51 @@ declare abstract class MMapGroupEntity<Props, DefaultProps extends {} = {}> exte
     addChild(child: MMapEntity<unknown>, index?: number): this;
     removeChild(child: MMapEntity<unknown>): this;
 }
-export { MMapEntity, MMapComplexEntity, MMapGroupEntity, Context as MMapContext };
+/**
+ * Context for MMap. It allows you to provide a value to the context and use it in the children of the context provider.
+ * ```ts
+ * const MMapSomeContext = new mappable.MMapContext('MMapSomeContext');
+ * class SomeValueProvider extends mappable.MMapGroupEntity<{}> {
+ *  constructor() {
+ *     super({});
+ *     this._provideContext(MMapSomeContext, {your: 'value'}); // Special method to provide context value
+ *  }
+ * }
+ * ```
+ * And some child entity can use this context:
+ * ```ts
+ * class SomeContextConsumer extends mappable.MMapEntity<{}> {
+ *    constructor() {
+ *        super({});
+ *    }
+ *
+ *    _onAttach() {
+ *      const value = this._consumeContext(MMapSomeContext); // Special method to get context value
+ *      console.log(value); // {your: 'value'}
+ *    }
+ * }
+ * ```
+ * In any level of nesting:
+ * ```tsx
+ * <SomeValueProvider>
+ *     <MMapContainer>
+ *          <MMapContainer>
+ *              <SomeContextConsumer />
+ *          </MMapContainer>
+ *     </MMapContainer>
+ * </SomeEntity>
+ * ```
+ * You can set the context value using [[MMapContextProvider]]:
+ * ```tsx
+ * <MMapContextProvider context={MMapSomeContext} value={{your: 'value'}}>
+ *     <MMapContainer>
+ *          <MMapContainer>
+ *              <SomeContextConsumer />
+ *          </MMapContainer>
+ *     </MMapContainer>
+ * </SomeEntity>
+ * ```
+ */
+declare class MMapContext<T> extends Context<T> {
+}
+export { MMapEntity, MMapComplexEntity, MMapGroupEntity, MMapContext };

package/imperative/MMapFeature/index.d.ts

@@ -23,9 +23,10 @@ type DefaultProps = typeof defaultProps & {
     id: string;
 };
 /**
- * The feature component on the map.
+ * Component for creating a geo object on the map.
+ * Supports drag-and-drop functionality, drawing styles, and event handling.
+ * Supported geometries: `Point`, `LineString`, `MultiLineString`, `Polygon` and `MultiPolygon`.
  *
- * @example
  * ```javascript
  * const feature = new MMapFeature({
  *     geometry: {
@@ -43,6 +44,19 @@ type DefaultProps = typeof defaultProps & {
  *     .addChild(new MMapDefaultFeaturesLayer())
  *     .addChild(feature);
  * ```
+ * You can add Point geometry with HTMLElement:
+ * ```javascript
+ * const feature = new MMapFeature({
+ *    geometry: {
+ *      type: 'Point',
+ *      coordinates: [37.40108963847453, 55.70173382087952]
+ *    },
+ *    style: {
+ *      element: document.createElement('div')
+ *    }
+ * });
+ * ```
+ * But better to use [[MMapMarker]] for this.
  */
 declare class MMapFeature extends MMapEntity<MMapFeatureProps, DefaultProps> {
     static defaultProps: Readonly<{
@@ -58,15 +72,13 @@ declare class MMapFeature extends MMapEntity<MMapFeatureProps, DefaultProps> {
     get geometry(): GenericGeometry<LngLat>;
     protected _onAttach(): void;
     protected _onDetach(): void;
-    protected _onUpdate({ id, source }: Partial<MMapFeatureProps>): void;
+    protected _onUpdate({ id, source, geometry }: Partial<MMapFeatureProps>): void;
     protected _getDefaultProps(): DefaultProps;
-    private __onDragStart;
-    private __onDragMove;
-    private __onDragEnd;
-    private __onClick;
-    private __onDoubleClick;
-    private __onFastClick;
-    private __isMySomeObject;
-    private __isMyDraggableObject;
+    private static _onDragStart;
+    private static _onDragMove;
+    private static _onDragEnd;
+    private static _onClick;
+    private static _onFastClick;
+    private static _onDoubleClick;
 }
 export { MMapFeature, MMapFeatureProps };