@christtrade/depth 0.12.21

package/types/core/DepthChart.d.ts

@@ -0,0 +1,458 @@
+import type { IDataAdapter, OhlcvBar, SymbolInfo } from '../interfaces/IDataAdapter';
+import type { IExecutionAdapter } from '../interfaces/IExecutionAdapter';
+import type { IAccountAdapter } from '../interfaces/IAccountAdapter';
+import type { ActiveDrawingTool, Drawing } from '../lib/types/drawing-types';
+import type { ChartSettings } from '../lib/types/chart-settings';
+import type { FootprintOptions } from '../lib/types/footprint';
+import { type DepthProps } from '../ChartOuter';
+import { ExecutionEngine } from './ExecutionEngine';
+import type { FillSearchOptions } from '../lib/matchingEngine';
+import { LiveTransformer } from '../interfaces/ICoordinateTransformer';
+import { BottomBarItem, ChartPlugin, InstalledPlugin, PluginType, ToolbarItem } from './PluginRegistry';
+import { RenderEngine } from './RenderEngine';
+import { ChartEvents, TypedEventBus } from './TypedEventBus';
+import { ChartState } from './ChartState';
+import type { SyncInLayout } from '../lib/types/layout-sync';
+import { ChartModel, type ChartPaneState } from './ChartModel';
+import { DrawingStore } from './DrawingStore';
+import { ChartPane, Indicator } from '../lib/types/indicator-types';
+import { AccountManager, LedgerAdjustment, LedgerFill, LedgerOrder, LedgerPosition, type AccountSaveState } from './AccountManager';
+import { PlaybackMode, type PrefetchOptions } from '../hooks/usePlaybackEngine';
+import { type ChartPreferences } from '../lib/storage';
+import { type PluginCatalogEntry, type PluginStartupEntry, type PluginStartupRecord } from './plugin-startup';
+export interface FeaturesOptions {
+    contextMenu?: boolean;
+    plugins?: boolean | {
+        enabled?: boolean;
+        indicators?: boolean;
+        charts?: boolean;
+        extensions?: boolean;
+        drawings?: boolean;
+    };
+    timeframe?: {
+        timeframes?: string[] | 'any';
+        allowCustom?: boolean;
+    };
+}
+export type TimePrecision = 's' | 'ms' | 'us' | 'ns';
+export type PlaybackOptions = {
+    /**
+     * Tunes forward prefetch during continuous playback. Optional - the engine
+     * measures real load latency and sizes the lead on its own.
+     */
+    prefetch?: PrefetchOptions;
+};
+export type AccountOptions = {
+    initialBalance?: number;
+    /** Settlement currency for the balance. Display only. Default: 'USD' */
+    currency?: string;
+    adapter?: IAccountAdapter;
+    adjustments?: LedgerAdjustment[];
+    fills?: LedgerFill[];
+    positions?: LedgerPosition[];
+    orders?: LedgerOrder[];
+    /**
+     * Tunes how skipped spans (from far jumps) are settled for fills. Accuracy
+     * by default. Also adjustable at runtime via `chart.account.setFillSearch`.
+     */
+    fillSearch?: Partial<FillSearchOptions>;
+};
+export interface ChartOptions {
+    dataAdapter: IDataAdapter;
+    initialLoad: {
+        start: string | number;
+        end: string | number;
+    };
+    playback?: PlaybackOptions;
+    horizon: string | number;
+    symbol: string;
+    timePrecision?: TimePrecision;
+    barNs?: bigint;
+    fpOptions?: FootprintOptions;
+    initialWindowNs?: bigint;
+    prefetchWindowNs?: bigint;
+    executionAdapter?: IExecutionAdapter;
+    hideToolbar?: boolean;
+    hideBottomToolbar?: boolean;
+    hideDrawingToolbar?: boolean;
+    hidePriceScale?: boolean;
+    hideTimeScale?: boolean;
+    hideStatusBar?: boolean;
+    hideLegend?: boolean;
+    timeframe?: string;
+    debug?: {
+        showDataStatusInBottomRightCorner?: boolean;
+    };
+    features?: FeaturesOptions;
+    /**
+     * Seed a first-run session from the user's TradingView preferences, if their
+     * charting library left any in localStorage on this origin. Defaults to true.
+     *
+     * Only fills in settings that are currently unset, runs at most once per
+     * device, and is skipped entirely when `restore` is supplied.
+     */
+    importTradingViewSettings?: boolean;
+    account?: AccountOptions;
+    /**
+     * Saved state to restore on construction.
+     * Obtain via chart.serialize(), pass back here on next mount.
+     */
+    restore?: ChartSaveState;
+    toolbar?: (chart: DepthChart) => React.ReactNode[];
+}
+/** Bump when the save document shape changes incompatibly; handled in migrate(). */
+export declare const SAVE_VERSION = 1;
+export interface LayoutDescriptor {
+    id: string;
+    label: string;
+    count: number;
+    cols: number;
+    rows: number;
+    areas: string;
+}
+export interface ChartSaveState {
+    /** Schema version. Absent = legacy/pre-versioning. */
+    version?: number;
+    /** Grid layout descriptor (which preset, how many cells). */
+    layout?: LayoutDescriptor;
+    /** Which properties the layout's cells share (crosshair, symbol, ...). */
+    syncInLayout?: SyncInLayout;
+    /** Column/row divider sizes (fr) and the focused pane index. */
+    gridColSizes?: number[];
+    gridRowSizes?: number[];
+    focusedPane?: number;
+    /** Trading account. Controller-level - one account across every pane. */
+    account?: AccountSaveState;
+    /** Shared plugin pool: each plugin's id + code, stored once. Restored under
+     *  the same id so a host re-installing it manually dedups. Pane plugin refs
+     *  point at these ids. */
+    plugins?: InstalledPlugin[];
+    /** Drawings keyed by symbol - drawings follow the symbol, not the pane. */
+    drawings?: Record<string, Drawing[]>;
+    /** Per-pane state: independent symbol / timeframe / settings / plugin refs. */
+    charts?: ChartPaneState[];
+    /**
+     * Device-level preferences that aren't per-pane: custom and favorite
+     * timeframes, favorite drawings, drawing style templates, color swatches, and
+     * each plugin's settings and KV store. Keyed by storage key.
+     */
+    preferences?: ChartPreferences;
+}
+/** Serialize a save document to a JSON string, encoding BigInts losslessly. */
+export declare function stringifyChartSave(state: ChartSaveState): string;
+/** Parse a JSON string produced by stringifyChartSave back into a save document. */
+export declare function parseChartSave(json: string): ChartSaveState;
+type PlaybackAPI<T> = {
+    play: () => T;
+    pause: () => T;
+    playing: boolean;
+    stepSize: string;
+    speed: number;
+    mode: PlaybackMode;
+    stepSnap: boolean;
+    setStepSize: (step: string) => T;
+    setSpeed: (speed: number) => T;
+    stepBack: () => T;
+    stepForward: () => T;
+    setMode: (mode: PlaybackMode) => T;
+    setStepSnap: (snap: boolean) => T;
+    /** Current playhead position, epoch ns. */
+    time: bigint;
+    /** Jump the playhead. Accepts ns (bigint), epoch ms, a Date, or an ISO string. */
+    goTo: (t: bigint | number | Date | string) => T;
+    /**
+     * Refuse every move that would put the playhead behind where it has already
+     * been. Refused moves emit `playback:blocked` rather than failing silently.
+     */
+    lockForward: (on?: boolean) => T;
+    /** Earliest time the playhead may move to, or null when it may move freely. */
+    floor: bigint | null;
+    allows: (tNs: bigint) => boolean;
+};
+export declare class DepthChart {
+    private readonly options;
+    readonly id: string;
+    readonly eventBus: TypedEventBus;
+    readonly executionEngine: ExecutionEngine;
+    private readonly dataEngine;
+    readonly transformer: LiveTransformer;
+    private features;
+    private readonly pluginRegistry;
+    private _renderEngine;
+    private _panelRegistry;
+    private _toolbarRegistry;
+    private _bottomBarRegistry;
+    private _openBarProviders;
+    private _horizon;
+    private readonly dataSources;
+    private readonly drawingRegistry;
+    private destroyed;
+    private registeredPlugins;
+    private _pluginStateListeners;
+    private _pluginCatalog;
+    private playbackController;
+    private readonly playbackStateRegistry;
+    private readonly pluginSchedules;
+    readonly state: ChartState;
+    private readonly _panes;
+    readonly drawingStore: DrawingStore;
+    readonly account: AccountManager | null;
+    playback: PlaybackAPI<DepthChart>;
+    private timePrecision;
+    constructor(options: ChartOptions);
+    setDataAdapter(adapter: IDataAdapter): this;
+    load(symbol: string): Promise<void>;
+    /**
+     * Re-fetch the charted symbol's window without moving the playhead. For when
+     * the data source's answer changes rather than the question - the host grants
+     * access to a resolution that was refused before, a feed gets backfilled.
+     *
+     * Switching timeframe is not a substitute: that refines bars from what is
+     * already loaded, so anything the first fetch didn't return never arrives.
+     */
+    reloadData(): Promise<void>;
+    getSymbolInfo(symbol: string): SymbolInfo | null;
+    /**
+     * The bar still being built at the playback horizon, on the focused pane, or
+     * `null` before any data has arrived.
+     *
+     * Unlike the tail of `getData().ohlcvBars` - which is the last bar that was
+     * *loaded*, at the fetch resolution and possibly past the horizon - this is
+     * the candle the chart is actually drawing on the right edge.
+     */
+    openBar(): OhlcvBar | null;
+    getMaxLookbackBars(): number;
+    horizon(): number;
+    fitToData(): this;
+    setActiveTool(tool: ActiveDrawingTool): this;
+    /**
+     * Set the active timeframe by label, e.g. "1m", "5m", "1h", "4h", "1d".
+     * Custom labels like "213m" or "2h" are accepted too.
+     */
+    setTimeframe(label: string): this;
+    /**
+     * The per-pane model for a layout cell index, created on first access. New
+     * panes inherit the chart's current symbol / timeframe / footprint options.
+     */
+    getChart(index: number): ChartModel;
+    /** All instantiated pane models, ordered by cell index. */
+    get charts(): ChartModel[];
+    get focusedChart(): ChartModel;
+    /**
+     * Is this timeframe allowed by the current feature set? The one source of
+     * truth for the gate - every timeframe switch is enforced against it.
+     */
+    isTimeframeAllowed(label: string): boolean;
+    /**
+     * Widen what's allowed at runtime, e.g. after the host grants a trial of a
+     * paid timeframe. Mutates the same `features` object the UI holds so
+     * call-time checks see it immediately, then emits `features:change` so the
+     * rendered locks catch up.
+     *
+     * Presentation only. Anything worth money has to be enforced by whatever
+     * serves the data, since a client can always be patched.
+     */
+    allowTimeframes(labels: string[] | 'any'): this;
+    /** Returns the label of the currently active timeframe, e.g. "1m". */
+    getTimeframe(): string;
+    /**
+     * The currently charted symbol. Reads the focused pane, which is the real
+     * truth - pane models update on every switch, whereas `state.symbol` is only
+     * a mirror (see _wireSymbolMirror) and as good as the events it has seen.
+     */
+    getSymbol(): string;
+    /**
+     * The tool armed for drawing - `{ name: 'cursor' }` when the chart is idle.
+     * What the toolbar highlights, not what is selected on the canvas. For that
+     * see `getSelectedDrawing`.
+     */
+    getActiveTool(): ActiveDrawingTool;
+    /**
+     * The drawing the user has selected, in the same `{ name, id, state }` shape
+     * as an armed tool, or null when nothing is.
+     *
+     * `state` is read live out of the drawing store, so it reflects a box that is
+     * still being dragged.
+     */
+    getSelectedDrawing(): ActiveDrawingTool | null;
+    /**
+     * Any drawing on the active symbol by id, same shape as
+     * `getSelectedDrawing`. Null once it has been deleted.
+     *
+     * The counterpart to selection: a host latched onto a drawing needs to keep
+     * reading it after the user selects something else, and needs the null to
+     * know when it is gone.
+     */
+    getDrawing(id: string): ActiveDrawingTool | null;
+    /**
+     * Fires whenever the active symbol's drawings change - added, edited,
+     * dragged or deleted. Returns an unsubscribe.
+     *
+     * Bound to whichever symbol is active when you call it, since drawings are
+     * stored per symbol. Re-subscribe on `chart:set-symbol` to follow the chart
+     * across instruments.
+     */
+    onDrawingsChanged(fn: () => void): () => void;
+    /**
+     * Patch chart visual settings (scale mode, grid, crosshair, etc.).
+     * Equivalent to using the settings dialog in the UI.
+     */
+    setChartSettings(patch: Partial<ChartSettings>): this;
+    /**
+     * Switch the active symbol on this chart instance only. Emits
+     * `chart:set-symbol`; the data engine, panes and trading bridge all react
+     * through their own subscriptions.
+     */
+    setSymbol(symbol: string): this;
+    addIndicator(id: string): this;
+    removeIndicator(id: string): this;
+    /**
+     * Swap the account adapter at runtime. Pass null to revert to the built-in
+     * eventBus-driven mode.
+     */
+    setAccountAdapter(adapter: IAccountAdapter | null): this;
+    /**
+     * Collect serializable state from every module. Store the result and pass it
+     * as `restore` on the next chart construction.
+     */
+    serialize(): ChartSaveState;
+    private _activePaneCount;
+    /**
+     * Distribute a saved document to every owner. Called from the constructor
+     * when `restore` is passed, and callable later for a "load session" action.
+     *
+     * Order matters: preferences first so a plugin's `getSettings()` sees its
+     * restored values during install, then the plugin pool so per-pane refs
+     * resolve against it, then account, layout, drawings, and the pane models.
+     *
+     * Preferences are merged, not replaced - a save document adds its timeframes
+     * and templates to whatever the device already has instead of wiping them.
+     */
+    restore(state: ChartSaveState): this;
+    getProps(): DepthProps;
+    on<K extends keyof ChartEvents>(event: K, handler: (data: ChartEvents[K]) => void): () => void;
+    off<K extends keyof ChartEvents>(event: K, handler: (data: ChartEvents[K]) => void): void;
+    use(plugin: ChartPlugin): this;
+    /**
+     * Apply an installed plugin to the panes. Safe to call before the plugin's
+     * worker has registered its capabilities - the activation is queued and runs
+     * as soon as the def lands.
+     */
+    add(pluginOrId: string | ChartPlugin): this;
+    /**
+     * Take a plugin's live instances off the panes without uninstalling it. It
+     * stays loaded, so hot reload keeps working and `add()` re-applies it
+     * instantly. To tear it down entirely use `unuse()`.
+     */
+    remove(pluginOrId: string | ChartPlugin): this;
+    /** Uninstall a plugin: kills its worker and removes everything it registered. */
+    unuse(id: string): this;
+    /** Is this plugin id currently loaded (installed or queued for install)? */
+    isPluginInstalled(id: string): boolean;
+    /**
+     * Pool plugin ids a restored session still expects but nothing has installed.
+     * A host that keeps plugin code in its own store rather than the save
+     * document (so `serialize().plugins` is stripped) installs these on mount,
+     * and the panes then rebuild their indicators with the saved settings.
+     */
+    getPendingPluginIds(): string[];
+    /**
+     * Tell the chart where the host keeps its plugin code. The provider is called
+     * on demand, so a host whose list changes (a script editor, a store) just
+     * returns the current one rather than re-registering.
+     *
+     * Setting it applies startup plugins straight away - the plugins a restored
+     * session references, plus anything the user left switched on - so a host that
+     * strips `plugins` out of its save document doesn't have to reinstall them by
+     * hand.
+     */
+    setPluginCatalog(provider: () => PluginCatalogEntry[]): this;
+    /** Every plugin the host has code for, loaded or not. */
+    getPluginCatalog(): PluginCatalogEntry[];
+    /**
+     * Install a plugin from the catalog, optionally putting it on the chart.
+     * Returns false when the catalog has no code for that id.
+     */
+    loadPlugin(id: string, opts?: {
+        activate?: boolean;
+    }): boolean;
+    /**
+     * Uninstall a plugin and stop loading it at startup. The counterpart to
+     * `loadPlugin` - `unuse()` on its own leaves the startup record alone, which
+     * is what a restart wants.
+     */
+    unloadPlugin(id: string): this;
+    /** What every plugin the user has an opinion about should do at startup. */
+    getPluginStartup(): PluginStartupRecord;
+    /**
+     * Record what a plugin should do when the chart opens. Merges into any
+     * existing entry; `null` forgets the plugin, which lets a restored save
+     * document decide again.
+     */
+    setPluginStartup(id: string, entry: Partial<PluginStartupEntry> | null): this;
+    /**
+     * Install what this session should open with: every plugin a restored pane
+     * references, plus every plugin marked autostart. Idempotent - already-loaded
+     * ids are skipped, so it is safe to call again after the catalog changes.
+     */
+    applyStartupPlugins(): this;
+    /** Name and type of every loaded plugin. */
+    getInstalledPlugins(): Array<{
+        id: string;
+        name: string;
+        type: PluginType;
+    }>;
+    /**
+     * Show or hide a plugin's panel.
+     *
+     * Goes through the registry rather than straight to the event, so a consumer
+     * that mounts later - the windows dropdown, a second panel host - reads the
+     * state the user left rather than what the plugin registered with.
+     */
+    setPanelVisible(id: string, visible: boolean): this;
+    /** Does this plugin have at least one live instance on a pane? */
+    isPluginActive(id: string): boolean;
+    /**
+     * Which plugins are loaded, and which have live instances on a pane. Two
+     * different states - a plugin can be installed (worker running, capabilities
+     * registered) without being applied to any pane.
+     */
+    getPluginState(): {
+        installed: Set<string>;
+        active: Set<string>;
+    };
+    /**
+     * Observe install/uninstall and pane activation/removal. Only fires when the
+     * set of ids actually changes - pane models notify on unrelated churn (axis
+     * drags rewrite settings every frame) that callers shouldn't re-render on.
+     */
+    onPluginStateChange(cb: (state: {
+        installed: Set<string>;
+        active: Set<string>;
+    }) => void): () => void;
+    private _notifyPluginState;
+    getRegisteredPlugins(): Map<string, {
+        indicator: Indicator;
+        activeByDefault: boolean;
+        pane: ChartPane;
+    }>;
+    getPanelRegistry(): ReadonlyMap<string, {
+        element: React.ReactNode;
+        title: string;
+        visible: boolean;
+    }>;
+    getToolbarRegistry(): ReadonlyMap<string, ToolbarItem>;
+    getBottomBarRegistry(): ReadonlyMap<string, BottomBarItem>;
+    attachRenderEngine(engine: RenderEngine): void;
+    /**
+     * Snapshot of the chart with every layer composited (base, drawings, UI).
+     * Returns null until the render engine has attached.
+     */
+    screenshot(): HTMLCanvasElement | null;
+    private _focusedCellId;
+    private _wireSymbolMirror;
+    private _wireDataRouting;
+    private _buildPluginContext;
+    destroy(): void;
+}
+export {};

package/types/core/DrawingRegistry.d.ts

@@ -0,0 +1,133 @@
+import type { Anchor, DrawingAnchorId, PluginDraftDrawing, PluginDrawing } from '../lib/types/drawing-types';
+import type { LiveTransformer } from '../interfaces/ICoordinateTransformer';
+import type { StyleField } from '../components/drawings/drawing-settings-dialog';
+export interface PluginDrawingRenderContext {
+    ctx: CanvasRenderingContext2D;
+    anchors: Anchor[];
+    w: number;
+    h: number;
+    oy: number;
+    transformer: LiveTransformer;
+    selected: boolean;
+    hovered: boolean;
+    hotAnchor: DrawingAnchorId | null;
+    data: unknown;
+}
+export interface PluginDrawingHitContext {
+    mx: number;
+    my: number;
+    anchors: Anchor[];
+    w: number;
+    h: number;
+    oy: number;
+    transformer: LiveTransformer;
+    data: unknown;
+}
+export interface PluginDrawingToolDef {
+    /** Must be globally unique. Use reverse-domain: 'com.myname.anchored-vwap' */
+    id: string;
+    name: string;
+    icon?: string;
+    cursor?: string;
+    /**
+     * Number of anchor clicks to commit the drawing.
+     * 'dynamic' = user keeps clicking, presses Escape to finish.
+     */
+    anchorCount: number | 'dynamic';
+    /**
+     * Render the committed drawing, on every canvas frame. Use ctx.anchors plus
+     * the transformer to get from data space to pixels. You must call
+     * ctx.save()/restore() if you change global canvas state.
+     */
+    render(ctx: PluginDrawingRenderContext): void;
+    /**
+     * Is the mouse over this drawing? Called with each anchor's pixel position
+     * already resolved, though you can do your own geometry. Return the anchor
+     * id that was hit, null for a body hit, or false for no hit.
+     */
+    hitTest(ctx: PluginDrawingHitContext): DrawingAnchorId | 'body' | false;
+    /**
+     * Called while the user is still placing anchors. Return draw commands for
+     * the preview, same signature as render. Without it, a dot is drawn at the
+     * last placed anchor.
+     */
+    preview?(ctx: PluginDrawingRenderContext & {
+        cursorAnchor: Anchor;
+    }): void;
+    /**
+     * Default style/data merged into the drawing on creation.
+     * Returned from getSettings() / stored in drawing.data.
+     */
+    defaultData?: unknown;
+    /**
+     * Fields for the Style tab of the drawing settings dialog. Each field's
+     * `key` names a key in the drawing's own `data`, so every drawing made with
+     * this tool is styled independently. Build them with the `StyleField`
+     * helpers exported alongside the dialog.
+     */
+    settingsSchema?: StyleField[];
+    /**
+     * Raw pointer and keyboard events while this tool is active. The plugin gets
+     * every event and can call ctx methods to commit drawings, update the draft,
+     * request redraws. Return true to stop the event reaching the chart's own
+     * handlers.
+     */
+    onPointerDown?(event: PluginToolEvent): boolean | void;
+    onPointerMove?(event: PluginToolEvent): boolean | void;
+    onPointerUp?(event: PluginToolEvent): boolean | void;
+    onKeyDown?(event: PluginKeyEvent): boolean | void;
+    onMove?(ctx: PluginDrawingMoveContext): unknown;
+    onActivate?(ctx: PluginToolActiveContext): void;
+    onDeactivate?(): void;
+}
+export interface PluginToolEvent {
+    ts: bigint;
+    price: number;
+    x: number;
+    y: number;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    buttons: number;
+    tool: PluginToolActiveContext;
+    plugin: PluginDrawingToolDef;
+}
+export interface PluginKeyEvent {
+    key: string;
+    code: string;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    tool: PluginToolActiveContext;
+}
+export interface PluginDrawingMoveContext {
+    data: unknown;
+    anchors: Anchor[];
+    anchor: DrawingAnchorId;
+    dts: bigint;
+    dprice: number;
+    curTs: bigint;
+    curPrice: number;
+}
+export interface PluginToolActiveContext {
+    /** Commit a drawing to the drawings array */
+    /** keepActive leaves the tool armed, for tools you place several of in a row. */
+    commitDrawing(drawing: Omit<PluginDrawing, 'id'> & {
+        keepActive?: boolean;
+    }): void;
+    /** Update the current draft (triggers redraw) */
+    setDraft(draft: PluginDraftDrawing | null): void;
+    /** Request a canvas redraw without changing draft */
+    requestRedraw(): void;
+    /** Deactivate this tool and return to cursor */
+    deactivate(): void;
+    /** The overlay canvas - for tools that want to paint directly every frame */
+    getOverlayCanvas(): HTMLCanvasElement;
+}
+export declare class DrawingRegistry {
+    private tools;
+    register(def: PluginDrawingToolDef): () => void;
+    get(id: string): PluginDrawingToolDef | undefined;
+    getAll(): PluginDrawingToolDef[];
+    has(id: string): boolean;
+}
+export declare const drawingRegistry: DrawingRegistry;

package/types/core/DrawingStore.d.ts

@@ -0,0 +1,26 @@
+import type { Drawing } from '../lib/types/drawing-types';
+type Listener = () => void;
+export declare class DrawingStore {
+    private bySymbol;
+    private listeners;
+    /** Drawings for a symbol. Returns a stable empty array when none exist. */
+    forSymbol(symbol: string): readonly Drawing[];
+    /** Find a single drawing within a symbol's bucket. */
+    find(symbol: string, id: string): Drawing | undefined;
+    /** Symbols that currently have at least one drawing. */
+    symbols(): string[];
+    add(symbol: string, drawing: Drawing): void;
+    update(symbol: string, id: string, patch: Partial<Drawing>): void;
+    remove(symbol: string, id: string): void;
+    /** Replace a symbol's whole bucket - reorder, bulk edit, restore. */
+    setForSymbol(symbol: string, drawings: Drawing[]): void;
+    clearSymbol(symbol: string): void;
+    /** Snapshot of every non-empty bucket, in the save document's shape. */
+    serialize(): Record<string, Drawing[]>;
+    /** Replace the whole store from a snapshot, notifying every symbol it touches. */
+    restore(map: Record<string, Drawing[]>): void;
+    /** Subscribe to one symbol's bucket. Returns an unsubscribe. */
+    subscribe(symbol: string, fn: Listener): () => void;
+    private _changed;
+}
+export {};