@mappable-world/mappable-types 0.0.1

package/imperative/MMapDefaultSatelliteLayer/index.d.ts

@@ -0,0 +1,41 @@
+import { MMapComplexEntity } from "../MMapEnities";
+/**
+ * MMapDefaultSatelliteLayer props
+ */
+type MMapDefaultSatelliteLayerProps = {
+    /** Should show layer */
+    visible?: boolean;
+};
+declare const defaultProps: {
+    readonly visible: true;
+    readonly source: "mappable-default-satellite";
+};
+type DefaultProps = typeof defaultProps;
+/**
+ * Map satellite layer to show satellite tiles on map.
+ *
+ * @example
+ * ```javascript
+ * const defaultSatelliteLayer = new MMapDefaultSatelliteLayer();
+ * // add to map
+ * map.addChild(defaultSatelliteLayer);
+ * // update
+ * defaultSatelliteLayer.update({visible: false});
+ * ```
+ */
+declare class MMapDefaultSatelliteLayer extends MMapComplexEntity<MMapDefaultSatelliteLayerProps, DefaultProps> {
+    static defaultProps: {
+        readonly visible: true;
+        readonly source: "mappable-default-satellite";
+    };
+    private _dataSource?;
+    private _layer?;
+    private _unwatchMapContext?;
+    protected __implGetDefaultProps(): DefaultProps;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    protected _onUpdate(propsDiff: Partial<MMapDefaultSatelliteLayerProps>): void;
+    private _createTileUrl;
+    private _getDataSourceDescription;
+}
+export { MMapDefaultSatelliteLayer, MMapDefaultSatelliteLayerProps };

package/imperative/MMapDefaultSchemeLayer/index.d.ts

@@ -0,0 +1,92 @@
+import type { VectorCustomization } from "../../common/types";
+import { MMapComplexEntity } from "../MMapEnities";
+/**
+ * MMapDefaultSchemeLayer props
+ */
+type MMapDefaultSchemeLayerProps = {
+    /** Should show layer */
+    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;
+            zIndex: number;
+        };
+        buildings: {
+            type: string;
+            zIndex: number;
+        };
+        icons: {
+            type: string;
+            zIndex: number;
+        };
+        labels: {
+            type: string;
+            zIndex: number;
+        };
+    };
+};
+type DefaultProps = typeof defaultProps;
+/**
+ * Map default layer to show mappable scheme on map.
+ *
+ * @example
+ * ```javascript
+ * const defaultSchemeLayer = new MMapDefaultSchemeLayer({theme: 'dark'});
+ * // add to map
+ * map.addChild(defaultSchemeLayer);
+ * // update
+ * defaultSchemeLayer.update({theme: 'light'});
+ * ```
+ */
+declare class MMapDefaultSchemeLayer extends MMapComplexEntity<MMapDefaultSchemeLayerProps, DefaultProps> {
+    static defaultProps: {
+        visible: boolean;
+        source: string;
+        /** @internal */
+        hotspotsEnabled: boolean;
+        layersInfo: {
+            ground: {
+                type: string;
+                zIndex: number;
+            };
+            buildings: {
+                type: string;
+                zIndex: number;
+            };
+            icons: {
+                type: string;
+                zIndex: number;
+            };
+            labels: {
+                type: string;
+                zIndex: number;
+            };
+        };
+    };
+    private _dataSource?;
+    private _layers;
+    private _unwatchMapContext?;
+    protected __implGetDefaultProps(): DefaultProps;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    protected _onUpdate(propsDiff: Partial<MMapDefaultSchemeLayerProps>): void;
+    private _createTileUrl;
+    private _getProjectionQuery;
+    private _getDataSourceDescription;
+}
+export { MMapDefaultSchemeLayer, MMapDefaultSchemeLayerProps };

package/imperative/MMapEnities.d.ts

@@ -0,0 +1,18 @@
+import type { MMap } from "./MMap";
+import { GenericComplexEntity, GenericEntity, GenericGroupEntity, Context } from "./Entities";
+declare abstract class MMapEntity<Props, DefaultProps extends {} = {}> extends GenericEntity<Props, DefaultProps, MMap> {
+    get root(): null | MMap;
+    get parent(): null | MMapComplexEntity<unknown>;
+}
+declare abstract class MMapComplexEntity<Props, DefaultProps extends {} = {}> extends GenericComplexEntity<Props, DefaultProps, MMap> implements MMapEntity<Props, DefaultProps> {
+    get root(): null | MMap;
+    get parent(): null | MMapComplexEntity<unknown>;
+}
+declare abstract class MMapGroupEntity<Props, DefaultProps extends {} = {}> extends GenericGroupEntity<Props, DefaultProps, MMap> implements MMapComplexEntity<Props, DefaultProps> {
+    get root(): null | MMap;
+    get parent(): null | MMapComplexEntity<unknown>;
+    readonly children: readonly MMapEntity<unknown>[];
+    addChild(child: MMapEntity<unknown>, index?: number): this;
+    removeChild(child: MMapEntity<unknown>): this;
+}
+export { MMapEntity, MMapComplexEntity, MMapGroupEntity, Context as MMapContext };

package/imperative/MMapFeature/index.d.ts

@@ -0,0 +1,66 @@
+import type { DrawingStyle, GenericGeometry, LngLat } from "../../common/types";
+import type { DraggableProps, FeatureClickEvents } from "./types";
+import { MMapEntity } from "../MMapEnities";
+import type { Geometry, MMapFeatureEventHandler } from "./types";
+/**
+ * MMapFeature props
+ */
+type MMapFeatureProps = {
+    id?: string;
+    geometry: Geometry;
+    source?: string;
+    style?: DrawingStyle;
+    properties?: Record<string, unknown>;
+} & DraggableProps<MMapFeatureEventHandler> & FeatureClickEvents;
+declare const defaultProps: Readonly<{
+    source: "mappable-default-feature";
+}>;
+type DefaultProps = typeof defaultProps & {
+    id: string;
+};
+/**
+ * The feature component on the map.
+ *
+ * @example
+ * ```javascript
+ * const feature = new MMapFeature({
+ *     geometry: {
+ *         type: 'LineString',
+ *         coordinates: [
+ *             [37.40108963847453, 55.70173382087952],
+ *             [37.60954231796791, 55.57717912610197]
+ *         ]
+ *     },
+ *     style: {
+ *         stroke: [{width: 12, color: 'rgb(14, 194, 219)'}]
+ *     }})
+ * map
+ *     .addChild(new MMapDefaultSchemeLayer())
+ *     .addChild(new MMapDefaultFeaturesLayer())
+ *     .addChild(feature);
+ * ```
+ */
+declare class MMapFeature extends MMapEntity<MMapFeatureProps, DefaultProps> {
+    static defaultProps: Readonly<{
+        source: "mappable-default-feature";
+    }>;
+    private static _uid;
+    private _id;
+    private _source;
+    private _isDragging;
+    constructor(props: MMapFeatureProps);
+    get properties(): Record<string, unknown> | undefined;
+    get geometry(): GenericGeometry<LngLat>;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    protected _onUpdate({ style, id, source }: Partial<MMapFeatureProps>): void;
+    protected __implGetDefaultProps(): DefaultProps;
+    private __onDragStart;
+    private __onDragMove;
+    private __onDragEnd;
+    private __onClick;
+    private __onDoubleClick;
+    private __onFastClick;
+    private __isMy;
+}
+export { MMapFeature, MMapFeatureProps };

package/imperative/MMapFeature/types.d.ts

@@ -0,0 +1,34 @@
+import type { LineStringGeometry, Margin, MultiLineStringGeometry, MultiPolygonGeometry, PointGeometry, PolygonGeometry } from "../../common/types";
+export interface DraggableProps<Callback> {
+    /** Feature can be draggable */
+    draggable?: boolean;
+    /** Will map center follows marker on drag if marker near the edge of the map */
+    mapFollowsOnDrag?: boolean | {
+        activeZoneMargin?: Margin;
+    };
+    /** 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.
+     * */
+    onDragEnd?: Callback;
+    /** Fires on drag move */
+    onDragMove?: Callback;
+    /** Will block maps events on marker */
+    blockEvents?: boolean;
+    /** Will block maps behaviors on marker */
+    blockBehaviors?: boolean;
+}
+export interface FeatureClickEvents {
+    /** Double click handler */
+    onDoubleClick?: (event: MouseEvent) => void;
+    /** Click handler */
+    onClick?: (event: MouseEvent) => void;
+    /** Fast click handler */
+    onFastClick?: (event: MouseEvent) => void;
+}
+export type Geometry = PolygonGeometry | MultiPolygonGeometry | LineStringGeometry | MultiLineStringGeometry | PointGeometry;
+export type MMapFeatureEventHandler = (coordinates: Geometry['coordinates']) => void | false;

package/imperative/MMapFeatureDataSource/index.d.ts

@@ -0,0 +1,27 @@
+import { MMapEntity } from "../MMapEnities";
+/**
+ * MMapFeatureDataSource props
+ */
+type MMapFeatureDataSourceProps = {
+    /** Data source id */
+    id: string;
+};
+/**
+ * Map geojson data source. Used to upload objects to the map in geojson format
+ *
+ * @example
+ * ```javascript
+ * const ID = 'id';
+ * const dataSource = new MMapFeatureDataSource({id: ID});
+ * const layer = new MMapLayer({source: ID, type: 'features', zIndex: 10});
+ * map
+ *     .addChild(dataSource)
+ *     .addChild(layer);
+ * ```
+ */
+declare class MMapFeatureDataSource extends MMapEntity<MMapFeatureDataSourceProps> {
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    protected _onUpdate(): void;
+}
+export { MMapFeatureDataSource, MMapFeatureDataSourceProps };

package/imperative/MMapHotspot/index.d.ts

@@ -0,0 +1,11 @@
+import type { GenericGeometry, LngLat } from "../../common/types";
+/**
+ * This is not a real MMapEntity, it cannot be added to the map.
+ * But you can check it by `instance of` in MMapListener handlers
+ */
+declare class MMapHotspot {
+    readonly geometry?: GenericGeometry<LngLat>;
+    readonly properties: Record<string, unknown>;
+    constructor(geometry: GenericGeometry<LngLat> | undefined, properties: Record<string, unknown>);
+}
+export { MMapHotspot };

package/imperative/MMapLayer/index.d.ts

@@ -0,0 +1,38 @@
+import type { RasterLayerOptions } from "../../common/types";
+import { MMapEntity } from "../MMapEnities";
+/**
+ * MMapLayer props
+ */
+type MMapLayerProps = {
+    /** Layer id */
+    id?: string;
+    /** Layer source */
+    source: string;
+    /** Layer type. For tile data sources should use 'ground' */
+    type: string;
+    /** Layer z-index to control order. Default is 1500 */
+    zIndex?: number;
+    /** Layer options */
+    options?: {
+        raster?: RasterLayerOptions;
+    };
+};
+declare const defaultProps: Readonly<{
+    zIndex: 1500;
+}>;
+type DefaultProps = typeof defaultProps & {
+    id: string;
+};
+/**
+ * Map layer.
+ */
+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;
+}
+export { MMapLayer, MMapLayerProps };

package/imperative/MMapListener/index.d.ts

@@ -0,0 +1,113 @@
+import type { IndoorPlan, PixelCoordinates } from "../../common/types";
+import { MMapFeature } from "../MMapFeature";
+import { MMapMarker } from "../MMapMarker";
+import type { BehaviorType, LngLat } from "../../common/types";
+import { MMapEntity } from "../MMapEnities";
+import { MMapHotspot } from "../MMapHotspot";
+import type { MMapCamera, MMapLocation } from "../MMap";
+export interface DomEvent {
+    coordinates: LngLat;
+    screenCoordinates: [
+        number,
+        number
+    ];
+}
+type HandlerEntity<TType extends string, TEntity> = {
+    type: TType;
+    entity: TEntity;
+};
+export type DomEventHandlerObject = HandlerEntity<"feature", MMapFeature> | HandlerEntity<"marker", MMapMarker> | HandlerEntity<"hotspot", MMapHotspot> | undefined;
+export type DomEventHandler = (object: DomEventHandlerObject, event: DomEvent) => void;
+type Location = Required<MMapLocation>;
+interface UpdateObject {
+    type: "update";
+    location: Location;
+    camera: MMapCamera;
+    mapInAction: boolean;
+}
+interface ResizeObject {
+    type: "resize";
+    size: Readonly<PixelCoordinates>;
+    mapInAction: boolean;
+}
+type MapEventHandler<TObject> = (object: TObject) => void;
+export type MapEventUpdateHandler = MapEventHandler<UpdateObject>;
+export type MapEventResizeHandler = MapEventHandler<ResizeObject>;
+export type IndoorPlansHandler = (object: {
+    type: IndoorPlanType;
+    indoorPlans: readonly IndoorPlan[] | null;
+}) => void;
+export type BehaviorMapEventHandler = (object: {
+    type: BehaviorType;
+    location: Location;
+    camera: MMapCamera;
+}) => void;
+export type DomEvents = {
+    onTouchStart: DomEventHandler;
+    onTouchMove: DomEventHandler;
+    onTouchEnd: DomEventHandler;
+    onTouchCancel: DomEventHandler;
+    onPointerDown: DomEventHandler;
+    onPointerMove: DomEventHandler;
+    onPointerUp: DomEventHandler;
+    onPointerCancel: DomEventHandler;
+    onFastClick: DomEventHandler;
+    onClick: DomEventHandler;
+    onDblClick: DomEventHandler;
+    onMouseUp: DomEventHandler;
+    onMouseDown: DomEventHandler;
+    onMouseEnter: DomEventHandler;
+    onMouseLeave: DomEventHandler;
+    onMouseMove: DomEventHandler;
+    onContextMenu: DomEventHandler;
+    onRightDblClick: DomEventHandler;
+};
+export type MapEvents = {
+    onUpdate: MapEventUpdateHandler;
+    onResize: MapEventResizeHandler;
+    /** @internal */
+    onIndoorPlansChanged: IndoorPlansHandler;
+};
+export type BehaviorEvents = {
+    onActionStart: BehaviorMapEventHandler;
+    onActionEnd: BehaviorMapEventHandler;
+};
+type IndoorPlanType = "indoorPlansChanged";
+export type NullablePartial<T> = {
+    [P in keyof T]?: T[P] | null;
+};
+type DomEventsProps = Partial<DomEvents> & {
+    layer?: string;
+};
+type MMapListenerProps = DomEventsProps | NullablePartial<MapEvents> | NullablePartial<BehaviorEvents>;
+/**
+ * A component for handling events of the map and its child elements. DOM events are also hung through this component.
+ * @example
+ * ```javascript
+ * const clickCallback = () => alert("Clicked!");
+ *
+ * const mapListener = new MMapListener({
+ *     layerId: "any",
+ *     onClick: clickCallback,
+ * });
+ *
+ * map.addChild(mapListener);
+ * ```
+ * @see [More about events](https://mappable.world/docs/jsapi/dg/concepts/events.html)
+ */
+declare class MMapListener extends MMapEntity<MMapListenerProps> {
+    private _domHandlers;
+    private _mapHandlers;
+    private _behaviorsHandlers;
+    private _subscribeDomEvent;
+    private _subscribeMapEvent;
+    private _subscribeMapIndoorPlansEvent;
+    private _subscribeActionEvent;
+    private _subscribe;
+    private _unsubscribe;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    protected _onUpdate(): void;
+    private __getRealCookie;
+}
+export { MMapListener, MMapListenerProps };

package/imperative/MMapMarker/index.d.ts

@@ -0,0 +1,98 @@
+import type { LngLat } from "../../common/types";
+import type { DraggableProps, FeatureClickEvents } from "../MMapFeature/types";
+import { reactify } from "../../reactify";
+import { MMapGroupEntity } from "../MMapEnities";
+/**
+ * MMapMarker events handler
+ */
+type MMapMarkerEventHandler = (coordinates: LngLat) => void | false;
+/**
+ * MMapMarker props
+ */
+type MMapMarkerProps = {
+    /** Coordinates of the marker */
+    coordinates: LngLat;
+    source?: string;
+    /** z index of the marker, defaults to 0 */
+    zIndex?: number;
+    properties?: Record<string, unknown>;
+    id?: string;
+} & DraggableProps<MMapMarkerEventHandler> & FeatureClickEvents;
+declare const defaultProps: Readonly<{
+    draggable: false;
+    mapFollowsOnDrag: false;
+    blockEvents: false;
+    blockBehaviors: false;
+    zIndex: 0;
+    source: "mappable-default-feature";
+}>;
+type DefaultProps = typeof defaultProps;
+/**
+ * The marker component on the map. Allows you to insert your own DOM implementation of the marker.
+ * > Does not provide a default implementation. See [[MMapDefaultMarker]]
+ *
+ * @example
+ * ```javascript
+ * const content = document.createElement('div');
+ * content.innerHTML = '<p>Draggable paragraph</p>';
+ * map.addChild(new MMapDefaultFeaturesLayer({zIndex: 1800}))
+ * map.addChild(new MMapMarker({
+ *     coordinates: [37, 55],
+ *     draggable: true
+ * }, content));
+ *```
+ * > Note: to insert a marker on the map, you need a [[MMapLayer]] layer with type 'markers'.
+ * The example above uses [[MMapDefaultFeaturesLayer]], which automatically adds the layer and the required datasource.
+ */
+declare class MMapMarker extends MMapGroupEntity<MMapMarkerProps, DefaultProps> {
+    static defaultProps: Readonly<{
+        draggable: false;
+        mapFollowsOnDrag: false;
+        blockEvents: false;
+        blockBehaviors: false;
+        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);
+    protected _getDefaultProps(): Readonly<{
+        draggable: false;
+        mapFollowsOnDrag: false;
+        blockEvents: false;
+        blockBehaviors: false;
+        zIndex: 0;
+        source: "mappable-default-feature";
+    }>;
+    private __feature;
+    get properties(): Record<string, unknown> | undefined;
+    get coordinates(): LngLat;
+    _onAttach(): void;
+    _onDetach(): void;
+    protected _onUpdate({ coordinates, zIndex, ...props }: Partial<MMapMarkerProps>): void;
+}
+export { MMapMarker, MMapMarkerProps, MMapMarkerEventHandler };

package/imperative/MMapReactContainer/index.d.ts

@@ -0,0 +1,37 @@
+import type TReact from "react";
+import type { Context } from "../Entities";
+import { reactify } from "../../reactify";
+import { MMapGroupEntity } from "../MMapEnities";
+interface MMapReactContainerPropsImpl<TContext> {
+    onElement: (element?: Element) => void;
+    onContext: (context?: TContext) => void;
+}
+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;
+    };
+    /** @internal */
+    static [reactify.overrideKey]: 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;
+    protected _onUpdate(props: Partial<ComputedMMapReactContainerProps<unknown>>): void;
+}
+export { MMapReactContainer, MMapReactContainerProps, MMapReactContainerPropsImpl };

package/imperative/MMapTileDataSource/index.d.ts

@@ -0,0 +1,57 @@
+import type { RasterTileDataSourceDescription, ZoomRange } from "../../common/types";
+import { MMapEntity } from "../MMapEnities";
+/**
+ * MMapTileDataSource props
+ */
+type MMapTileDataSourceProps = {
+    /** Data source id */
+    id: string;
+    /** Min and max zoom for tiles */
+    zoomRange?: ZoomRange;
+    /**
+         * Restrict min and max map zoom.
+         * Result map zoomRange will be the intersection of the map zoomRange
+         * and all data sources with the clampMapZoom option enabled
+         **/
+    clampMapZoom?: boolean;
+    /** Raster data source description */
+    raster?: RasterTileDataSourceDescription;
+    /** Data source copyrights */
+    copyrights?: string[];
+};
+/**
+ * Create map tile data source.
+ *
+ * @example
+ * ```javascript
+ * const layer = new MMapLayer({
+ *     id: 'layer-source-ground',
+ *     source: 'source',
+ *     type: 'ground',
+ *     raster: {
+ *         awaitAllTilesOnFirstDisplay: true
+ *     }
+ * });
+ * const map = new MMap(ref.current, {
+ *     location: [37.622504, 55.753215],
+ *     mode: 'vector'
+ * });
+ * map.addChild(new MMapTileDataSource({
+ *     id: 'source',
+ *     raster: {
+ *         type: 'ground',
+ *         fetchTile: 'https://my.host.example/tiles?x={{x}}&y={{y}}&z={{z}}&scale={{scale}}'
+ *     },
+ *     zoomRange: {min: 0, max: 19},
+ *     clampMapZoom: true
+ * }));
+ * map.addChild(layer);
+ * ```
+ */
+declare class MMapTileDataSource extends MMapEntity<MMapTileDataSourceProps> {
+    private _id?;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    protected _onUpdate(props: Partial<MMapTileDataSourceProps>): void;
+}
+export { MMapTileDataSource, MMapTileDataSourceProps };

package/imperative/config.d.ts

@@ -0,0 +1,6 @@
+export class Config {
+}
+export type ConfigMeta = {
+    hosts: {};
+};
+export type ConfigMetaMetrics = {};

package/imperative/fetchConfig.d.ts

@@ -0,0 +1,18 @@
+import { Config } from "./config";
+/**
+ * Request options
+ */
+export type FetchConfigOptions = {
+    /** Language */
+    lang: string;
+    /** Signal to abort request */
+    signal?: AbortSignal;
+};
+/**
+ * Requests config which is necessary for a map construction
+ *
+ * @param {FetchConfigOptions} options Request options
+ * @param {Config} config Current config
+ * @returns {Promise<Config>} config for map construction
+ */
+export declare function fetchConfig(options: FetchConfigOptions, config?: Config | undefined): Promise<Config>;

package/imperative/geolocation.d.ts

@@ -0,0 +1,10 @@
+import type { LngLat } from "../common/types";
+import { Config } from "./config";
+declare const geolocation: {
+    getPosition: typeof getPosition;
+};
+export declare function getPosition(options?: PositionOptions, config?: Config | undefined): Promise<{
+    coords: LngLat;
+    accuracy?: number;
+}>;
+export { geolocation };