@mappable-world/mappable-types 0.0.9 → 0.0.11

package/imperative/MMap/index.d.ts

@@ -274,6 +274,11 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
          * @param {Config} config
          */
     setConfig(config: Config): void;
+    /**
+         * setter for {@link MMapProps}.projection prop
+         * @param {Projection} projection
+         */
+    setProjection(projection: Projection): void;
     /**
          * Destroy map and remove it from user DOM-element
          */

package/imperative/MMapContainer/index.d.ts

@@ -0,0 +1,35 @@
+import type TReact from "react";
+import type { Context } from "../Entities";
+import { MMapGroupEntity } from "../MMapEnities";
+import { overrideKeyReactify } from "../wrappers";
+interface MMapContainerPropsImpl<TContext> {
+    onElement: (element?: Element) => void;
+    onContext: (context?: TContext) => void;
+}
+interface MMapContainerProps<TContext> {
+    tagName?: string;
+    className?: string;
+    style?: TReact.CSSProperties;
+    context?: Context<TContext>;
+}
+declare const defaultProps: {
+    tagName: string;
+};
+type DefaultProps = typeof defaultProps;
+type ComputedMMapContainerProps<TContext> = MMapContainerProps<TContext> & MMapContainerPropsImpl<TContext>;
+declare class MMapContainer extends MMapGroupEntity<ComputedMMapContainerProps<unknown>, DefaultProps> {
+    static defaultProps: {
+        tagName: string;
+    };
+    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<import("../MMapReactContainer").MMapReactContainer, TReact.FC<import("../MMapReactContainer").MMapReactContainerProps<unknown> & {
+        children?: TReact.ReactNode;
+    }>>;
+    element?: Element;
+    private _detachDom?;
+    private _disposeWatch?;
+    protected _onAttach(): void;
+    private _adjustContext;
+    protected _onDetach(): void;
+    protected _onUpdate(props: Partial<ComputedMMapContainerProps<unknown>>): void;
+}
+export { MMapContainer, MMapContainerProps, MMapContainerPropsImpl, ComputedMMapContainerProps };

package/imperative/MMapFeature/index.d.ts

@@ -51,13 +51,13 @@ declare class MMapFeature extends MMapEntity<MMapFeatureProps, DefaultProps> {
     private static _uid;
     private _id;
     private _source;
-    private _isDragging;
+    private _defaultPropsId?;
     constructor(props: MMapFeatureProps);
     get properties(): Record<string, unknown> | undefined;
     get geometry(): GenericGeometry<LngLat>;
     protected _onAttach(): void;
     protected _onDetach(): void;
-    protected _onUpdate({ style, id, source, disableRoundCoordinates, hideOutsideViewport: newHideOutsideViewport }: Partial<MMapFeatureProps>): void;
+    protected _onUpdate({ id, source }: Partial<MMapFeatureProps>): void;
     private __onDragStart;
     private __onDragMove;
     private __onDragEnd;

package/imperative/MMapListener/index.d.ts

@@ -17,6 +17,18 @@ type HandlerEntity<TType extends string, TEntity> = {
     entity: TEntity;
 };
 export type DomEventHandlerObject = HandlerEntity<"feature", MMapFeature> | HandlerEntity<"marker", MMapMarker> | HandlerEntity<"hotspot", MMapHotspot> | undefined;
+interface TileLayerState {
+    /** Number of tiles loaded from the server. */
+    tilesLoaded: number;
+    /** Number of tiles ready to be displayed. */
+    tilesReady: number;
+    /** Total number of tiles in the visible area. */
+    tilesTotal: number;
+}
+interface MapState {
+    getLayerState(layerId: string, type: string, effectiveMode?: "raster" | "vector"): Record<string, unknown> | undefined;
+    getLayerState(layerId: string, type: "tile", effectiveMode?: "raster" | "vector"): TileLayerState | undefined;
+}
 export type DomEventHandler = (object: DomEventHandlerObject, event: DomEvent) => void;
 type Location = Required<MMapLocation>;
 interface UpdateObject {
@@ -33,6 +45,7 @@ interface ResizeObject {
 type MapEventHandler<TObject> = (object: TObject) => void;
 export type MapEventUpdateHandler = MapEventHandler<UpdateObject>;
 export type MapEventResizeHandler = MapEventHandler<ResizeObject>;
+export type MapEventReadyStateChangeHandler = MapEventHandler<MapState>;
 export type IndoorPlansHandler = (object: {
     type: IndoorPlanType;
     indoorPlans: readonly IndoorPlan[] | null;
@@ -65,6 +78,7 @@ export type DomEvents = {
 export type MapEvents = {
     onUpdate: MapEventUpdateHandler;
     onResize: MapEventResizeHandler;
+    onStateChanged: MapEventReadyStateChangeHandler;
 };
 export type BehaviorEvents = {
     onActionStart: BehaviorMapEventHandler;
@@ -100,6 +114,7 @@ declare class MMapListener extends MMapEntity<MMapListenerProps> {
     private _subscribeDomEvent;
     private _subscribeMapEvent;
     private _subscribeMapIndoorPlansEvent;
+    private _subscribeMapStateChanged;
     private _subscribeActionEvent;
     private _subscribe;
     private _unsubscribe;

package/imperative/MMapReactContainer/index.d.ts

@@ -1,35 +1,9 @@
-import type TReact from "react";
-import type { Context } from "../Entities";
-import { MMapGroupEntity } from "../MMapEnities";
-import { overrideKeyReactify } from "../wrappers";
-interface MMapReactContainerPropsImpl<TContext> {
-    onElement: (element?: Element) => void;
-    onContext: (context?: TContext) => void;
+import { MMapContainer, MMapContainerProps, MMapContainerPropsImpl } from "../MMapContainer";
+/** @deprecated Use MMapContainerPropsImpl instead */
+type MMapReactContainerPropsImpl<TContext> = MMapContainerPropsImpl<TContext>;
+/** @deprecated Use MMapContainerProps instead */
+type MMapReactContainerProps<TContext> = MMapContainerProps<TContext>;
+/** @deprecated Use MMapContainer instead */
+declare class MMapReactContainer extends MMapContainer {
 }
-interface MMapReactContainerProps<TContext> {
-    tagName?: string;
-    className?: string;
-    style?: TReact.CSSProperties;
-    context?: Context<TContext>;
-}
-declare const defaultProps: {
-    tagName: string;
-};
-type DefaultProps = typeof defaultProps;
-type ComputedMMapReactContainerProps<TContext> = MMapReactContainerProps<TContext> & MMapReactContainerPropsImpl<TContext>;
-declare class MMapReactContainer extends MMapGroupEntity<ComputedMMapReactContainerProps<unknown>, DefaultProps> {
-    static defaultProps: {
-        tagName: string;
-    };
-    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapReactContainer, TReact.FC<MMapReactContainerProps<unknown> & {
-        children?: TReact.ReactNode;
-    }>>;
-    element?: Element;
-    private _detachDom?;
-    private _disposeWatch?;
-    protected _onAttach(): void;
-    private _adjustContext;
-    protected _onDetach(): void;
-    protected _onUpdate(props: Partial<ComputedMMapReactContainerProps<unknown>>): void;
-}
-export { MMapReactContainer, MMapReactContainerProps, MMapReactContainerPropsImpl };
+export { MMapReactContainer, MMapReactContainerPropsImpl, MMapReactContainerProps };

package/imperative/MMapTileDataSource/index.d.ts

@@ -53,5 +53,6 @@ declare class MMapTileDataSource extends MMapEntity<MMapTileDataSourceProps> {
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(props: Partial<MMapTileDataSourceProps>): void;
+    private _validateVectorSource;
 }
 export { MMapTileDataSource, MMapTileDataSourceProps };

package/imperative/index.d.ts

@@ -1,4 +1,4 @@
-export { MMap, MMapProps, MMapCenterLocation, MMapZoomLocation, MMapBoundsLocation, MMapCenterZoomLocation, MMapLocationRequest } from "./MMap";
+export { MMap, MMapProps, MMapCenterLocation, MMapZoomLocation, MMapBoundsLocation, MMapCenterZoomLocation, MMapLocationRequest, MMapCameraRequest } from "./MMap";
 export { MMapCopyrightsPosition } from "./MMapCopyrights";
 export { MMapEntity, MMapComplexEntity, MMapGroupEntity, MMapContext } from "./MMapEnities";
 export { MMapDefaultFeaturesLayer, MMapDefaultFeaturesLayerProps } from "./MMapDefaultFeaturesLayer";
@@ -14,6 +14,7 @@ export { MMapTileDataSource, MMapTileDataSourceProps } from "./MMapTileDataSourc
 export { MMapControls, MMapControlsProps } from "./MMapControls";
 export { MMapControl, MMapControlProps, MMapControlButton, MMapControlButtonProps, MMapControlCommonButton } from "./MMapControl";
 export { MMapCollection } from "./MMapCollection";
+export { MMapContainer, MMapContainerProps, MMapContainerPropsImpl, ComputedMMapContainerProps } from "./MMapContainer";
 export * from "./mappable-worldMaps";
 export * from "./search";
 export * from "./suggest";

package/imperative/wrappers.d.ts

@@ -40,3 +40,5 @@
  * ```
  */
 export declare const overrideKeyReactify: unique symbol;
+export declare const overrideKeyVuefy: unique symbol;
+export declare const optionsKeyVuefy: unique symbol;

package/modules/controls-extra/MMapOpenMapsButton/index.d.ts

@@ -1,4 +1,5 @@
 import { MMapEntity } from "../../../imperative/MMapEnities";
+import type { CustomVuefyOptions } from "../../vuefy";
 /**
  * MMapOpenMapsButton props
  */
@@ -7,5 +8,6 @@ type MMapOpenMapsButtonProps = {
     title?: string;
 };
 declare class MMapOpenMapsButton extends MMapEntity<MMapOpenMapsButtonProps> {
+    static [mappable.optionsKeyVuefy]: CustomVuefyOptions<MMapOpenMapsButton>;
 }
 export { MMapOpenMapsButton, MMapOpenMapsButtonProps };

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

@@ -1,7 +1,8 @@
 import { MMapComplexEntity } from "../../../imperative/MMapEnities";
-import type { MMapFeatureEditorProps } from "./interface";
-import { MMapFeatureEditorDefaultPreviewPoint } from "./MMapFeatureEditorDefaultPreviewPoint";
+import type { CustomVuefyOptions } from "../../vuefy";
 import { MMapFeatureEditorDefaultPoint } from "./MMapFeatureEditorDefaultPoint";
+import { MMapFeatureEditorDefaultPreviewPoint } from "./MMapFeatureEditorDefaultPreviewPoint";
+import type { MMapFeatureEditorProps } from "./interface";
 declare const defaultProps: Readonly<{
     isActive: true;
     featureStyle: {};
@@ -24,6 +25,7 @@ declare class MMapFeatureEditor extends MMapComplexEntity<MMapFeatureEditorProps
         previewPointElement: MMapFeatureEditorDefaultPreviewPoint;
         renderPoint: () => MMapFeatureEditorDefaultPoint;
     }>;
+    static [mappable.optionsKeyVuefy]: CustomVuefyOptions<MMapFeatureEditor>;
     private _previewPoint;
     private _draggingPoint;
     private _getName;

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

@@ -1,5 +1,6 @@
 import { MMapComplexEntity, MMapEntity } from "../../../imperative/MMapEnities";
 import type { MMapHotspot } from "../../../imperative/MMapHotspot";
+import type { CustomVuefyOptions } from "../../vuefy";
 type MMapCursorProps = {
     /** Layer to follow */
     layer?: string;
@@ -20,8 +21,9 @@ declare class MMapCursor extends MMapComplexEntity<MMapCursorProps, DefaultProps
         cursor: "pointer";
         isActive: (object: MMapEntity<unknown, {}> | MMapHotspot) => boolean;
     }>;
+    static [mappable.optionsKeyVuefy]: CustomVuefyOptions<MMapCursor>;
     constructor(props: MMapCursorProps);
     private _onMouseMove;
     private _onMouseLeave;
 }
-export { MMapCursorProps, MMapCursor };
+export { MMapCursor, MMapCursorProps };

package/modules/vuefy/index.d.ts

@@ -0,0 +1,10 @@
+import { optionsKeyVuefy, overrideKeyVuefy } from "../../imperative/wrappers";
+import type { CustomVuefyFn, CustomVuefyOptions, Vuefy } from "./types";
+import type TVue from "@vue/runtime-core";
+export type GenericVuefy = {
+    readonly overrideKey: typeof overrideKeyVuefy;
+    readonly optionsKey: typeof optionsKeyVuefy;
+    bindTo(Vue: typeof TVue): Vuefy;
+};
+export declare const vuefy: Readonly<GenericVuefy>;
+export type { CustomVuefyFn, CustomVuefyOptions, Vuefy };

package/modules/vuefy/options/common.d.ts

@@ -0,0 +1,17 @@
+import type { CustomVuefyOptions } from "..";
+import { MMap, MMapContainer, MMapControlButton, MMapControls, MMapDefaultFeaturesLayer, MMapDefaultSchemeLayer, MMapFeature, MMapFeatureDataSource, MMapLayer, MMapMarker, MMapTileDataSource } from "../../../imperative";
+import { type EntityConstructor, type GenericEntity } from "../../../imperative/Entities";
+import type { ComputedMMapMarkerContainerProps } from "../overrides/MMapMarker";
+export declare const MMapVuefyOptions: CustomVuefyOptions<MMap>;
+export declare const MMapControlButtonVuefyOptions: CustomVuefyOptions<MMapControlButton>;
+export declare const MMapControlsVuefyOptions: CustomVuefyOptions<MMapControls>;
+export declare const MMapDefaultFeaturesLayerVuefyOptions: CustomVuefyOptions<MMapDefaultFeaturesLayer>;
+export declare const MMapDefaultSchemeLayerVuefyOptions: CustomVuefyOptions<MMapDefaultSchemeLayer>;
+export declare const MMapFeatureVuefyOptions: CustomVuefyOptions<MMapFeature>;
+export declare const MMapFeatureDataSourceVuefyOptions: CustomVuefyOptions<MMapFeatureDataSource>;
+export declare const MMapLayerVuefyOptions: CustomVuefyOptions<MMapLayer>;
+export declare const MMapMarkerVuefyOptions: CustomVuefyOptions<MMapMarker, ComputedMMapMarkerContainerProps>;
+export declare const MMapTileDataSourceVuefyOptions: CustomVuefyOptions<MMapTileDataSource>;
+export declare const MMapContainerVuefyOptions: CustomVuefyOptions<MMapContainer>;
+declare const _default: Map<EntityConstructor<GenericEntity<unknown, {}, import("../../../imperative/Entities").GenericRootEntity<unknown, {}>>>, CustomVuefyOptions<GenericEntity<unknown, {}, import("../../../imperative/Entities").GenericRootEntity<unknown, {}>>>>;
+export default _default;

package/modules/vuefy/options/index.d.ts

@@ -0,0 +1,2 @@
+import commonOptions from "./common";
+export default commonOptions;

package/modules/vuefy/overrides/MMap.d.ts

@@ -0,0 +1,3 @@
+import type { MMap as MMapI } from "../../../imperative/MMap";
+import type { CustomVuefyFn } from "../types";
+export declare const MMapVuefyOverride: CustomVuefyFn<MMapI>;

package/modules/vuefy/overrides/MMapContainer.d.ts

@@ -0,0 +1,3 @@
+import type { MMapContainer as MMapContainerI } from "../../../imperative/MMapContainer";
+import type { CustomVuefyFn } from "../types";
+export declare const MMapContainerVuefyOverride: CustomVuefyFn<MMapContainerI>;

package/modules/vuefy/overrides/MMapControl.d.ts

@@ -0,0 +1,3 @@
+import type { MMapControl as MMapControlI } from "../../../imperative/MMapControl";
+import type { CustomVuefyFn } from "../types";
+export declare const MMapControlVuefyOverride: CustomVuefyFn<MMapControlI>;

package/modules/vuefy/overrides/MMapControlButton.d.ts

@@ -0,0 +1,3 @@
+import type { MMapControlButton as MMapControlButtonI } from "../../../imperative/MMapControl";
+import type { CustomVuefyFn } from "../types";
+export declare const MMapControlButtonVuefyOverride: CustomVuefyFn<MMapControlButtonI>;

package/modules/vuefy/overrides/MMapMarker.d.ts

@@ -0,0 +1,6 @@
+import type { MMapMarker as MMapMarkerI, MMapMarkerProps } from "../../../imperative/MMapMarker";
+import type { CustomVuefyFn } from "../types";
+export type ComputedMMapMarkerContainerProps = MMapMarkerProps & {
+    markerElement: HTMLElement;
+};
+export declare const MMapMarkerVuefyOverride: CustomVuefyFn<MMapMarkerI, ComputedMMapMarkerContainerProps>;

package/modules/vuefy/overrides/index.d.ts

@@ -0,0 +1,3 @@
+import type { CustomVuefyFn, DefaultCtor, DefaultEntity } from "../types";
+declare const _default: Map<DefaultCtor, CustomVuefyFn<DefaultEntity>>;
+export default _default;

package/modules/vuefy/types.d.ts

@@ -0,0 +1,50 @@
+import type TVue from "@vue/runtime-core";
+import type { Context, EntityConstructor, EntityProps, GenericEntity } from "../../imperative/Entities";
+import type { optionsKeyVuefy, overrideKeyVuefy } from "../../imperative/wrappers";
+export type BaseModule = Record<string | symbol, unknown>;
+export type DefaultEntity = GenericEntity<unknown>;
+export type DefaultContext = Context<unknown>;
+export type DefaultCtor = EntityConstructor<DefaultEntity>;
+export type PropsFromCtor<TCtor extends DefaultCtor> = EntityProps<InstanceType<TCtor>>;
+export type VuefyPropsModule<TModule extends BaseModule> = {
+    [Key in keyof TModule]: TModule[Key] extends GenericEntity<infer Props> ? VuefyPropsObject<Props> | VuefyPropsArray<Props> : unknown;
+};
+export type VuefyPropsObject<RawProps> = {
+    [K in keyof RawProps]-?: TVue.PropType<RawProps[K]> | TVue.Prop<RawProps[K]>;
+};
+export type VuefyPropsNullObject<RawProps> = {
+    [K in keyof RawProps]-?: null;
+};
+export type VuefyPropsArray<RawProps> = Array<keyof RawProps>;
+export type Vuefy = {
+    module: VuefyModuleFn;
+    entity: VuefyEntityFn;
+};
+export interface VuefyModuleFn {
+    <TModule extends BaseModule = BaseModule>(module: TModule, props?: VuefyPropsModule<TModule>): VuefiedModule<TModule>;
+}
+export type VuefyEntityFn = <TCtor extends DefaultCtor, TProps = PropsFromCtor<TCtor>>(...args: Parameters<VuefyEntityFnGen<TCtor, TProps>>) => ReturnType<VuefyEntityFnGen<TCtor, TProps>>;
+export type VuefyEntityFnGen<TCtor extends DefaultCtor, TProps = PropsFromCtor<TCtor>> = (ctor: TCtor, props?: VuefyPropsObject<TProps> | VuefyPropsArray<TProps>, displayName?: string) => TVue.Component<TProps>;
+export type VuefyContextFn = <TContext extends DefaultContext>(context?: TContext) => symbol;
+export type InternalVuefyEntityFn = <TCtor extends DefaultCtor, TProps = PropsFromCtor<TCtor>>(...args: Parameters<InternalVuefyEntityFnGen<TCtor, TProps>>) => ReturnType<InternalVuefyEntityFnGen<TCtor, TProps>>;
+export type InternalVuefyEntityFnGen<TCtor extends DefaultCtor, TProps = PropsFromCtor<TCtor>> = (ctor: TCtor, props: VuefyPropsObject<TProps>, displayName: string) => TVue.Component<TProps>;
+export type VuefiedModule<TModule extends BaseModule> = {
+    [Property in keyof TModule]: TModule[Property] extends DefaultCtor ? ReturnType<VuefyEntityFnGen<TModule[Property]>> : TModule[Property] extends typeof Context ? ReturnType<VuefyContextFn> : TModule[Property];
+};
+export type Overrided<TCtor extends DefaultCtor, TVueProps> = {
+    [overrideKeyVuefy]: CustomVuefyFn<InstanceType<TCtor>, TVueProps>;
+};
+export type Options<TCtor extends DefaultCtor, TVueProps> = {
+    [optionsKeyVuefy]: CustomVuefyOptions<InstanceType<TCtor>, TVueProps>;
+};
+export type CustomVuefyFn<TEntity extends DefaultEntity, TExternalProps = EntityProps<TEntity>> = (ctor: EntityConstructor<TEntity>, props: VuefyPropsObject<TExternalProps>, params: {
+    vuefy: {
+        module: VuefyModuleFn;
+        entity: VuefyEntityFn;
+        context: VuefyContextFn;
+    };
+    Vue: typeof TVue;
+}) => TVue.Component<TExternalProps>;
+export type CustomVuefyOptions<TEntity extends DefaultEntity, TExternalProps = EntityProps<TEntity>> = {
+    props: VuefyPropsObject<TExternalProps> | VuefyPropsArray<TExternalProps>;
+};

package/modules/vuefy/vuefy.d.ts

@@ -0,0 +1,3 @@
+import type TVue from "@vue/runtime-core";
+import type { Vuefy } from "./types";
+export declare function createVuefy(Vue: typeof TVue): Vuefy;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mappable-world/mappable-types",
-    "version": "0.0.9",
+    "version": "0.0.11",
     "description": "Types for mappable maps library",
     "main": "",
     "types": "index.d.ts",
@@ -16,5 +16,10 @@
         "registry": "https://registry.npmjs.org"
     },
     "homepage": "https://mappable.world",
-    "license": "Apache-2.0"
+    "license": "Apache-2.0",
+    "dependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "@vue/runtime-core": "*"
+    }
 }

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

@@ -67,6 +67,8 @@ declare class MMapClusterer extends mappable.MMapComplexEntity<MMapClustererProp
         }, {}>> | undefined;
         key?: import("react").Key | null | undefined;
     }>>;
+    static [mappable.overrideKeyVuefy]: import("../../../modules/vuefy").CustomVuefyFn<MMapClusterer>;
+    static [mappable.optionsKeyVuefy]: import("../../../modules/vuefy").CustomVuefyOptions<MMapClusterer>;
     /** All created entities with cluster id*/
     private _entitiesCache;
     /** Viewport entities with cluster id */

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

@@ -0,0 +1,4 @@
+import type { CustomVuefyFn, CustomVuefyOptions } from "../../../../modules/vuefy";
+import type { MMapClusterer } from "..";
+export declare const MMapClustererVuefyOptions: CustomVuefyOptions<MMapClusterer>;
+export declare const MMapClustererVuefyOverride: CustomVuefyFn<MMapClusterer>;

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

@@ -1,4 +1,5 @@
 import type { EasingFunctionDescription, LngLat } from "../../../common/types";
+import type { CustomVuefyOptions } from "../../../modules/vuefy";
 /**
  * MMapGeolocationControl props
  */
@@ -31,6 +32,7 @@ declare class MMapGeolocationControl extends mappable.MMapGroupEntity<MMapGeoloc
     static defaultProps: Readonly<{
         duration: 500;
     }>;
+    static [mappable.optionsKeyVuefy]: CustomVuefyOptions<MMapGeolocationControl>;
     private _control;
     private _button;
     private _spinner;

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

@@ -1,6 +1,7 @@
 import type { EasingFunctionDescription } from "../../../common/types";
 import type { MMapControlCommonButton } from "../../../imperative/MMapControl";
 import type { MMapListener } from "../../../imperative/MMapListener";
+import type { CustomVuefyOptions } from "../../../modules/vuefy";
 /**
  * MMapZoomControl props
  */
@@ -30,6 +31,7 @@ declare class MMapZoomControl extends mappable.MMapControl<MMapZoomControlProps>
     static defaultProps: Readonly<{
         duration: 200;
     }>;
+    static [mappable.optionsKeyVuefy]: CustomVuefyOptions<MMapZoomControl>;
     protected _zoomIn: MMapControlCommonButton;
     protected _zoomOut: MMapControlCommonButton;
     protected _listener: MMapListener;

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

@@ -1,7 +1,8 @@
-import type TReact from "react";
-import type { MMapFeature, MMapMarker, MMapHotspot } from "../../../imperative";
+import type { MMapFeature, MMapHotspot, MMapMarker } from "../../../imperative";
+import type { CustomVuefyFn, CustomVuefyOptions } from "../../../modules/vuefy";
 import type { CustomReactify } from "../../../reactify/reactify";
-import { overrideKeyReactify } from "../../../imperative/wrappers";
+import type TReact from "react";
+import { optionsKeyVuefy, overrideKeyReactify, overrideKeyVuefy } from "../../../imperative/wrappers";
 type MMapHintProps = {
     hint: (object: MMapFeature | MMapMarker | MMapHotspot | undefined) => unknown;
 };
@@ -40,6 +41,8 @@ declare const MMapHintContext: import("../../../imperative/Entities").Context<un
  */
 declare class MMapHint extends mappable.MMapGroupEntity<MMapHintProps> {
     static [overrideKeyReactify]: CustomReactify<MMapHint, TReact.FC<MMapHintProps>>;
+    static [overrideKeyVuefy]: CustomVuefyFn<MMapHint>;
+    static [optionsKeyVuefy]: CustomVuefyOptions<MMapHint>;
     private _destroyDomContext;
     private _detachDom;
     private _element;

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

@@ -80,6 +80,8 @@ declare class MMapDefaultMarker extends mappable.MMapComplexEntity<MMapDefaultMa
         ref?: import("react").Ref<import("../../../imperative/MMapEnities").MMapEntity<MMapDefaultMarkerProps, {}>> | undefined;
         key?: import("react").Key | null | undefined;
     }>>;
+    static [mappable.overrideKeyVuefy]: import("../../../modules/vuefy").CustomVuefyFn<MMapDefaultMarker>;
+    static [mappable.optionsKeyVuefy]: import("../../../modules/vuefy").CustomVuefyOptions<MMapDefaultMarker>;
     private _marker;
     private _container;
     private _popup;

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

@@ -0,0 +1,4 @@
+import type { CustomVuefyFn, CustomVuefyOptions } from "../../../../modules/vuefy";
+import type { MMapDefaultMarker } from "..";
+export declare const MMapDefaultMarkerVuefyOptions: CustomVuefyOptions<MMapDefaultMarker>;
+export declare const MMapDefaultMarkerVuefyOverride: CustomVuefyFn<MMapDefaultMarker>;

package/reactify/overrides/MMapContainer.d.ts

@@ -0,0 +1,6 @@
+import type TReact from "react";
+import type { CustomReactify } from "../reactify";
+import type { MMapContainer, MMapContainerProps } from "../../imperative/MMapContainer";
+type ReactProps<T> = TReact.PropsWithChildren<MMapContainerProps<T>>;
+export declare const MMapContainerReactifyOverride: CustomReactify<MMapContainer, TReact.FC<ReactProps<unknown>>>;
+export {};

package/reactify/overrides/MMapReactContainer.d.ts

@@ -2,5 +2,6 @@ import type TReact from "react";
 import type { CustomReactify } from "../reactify";
 import type { MMapReactContainer, MMapReactContainerProps } from "../../imperative/MMapReactContainer";
 type ReactProps<T> = TReact.PropsWithChildren<MMapReactContainerProps<T>>;
+/** @deprecated Use MMapContainerReactifyOverride instead */
 export declare const MMapReactContainerReactifyOverride: CustomReactify<MMapReactContainer, TReact.FC<ReactProps<unknown>>>;
 export {};

package/reactify/overrides/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./MMap";
+export * from "./MMapContainer";
 export * from "./MMapControl";
+export * from "./MMapControlButton";
 export * from "./MMapMarker";
 export * from "./MMapReactContainer";
-export * from "./MMapControlButton";