@kortexya/nodus 0.1.0

package/types/internals/Geo.d.ts

@@ -0,0 +1,127 @@
+import { Module } from './Module';
+export declare class Geo extends Module {
+    L: any;
+    private _enabled;
+    private _settings;
+    private _edgesOriginalTextStyle;
+    private _nodesOriginalTextStyle;
+    private _hoverEdgesOriginalTextStyle;
+    private _hoverNodesOriginalTextStyle;
+    private _nodeDraggingSetting;
+    private _transition;
+    private _attribution;
+    private _updating;
+    private _updateRate;
+    private _applyingGeoBackground;
+    private _x;
+    private _y;
+    private _map;
+    private _mapContainer;
+    private _tileLayer;
+    private _layer;
+    private _filter;
+    private _projection;
+    private _prevSettings;
+    private _nodeDragOffsetX;
+    private _nodeDragOffsetY;
+    private _updateRequest;
+    private _onCameraUpdate;
+    private _syncMapWithCamera;
+    private _onNodesDragStart;
+    private _onNodesDragged;
+    private _onMapUpdate;
+    runLayout: ({ type, nodes, latitudePath, longitudePath, options, center, }: {
+        type: string;
+        nodes: any;
+        latitudePath?: string;
+        longitudePath?: string;
+        options?: any;
+        center: {
+            latitude: number;
+            longitude: number;
+        };
+    }) => Promise<any[]>;
+    onMounted(): void;
+    private _onDataChange;
+    private _refreshOrAddNodes;
+    private _updatePrevNodesCoordinates;
+    private _restorePrevNodesCoordinates;
+    _updateNodesCoordinates(nodes: any): void;
+    private _createMapTileLayer;
+    private _setupTileLayer;
+    private _onSettingsChanged;
+    private _setMapDragging;
+    private _fromLatLngToPoint;
+    private _fromPointToLatLng;
+    private _updateSizes;
+    enable(options?: any): Promise<void>;
+    getMap(): any;
+    getOptions(): Record<string, any>;
+    setOptions(options: any): void;
+    disable(options?: any): Promise<void>;
+    isEnabled(): boolean;
+    toggle(options?: any): Promise<void>;
+    getContainerCoords(nodes: any): any[];
+    getContainerCoord(node: any): any;
+    setEnabled(value: boolean, options?: any): Promise<void>;
+    destroy(): Promise<void>;
+    private _cacheOriginalTextStyles;
+    private _registerTextStyle;
+    private _restoreTextStyle;
+    private _setDragging;
+    private _setAttributionOptions;
+    private _nodeIsVisible;
+    private _updateSettingsForMap;
+    getGraphPosition(nodes: any): {
+        center: any;
+        zoom: number;
+    };
+    private _initMap;
+    private _clampZoom;
+    private _show;
+    updateProjection(): void;
+    private _hasCustomProjection;
+    private _setupLayers;
+    private _adjustMinvisibleSizes;
+    private _hide;
+    private _destroyMapSync;
+    private _transformToGeo;
+    private _addGraphAttributesLayer;
+    private _transformToGraph;
+    getPointFromLatLng(node: any): {
+        x: number;
+        y: number;
+    };
+    private _createFinalPositionLayer;
+    setCenter(lat: number, lng: number): Promise<void>;
+    setZoom(zoom: number): Promise<void>;
+    zoomIn(): Promise<void>;
+    zoomOut(): Promise<void>;
+    setView(lat: number, lng: number, zoom: number): Promise<void>;
+    getView(): {
+        zoom: number;
+        latitude: number;
+        longitude: number;
+    } | undefined;
+    getCenter(): {
+        latitude: number;
+        longitude: number;
+    } | undefined;
+    getZoom(): number | undefined;
+    resetCoordinates(): void;
+    getUnprojectedCoordinates(node: any): {
+        x: number;
+        y: number;
+    };
+    get latitudePath(): any;
+    get longitudePath(): any;
+    get filter(): any;
+    exportBackground(params: {
+        pixelRatio: number;
+        width: number;
+        height: number;
+        zoom: number;
+        x: number;
+        y: number;
+    }): Promise<HTMLCanvasElement>;
+}

package/types/internals/Graph.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Graph: internal graph data management module.
+ * Manages node/edge Storage, FlexArrays, Topology, and cache lists.
+ */
+import { Module } from './Module';
+import { Storage } from './Storage';
+import { IndexList } from './IndexList';
+import { Topology } from './Topology';
+import { FlexArray } from './FlexArray';
+declare function makeCacheListsForFilters(getMax: () => number, acquireList: () => IndexList, filters: Record<string, (i: number) => boolean>): {
+    all: {
+        getList(): Uint32Array;
+        invalidList(): void;
+    };
+    visible: {
+        getList(): Uint32Array;
+        invalidList(): void;
+    };
+    raw: {
+        getList(): Uint32Array;
+        invalidList(): void;
+    };
+    _all: {
+        getList(): Uint32Array;
+        invalidList(): void;
+    };
+};
+export declare class Graph extends Module {
+    storage: {
+        nodes: Storage;
+        edges: Storage;
+        fetch(isNode: boolean): Storage;
+    };
+    private _promisesToResolve;
+    private _nodeIndexLists;
+    private _edgeIndexLists;
+    private _onNewFrame;
+    topology: Topology;
+    private _nodes;
+    private _edges;
+    private _nodeFilters;
+    private _edgeFilters;
+    private _nodeCacheLists;
+    private _edgeCacheLists;
+    node: (index: number) => any;
+    edge: (index: number) => any;
+    nodeList: (indexes: Uint32Array) => any;
+    edgeList: (indexes: Uint32Array) => any;
+    constructor(nodus: any);
+    onMounted(): void;
+    onReady(params: any): void;
+    createIndexList(isNode: boolean): IndexList;
+    getDom(): any;
+    acquireIndexList(isNode: boolean): IndexList;
+    getObjectList(isNode: boolean): FlexArray;
+    getListFactory(isNode: boolean): (indexes: Uint32Array) => any;
+    getStorage(isNode: boolean): Storage;
+    getFilter(isNode: boolean, name: string): (i: number) => boolean;
+    fireEvent(name: string, data: any): void;
+    getCacheLists(isNode: boolean): ReturnType<typeof makeCacheListsForFilters>;
+    private _resolvePromises;
+    private _initialize;
+    getNodeMaxIndex(): number;
+    getEdgeMaxIndex(): number;
+    isExcluded(element: any): any[];
+    setExcluded(element: any, value: boolean): void;
+    setMultipleExcluded(elements: any, flags: (boolean | number)[]): void;
+    addNode(raw: any, opts?: any): any;
+    addEdge(raw: any, opts?: any): any;
+    addNodes(raws: any[], opts?: any): Promise<any>;
+    addEdges(raws: any[], opts?: any): Promise<any>;
+    addGraph(data: any, opts?: any): Promise<any>;
+    getExtremityIndex(edgeId: any, endpoint: any, side: number, ignoreInvalid: boolean): number | undefined;
+    getNodes(filter?: any): any;
+    getEdges(filter?: any): any;
+    getElements(isNode: boolean, arg?: any): any;
+    getNode(id: any): any;
+    getEdge(id: any): any;
+    private _getElement;
+    clear(): void;
+    createAttribute(isNode: boolean, opts: any, registerByName?: boolean): FlexArray;
+    createNodeAttribute(opts: any, registerByName: boolean): FlexArray;
+    createEdgeAttribute(opts: any, registerByName: boolean): FlexArray;
+    getAttribute(isNode: boolean, name: string): FlexArray | undefined;
+    getAttributes(isNode: boolean, names: string[]): (FlexArray | undefined)[];
+    getNodeAttribute(name: string): FlexArray | undefined;
+    getNodeAttributes(names: string[]): (FlexArray | undefined)[];
+    getEdgeAttribute(name: string): FlexArray | undefined;
+    getEdgeAttributes(names: string[]): (FlexArray | undefined)[];
+    getAllNodeAttributes(): Record<string, FlexArray>;
+    getAllEdgeAttributes(): Record<string, FlexArray>;
+    setSource(edge: any, node: any): void;
+    setTarget(edge: any, node: any): void;
+    getParallelEdges(element: any, opts?: any): any;
+    hasParallelEdges(element: any): boolean;
+    getEdgesBetweenTwoNodes(node1: any, node2: any): any;
+    getAdjacentDirections(nodeIndex: number): any;
+    getEdgeIndexesInDirection(dirIndex: number): any;
+    fastGetNodesAdjacentElements(element: any): any;
+    fastGetEdgesAdjacentElements(element: any): any;
+    getAdjacentNodes(element: any, opts?: any): any;
+    getAdjacentEdges(element: any, opts?: any): any;
+    getDegree(element: any, opts?: any): number[];
+    degrees(element: any, opts?: any): number[];
+    getAdjacencyList(opts?: any): any;
+    getConnectedComponents(element: any, opts?: any): any[];
+    getConnectedComponentByNode(element: any, opts?: any): any[];
+}
+export { Graph as Graph2 };

package/types/internals/Graphics.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Graphics — main WebGL/canvas graphics coordinator.
+ * Faithfully translated from /tmp/nodus_extracted/Graphics.js
+ */
+import { Module } from './Module';
+import { GraphicsEngine } from './GraphicsEngine';
+export declare class Graphics extends Module {
+    _debug: boolean;
+    _initDone: boolean;
+    _boundaries: {
+        maxSize: number;
+        maxMinVisibleSize: number;
+    };
+    _visibility: {
+        nodes: number;
+        edges: number;
+        nodeTexts: number;
+        edgeTexts: number;
+    };
+    _nextAnimationId: number;
+    _animations: any[];
+    _rendererState: {
+        type: any;
+        code: any;
+        state: string;
+        message: string;
+    };
+    _cursorStyle: any[];
+    _fontsNewlyLoaded: any[];
+    _nextGeIndex: number;
+    _availableGeIndexes: number[];
+    _renderOnNewFrame: boolean;
+    _attributesManager: any;
+    _imageManager: any;
+    _fontManager: any;
+    _engine: GraphicsEngine;
+    _domWrapper: any;
+    _nodeAnimationMap: Map<any, any>;
+    _edgeAnimationMap: Map<any, any>;
+    _movingNodes: Set<any>;
+    _movingEdges: Set<any>;
+    _formatText: any;
+    _visibleAttributeLayer: any;
+    _dataAttributeLayer: any;
+    constructor(nodus: any);
+    private _isBufferDisplayable;
+    private _onRendererChange;
+    private _onNewFrame;
+    private _applyCursorStyle;
+    private _updateImageCrossOrigin;
+    onMounted(): void;
+    onReady(e: any): void;
+    getTransparentBackgroundColor(): string | null;
+    pauseRendering(): void;
+    resumeRendering(): void;
+    _render(): void;
+    _fireRendererStateChangeEvent(): void;
+    _updateRendererState({ type: e, state: t, code: s, message: o }: any): void;
+    getImageData(): Promise<any>;
+    getNodeAttributes(): any;
+    getEdgeAttributes(): any;
+    getGraphicsEngine(): GraphicsEngine;
+    getImageManager(): any;
+    getFontManager(): any;
+    allocateGraphicsEngineBlockId(): number;
+    releaseGraphicsEngineBlockId(e: number): void;
+    addCursorStyle(e: any): void;
+    removeCursorStyle(e: any): void;
+    reloadFonts(): void;
+    getDomElement(): any;
+    setTextHidden(e: any, t: any): void;
+    resetTextHidden(): void;
+    getAttributesManager(): any;
+    _checkFontsNewlyLoaded(): boolean;
+    private _normalizeCurrentNodeCoordinates;
+    _loadGraphInGraphicsEngine(): void;
+    _forceCompleteGraphRefresh(): void;
+    export(e: any, t: any, s: any, o: any): Promise<any>;
+    addAttributeLayer(e: any): any;
+    getAttributeValues(e: any, t: any, s: any, o: any): any;
+    forceAttributesComputation(): void;
+    resolveAtNextFrame(e?: any): Promise<any>;
+    isMoving(e: any): boolean;
+    animate(e: any, t: any, s: any, o: any): Promise<any>;
+    isAnimating(): boolean;
+    getAnimationInformation(e: any): any;
+    _toSubGraph(e: any): {
+        nodes: any;
+        edges: any;
+    };
+    _animate(e: any, t: any, s: any, { duration: o, easing: c }: any): Promise<any>;
+    _removeFinishedAnimations(): void;
+    _getAnimationElements(e: any): {
+        nodes: any;
+        edges: any;
+    };
+    _resetAnimationAttributes({ nodes: e, edges: t }: any): void;
+    _getLongestAnimation(e: any, t: any, s: Set<number>): any;
+    _processAnimations(): void;
+    hideTexts(): void;
+    showTexts(): void;
+    setNodesVisibility(value: boolean): void;
+    setNodeTextsVisibility(value: boolean): void;
+    setEdgesVisibility(value: boolean): void;
+    setEdgeTextsVisibility(value: boolean): void;
+    _updateVisibilityCounter(e: keyof typeof this._visibility, value: boolean): void;
+    detectNode(e: any, t: any, s: any, o: any, c: any, p: any): any;
+    private _detectNodeByShapeFallback;
+    detectEdge(e: any, t: any, s: any, o: any, c: any, p: any): any;
+    getVisibilityCounters(): typeof this._visibility;
+    destroy(): void;
+}

package/types/internals/GraphicsEngine.d.ts

@@ -0,0 +1,96 @@
+/**
+ * GraphicsEngine — canvas/WebGL rendering engine (viewport, DOM wrapper, renderer management).
+ * Faithfully translated from /tmp/nodus_extracted/GraphicsEngine.js
+ */
+/** Minimal event emitter mixin providing on/fire in addition to EventTarget. */
+declare class GEEventEmitter extends EventTarget {
+    private _geListeners;
+    on(event: string, handler: (data?: any) => void): this;
+    fire(event: string, data?: any): void;
+}
+export declare class GraphicsEngine extends GEEventEmitter {
+    _view: any;
+    _domWrapper: any;
+    _domElement: any;
+    _currentElementSize: number;
+    _currentBlockOffset: number;
+    _currentByteOffset: number;
+    _blockIdToAddress: Uint32Array;
+    _renderersByType: Record<string, any>;
+    _switchMainRenderer: boolean;
+    _refreshTexts: boolean;
+    _backgroundColor: any;
+    _initData: any;
+    _patternManager: any;
+    _shapeManager: any;
+    _boundariesManager: any;
+    _textManager: any;
+    _bufferOffsetToId: any;
+    _memoryManager: any;
+    _bufferList: any;
+    _renderer: any;
+    _renderType: any;
+    _attributesManager: any;
+    _currentDataView: any;
+    _currentSideDataView: any;
+    _currentSideElementSize: any;
+    _currentSideByteOffset: any;
+    constructor(e?: any);
+    static createInitData(): any;
+    static cacheInitData(e: any): void;
+    static getCachedInitData(): any;
+    static clearCachedInitData(): void;
+    freeBlock(e: number): any;
+    _ensureDomElementsFitParent(): void;
+    _ensureCorrectBackgroundColor(): void;
+    createGroup(): any;
+    parseColor(e: any): any;
+    clear(): void;
+    notifyFontsReloaded(): void;
+    notifyPatternUpdate(): void;
+    getShapePoints(e: any): any;
+    checkShapeHit(e: any, t: number, s: number): boolean;
+    setGlobalBoundaries(e: any): boolean;
+    _resizeBlockArray(e: number): void;
+    registerShape(e: any, t: any): void;
+    updateShape(e: any, t: any): void;
+    _bindBlock(e: number, t: any, s: any, o: any, c: any, p: any, At: any): any;
+    _setItemIndex(e: number): void;
+    _checkBlockId(e: number): void;
+    _setTextCharacters(e: any): void;
+    _storeElement(e: any, t: boolean): void;
+    storeGroup(e: number, t: any): any;
+    _refreshTextElements(): void;
+    extractElement(e: any, t?: number): any;
+    getDomElement(): any;
+    getDomWrapper(): any;
+    measureText(e: any, t: any, s: any, o?: number): any;
+    setRenderType(e: any): void;
+    setEdgeArrowSizeRatio(e: number): void;
+    setEdgeMinTipSize(e: number): void;
+    setBentEdges(e: boolean, t: boolean): void;
+    getBentEdges(): {
+        bentEnable: boolean;
+        bentVertical: boolean;
+    };
+    _ensureMainRendererReady(): void;
+    _updateDomElement(): void;
+    _appendDomChild(e: any): void;
+    _instanciateRenderer(e: any): any;
+    setAttributesManager(m: any): void;
+    setView(e: any): void;
+    getTextManager(): any;
+    _updateManagers(): void;
+    render(): void;
+    ensureAnimationsReady(): void;
+    export(e: any, t: any, s: any): Promise<any>;
+    getCurrentTime(): number;
+    getImageData(): any;
+    destroy(): void;
+    transparentify(e: string): string;
+    initDebugRenderingLoop({ triggerKey: e, start: t }?: {
+        triggerKey?: string | undefined;
+        start?: boolean | undefined;
+    }): void;
+}
+export {};

package/types/internals/Hover.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Hover — manages hover state for nodes and edges using CSS classes and cursor styles.
+ * Faithfully translated from /tmp/nodus_extracted/Hover.js
+ */
+import { Module } from './Module';
+export declare class Hover extends Module {
+    private _delay;
+    private _manualTriggerDetection;
+    private _hovered;
+    private _hoveredTextHidden;
+    private _timeout;
+    private _animationOptions;
+    private _hoverClass;
+    private _hoverExtremityHighlightedClass;
+    private _onAnimate;
+    private _onBeforeNewFrame;
+    private _onClear;
+    private _resetHover;
+    private _setAnimationOptions;
+    replaceNullColor(attrs: any, path: string): void;
+    updateNodeAttributes(attrs: any, fullOverwrite: boolean): void;
+    updateEdgeAttributes(attrs: any, fullOverwrite: boolean): void;
+    getHoverClassDefinition(): any;
+    onMounted(): void;
+    private _registerSettings;
+    setEdgeExtremitiesAttributes(attrs: any, fullOverwrite: boolean): void;
+    private _updateExtremityHighlightLayer;
+    private _removeTimeout;
+    private _hover;
+    private _unhover;
+    private _setElementHighlight;
+}

package/types/internals/Hypergraph.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Internal Hypergraph module. Owns the in-memory hypergraph state, the
+ * simplifier scale stack, the layout result, and the canvas / SVG
+ * overlay layer handles. Exposes the runtime that the public
+ * HypergraphAPI delegates into.
+ */
+import { Module } from './Module';
+import { Hypergraph as HypergraphDS, type AtomicOperationRecord, type HypergraphData, type HypergraphId, type HypergraphRenderOptions, type InteractionEvent, type LayoutOptions, type SimplificationOptions, type Vec2, type QualityMetrics, type PolygonRenderState } from '../hypergraph';
+interface RenderHandles {
+    primal?: any;
+    dual?: any;
+}
+export declare class Hypergraph extends Module {
+    /** Current working hypergraph (mutated by simplifier; restored by reverser). */
+    H: HypergraphDS;
+    /** Captured snapshots H_0..H_n. scales[0] is original, scales[n] is simplest. */
+    scales: HypergraphData[];
+    /** Operation reversal stack (most-recent op last). */
+    operations: AtomicOperationRecord[];
+    /** H_0 cardinalities, used by the optimizer/reverser per paper §5.3
+     *  to size polygons by the original (not the simplified) cardinality. */
+    originalCardinality: Map<HypergraphId, number>;
+    /** Current vertex/dual positions. Polygons read from this map; if a
+     *  vertex has `nodeId` set and no entry here, the renderer falls back
+     *  to the live Nodus node's position via `_resolvePosition`. */
+    positions: Map<HypergraphId, Vec2>;
+    dualPositions: Map<HypergraphId, Vec2>;
+    /** Vertex id → bound Nodus node id (when the demo / OSFKB adapter
+     *  provides one). Lets polygons follow node drags without re-running
+     *  the optimizer. */
+    private _nodeBindings;
+    /** Listener handle for nodes.move so we know to refresh polygons. */
+    private _onNodesMove;
+    /** Active scale being viewed (0 = H_0, scales.length-1 = H_n). */
+    activeScale: number;
+    /** Last applied render options. */
+    renderOptions: PolygonRenderState['options'] | null;
+    private _layers;
+    hoveredHyperedge: HypergraphId | null;
+    hoveredDualOf: HypergraphId | null;
+    hoveredVertex: HypergraphId | null;
+    selectedHyperedges: Set<HypergraphId>;
+    selectedVertices: Set<HypergraphId>;
+    private _onMouseMove;
+    private _onClick;
+    private _onMouseOut;
+    private _previousCursor;
+    /** EventsModule channel name used for hypergraph lifecycle events. */
+    private static EVENT_NAMES;
+    onMounted(): void;
+    destroy(): void;
+    setData(data: HypergraphData): void;
+    private _bindNodeMoveListener;
+    /**
+     * Resolve a vertex's current position. Priority:
+     *   1. optimizer-set positions (from `optimize()` / `reverse()`)
+     *   2. bound Nodus node position via `node.getPosition()`
+     *   3. undefined — caller skips this vertex.
+     */
+    private _resolvePosition;
+    /** Build a live positions map for the renderer — combines optimizer
+     *  output with bound Nodus node positions. */
+    private _livePositions;
+    fromNodesAndEdges(opts: {
+        groupBy: (n: any) => Array<HypergraphId>;
+    }): void;
+    getData(): HypergraphData;
+    getDualData(): HypergraphData;
+    simplify(opts?: SimplificationOptions): {
+        scales: number;
+        operations: number;
+    };
+    layout(opts?: LayoutOptions): Promise<{
+        totalEnergy: number;
+        overlapCount: number;
+    }>;
+    /**
+     * Current vertex positions as the renderer sees them: combines the
+     * optimizer's output with live Nodus-node positions (when vertices
+     * are bound via `nodeId`). This is what gets returned to public
+     * callers — `this.positions` alone may be empty when no optimizer
+     * pass has run, even though polygons render fine.
+     */
+    getVertexPositions(): Map<HypergraphId, Vec2>;
+    getDualPositions(): Map<HypergraphId, Vec2>;
+    /** CCW convex-hull polygon for one hyperedge — uses live positions. */
+    getHyperedgePolygon(heId: HypergraphId): Vec2[];
+    render(opts?: HypergraphRenderOptions): RenderHandles;
+    private _bindInteraction;
+    private _unbindInteraction;
+    private _hitState;
+    private _updateCursor;
+    setSelected(opts: {
+        hyperedges?: HypergraphId[];
+        vertices?: HypergraphId[];
+        replace?: boolean;
+    }): void;
+    toggleSelected(opts: {
+        hyperedge?: HypergraphId;
+        vertex?: HypergraphId;
+    }): void;
+    clearSelection(): void;
+    getHyperedgeAtPoint(world: Vec2): InteractionEvent;
+    refreshLayers(): void;
+    removeLayers(): void;
+    setActiveView(view: 'primal' | 'dual' | 'both'): void;
+    hideLayers(): void;
+    showLayers(): void;
+    countOverlaps(): number;
+    computeMetrics(): QualityMetrics;
+}
+export {};

package/types/internals/IndexList.d.ts

@@ -0,0 +1,28 @@
+/**
+ * IndexList: a growable Uint32Array buffer for collecting element indexes.
+ *
+ * Backed by a typed array that doubles its capacity on demand, it offers an
+ * efficient way to accumulate a variable-length sequence of u32 indexes and
+ * then snapshot them out as a compact slice.
+ */
+export declare class IndexList {
+    private _buffer;
+    private _capacity;
+    private _size;
+    private _busy;
+    constructor();
+    isBusy(): boolean;
+    markBusy(): this;
+    sliceAndReset(): Uint32Array;
+    reset(): this;
+    reserve(capacity: number): this;
+    private _setCapacity;
+    push(value: number): this;
+    pushUnchecked(value: number): this;
+    slice(start?: number, end?: number): Uint32Array;
+    getBuffer(): Uint32Array;
+    getLength(): number;
+    getCapacity(): number;
+    setLength(n: number): this;
+    isEmpty(): boolean;
+}

package/types/internals/IndividualAttributes.d.ts

@@ -0,0 +1,27 @@
+/**
+ * IndividualAttributes — manages per-element attribute layers (original + individual).
+ *
+ * Maintains two attribute layers on the graphics module: an "original" layer that
+ * holds attributes supplied when elements are added, and an "individual" layer that
+ * holds per-element overrides applied at runtime. The individual layer takes
+ * precedence via its higher layer priority, allowing overrides to be set and reset
+ * without losing the original values.
+ */
+import { Module } from './Module';
+export declare class IndividualAttributes extends Module {
+    private _graphics;
+    private _originalAttributesLayer;
+    private _individualAttributesLayer;
+    onMounted(): void;
+    private _onAddElements;
+    getOriginalAttributes(): any;
+    getIndividualAttributes(): any;
+    setMultipleAttributes(elements: any, values: any, opts: any): Promise<any>;
+    setSingleAttribute(elements: any, path: string, value: any, opts: any): Promise<any>;
+    resetMultipleAttributes(elements: any, attrs: string[] | null | undefined, opts: any): Promise<any>;
+    getMultipleAttributes(elements: any, paths: string[]): any;
+    getSingleAttribute(elements: any, path: string): any;
+    replaceOriginalAttributes(elements: any, attrs: any, skipPaths?: string[]): void;
+    getSinglePreviousAttribute(elements: any, path: string): any;
+    getMultiplePreviousAttributes(elements: any, paths: string[]): any;
+}

package/types/internals/Interactions.d.ts

@@ -0,0 +1,45 @@
+import { Module } from './Module';
+interface ProgressiveInteractionOptions {
+    priority: string | number;
+    check?: (info: any) => boolean;
+    onStart?: (info: any) => void;
+    onProgress?: (info: any) => void;
+    onStop?: (info: any) => void;
+    disableDetection?: boolean;
+}
+interface NonProgressiveInteractionOptions {
+    priority: string | number;
+    check?: (info: any) => boolean;
+    handler?: (info: any) => void;
+}
+interface InteractionHandle {
+    start(info: any): void;
+}
+export declare class Interactions extends Module {
+    private _current?;
+    private _interactionsByStartEvent;
+    private _boundProgressEvents;
+    private _boundStopEvents;
+    private _onStartInteractionEvent;
+    private _onProgressInteractionEvent;
+    private _onStopInteractionEvent;
+    onMounted(): void;
+    private _startInteraction;
+    private _stopCurrentInteraction;
+    private _forceStartInteraction;
+    private _createWrapper;
+    private _addInteraction;
+    private _createProgressiveInteraction;
+    private _createNonProgressiveInteraction;
+    onDrag(options: ProgressiveInteractionOptions): InteractionHandle;
+    onGesture(options: ProgressiveInteractionOptions): InteractionHandle;
+    onClick(options: NonProgressiveInteractionOptions): InteractionHandle;
+    onDoubleClick(options: NonProgressiveInteractionOptions): InteractionHandle;
+    onHover(options: NonProgressiveInteractionOptions): InteractionHandle;
+    onUnhover(options: NonProgressiveInteractionOptions): InteractionHandle;
+    onMouseWheel(options: NonProgressiveInteractionOptions): InteractionHandle;
+    onMouseDown(options: NonProgressiveInteractionOptions): InteractionHandle;
+    onMouseUp(options: NonProgressiveInteractionOptions): InteractionHandle;
+    onMouseMove(options: NonProgressiveInteractionOptions): InteractionHandle;
+}
+export {};