@mappable-world/mappable-types 0.0.1

package/imperative/Entities.d.ts

@@ -0,0 +1,120 @@
+type ContextWatcherFn = () => void;
+declare class Context<_T> {
+    readonly name: string;
+    constructor(name: string);
+}
+declare class ContextProvider<T> {
+    private _context?;
+    watchers: Set<ContextWatcherFn>;
+    consume(): T | undefined;
+    provide(nextContext: T): void;
+}
+/** @internal */
+export interface __ImplEntity {
+    __implUpdateProps(props: unknown): void;
+    __implAttach(): void;
+    __implDetach(): void;
+    __implAttachTo?(parent: GenericComplexEntity<unknown> | null): void;
+    readonly children?: ReadonlyArray<GenericEntity<unknown>>;
+    readonly __implChildren?: ReadonlyArray<GenericEntity<unknown>>;
+    readonly __implParent: GenericComplexEntity<unknown> | null;
+    __implNotifyDomContextOnDescendantMoved: boolean;
+    addChild(child: GenericEntity<unknown>, before?: GenericEntity<unknown>): this;
+    removeChild(child: GenericEntity<unknown>): this;
+    _consumeContext<T>(consumer: Context<T>): T | undefined;
+    _provideContext<T>(consumer: Context<T>, ctx: T): void;
+}
+/** @internal */
+export declare const __implHooks: {
+    DomContextOnDescendantMoved?: (entity: GenericComplexEntity<unknown>, descendant: GenericEntity<unknown>) => void;
+};
+type WithDefaults<Props, DefaultProps extends Partial<Props>> = Props & {
+    [K in keyof DefaultProps]: K extends keyof Props ? NonNullable<Props[K]> : never;
+};
+/** @internal */
+declare abstract class GenericEntity<Props, DefaultProps extends {} = {}, Root extends GenericRootEntity<unknown> = GenericRootEntity<unknown>> {
+    protected _props: WithDefaults<Props, DefaultProps>;
+    private __implRoot;
+    private __implParent;
+    protected __implProxyParent: GenericComplexEntity<unknown> | null;
+    protected __implNotifyDomContextOnDescendantMoved: boolean;
+    private __implCtxMap?;
+    private __implCtxWatchers?;
+    /**
+         * @internal
+         * @param {Props} props
+         * @param {DefaultProps} defaultProps
+         */
+    constructor(props: Props);
+    protected __implGetDefaultProps(_props: Props): DefaultProps | undefined;
+    destroy?(): void;
+    update(changedProps: Partial<Props>): void;
+    private __implUpdateProps;
+    protected _onAttach?(): void;
+    protected _onDetach?(): void;
+    protected _onUpdate?(props: Partial<Props>, oldProps: Props): void;
+    protected __implAttachExtra(): void;
+    protected __implDetachExtra(): void;
+    protected __implAttachTo?(parent: GenericComplexEntity<unknown> | null): void;
+    get parent(): GenericComplexEntity<unknown> | null;
+    get root(): Root | null;
+    private __implFindRoot;
+    private __implAttach;
+    private __implDetach;
+    protected _provideContext<T>(consumer: Context<T>, ctx: T): void;
+    private __implGetContextProvider;
+    protected _consumeContext<T>(consumer: Context<T>): T | undefined;
+    /**
+         * Subscribes to changes in a context.
+         * @param context
+         * @param watcher
+         * @param params
+         * @param params.immediate Calls watcher immediately. For most handlers it allows to inline watcher function.
+         * @returns Function to unsubscribe from changes context.
+         * For most handlers it can be, because it is called automatically on detach.
+         * @internal
+         */
+    protected _watchContext<T>(context: Context<T>, watcher: ContextWatcherFn, params?: {
+        immediate: boolean;
+    }): () => void;
+    protected __implReposition(): void;
+}
+interface ComplexOptions<Root extends GenericRootEntity<unknown> = GenericRootEntity<unknown>> {
+    children?: GenericEntity<unknown, {}, Root>[];
+    container?: boolean;
+}
+/** @internal */
+declare class GenericComplexEntity<Props, DefaultProps extends {} = {}, Root extends GenericRootEntity<unknown> = GenericRootEntity<unknown>> extends GenericEntity<Props, DefaultProps, Root> {
+    private __implChildren;
+    protected readonly children: readonly GenericEntity<unknown, {}, Root>[];
+    protected readonly _childContainer: GenericComplexEntity<unknown, {}, Root>;
+    constructor(props: Props, options?: ComplexOptions<Root>);
+    protected __makeProxyContainer(): GenericComplexEntity<unknown, {}, Root>;
+    /**
+         * Adds a child directly to __implChildren, without _childContainer
+         */
+    protected _addDirectChild(child: GenericEntity<unknown, {}, Root>, index?: number): void;
+    protected addChild(child: GenericEntity<unknown, {}, Root>, index?: number): this;
+    protected _removeDirectChild(child: GenericEntity<unknown, {}, Root>): void;
+    protected removeChild(child: GenericEntity<unknown, {}, Root>): this;
+    protected __implAttachExtra(): void;
+    protected __implDetachExtra(): void;
+}
+/** @internal */
+declare class GenericGroupEntity<Props, DefaultProps extends {} = {}, Root extends GenericRootEntity<unknown> = GenericRootEntity<unknown>> extends GenericComplexEntity<Props, DefaultProps, Root> {
+    readonly children: readonly GenericEntity<unknown, {}, Root>[];
+    protected readonly _childContainer: GenericGroupEntity<unknown, {}, Root>;
+    protected __makeProxyContainer(): GenericGroupEntity<unknown, {}, Root>;
+    addChild(child: GenericEntity<unknown, {}, Root>, index?: number): this;
+    removeChild(child: GenericEntity<unknown, {}, Root>): this;
+}
+/** @internal */
+declare abstract class GenericRootEntity<Props, DefaultProps extends {} = {}> extends GenericGroupEntity<Props, DefaultProps> {
+    get root(): this;
+    protected _onAttach: undefined;
+    protected _onDetach: undefined;
+    protected __implAttachTo: undefined;
+}
+type EntityProps<T extends GenericEntity<unknown>> = T extends GenericEntity<infer P> ? P : never;
+type EntityConstructor<TEntity extends GenericEntity<unknown>> = new (...args: any[]) => TEntity;
+export { GenericEntity, GenericComplexEntity, GenericGroupEntity, GenericRootEntity, Context, ContextProvider, EntityConstructor, EntityProps };

package/imperative/MMap/index.d.ts

@@ -0,0 +1,283 @@
+import type { BehaviorType, LngLat, MapMode, Margin, PixelCoordinates, Projection, ReadonlyLngLat, LngLatBounds, ZoomRange, ZoomRounding, WorldOptions, ZoomStrategy, EasingFunctionDescription } from "../../common/types";
+import type { MMapEntity } from "../MMapEnities";
+import { GenericRootEntity } from "../Entities";
+import { MMapCopyrightsPosition } from "../MMapCopyrights";
+import { Config } from "../config";
+import { reactify } from "../../reactify";
+/**
+ * Sets map center.
+ */
+export type MMapCenterLocation = {
+    center: LngLat;
+};
+/**
+ * Sets map zoom.
+ */
+export type MMapZoomLocation = {
+    zoom: number;
+};
+/**
+ * Sets map bounds.
+ */
+export type MMapBoundsLocation = {
+    bounds: LngLatBounds;
+};
+/**
+ * Sets map center and zoom. Combination of MMapCenterLocation and MMapZoomLocation
+ */
+export type MMapCenterZoomLocation = MMapCenterLocation & MMapZoomLocation;
+/**
+ * Sets map center and zoom or bounds. Combination of @mixes MMapZoomLocation and MMapBoundsLocation
+ */
+export type MMapLocation = MMapCenterZoomLocation & Partial<MMapBoundsLocation>;
+/**
+ * Observer camera position
+ */
+export type MMapCamera = {
+    /** Map tilt in radians. Can take values from 0 to 45 degrees (degrees * (Math.PI / 180)) */
+    tilt?: number;
+    /** Map rotation in degrees. Can take values from -180 to 180 degrees */
+    azimuth?: number;
+};
+/**
+ * Describes how to change current map location. Change can be instantenious or animated if duration property is set.
+ */
+export type MMapLocationRequest = (MMapBoundsLocation | MMapCenterLocation | MMapZoomLocation | MMapCenterZoomLocation) & {
+    /** Animation duration */
+    duration?: number;
+    /** Animation easing function */
+    easing?: EasingFunctionDescription;
+};
+export type MMapCameraRequest = MMapCamera & {
+    /** Animation duration */
+    duration?: number;
+    /** Animation easing function */
+    easing?: EasingFunctionDescription;
+};
+/**
+ * MMap props
+ */
+export type MMapProps = {
+    /** Map container css class name */
+    className?: string;
+    /** Initial location or request to change location with duration */
+    location: MMapLocationRequest;
+    /** Initial camera or request to change camera with duration */
+    camera?: MMapCameraRequest;
+    /** Map mode, 'auto' (default. Show raster tiles while vector tiles are loading), 'raster' or 'vector' (without raster preloading). */
+    mode?: MapMode;
+    /** Active behaviors */
+    behaviors?: BehaviorType[];
+    /** Sets the map view area so that the user cannot move outside of this area. */
+    restrictMapArea?: LngLatBounds | false;
+    /** Restrict min and max map zoom */
+    zoomRange?: ZoomRange;
+    /** Zoom strategy describes if map center is bound to the zoom point or not */
+    zoomStrategy?: ZoomStrategy;
+    /** Set rounding for zoom. If `auto` is selected, zoom will be `snap` for `raster` and `smooth` for `vector` `MapMode`. Default is `auto`.*/
+    zoomRounding?: ZoomRounding;
+    /** Map margins */
+    margin?: Margin;
+    /** Other configs */
+    config?: Config;
+    /** Strategy for fetching hotspots, for whole viewport or for tiles that pointer is hovering at */
+    hotspotsStrategy?: "forViewport" | "forPointerPosition";
+    /**
+         * Whether to show map copyrights.
+         * > The option is ignored if `config.meta.copyrights.allowRemove` has a falsy value
+         * @internal
+         */
+    copyrights?: boolean;
+    /** Position of copyright on the page. Default is 'bottom right' */
+    copyrightsPosition?: MMapCopyrightsPosition;
+    /**
+         * Projection used in map
+         */
+    projection?: Projection;
+    /**
+         * Whether to repeat the world in X and Y
+         */
+    worldOptions?: WorldOptions;
+};
+export interface Experiments {
+    mappableVectorGraphics?: boolean;
+}
+declare const defaultProps: Readonly<{
+    className: "";
+    camera: {
+        tilt: number;
+        azimuth: number;
+    };
+    mode: "auto";
+    zoomRounding: "auto";
+    hotspotsStrategy: "forViewport" | "forPointerPosition";
+    zoomRange: ZoomRange;
+    zoomStrategy: "zoomToPointer";
+    behaviors: string[];
+    margin: Margin | undefined;
+    copyrights: true;
+    copyrightsPosition: "bottom right";
+    worldOptions: {
+        cycledX: boolean;
+        cycledY: boolean;
+    };
+    restrictMapArea: false;
+    readonly config: Config | undefined;
+    projection: Projection;
+}>;
+type DefaultProps = typeof defaultProps;
+/**
+ * Main API class. Create a map container.
+ *
+ * @example
+ * ```javascript
+ * const map = new MMap(
+ *     document.getElementById('map-root'),
+ *     {location: {center: [37.622504, 55.753215], zoom: 10}}
+ * );
+ * // add default Mappable scheme layer
+ * map.addChild(new MMapDefaultSchemeLayer());
+ * // relocate map to another point with animation in 200 milliseconds
+ * map.setLocation({center: [48.707067, 44.516975], duration: 200});
+ * // change mode from default `auto` to `raster`
+ * map.setMode('raster');
+ * // get map zoom for some calculations
+ * const zoom = map.zoom;
+ * ```
+ */
+declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
+    #private;
+    static defaultProps: Readonly<{
+        className: "";
+        camera: {
+            tilt: number;
+            azimuth: number;
+        };
+        mode: "auto";
+        zoomRounding: "auto";
+        hotspotsStrategy: "forViewport" | "forPointerPosition";
+        zoomRange: ZoomRange;
+        zoomStrategy: "zoomToPointer";
+        behaviors: string[];
+        margin: Margin | undefined;
+        copyrights: true;
+        copyrightsPosition: "bottom right";
+        worldOptions: {
+            cycledX: boolean;
+            cycledY: boolean;
+        };
+        restrictMapArea: false;
+        readonly config: Config | undefined;
+        projection: Projection;
+    }>;
+    /** @internal */
+    static [reactify.overrideKey]: import("../../reactify/reactify").CustomReactify<MMap, import("react").ForwardRefExoticComponent<MMapProps & {
+        children?: import("react").ReactNode;
+    } & import("react").RefAttributes<GenericRootEntity<MMapProps & {
+        container: HTMLElement;
+    }, {}>>>>;
+    private readonly _rootContainer;
+    private readonly _container;
+    private readonly _resizeObserver;
+    private _vectorInitFailed;
+    private __abortVectorLoad?;
+    private _layers;
+    private _copyrights;
+    private _coverage;
+    constructor(rootContainer: HTMLElement, props: MMapProps, children?: MMapEntity<unknown>[]);
+    readonly children: MMapEntity<unknown>[];
+    addChild(child: MMapEntity<unknown>, index?: number): this;
+    removeChild(child: MMapEntity<unknown>): this;
+    protected __implGetDefaultProps(): DefaultProps;
+    private _canBeMainLayer;
+    private _prepareLayersToSet;
+    private _filterLayers;
+    private _upsertLayer;
+    private _removeLayer;
+    /**
+         * Main map container
+         */
+    get container(): HTMLElement;
+    /**
+         * getter for {@link MMapProps}.location.center prop
+         */
+    get center(): ReadonlyLngLat;
+    /**
+         * getter for {@link MMapProps}.location.zoom prop
+         */
+    get zoom(): number;
+    get tilt(): number;
+    get azimuth(): number;
+    /**
+         * getter for {@link MMapProps}.location.bounds prop
+         */
+    get bounds(): LngLatBounds;
+    /**
+         * getter for {@link MMapProps}.zoomRange prop
+         */
+    get zoomRange(): Readonly<ZoomRange>;
+    /**
+         * getter for {@link MMapProps}.projection prop
+         */
+    get projection(): Projection;
+    /**
+         * getter for map size
+         */
+    get size(): PixelCoordinates;
+    /**
+         * getter for {@link MMapProps}.behaviors prop
+         */
+    get behaviors(): Readonly<BehaviorType[]>;
+    /**
+         * getter for {@link MMapProps}.config prop
+         */
+    get config(): Readonly<Config>;
+    /**
+         * setter for {@link MMapProps}.location prop
+         * @param location
+         */
+    setLocation(location: MMapLocationRequest): void;
+    private __setLocation;
+    /**
+         * setter for {@link MMapProps}.mode prop
+         * @param {MapMode} mode
+         */
+    setMode(mode: MapMode): void;
+    /**
+         * setter for {@link MMapProps}.zoomRange prop
+         * @param {ZoomRange} zoomRange
+         */
+    setZoomRange(zoomRange: ZoomRange): void;
+    /**
+         * setter for {@link MMapProps}.behaviors prop
+         * @param {BehaviorType[]} behaviors
+         */
+    setBehaviors(behaviors: BehaviorType[]): void;
+    /**
+         * setter for {@link MMapProps}.zoomRounding prop
+         * @param {ZoomRounding} zoomRounding
+         */
+    setZoomRounding(zoomRounding: ZoomRounding): void;
+    /**
+         * setter for {@link MMapProps}.margin prop
+         * @param {Margin} margin
+         */
+    setMargin(margin: Margin): void;
+    /**
+         * setter for {@link MMapProps}.config prop
+         * @param {Config} config
+         */
+    setConfig(config: Config): void;
+    /**
+         * Destroy map and remove it from user DOM-element
+         */
+    destroy(): void;
+    private _createMap;
+    private get _correctMode();
+    protected _onUpdate(propsDiff: Partial<MMapProps>): void;
+    private _loadVector;
+    private __onVectorInitFailed;
+    private __loadVectorEngine;
+    private __toggleCopyrights;
+}
+export { MMap };

package/imperative/MMap/projection.d.ts

@@ -0,0 +1,2 @@
+import { sphericalMercator } from "../utils/projections/spherical-mercator";
+export { sphericalMercator as projection };

package/imperative/MMapCollection/index.d.ts

@@ -0,0 +1,3 @@
+import { MMapGroupEntity } from "../MMapEnities";
+export declare class MMapCollection extends MMapGroupEntity<{}> {
+}

package/imperative/MMapControl/MMapControl.d.ts

@@ -0,0 +1,45 @@
+import { DomEntity } from "../DomContext";
+import { reactify } from "../../reactify";
+/**
+ * MMapControl props
+ */
+export type MMapControlProps = {};
+/**
+ *  DOM wrapper for creating custom controls. Connects the styles required by the control.
+ *
+ * @example
+ * ```javascript
+ * const control = new MMapControl({});
+ * class MMapSomeController extends DomEntity {
+ *     _createDom() {
+ *         const element = document.createElement('button');
+ *         this._updateDom(element, this._props, true);
+ *         return element;
+ *     }
+ *     _updateDom(element, props, init = false) {
+ *         element.innerText = props.title;
+ *     }
+ * }
+ * const button = new MMapSomeController({
+ *     title: 'Click me!'
+ * });
+ * control.addChild(button);
+ * map.addChild(control);
+ * @see [[MMapControlCommonButton]]
+ * ```
+ *
+ * @module MMapControl
+ */
+export declare class MMapControl<T extends MMapControlProps = MMapControlProps> extends DomEntity<T> {
+    /** @internal */
+    static [reactify.overrideKey]: import("../../reactify/reactify").CustomReactify<MMapControl<MMapControlProps>, import("react").ForwardRefExoticComponent<{
+        children?: import("react").ReactNode;
+    } & import("react").RefAttributes<import("../Entities").GenericEntity<{
+        controlElement: HTMLElement;
+    }, {}, import("../Entities").GenericRootEntity<unknown, {}>>>>>;
+    protected _createDom(): {
+        element: HTMLElement;
+        container: HTMLElement;
+    };
+    protected _updateDom(element: HTMLElement): void;
+}

package/imperative/MMapControl/MMapControlButton.d.ts

@@ -0,0 +1,55 @@
+import { DomEntity } from "../DomContext";
+import { MMapComplexEntity } from "../MMapEnities";
+/**
+ * MMapControlButton props
+ */
+export type MMapControlCommonButtonProps = {
+    /** On click handler */
+    onClick?: () => void;
+    /** Should be disabled */
+    disabled?: boolean;
+    /** Text content */
+    text?: string;
+    /** Text color */
+    color?: string;
+    /** Background color */
+    background?: string;
+    /** HTML element */
+    element?: HTMLElement;
+};
+export type MMapControlButtonProps = MMapControlCommonButtonProps;
+/**
+ * Default control button.
+ */
+export declare class MMapControlCommonButton extends DomEntity<MMapControlCommonButtonProps, HTMLButtonElement> {
+    protected _createDom(): {
+        element: HTMLButtonElement;
+        container: HTMLElement;
+    };
+    protected _updateDom(element: HTMLButtonElement, props: Partial<MMapControlCommonButtonProps>, init?: boolean): void;
+}
+/**
+ * The control element - button.
+ * ```javascript
+ * const map = new MMap(document.getElementById('map-root'), {...});
+ * const controls = new MMapControls({position: 'top left horizontal'});
+ * let count = 0;
+ * const button = new MMapControlButton({
+ *     text: 'Click me!',
+ *     onClick: () => {
+ *         button.update({text: 'Clicked:' + ++count});
+ *     }
+ * });
+ * controls.addChild(button);
+ * map.addChild(controls);
+ * ```
+ *
+ * @see https://mappable.world/docs/jsapi/dg/concepts/controls/about.html
+ */
+export declare class MMapControlButton extends MMapComplexEntity<MMapControlButtonProps> {
+    private _control;
+    private _button;
+    constructor(props: MMapControlButtonProps);
+    protected _onUpdate(props: Partial<MMapControlButtonProps>): void;
+    get text(): string | undefined;
+}

package/imperative/MMapControl/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MMapControl";
+export * from "./MMapControlButton";

package/imperative/MMapControls/index.d.ts

@@ -0,0 +1,43 @@
+import { DomEntity } from "../DomContext";
+type VerlicalPosition = "top" | "bottom";
+type HorizontalPosition = "left" | "right";
+type Orientation = "horizontal" | "vertical";
+/**
+ * Describes controls position.
+ */
+type Position = VerlicalPosition | HorizontalPosition | `${VerlicalPosition} ${HorizontalPosition}` | `${HorizontalPosition} ${VerlicalPosition}`;
+/**
+ * MMapControls props
+ */
+export type MMapControlsProps = {
+    /** Controls position. */
+    position: Position;
+    /** Controls orientation. */
+    orientation?: Orientation;
+};
+/**
+ * DOM container for grouping a number of controls to group and position them
+ * @example
+ *```javascript
+ * const map = new MMap(document.getElementById('map-root'), {
+ *     location: [37.622504, 55.753215],
+ *     mode: 'raster'
+ * });
+ * const controls = new MMapControls({position: 'top left horizontal'});
+ * const button = text => new MMapControlButton({
+ *     text: 'Click me',
+ *     onClick: () => {
+ *         alert('Click');
+ *     }
+ * });
+ * map.addChild(controls);
+ * ```
+ */
+export declare class MMapControls extends DomEntity<MMapControlsProps> {
+    protected _createDom(): {
+        element: HTMLElement;
+        container: HTMLElement;
+    };
+    protected _updateDom(element: HTMLElement): void;
+}
+export {};

package/imperative/MMapCopyrights/index.d.ts

@@ -0,0 +1,44 @@
+import { DomEntity } from "../DomContext";
+type MMapCopyrightsPosition = "top left" | "top right" | "bottom left" | "bottom right";
+type MMapCopyrightsProps = {
+    /** Position of copyright on the map */
+    position?: MMapCopyrightsPosition;
+};
+declare const defaultProps: Readonly<{
+    position: MMapCopyrightsPosition;
+}>;
+type DefaultProps = typeof defaultProps;
+/**
+ * The copyright display component on the map.
+ * Data for display uses from the `MMapCoverage` component
+ */
+declare class MMapCopyrights extends DomEntity<MMapCopyrightsProps, HTMLElement, DefaultProps> {
+    static defaultProps: Readonly<{
+        position: MMapCopyrightsPosition;
+    }>;
+    private _boxElement;
+    private _copyrightsTextElement;
+    private _linkElement;
+    private _logoElement;
+    private _mapWidth;
+    private _copyrights;
+    private _fixedCopyrights;
+    private _userAgreementText;
+    private _userAgreementState;
+    private _unwatchMapContext?;
+    constructor(props?: MMapCopyrightsProps);
+    protected __implGetDefaultProps(): DefaultProps;
+    protected _updateDom(): void;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    protected _createDom(): HTMLDivElement;
+    private _syncDom;
+    private _syncMapWidth;
+    private _setUserAgreementText;
+    private _setUserAgreementState;
+    private _setCopyrights;
+    private _setFixedCopyrights;
+    private _copyrightsChangeHandler;
+    private _adjustText;
+}
+export { MMapCopyrights, MMapCopyrightsProps, MMapCopyrightsPosition };

package/imperative/MMapCoverage/index.d.ts

@@ -0,0 +1,19 @@
+import { MMapComplexEntity } from "../MMapEnities";
+interface MMapCoverageProps {
+    onError?: (e: Error) => void;
+}
+/**
+ * The component of loading data on copyrights on the map and the zoom range for
+ * the area where the center of the map is located
+ */
+declare class MMapCoverage extends MMapComplexEntity<MMapCoverageProps, {}> {
+    private _abortController?;
+    private _prevMeta;
+    private _unwatchMapContext?;
+    constructor(props?: MMapCoverageProps);
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    private _compareIfMetaDiffers;
+    private _attemptCoverageRequest;
+}
+export { MMapCoverage, MMapCoverageProps };

package/imperative/MMapDefaultFeaturesLayer/index.d.ts

@@ -0,0 +1,41 @@
+import { MMapComplexEntity } from "../MMapEnities";
+/**
+ * MMapDefaultFeaturesLayer props
+ */
+type MMapDefaultFeaturesLayerProps = {
+    /** Should show layer. Default is true */
+    visible?: boolean;
+    /** Layer z-index */
+    zIndex?: number;
+};
+declare const defaultProps: Readonly<{
+    visible: true;
+    source: "mappable-default-feature";
+}>;
+type DefaultProps = typeof defaultProps;
+/**
+ * Map defaults layer to show features on map.
+ *
+ * @example
+ * ```javascript
+ * const defaultFeaturesLayer = new MMapDefaultFeaturesLayer();
+ * // add to map
+ * map.addChild(defaultFeaturesLayer);
+ * // update
+ * defaultFeaturesLayer.update({zIndex: 1501});
+ * ```
+ */
+declare class MMapDefaultFeaturesLayer extends MMapComplexEntity<MMapDefaultFeaturesLayerProps, DefaultProps> {
+    static defaultProps: Readonly<{
+        visible: true;
+        source: "mappable-default-feature";
+    }>;
+    private _dataSource?;
+    private _featuresLayer?;
+    private _markerLayer?;
+    protected __implGetDefaultProps(): DefaultProps;
+    protected _onAttach(): void;
+    protected _onUpdate(propsDiff: Partial<MMapDefaultFeaturesLayerProps>): void;
+    protected _onDetach(): void;
+}
+export { MMapDefaultFeaturesLayer, MMapDefaultFeaturesLayerProps };