@mappable-world/mappable-types 0.0.5 → 0.0.7

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

@@ -55,12 +55,12 @@ type ComposeTileUrlFunction = (x: number, y: number, z: number, scale: number, s
 type FetchHotspotsFunction = (x: number, y: number, z: number, signal: AbortSignal) => Promise<Hotspot[]>;
 interface RasterTileDataSourceDescription {
     /**
-     * Either template tile url:
-     *   - {{x}} {{y}} {{z}} placeholders for tile coordinates
-     *   - {{scale}} placeholders for pixel scale (e.g. retina is 2)
-     * Or function that returns final url.
-     * Or function that fetches tile manually.
-     */
+         * Either template tile url:
+         *   - {{x}} {{y}} {{z}} placeholders for tile coordinates
+         *   - {{scale}} placeholders for pixel scale (e.g. retina is 2)
+         * Or function that returns final url.
+         * Or function that fetches tile manually.
+         */
     fetchTile: string | ComposeTileUrlFunction | FetchTileFunction;
     /** Name of data provided by this data source. Should be referenced in layer. */
     type: string;
@@ -68,25 +68,25 @@ interface RasterTileDataSourceDescription {
     size?: number;
     transparent?: boolean;
     /**
-     * Returns promise that is going to be resolved by hotspots for tile, or rejected with {name: 'AbortError'}.
-     * Hotspots are expected to be sorted from bottom to top (aka far to near).
-     */
+         * Returns promise that is going to be resolved by hotspots for tile, or rejected with {name: 'AbortError'}.
+         * Hotspots are expected to be sorted from bottom to top (aka far to near).
+         */
     fetchHotspots?: FetchHotspotsFunction;
     /**
-     * Defines maximum distance between tile and pointer, till which we keep alive unfinished requests
-     * for hotspots for that tile.
-     */
+         * Defines maximum distance between tile and pointer, till which we keep alive unfinished requests
+         * for hotspots for that tile.
+         */
     hotspotAbortRadius?: number;
     /**
-     * Defines how far inside into tile hotspots from other tile can go.
-     * For example, tile may have a little part of POI from neightbour tile, but no hotspot for it in data.
-     */
+         * Defines how far inside into tile hotspots from other tile can go.
+         * For example, tile may have a little part of POI from neightbour tile, but no hotspot for it in data.
+         */
     hotspotInset?: number;
     /**
-     * Defines how much pixels should be added to hotspot to increase its area.
-     * Moves each point of hotspot X pixels away from the center of the hotspots.
-     * NOTE: Currently works only on hotspots with Polygon geometry.
-     */
+         * Defines how much pixels should be added to hotspot to increase its area.
+         * Moves each point of hotspot X pixels away from the center of the hotspots.
+         * NOTE: Currently works only on hotspots with Polygon geometry.
+         */
     hotspotPadding?: number;
 }
 interface HotspotsOptions {
@@ -97,25 +97,35 @@ type VectorTileSize = 'X1' | 'X4' | 'X16';
 type VectorDataSourcePriority = 'low' | 'medium' | 'high';
 type VectorObjectsCollisionPriority = 'low' | 'medium' | 'high' | 'ultra';
 interface VectorTileDataSourceDescription {
+    /** Default is `'vmap2'` */
+    tileFormat?: 'vmap2' | 'vmap3';
     tileUrl: string;
     imageUrl?: string;
     meshUrl?: string;
+    richModelUrl?: string;
     glyphRangeUrl?: string;
     indoorPlanUrl?: string;
+    styleUrl?: string;
+    fontListUrl?: string;
+    fontObjectUrl?: string;
     tileRequestWithCredentials?: boolean;
     imageRequestWithCredentials?: boolean;
     meshRequestWithCredentials?: boolean;
     glyphRequestWithCredentials?: boolean;
+    richModelRequestWithCredentials?: boolean;
     tileRequestHeaders?: Record<string, string>;
     iconRequestHeaders?: Record<string, string>;
     glyphRequestHeaders?: Record<string, string>;
     meshRequestHeaders?: Record<string, string>;
+    richModelRequestHeaders?: Record<string, string>;
     priority: VectorDataSourcePriority;
     collisionPriority?: VectorObjectsCollisionPriority;
     requestTileSize?: VectorTileSize;
     tileBeltSize?: number;
     lowPrecisionBeltTiles?: boolean;
     tileCacheSize?: number;
+    richModelCacheSize?: number;
+    richModelEnabled?: boolean;
     allObjectsInteractive?: boolean;
     /** Forces tiles to wait for the icons, disables hiding icons by zoom diff */
     iconsOnlyTiles?: boolean;

package/common/types/geojson.d.ts

@@ -2,12 +2,12 @@ import type { LngLat } from "./lng-lat";
 interface GenericPolygonGeometry<TCoordinates> {
     type: 'Polygon';
     /**
-     * Polygon's rings.
-     *
-     * @remarks
-     * Inner rings may extend beyond outer ring.
-     * GeoJSON doesn't allow this, but there's a lot of data like this in this JS API.
-     */
+         * Polygon's rings.
+         *
+         * @remarks
+         * Inner rings may extend beyond outer ring.
+         * GeoJSON doesn't allow this, but there's a lot of data like this in this JS API.
+         */
     coordinates: TCoordinates[][];
 }
 interface GenericMultiPolygonGeometry<TCoordinates> {
@@ -40,9 +40,9 @@ interface GenericPointFeature<TCoordinates> extends GenericFeature<TCoordinates>
 interface GenericMappableFeatureCollection<TCoordinates> {
     type: 'FeatureCollection';
     /**
-     * Could be collection of features or collection of feature collections.
-     * This is not defined by GEO JSON spec, but there is such cases in our data.
-     */
+         * Could be collection of features or collection of feature collections.
+         * This is not defined by GEO JSON spec, but there is such cases in our data.
+         */
     features: (GenericFeature<TCoordinates> | GenericMappableFeatureCollection<TCoordinates>)[];
     properties?: Record<string, unknown>;
 }

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

@@ -7,21 +7,19 @@ interface VectorObjectsInteractiveArea {
 type RasterLayerOptions = Record<string, unknown> & {
     opacity?: number;
     /**
-     * Show all tiles simultaneously on a first display
-     * However if map state changed original logic is applied
-     */
+         * Show all tiles simultaneously on a first display
+         * However if map state changed original logic is applied
+         */
     awaitAllTilesOnFirstDisplay?: boolean;
     /**
-     * Controls animation duration of the revealing newly downloaded tiles
-     * Values less than or equal to zero turn off animation
-     */
+         * Controls animation duration of the revealing newly downloaded tiles
+         * Values less than or equal to zero turn off animation
+         */
     tileRevealDuration?: number;
 };
 type VectorLayerOptions = Record<string, unknown> & {
     modelsAppearingAnimation?: {
-        transitionZoom: number;
         duration: number;
-        limitByZoom: number;
     };
     iconsInteractiveArea?: VectorObjectsInteractiveArea;
     transformLayers?: Record<string, {

package/imperative/Entities.d.ts

@@ -9,83 +9,31 @@ declare class ContextProvider<T> {
     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>);
@@ -97,10 +45,7 @@ declare class GenericComplexEntity<Props, DefaultProps extends {} = {}, Root ext
     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>;
@@ -108,12 +53,10 @@ declare class GenericGroupEntity<Props, DefaultProps extends {} = {}, Root exten
     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;

package/imperative/MMap/index.d.ts

@@ -82,12 +82,6 @@ export type MMapProps = {
     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;
     /**
@@ -167,12 +161,6 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
         readonly config: Config;
         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;
@@ -185,7 +173,6 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
     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;

package/imperative/MMapControl/MMapControl.d.ts

@@ -31,12 +31,6 @@ export type MMapControlProps = {};
  * @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;

package/imperative/MMapControl/MMapControlButton.d.ts

@@ -18,6 +18,7 @@ export type MMapControlCommonButtonProps = {
     element?: HTMLElement;
 };
 export type MMapControlButtonProps = MMapControlCommonButtonProps;
+/** @module MMapControlButton */
 /**
  * Default control button.
  */

package/imperative/MMapCopyrights/index.d.ts

@@ -27,7 +27,6 @@ declare class MMapCopyrights extends DomEntity<MMapCopyrightsProps, HTMLElement,
     private _userAgreementState;
     private _unwatchMapContext?;
     constructor(props?: MMapCopyrightsProps);
-    protected __implGetDefaultProps(): DefaultProps;
     protected _updateDom(): void;
     protected _onAttach(): void;
     protected _onDetach(): void;

package/imperative/MMapDefaultFeaturesLayer/index.d.ts

@@ -33,7 +33,6 @@ declare class MMapDefaultFeaturesLayer extends MMapComplexEntity<MMapDefaultFeat
     private _dataSource?;
     private _featuresLayer?;
     private _markerLayer?;
-    protected __implGetDefaultProps(): DefaultProps;
     protected _onAttach(): void;
     protected _onUpdate(propsDiff: Partial<MMapDefaultFeaturesLayerProps>): void;
     protected _onDetach(): void;

package/imperative/MMapDefaultSchemeLayer/index.d.ts

@@ -8,19 +8,12 @@ type MMapDefaultSchemeLayerProps = {
     visible?: boolean;
     /** Vector tiles customization. Not allowed on a free tariff. */
     customization?: VectorCustomization;
-    /**
-         * Should to fetch hotspots
-         * @internal
-         */
-    hotspotsEnabled?: boolean;
     /** Theme applied to the scheme */
     theme?: "dark" | "light";
 };
 declare const defaultProps: {
     visible: boolean;
     source: string;
-    /** @internal */
-    hotspotsEnabled: boolean;
     layersInfo: {
         ground: {
             type: string;
@@ -57,8 +50,6 @@ declare class MMapDefaultSchemeLayer extends MMapComplexEntity<MMapDefaultScheme
     static defaultProps: {
         visible: boolean;
         source: string;
-        /** @internal */
-        hotspotsEnabled: boolean;
         layersInfo: {
             ground: {
                 type: string;
@@ -81,7 +72,6 @@ declare class MMapDefaultSchemeLayer extends MMapComplexEntity<MMapDefaultScheme
     private _dataSource?;
     private _layers;
     private _unwatchMapContext?;
-    protected __implGetDefaultProps(): DefaultProps;
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(propsDiff: Partial<MMapDefaultSchemeLayerProps>): void;

package/imperative/MMapFeature/index.d.ts

@@ -54,7 +54,6 @@ declare class MMapFeature extends MMapEntity<MMapFeatureProps, DefaultProps> {
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate({ style, id, source }: Partial<MMapFeatureProps>): void;
-    protected __implGetDefaultProps(): DefaultProps;
     private __onDragStart;
     private __onDragMove;
     private __onDragEnd;

package/imperative/MMapFeature/types.d.ts

@@ -9,11 +9,11 @@ export interface DraggableProps<Callback> {
     /** Fires on drag start */
     onDragStart?: Callback;
     /**
-     * Maybe a function which will be called when the user drags and drops the element to a new position in the map.
-     * The arguments to the function will be with new coordinates.
-     * A component using with component should immediately store the new coordinates into its state and then pass
-     * the new coordinates as the marker's props.
-     * */
+         * Maybe a function which will be called when the user drags and drops the element to a new position in the map.
+         * The arguments to the function will be with new coordinates.
+         * A component using with component should immediately store the new coordinates into its state and then pass
+         * the new coordinates as the marker's props.
+         * */
     onDragEnd?: Callback;
     /** Fires on drag move */
     onDragMove?: Callback;

package/imperative/MMapLayer/index.d.ts

@@ -30,7 +30,6 @@ declare class MMapLayer extends MMapEntity<MMapLayerProps, DefaultProps> {
     static defaultProps: Readonly<{
         zIndex: 1500;
     }>;
-    protected __implGetDefaultProps(props: MMapLayerProps): DefaultProps;
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(): void;

package/imperative/MMapListener/index.d.ts

@@ -65,8 +65,6 @@ export type DomEvents = {
 export type MapEvents = {
     onUpdate: MapEventUpdateHandler;
     onResize: MapEventResizeHandler;
-    /** @internal */
-    onIndoorPlansChanged: IndoorPlansHandler;
 };
 export type BehaviorEvents = {
     onActionStart: BehaviorMapEventHandler;

package/imperative/MMapMarker/index.d.ts

@@ -53,30 +53,6 @@ declare class MMapMarker extends MMapGroupEntity<MMapMarkerProps, DefaultProps>
         zIndex: 0;
         source: "mappable-default-feature";
     }>;
-    /** @internal */
-    static [reactify.overrideKey]: import("../../reactify/reactify").CustomReactify<MMapMarker, import("react").ForwardRefExoticComponent<{
-        /** Coordinates of the marker */
-        coordinates: LngLat;
-        source?: string | undefined;
-        /** z index of the marker, defaults to 0 */
-        zIndex?: number | undefined;
-        properties?: Record<string, unknown> | undefined;
-        id?: string | undefined;
-    } & DraggableProps<MMapMarkerEventHandler> & FeatureClickEvents & {
-        markerElement?: HTMLElement | undefined;
-    } & {
-        children?: import("react").ReactNode;
-    } & import("react").RefAttributes<import("../Entities").GenericEntity<{
-        /** Coordinates of the marker */
-        coordinates: LngLat;
-        source?: string | undefined;
-        /** z index of the marker, defaults to 0 */
-        zIndex?: number | undefined;
-        properties?: Record<string, unknown> | undefined;
-        id?: string | undefined;
-    } & DraggableProps<MMapMarkerEventHandler> & FeatureClickEvents & {
-        markerElement?: HTMLElement | undefined;
-    }, {}, import("../Entities").GenericRootEntity<unknown, {}>>>>>;
     readonly element: HTMLElement;
     private _destroyDomCtx?;
     constructor(props: MMapMarkerProps, element?: HTMLElement);

package/imperative/MMapReactContainer/index.d.ts

@@ -21,14 +21,9 @@ declare class MMapReactContainer extends MMapGroupEntity<ComputedMMapReactContai
     static defaultProps: {
         tagName: string;
     };
-    /** @internal */
-    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapReactContainer, TReact.FC<MMapReactContainerProps<unknown> & {
-        children?: TReact.ReactNode;
-    }>>;
     element?: Element;
     private _detachDom?;
     private _disposeWatch?;
-    protected __implGetDefaultProps(): DefaultProps;
     protected _onAttach(): void;
     private _adjustContext;
     protected _onDetach(): void;

package/imperative/suggest.d.ts

@@ -47,5 +47,13 @@ export type SuggestResponseItem = {
     type?: DeprecatedObjectType;
 };
 export type SuggestResponse = SuggestResponseItem[];
+/**
+ * Static function to work with Suggest API.
+ *
+ *
+ * @param {SuggestOptions} options Request options
+ * @param {Config} config Current config
+ * @returns {Promise<SuggestResponse>}
+ */
 export declare function suggest(options: SuggestOptions, config?: Config | undefined): Promise<SuggestResponse>;
 export {};

package/imperative/utils/metrics.d.ts

@@ -1,5 +1,3 @@
-/** @internal */
-export type MetricsConfig = {};
 type Metrics = {};
 type TransportOptions = {
     share?: number;
@@ -10,8 +8,5 @@ type CreateTransportOptions = {
     /** Events with share (if defined) less than this value will not be sent, should be in [0, 1] range */
     sendBoundary?: number;
 };
-export declare function createMetricsTransport<T extends Record<string, unknown>>(config: MetricsConfig, options?: CreateTransportOptions): MetricsTransport<T>;
 export declare const SEND_BOUNDARY: number;
-export declare function initMetrics(config: MetricsConfig): void;
-export declare function sendMetrics(data: Metrics, options?: TransportOptions): void;
 export {};

package/import.d.ts

@@ -5,24 +5,11 @@ export type Module = Function | null | {
 };
 export type Loader = (pkg: string) => Promise<Module> | Module;
 export interface Import {
-    /** @internal */
-    __implCache: Record<string, Promise<Module>>;
-    /** @internal */
-    __implInit(base: string, ready: Promise<unknown>): void;
-    /** @internal */
-    __implInlineModules: Record<string, () => Promise<Module>>;
     loaders: Loader[];
     default: Loader;
     script: (url: string) => Promise<unknown>;
     cssText: (cssText: string, name: string) => Promise<unknown>;
     style: (url: string) => Promise<unknown>;
 }
-declare global {
-    const __MODULES__: string[];
-    const __PACKAGES__: string[];
-    const __VENDOR__: "mappable-world" | "mappable-world";
-    const __NAMESPACE__: "mappable" | "mappable";
-    const __LOGO_WIDHT__: `${number}px`;
-}
 declare const mappableImport: Import;
 export { mappableImport };

package/main.d.ts

@@ -1,8 +1 @@
 export * from "./imperative";
-export * as __implReactify from "./reactify";
-export declare const __implReactifyOverride: (reactify: import("./reactify").Reactify) => {
-    reactify: import("./reactify").Reactify;
-    MMapReactContainer: import("react").FC<import("./imperative/MMapReactContainer").MMapReactContainerProps<unknown> & {
-        children?: import("react").ReactNode;
-    }>;
-};

package/modules/editors/MMapFeatureEditor/MMapFeatureEditor.d.ts

@@ -31,7 +31,6 @@ declare class MMapFeatureEditor extends MMapComplexEntity<MMapFeatureEditorProps
     private shape;
     private line;
     constructor(props: MMapFeatureEditorProps);
-    protected __implGetDefaultProps(): DefaultProps;
     private _updatePreviewPoint;
     private _updateDraggingPoint;
     protected _onUpdate({ points, geometry, featureStyle, isActive, prefix, zIndex }: Partial<MMapFeatureEditorProps>): void;

package/modules/utils/MMapCursor/index.d.ts

@@ -21,7 +21,6 @@ declare class MMapCursor extends MMapComplexEntity<MMapCursorProps, DefaultProps
         isActive: (object: MMapEntity<unknown, {}> | MMapHotspot) => boolean;
     }>;
     constructor(props: MMapCursorProps);
-    protected __implGetDefaultProps(): DefaultProps;
     private _onMouseMove;
     private _onMouseLeave;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mappable-world/mappable-types",
-    "version": "0.0.5",
+    "version": "0.0.7",
     "description": "Types for mappable maps library",
     "main": "",
     "types": "index.d.ts",

package/packages/clusterer/MMapClusterer/MMapClusterer.d.ts

@@ -50,14 +50,6 @@ declare class MMapClusterer extends mappable.MMapComplexEntity<MMapClustererProp
     static defaultProps: Readonly<{
         tickTimeout: 200;
     }>;
-    /** @internal */
-    static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapClusterer, import("react").ForwardRefExoticComponent<MMapClustererProps & {
-        marker: (feature: Feature) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
-        cluster: (coordinates: LngLat, features: Feature[]) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
-    } & import("react").RefAttributes<MMapEntity<MMapClustererProps & {
-        marker: (feature: Feature) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
-        cluster: (coordinates: LngLat, features: Feature[]) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
-    }, {}>>>>;
     /** All created entities with cluster id*/
     private _entitiesCache;
     /** Viewport entities with cluster id */
@@ -99,7 +91,6 @@ declare class MMapClusterer extends mappable.MMapComplexEntity<MMapClustererProp
          */
     private _syncVisibleEntities;
     private _render;
-    protected __implGetDefaultProps(): DefaultProps;
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(): void;

package/packages/clusterer/MMapClusterer/helpers/throttle.d.ts

@@ -1,11 +1,3 @@
-/**
- * Throttles a function and delays its execution, so it's only called at most
- * once within a given time period.
- *
- * @param {Function} fn The function to throttle.
- * @param {number} wait The amount of time that must pass before the function can be called again.
- * @return {Function} The throttled function.
- */
 /**
  * Throttles a function and delays its execution, so it's only called at most
  * once within a given time period.

package/packages/clusterer/MMapClusterer/react/MMapClusterer.d.ts

@@ -1,6 +1,6 @@
 import type TReact from "react";
 import type { LngLat, MMapEntity } from "../../../..";
-import type { CustomReactify } from "../../../../reactify/reactify";
+import type { CustomReactify, OverrideProps } from "../../../../reactify/reactify";
 import type { Feature } from "../interface";
 import type { MMapClusterer as MMapClustererI, MMapClustererProps } from "../MMapClusterer";
 /**
@@ -33,12 +33,12 @@ import type { MMapClusterer as MMapClustererI, MMapClustererProps } from "../MMa
  * </MMap>
  * ```
  */
-type MMapClustererReactifiedProps = MMapClustererProps & {
+type MMapClustererReactifiedProps = OverrideProps<MMapClustererProps, {
     /** Function that returns MMapMarker react component to render marker*/
     marker: (feature: Feature) => TReact.ReactElement;
     /** Function that returns MMapMarker react component to render cluster*/
     cluster: (coordinates: LngLat, features: Feature[]) => TReact.ReactElement;
-};
+}>;
 type MMapClustererR = TReact.ForwardRefExoticComponent<MMapClustererReactifiedProps & React.RefAttributes<MMapEntity<MMapClustererReactifiedProps>>>;
 export declare const MMapClustererReactifyOverride: CustomReactify<MMapClustererI, MMapClustererR>;
 export {};

package/packages/controls/MMapGeolocationControl/index.d.ts

@@ -39,7 +39,6 @@ declare class MMapGeolocationControl extends mappable.MMapGroupEntity<MMapGeoloc
     private _element;
     private _unwatchMapContext?;
     constructor(props: MMapGeolocationControlProps);
-    protected __implGetDefaultProps(): DefaultProps;
     private _timeout;
     private _setLoading;
     private _position;

package/packages/controls/MMapZoomControl/index.d.ts

@@ -35,7 +35,6 @@ declare class MMapZoomControl extends mappable.MMapControl<MMapZoomControlProps>
     protected _listener: MMapListener;
     private _currentZoom;
     constructor(props: MMapZoomControlProps);
-    protected __implGetDefaultProps(): DefaultProps;
     private _onMapUpdate;
     private _changeZoom;
     protected _onAttach(): void;

package/packages/hint/MMapHint/index.d.ts

@@ -39,8 +39,6 @@ declare const MMapHintContext: import("../../../imperative/Entities").Context<un
  * ```
  */
 declare class MMapHint extends mappable.MMapGroupEntity<MMapHintProps> {
-    /** @internal */
-    static [reactify.overrideKey]: CustomReactify<MMapHint, TReact.FC<MMapHintProps>>;
     private _destroyDomContext;
     private _detachDom;
     private _element;

package/packages/markers/MMapDefaultMarker/index.d.ts

@@ -43,16 +43,6 @@ declare class MMapDefaultMarker extends mappable.MMapComplexEntity<MMapDefaultMa
     static defaultProps: Readonly<{
         color: "#f33";
     }>;
-    /** @internal */
-    static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapDefaultMarker, import("react").ForwardRefExoticComponent<{
-        coordinates: LngLat; /** Should popup hide marker. Default is false */
-        source?: string | undefined;
-        zIndex?: number | undefined;
-        properties?: Record<string, unknown> | undefined;
-        id?: string | undefined;
-    } & import("../../../imperative/MMapFeature/types").DraggableProps<import("../../../imperative/MMapMarker").MMapMarkerEventHandler> & import("../../../imperative/MMapFeature/types").FeatureClickEvents & DefaultMarkerCustomProps & {
-        children?: import("react").ReactNode;
-    } & import("react").RefAttributes<import("../../../imperative/MMapEnities").MMapEntity<MMapDefaultMarkerProps, {}>>>>;
     private _marker;
     private _container;
     private _popup;
@@ -62,7 +52,6 @@ declare class MMapDefaultMarker extends mappable.MMapComplexEntity<MMapDefaultMa
     constructor(props: MMapDefaultMarkerProps);
     private _createMarker;
     private __onElementClick;
-    protected __implGetDefaultProps(): DefaultProps;
     private _togglePopup;
     private _createPopup;
     protected _onUpdate(changedProps: Partial<MMapDefaultMarkerProps>): void;

package/reactify/reactify.d.ts

@@ -26,20 +26,21 @@ export type CustomReactify<TEntity extends GenericEntity<unknown>, TResult> = (c
     React: typeof TReact;
     ReactDOM: typeof TReactDOM;
 }) => TResult;
-export type Overrided<TReactResult> = {
-    [overrideKeyReactify]: CustomReactify<GenericEntity<unknown>, TReactResult>;
+export type Overrided<TCtor extends EntityConstructor<GenericEntity<unknown>>, TReactResult> = {
+    [overrideKeyReactify]: CustomReactify<InstanceType<TCtor>, TReactResult>;
 };
 type InternalReactify<TEntity extends GenericEntity<unknown>> = (ctor: EntityConstructor<TEntity>, displayName?: string) => TReact.ForwardRefExoticComponent<TReact.PropsWithoutRef<TReact.PropsWithChildren<EntityProps<TEntity>>> & React.RefAttributes<TEntity | undefined>>;
-type InternalReactifyEntity<TCtor extends EntityConstructor<GenericEntity<unknown>>> = (ctor: TCtor, displayName?: string) => TCtor extends Overrided<infer TResult> ? TResult : ReturnType<InternalReactify<InstanceType<TCtor>>>;
+type InternalReactifyEntity<TCtor extends EntityConstructor<GenericEntity<unknown>>> = (ctor: TCtor, displayName?: string) => TCtor extends Overrided<TCtor, infer TResult> ? TResult : ReturnType<InternalReactify<InstanceType<TCtor>>>;
 export type ReactifyEntity = <TCtor extends EntityConstructor<GenericEntity<unknown>>>(...args: Parameters<InternalReactifyEntity<TCtor>>) => ReturnType<InternalReactifyEntity<TCtor>>;
 export type ReactifiedEntity<TCtor extends EntityConstructor<GenericEntity<unknown>>> = ReturnType<InternalReactifyEntity<TCtor>>;
-export interface ReactifyModule<TModule extends BaseModule = BaseModule> {
-    (module: TModule): ReactifiedModule<TModule>;
+export interface ReactifyModule {
+    <TModule extends BaseModule = BaseModule>(module: TModule): ReactifiedModule<TModule>;
 }
 export type GetReactContext<TContext extends Context<unknown>> = (context?: TContext | undefined) => React.Context<unknown>;
 export type ReactifiedModule<TModule extends BaseModule> = {
     [Property in keyof TModule]: TModule[Property] extends EntityConstructor<GenericEntity<unknown>> ? ReturnType<InternalReactifyEntity<TModule[Property]>> : TModule[Property] extends typeof Context ? ReturnType<GetReactContext<TModule[Property]>> : TModule[Property];
 };
 export type BaseModule = Record<string | symbol, unknown>;
+export type OverrideProps<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
 export default function createReactify(React: typeof TReact, ReactDOM: typeof TReactDOM): Reactify;
 export {};