@sakuzu/maplibre-gl-draw 1.0.0

package/dist/api/import-export/types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Types internal to the Import/Export module
+ */
+import type { Feature, FileData } from '../../store/types.js';
+/**
+ * GeoJSON import result (internal use).
+ *
+ * For a feature that contains image data, fileData is returned alongside it.
+ */
+export interface ConvertedFeatureResult {
+    feature: Feature;
+    fileData?: FileData;
+}
+/**
+ * Options for GeoJSON import
+ */
+export interface GeoJSONImportOptions {
+    /**
+     * Whether to expand Multi* geometries into features with a single geometry
+     *
+     * The default is false, which keeps MultiPoint / MultiLineString / MultiPolygon
+     * as Multi features as they are (so properties are not duplicated).
+     * Setting it to true expands them as before, assigning a new ID to each part.
+     */
+    flattenMulti?: boolean;
+}

package/dist/api/import-export/types.js

@@ -0,0 +1,3 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export {};

package/dist/api/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * API module
+ *
+ * Only the symbols that src/index.ts publishes are listed here (see "The public
+ * surface" in CONTRIBUTING.md). Internal code imports from the defining file.
+ */
+export type { CustomFeatureHandler, CustomFeatureRenderer, CustomOverlayRenderer, CustomRendererDrawContext, CustomResizeResult, LayerAwareOverlayRenderer, } from '../extension/index.js';
+export type { EventPayloads, MapLibreGLDraw, TerrainDiagnostics, TerrainRenderDiagnostics, } from './api.js';
+export type { Options } from './context.js';
+export type { GeometryApi, GeometryApiDeps, GeometryBufferOptions, GeometryOperations, } from './geometry-operations.js';
+export { createGeometryApi } from './geometry-operations.js';
+export type { InputOperations, SyntheticInputOptions, SyntheticKeyOptions, SyntheticLngLat, SyntheticModifiers, } from './input-api.js';
+export type { SnappingOperations } from './snapping-api.js';
+export type { TopologyOperations } from './topology-api.js';
+export type { TracingOperations } from './tracing-api.js';

package/dist/api/index.js

@@ -0,0 +1,3 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export { createGeometryApi } from './geometry-operations.js';

package/dist/api/input-api.d.ts

@@ -0,0 +1,158 @@
+import type { Coordinate } from '../store/types.js';
+/**
+ * The coordinate of a synthetic input
+ *
+ * Either `{ lng, lat }` or `[lng, lat]` (Coordinate) can be passed. The screen position is
+ * computed with `map.project`, so the caller does not prepare it.
+ */
+export type SyntheticLngLat = {
+    lng: number;
+    lat: number;
+} | Coordinate;
+/**
+ * The modifier keys of a synthetic input (an omitted key is false)
+ */
+export interface SyntheticModifiers {
+    /** Whether Shift is held */
+    shift?: boolean;
+    /** Whether Alt (Option) is held; by default it releases snapping */
+    alt?: boolean;
+    /** Whether Ctrl is held */
+    ctrl?: boolean;
+    /** Whether Meta (Cmd) is held */
+    meta?: boolean;
+}
+/**
+ * The options of a synthetic input (click / move)
+ *
+ * @example
+ * ```typescript
+ * // Place the point exactly where the numbers say, without snapping
+ * draw.input.click([139.7, 35.68], { snap: false });
+ * ```
+ */
+export interface SyntheticInputOptions {
+    /** The modifier keys. When omitted, they are all false */
+    modifiers?: SyntheticModifiers;
+    /**
+     * Whether to pass through snapping (default true)
+     *
+     * Setting it to false raises `snap: false` on the normalized event, and the InputRouter
+     * distributes the raw coordinate to the modes without going through the SnapService. Use it
+     * when an exact coordinate is to be given numerically.
+     */
+    snap?: boolean;
+}
+/**
+ * The options of a synthetic key input
+ *
+ * @example
+ * ```typescript
+ * draw.input.key('g', { modifiers: { ctrl: true } }); // groups the selection in select mode
+ * ```
+ */
+export interface SyntheticKeyOptions {
+    /** The modifier keys. When omitted, they are all false */
+    modifiers?: SyntheticModifiers;
+    /**
+     * The value equivalent to KeyboardEvent.code
+     *
+     * When omitted, it is inferred from key (alphanumerics become KeyA / Digit1, anything else
+     * is the same as key).
+     */
+    code?: string;
+}
+/**
+ * The synthetic input of a draw instance, reached as `draw.input`: clicks, moves and keys
+ * given to the modes from code.
+ *
+ * It is the path for giving points to a drawing mode from numeric input (a distance and a
+ * bearing, absolute coordinates), from tests and from automation. The events enter where
+ * real input is dispatched, so snapping and the plugins see them as usual and a mode needs
+ * no special branch. The thresholds of real input (the click / drag distinction) are not
+ * involved. A synthetic event counts as mouse input, and its `originalEvent` is a stand-in
+ * marked with `synthetic: true`. The input fields of a numeric input UI are not part of the
+ * library.
+ *
+ * @example
+ * ```typescript
+ * draw.setMode('draw_line');
+ * draw.input.click([139.7, 35.68]);
+ * draw.input.click([139.71, 35.68]);
+ * draw.input.click([139.71, 35.69]);
+ * draw.input.key('Enter');
+ * // Finishing returns to select mode with the new feature selected
+ * const [line] = draw.getSelectedFeatures();
+ * ```
+ */
+export interface InputOperations {
+    /**
+     * Synthesizes a click.
+     *
+     * So that the order matches that of a real cursor, it distributes a `mousemove` at the same
+     * coordinate and then distributes a `click`. The drawing modes interpret a click by looking
+     * at the state built up by the movement (the radius of a circle, the proximity test of the
+     * start and end points of a line or polygon), so these two are the minimal sequence that
+     * advances the drawing. Clicking the first point of a polygon again closes it; a circle takes
+     * a click on its center and one on its edge.
+     *
+     * @param lngLat where to click
+     * @param options the modifier keys and whether to snap
+     *
+     * @example
+     * ```typescript
+     * draw.setMode('draw_circle');
+     * draw.input.click([139.7, 35.68]); // the center
+     * draw.input.click([139.71, 35.68]); // sets the radius and finishes
+     * ```
+     */
+    click(lngLat: SyntheticLngLat, options?: SyntheticInputOptions): void;
+    /**
+     * Synthesizes a mouse move.
+     *
+     * It moves the preview while drawing (the tentative geometry) without adding a point.
+     *
+     * @param lngLat where the pointer moves to
+     * @param options the modifier keys and whether to snap
+     */
+    move(lngLat: SyntheticLngLat, options?: SyntheticInputOptions): void;
+    /**
+     * Synthesizes a key input (keydown).
+     *
+     * Enter finishes the drawing, Escape cancels it, and Backspace / Delete removes the last
+     * vertex. There is no path in the library that reads keyup, so only keydown is
+     * distributed.
+     *
+     * @param key the value of `KeyboardEvent.key` (`Enter`, `Escape`, `a` and so on)
+     * @param options the modifier keys and the `KeyboardEvent.code`
+     *
+     * @example
+     * ```typescript
+     * draw.input.key('Backspace'); // remove the last vertex
+     * draw.input.key('Escape'); // cancel the drawing
+     * ```
+     */
+    key(key: string, options?: SyntheticKeyOptions): void;
+    /**
+     * Switches the holding of pointer-originated input.
+     *
+     * It is the entry point for stopping pointer interruptions while the keyboard is deciding
+     * the coordinate, such as in a numeric input panel. While it is held, the click / dblclick /
+     * mousemove of the real pointer no longer reach the modes, and only synthetic input (click /
+     * move / key) moves the coordinate. Panning and zooming the map (mousedown / drag events)
+     * keep working while it is held.
+     *
+     * Be sure to set it back to false once the panel is closed.
+     *
+     * @param held true to hold the pointer input, false to release it
+     *
+     * @example
+     * ```typescript
+     * numericPanel.onopen = () => draw.input.setPointerHold(true);
+     * numericPanel.onclose = () => draw.input.setPointerHold(false);
+     * ```
+     */
+    setPointerHold(held: boolean): void;
+    /** Whether pointer-originated input is being held */
+    isPointerHeld(): boolean;
+}

package/dist/api/input-api.js

@@ -0,0 +1,144 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/** The state in which no modifier key is pressed */
+const NO_MODIFIERS = { shift: false, ctrl: false, alt: false, meta: false };
+/**
+ * The marker that indicates a synthetic event
+ *
+ * Attaching it to originalEvent makes it distinguishable from a real event in plugins and
+ * while debugging.
+ *
+ * @internal
+ */
+export const SYNTHETIC_EVENT_MARKER = 'synthetic';
+function toLngLat(lngLat) {
+    return Array.isArray(lngLat) ? { lng: lngLat[0], lat: lngLat[1] } : lngLat;
+}
+function toModifiers(modifiers) {
+    if (!modifiers)
+        return { ...NO_MODIFIERS };
+    return {
+        shift: modifiers.shift ?? false,
+        ctrl: modifiers.ctrl ?? false,
+        alt: modifiers.alt ?? false,
+        meta: modifiers.meta ?? false,
+    };
+}
+/**
+ * Infers the equivalent of KeyboardEvent.code from key
+ */
+function inferCode(key) {
+    if (/^[a-zA-Z]$/.test(key))
+        return `Key${key.toUpperCase()}`;
+    if (/^[0-9]$/.test(key))
+        return `Digit${key}`;
+    if (key === ' ')
+        return 'Space';
+    return key;
+}
+/**
+ * A synthetic originalEvent (the equivalent of a MouseEvent)
+ *
+ * It is a minimal dummy that has only the members the InputRouter and the modes touch.
+ * What the implementation touches is only preventDefault / stopPropagation (when the
+ * InputRouter consumes onMouseDown, and the shortcuts of the select mode) and target (the
+ * container test of the plugin interactions), so it is given those plus the fields for
+ * reading the modifier keys and the coordinate.
+ */
+function createSyntheticMouseEvent(type, point, modifiers) {
+    return {
+        type,
+        [SYNTHETIC_EVENT_MARKER]: true,
+        button: 0,
+        buttons: 0,
+        // A synthetic input has no offset on the page, so put in the canvas-relative coordinate as is
+        clientX: point.x,
+        clientY: point.y,
+        target: null,
+        currentTarget: null,
+        shiftKey: modifiers.shift,
+        ctrlKey: modifiers.ctrl,
+        altKey: modifiers.alt,
+        metaKey: modifiers.meta,
+        defaultPrevented: false,
+        preventDefault() { },
+        stopPropagation() { },
+        stopImmediatePropagation() { },
+    };
+}
+/**
+ * A synthetic originalEvent (the equivalent of a KeyboardEvent)
+ */
+function createSyntheticKeyboardEvent(key, code, modifiers) {
+    return {
+        type: 'keydown',
+        [SYNTHETIC_EVENT_MARKER]: true,
+        key,
+        code,
+        repeat: false,
+        target: null,
+        currentTarget: null,
+        shiftKey: modifiers.shift,
+        ctrlKey: modifiers.ctrl,
+        altKey: modifiers.alt,
+        metaKey: modifiers.meta,
+        defaultPrevented: false,
+        preventDefault() { },
+        stopPropagation() { },
+        stopImmediatePropagation() { },
+    };
+}
+/** @internal */
+export function createInputApi(deps) {
+    const { map, inputRouter } = deps;
+    /**
+     * Builds a normalized mouse event
+     *
+     * The screen point is computed with map.project (a value with the same meaning as the point
+     * the InputNormalizer receives from MapLibre).
+     */
+    function buildMouseEvent(type, lngLat, options) {
+        const resolved = toLngLat(lngLat);
+        const projected = map.project([resolved.lng, resolved.lat]);
+        const point = { x: projected.x, y: projected.y };
+        const modifiers = toModifiers(options?.modifiers);
+        return {
+            type,
+            point,
+            lngLat: { lng: resolved.lng, lat: resolved.lat },
+            originalEvent: createSyntheticMouseEvent(type, point, modifiers),
+            modifiers,
+            snap: options?.snap ?? true,
+        };
+    }
+    return {
+        input: {
+            click(lngLat, options) {
+                // Use the same order as a real cursor (move, then click).
+                inputRouter.dispatch(buildMouseEvent('mousemove', lngLat, options));
+                inputRouter.dispatch(buildMouseEvent('click', lngLat, options));
+            },
+            move(lngLat, options) {
+                inputRouter.dispatch(buildMouseEvent('mousemove', lngLat, options));
+            },
+            setPointerHold(held) {
+                inputRouter.setPointerHold(held);
+            },
+            isPointerHeld() {
+                return inputRouter.isPointerHeld();
+            },
+            key(key, options) {
+                const modifiers = toModifiers(options?.modifiers);
+                const code = options?.code ?? inferCode(key);
+                const event = {
+                    type: 'keydown',
+                    key,
+                    code,
+                    modifiers,
+                    originalEvent: createSyntheticKeyboardEvent(key, code, modifiers),
+                };
+                inputRouter.dispatch(event);
+            },
+        },
+    };
+}

package/dist/api/instance-api.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Instance API
+ *
+ * Provides the basic operations of a MapLibreGLDraw instance (getting the Map / Store,
+ * switching the Mode, Metadata, destroy). It gathers the related methods that are small and
+ * not large enough to deserve a file of their own.
+ */
+import type { CustomLayerInterface as MapLibreCustomLayerInterface, Map as MapLibreMap } from 'maplibre-gl';
+import type { InputRouter } from '../dispatcher/input-router.js';
+import type { InputNormalizer } from '../dispatcher/normalizer.js';
+import type { ModeManager } from '../modes/manager.js';
+import type { PluginManager } from '../plugins/plugin-manager.js';
+import type { AutoNameGenerator } from '../shared/utils/name-generator.js';
+import type { PixelRatioSource } from '../shared/utils/pixel-ratio.js';
+import type { EventBridge } from '../store/event-bridge.js';
+import type { Store } from '../store/store.js';
+import type { RenderCoordinator } from '../view/coordinator.js';
+import type { CustomLayerInterface } from '../view/layer/index.js';
+import type { MapLibreGLDraw } from './api.js';
+export type InstanceApi = Pick<MapLibreGLDraw, 'getMap' | 'getStore' | 'getMode' | 'setMode' | 'getMetadata' | 'setMetadata' | 'isReadOnly' | 'setReadOnly' | 'isInteractionLocked' | 'setInteractionLock' | 'getRenderSlots' | 'getRenderScale' | 'setRenderScale' | 'getPixelRatio' | 'getTerrainDiagnostics' | 'hasPendingWork' | 'isLocallyHidden' | 'getLocallyHidden' | 'setLocallyHidden' | 'destroy'>;
+export interface InstanceApiDeps {
+    map: MapLibreMap;
+    store: Store;
+    modeManager: ModeManager;
+    eventBridge: EventBridge;
+    renderCoordinator: RenderCoordinator;
+    inputRouter: InputRouter;
+    inputNormalizer: InputNormalizer;
+    customLayer: MapLibreCustomLayerInterface | CustomLayerInterface;
+    autoNameGenerator: AutoNameGenerator;
+    /** Needed in order to unregister the plugins on destroy (releasing the extension point
+     * registries) */
+    pluginManager: PluginManager;
+    /** The source of the render scale (the actual object held by the Context; setRenderScale
+     * rewrites it) */
+    pixelRatioSource: PixelRatioSource;
+}
+export declare function createInstanceApi(deps: InstanceApiDeps): InstanceApi;

package/dist/api/instance-api.js

@@ -0,0 +1,136 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { INITIAL_DRAPE_DEBUG } from '../view/terrain/context.js';
+import { getTerrainDrapeDebug, getTerrainRenderState, INACTIVE_TERRAIN_STATE, } from '../view/terrain/state.js';
+export function createInstanceApi(deps) {
+    const { map, store, modeManager, eventBridge, renderCoordinator, inputRouter, inputNormalizer, customLayer, autoNameGenerator, pixelRatioSource, pluginManager, } = deps;
+    return {
+        getMap() {
+            return map;
+        },
+        getStore() {
+            return store;
+        },
+        getMode() {
+            return modeManager.getMode();
+        },
+        setMode(mode) {
+            // Following the SSoT, call Store.setMode() through the ModeManager
+            // The event is emitted from the Store through the EventBridge
+            return modeManager.setMode(mode);
+        },
+        getMetadata() {
+            return store.getMetadata();
+        },
+        setMetadata(metadata) {
+            return store.setMetadata(metadata);
+        },
+        isReadOnly() {
+            return store.isReadOnly();
+        },
+        setReadOnly(value) {
+            store.setReadOnly(value);
+        },
+        isInteractionLocked() {
+            return store.isInteractionLocked();
+        },
+        setInteractionLock(value) {
+            store.setInteractionLock(value);
+            // If drawing is in progress at the moment the interaction lock is applied, discard the
+            // tentative geometry and go back to select. Switching to select through the modeManager
+            // makes the onStop of the drawing handler clean up the tentative geometry. The setMode
+            // gate lets a transition to select through, so this holds naturally.
+            if (value && store.getMode() !== 'select') {
+                modeManager.setMode('select');
+            }
+        },
+        getRenderSlots() {
+            // For a CustomLayer without frames (an external implementation), return the single
+            // conventional layer as one interval
+            if ('getRenderSlots' in customLayer && typeof customLayer.getRenderSlots === 'function') {
+                return customLayer.getRenderSlots();
+            }
+            return [{ layerId: customLayer.id, from: 0, to: store.getLayerOrder().length }];
+        },
+        getRenderScale() {
+            return pixelRatioSource.getRenderScale();
+        },
+        setRenderScale(scale) {
+            // The retained batches that have already been baked are rebuilt by looking at the
+            // scale, so prompt a redraw only when it has changed (on the next frame the CustomLayer
+            // and the datasets each start rebuilding).
+            if (!pixelRatioSource.setRenderScale(scale))
+                return;
+            map.triggerRepaint();
+        },
+        getPixelRatio() {
+            return pixelRatioSource.resolve();
+        },
+        getTerrainDiagnostics() {
+            // The terrain state is held by the CustomLayer of this instance (an external
+            // implementation without one reports the inactive state)
+            const terrain = 'getTerrainContext' in customLayer && typeof customLayer.getTerrainContext === 'function'
+                ? customLayer.getTerrainContext()
+                : null;
+            return Object.freeze({
+                render: toRenderDiagnostics(terrain ? getTerrainRenderState(terrain) : INACTIVE_TERRAIN_STATE),
+                drape: Object.freeze({
+                    ...(terrain ? getTerrainDrapeDebug(terrain) : INITIAL_DRAPE_DEBUG),
+                }),
+            });
+        },
+        hasPendingWork() {
+            // The engine of this instance knows its deferred work (an external implementation of the
+            // layer reports none)
+            return ('hasPendingWork' in customLayer &&
+                typeof customLayer.hasPendingWork === 'function' &&
+                customLayer.hasPendingWork());
+        },
+        isLocallyHidden(id) {
+            return store.isLocallyHidden(id);
+        },
+        getLocallyHidden() {
+            return store.getLocallyHidden();
+        },
+        setLocallyHidden(id, hidden) {
+            store.setLocallyHidden(id, hidden);
+        },
+        destroy() {
+            inputRouter.stop();
+            inputNormalizer.detach();
+            eventBridge.stop();
+            modeManager.stop();
+            renderCoordinator.stop();
+            autoNameGenerator.dispose();
+            // Unregister the plugins so that each one runs its onUninstall (timers, subscriptions and
+            // anything else it holds outside the draw instance). The extension point registries
+            // themselves belong to this instance and are cleared with it, so no provider of the
+            // destroyed instance can reach a live one.
+            for (const name of pluginManager.getPluginNames()) {
+                pluginManager.unregister(name);
+            }
+            // There can be several frames, so remove all of them
+            const slotLayers = 'getSlotLayers' in customLayer && typeof customLayer.getSlotLayers === 'function'
+                ? customLayer.getSlotLayers()
+                : [customLayer];
+            for (const slotLayer of slotLayers) {
+                if (map.getLayer(slotLayer.id)) {
+                    map.removeLayer(slotLayer.id);
+                }
+            }
+        },
+    };
+}
+/** The plain numbers of a terrain state, without the GL objects and the internal plans */
+function toRenderDiagnostics(state) {
+    return Object.freeze({
+        active: state.active,
+        atlasRect: [...state.atlasRect],
+        atlasSize: [...state.atlasSize],
+        elevationScale: state.elevationScale,
+        liftMeters: state.liftMeters,
+        stepMeters: state.stepMeters,
+        stepGrid: state.stepGrid,
+        generation: state.generation,
+    });
+}

package/dist/api/layer-api.d.ts

@@ -0,0 +1,12 @@
+import type { AutoNameGenerator } from '../shared/utils/name-generator.js';
+import type { Store } from '../store/store.js';
+import type { MapLibreGLDraw } from './api.js';
+export type LayerApi = Pick<MapLibreGLDraw, 'getAllLayers' | 'getLayer' | 'addLayer' | 'updateLayer' | 'deleteLayer' | 'getLayerOrder' | 'setLayerOrder' | 'reorderInLayer' | 'moveToLayer' | 'getActiveLayer' | 'setActiveLayer'>;
+export interface LayerApiDeps {
+    store: Store;
+    generateFeatureId: () => string;
+    autoNameGenerator: AutoNameGenerator;
+    getActiveLayerId: () => string;
+    setActiveLayerId: (id: string) => void;
+}
+export declare function createLayerApi(deps: LayerApiDeps): LayerApi;

package/dist/api/layer-api.js

@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Layer API
+ *
+ * Provides the Layer CRUD and Active Layer operations of MapLibreGLDraw.
+ */
+import { moveToLayer as moveToLayerImpl } from '../operations/layer-operations.js';
+import { onlyLockOrVisibility } from './feature-api.js';
+export function createLayerApi(deps) {
+    const { store, generateFeatureId, autoNameGenerator, getActiveLayerId, setActiveLayerId } = deps;
+    return {
+        getAllLayers() {
+            return store.getAllLayers();
+        },
+        getLayer(id) {
+            return store.getLayer(id);
+        },
+        addLayer(name) {
+            const id = generateFeatureId();
+            const layerName = name || autoNameGenerator.generateLayerName();
+            const layer = {
+                id,
+                name: layerName,
+                visible: true,
+                locked: false,
+                opacity: 1,
+                order: [],
+            };
+            // A write refused because the Store is read-only returns null
+            return store.createLayer(layer) ? id : null;
+        },
+        updateLayer(id, updates) {
+            // While locked, reject any change other than locked/visible (full protection)
+            const layer = store.getLayer(id);
+            if (layer?.locked && !onlyLockOrVisibility(updates))
+                return false;
+            return store.updateLayer(id, updates);
+        },
+        deleteLayer(id) {
+            return store.deleteLayer(id);
+        },
+        getLayerOrder() {
+            return store.getLayerOrder();
+        },
+        setLayerOrder(order) {
+            return store.setLayerOrder(order);
+        },
+        reorderInLayer(itemId, layerId, newIndex) {
+            return store.reorderInLayer(itemId, layerId, newIndex);
+        },
+        moveToLayer(itemId, targetLayerId) {
+            moveToLayerImpl(store, itemId, targetLayerId);
+        },
+        getActiveLayer() {
+            return getActiveLayerId();
+        },
+        setActiveLayer(layerId) {
+            setActiveLayerId(layerId);
+        },
+    };
+}

package/dist/api/selection-api.d.ts

@@ -0,0 +1,7 @@
+import type { Store } from '../store/store.js';
+import type { MapLibreGLDraw } from './api.js';
+export type SelectionApi = Pick<MapLibreGLDraw, 'getSelection' | 'select' | 'deselect' | 'getSelectedFeatures' | 'getSelectedIds' | 'deleteSelection' | 'selectVertices' | 'deselectVertices' | 'getSelectedVertices' | 'deleteVertices'>;
+export interface SelectionApiDeps {
+    store: Store;
+}
+export declare function createSelectionApi(deps: SelectionApiDeps): SelectionApi;