@kortexya/nodus 0.1.0

package/types/publicTypes.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Public type definitions shared across the Nodus API surface.
+ *
+ * These describe the plain-JSON graph format that {@link Nodus.setGraph} and
+ * the parsers accept, plus a handful of small style primitives reused by the
+ * interaction tools. They are intentionally permissive so consumers can attach
+ * arbitrary `data` and visual attributes to nodes and edges.
+ */
+import type { Node } from './core/Node';
+import type { Edge } from './core/Edge';
+export type { Point, SimpleBoundingBox } from './geometry/types';
+/** Unique identifier for a node. */
+export type NodeId = string | number;
+/** Unique identifier for an edge. */
+export type EdgeId = string | number;
+/** A CSS color string, or `null` to clear/inherit. */
+export type Color = string | null;
+/** Free-form bag of visual attributes attached to a node or edge. */
+export type ElementAttributes = Record<string, any>;
+/** Plain-JSON representation of a node. */
+export interface RawNode<T = any> {
+    id?: NodeId;
+    attributes?: ElementAttributes;
+    data?: T;
+}
+/** Plain-JSON representation of an edge. */
+export interface RawEdge<T = any> {
+    id?: EdgeId;
+    source: NodeId;
+    target: NodeId;
+    attributes?: ElementAttributes;
+    data?: T;
+}
+/** Plain-JSON representation of a graph: a set of nodes and edges. */
+export interface RawGraph<T = any, U = any> {
+    nodes: RawNode<T>[];
+    edges: RawEdge<U>[];
+}
+/** Valid CSS cursor keywords accepted by the interaction tools. */
+export type CursorStyle = 'auto' | 'default' | 'none' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'alias' | 'copy' | 'move' | 'no-drop' | 'not-allowed' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ew-resize' | 'ns-resize' | 'nesw-resize' | 'nwse-resize' | 'col-resize' | 'row-resize' | 'all-scroll' | 'zoom-in' | 'zoom-out' | 'grab' | 'grabbing';
+/** Options for the connect-nodes interaction tool. */
+export interface ConnectNodesOptions<ND = any, ED = any> {
+    continueDrawing?: boolean;
+    cursorStyle?: CursorStyle;
+    strokeColor?: Color;
+    strokeWidth?: number;
+    dashLength?: number;
+    dashed?: boolean;
+    createNodes?: boolean;
+    condition?: (source: Node<ND, ED>, target?: Node<ND, ED>) => boolean;
+    onNodeCreated?: (node: Node<ND, ED>) => void;
+    onEdgeCreated?: (edge: Edge<ED, ND>) => void;
+    createEdge?: (edge: RawEdge<ED>) => RawEdge<ED>;
+    createNode?: (node: RawNode<ND>) => RawNode<ND>;
+    onComplete?: (source: Node<ND, ED>, target: Node<ND, ED>, edge?: Edge<ED, ND>) => void;
+}

package/types/renderers/CanvasRenderer.d.ts

@@ -0,0 +1,86 @@
+/**
+ * CanvasRenderer — Canvas 2D renderer that extends CpuRenderer.
+ *
+ * Implements the low-level Canvas 2D drawing primitives (shapes, lines,
+ * curves, text, images and pie charts) that CpuRenderer invokes during its
+ * `_render()` pipeline, translating scene geometry into `CanvasRenderingContext2D`
+ * calls scaled by the device pixel ratio.
+ */
+import { CpuRenderer } from '../internals/rendering/CpuRenderer';
+import type { RendererBaseOptions, ChangeFlags } from '../internals/rendering/RendererBase';
+export declare class CanvasRenderer extends CpuRenderer {
+    protected _canvas: HTMLCanvasElement;
+    protected _ctx: CanvasRenderingContext2D;
+    private _imgCanvas;
+    private _imgCtx;
+    constructor(opts: RendererBaseOptions);
+    static getName(): string;
+    static isAvailable(): boolean;
+    getDomElement(): HTMLCanvasElement;
+    _render({ shapesChanged, dimensionsChanged }: ChangeFlags): void;
+    protected _drawRoundedRectangle(center: {
+        x: number;
+        y: number;
+    }, halfW: number, halfH: number, angle: number, fillColor: string | null): void;
+    protected _drawCircle(center: {
+        x: number;
+        y: number;
+    }, radius: number): void;
+    protected _drawPolygon(points: Array<{
+        x: number;
+        y: number;
+    }>): void;
+    protected _drawStraightLine(from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }): void;
+    protected _drawQuadraticCurve(from: {
+        x: number;
+        y: number;
+    }, control: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }): void;
+    protected _drawCubicCurve(from: {
+        x: number;
+        y: number;
+    }, cp1: {
+        x: number;
+        y: number;
+    }, cp2: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }): void;
+    protected _fill(color: string | null): void;
+    protected _stroke(color: string | null, width?: number, dash?: number[]): void;
+    protected _startClip(): void;
+    protected _endClip(): void;
+    protected _startReverseClip(): void;
+    protected _endReverseClip(): void;
+    protected _displayText(position: {
+        x: number;
+        y: number;
+    }, angle: number, text: string, color: string, fontFamily: string, fontSize: number, isIcon: boolean, textAlign: string, textWidth: number, offsetX: number, offsetY: number, _unused?: any, stroke?: {
+        color: string;
+        width: number;
+    }): void;
+    protected _displayImage(center: {
+        x: number;
+        y: number;
+    }, width: number, height: number, image: any, scaled: boolean, duplicated: boolean, opacity: number): void;
+    protected _displayPieChart(center: {
+        x: number;
+        y: number;
+    }, radius: number, colors: string[]): void;
+    private _blendImageOnBackground;
+    getImageData(): ImageData;
+}

package/types/renderers/Renderer.d.ts

@@ -0,0 +1,13 @@
+import { Nodus } from '../Nodus';
+import { Module } from '../internals/Module';
+export declare abstract class Renderer extends Module {
+    protected canvas: HTMLCanvasElement | null;
+    protected ctx: CanvasRenderingContext2D | WebGLRenderingContext | null;
+    protected width: number;
+    protected height: number;
+    constructor(nodus: Nodus<any, any>);
+    init(container: HTMLElement): void;
+    resize(): void;
+    abstract render(): void;
+    refresh(): void;
+}

package/types/renderers/SVGRenderer.d.ts

@@ -0,0 +1,57 @@
+import { Renderer } from './Renderer';
+import { Nodus } from '../Nodus';
+export declare class SvgRenderer extends Renderer {
+    private _svgRoot;
+    private _defsEl;
+    private _stylesGroup;
+    private _background;
+    private _viewGroup;
+    private _selectionGroup;
+    private _edgeGroup;
+    private _nodeGroup;
+    private _labelGroup;
+    private _badgeGroup;
+    private _transform;
+    private _backgroundColor;
+    private _renderBackground;
+    private _nodeElements;
+    private _edgeElements;
+    private _edgeArrowMarkers;
+    private _labelElements;
+    private _labelBgElements;
+    private _badgeElements;
+    private _edgeLabelElements;
+    private _selectionElements;
+    private _selectedNodes;
+    private _selectedEdges;
+    private _selectionColor;
+    private _clipPathCounter;
+    constructor(nodus: Nodus<any, any>);
+    static getName(): string;
+    static isAvailable(): boolean;
+    init(container: HTMLElement): void;
+    resize(): void;
+    setTransform(x: number, y: number, zoom: number, angle?: number): void;
+    private _updateTransform;
+    setBackgroundColor(color: string | null, render?: boolean): void;
+    setSelectedNodes(nodeIndices: number[]): void;
+    setSelectedEdges(edgeIndices: number[]): void;
+    render(): void;
+    private _clear;
+    private _renderEdges;
+    private _createEdgePath;
+    private _computeControlPoint;
+    private _renderEdgeLabel;
+    private _renderNodes;
+    private _createShapeElement;
+    private _renderBadge;
+    private _renderNodeLabel;
+    private _getColor;
+    getNodeAt(screenX: number, screenY: number): number | null;
+    getEdgeAt(screenX: number, screenY: number): number | null;
+    toSVGString(): string;
+    toDataURL(): string;
+    destroy(): void;
+    requestRender(): void;
+}
+export { SvgRenderer as SVGRenderer };

package/types/renderers/WasmGraphRenderer.d.ts

@@ -0,0 +1,118 @@
+/**
+ * WasmGraphRenderer — a live Rust/wgpu renderer for a Nodus graph.
+ *
+ * Drives the real Nodus CIRCLE + EDGE WGSL shaders (via the `nodus-render-wasm` `WasmRenderer`)
+ * from the live graph: it extracts each node's resolved style (colour/shape/size/stroke) into the
+ * SoA the shaders decode, re-reads positions every frame, and follows the live camera. The
+ * `WasmRenderer` class is injected so the heavy wgpu module stays lazy-loaded by the caller.
+ *
+ * This is the integration layer: `await WasmGraphRenderer.create(nodus, canvas, WasmRenderer)` then
+ * `.start()` runs a requestAnimationFrame loop; `.renderFrame()` draws one frame on demand.
+ */
+export interface WasmGraphRendererOptions {
+    /** Camera mode: 'follow' reads the Nodus camera (default); 'fit' auto-fits the graph each frame. */
+    camera?: 'follow' | 'fit';
+    /** Background clear colour is white in the shader; this controls supersampling (default 2). */
+    pixelRatio?: number;
+    /** Edge arrowheads: 'none' (default), 'target' (head), or 'both'. */
+    arrows?: 'none' | 'target' | 'both';
+}
+export declare class WasmGraphRenderer {
+    private _nodus;
+    private _canvas;
+    private _wasm;
+    private _opts;
+    private _raf;
+    private _toLinear;
+    private _styleVersion;
+    private _radii;
+    private _fill;
+    private _shape;
+    private _stroke;
+    private _sw;
+    private _outline;
+    private _haloCol;
+    private _haloW;
+    private _imageTile;
+    private _atlasKey;
+    private _pieOffset;
+    private _pieCount;
+    private _pieSegs;
+    private _edges;
+    private _edgeColor;
+    private _edgeWidth;
+    private _edgeCurv;
+    private _xs;
+    private _ys;
+    private _nodeIds;
+    private _labels;
+    private _lastCam;
+    private _fitted;
+    private _glyphs;
+    private _fontPx;
+    private _highlight;
+    private _pieData;
+    private _badgeNode;
+    private _badgeAngle;
+    private _badgeScale;
+    private _badgePosScale;
+    private _badgeFill;
+    private _badgeStrokeCol;
+    private _badgeStrokeW;
+    private _badgeText;
+    private _badgeTextCol;
+    private constructor();
+    /** Create a renderer bound to `canvas`. `WasmRendererClass` is the lazy-loaded wgpu class. */
+    static create(nodus: any, canvas: HTMLCanvasElement, WasmRendererClass: any, opts?: WasmGraphRendererOptions): Promise<WasmGraphRenderer>;
+    /** Rasterise an ASCII glyph atlas (white, alpha=coverage) into a texture the TEXT shader samples,
+     * recording each glyph's UV region. Monospace-ish layout in a fixed cell grid. */
+    private _buildAtlas;
+    /** Load image URLs into a 16×16 tile grid atlas (64px tiles, 1024² sRGB) and upload it; redraw on
+     * completion so node icons appear. attrEx.y (set in _buildNodeAttrs) selects each node's tile. */
+    private _loadAtlas;
+    /** Lay out each node's label into TEXT-shader glyph instances (5 vec4f each), from live positions.
+     * `zoom` is the dpr-scaled camera zoom; the world font size is derived so labels stay a constant
+     * on-screen size (backing px = world·zoom, so worldFont = targetCssPx·dpr / zoom). */
+    private _buildText;
+    private _dpr;
+    private _sizeCanvas;
+    /** getAttribute that returns null instead of throwing on an undefined attribute name. */
+    private _safeAttr;
+    /** A Nodus style value (false/null = off, colour string, or {color,...}) → LINEAR rgba, or null. */
+    private _styleColor;
+    /** Width from a style value ({width} object) or a default. */
+    private _styleWidth;
+    /** Re-read each node's resolved style into the SoA. Cheap: skipped unless the graph version moved. */
+    private _rebuildStyle;
+    /** The camera as (cx, cy, zoom) for the shader, accounting for DPR (zoom·dpr) — or auto-fit. */
+    private _camera;
+    /** Set the node ids that get a highlight ring (selection/hover); redraw to reflect it. */
+    setHighlight(ids: any[]): void;
+    /** Render a node as a pie chart of equal-angle colour slices (or clear with null). Restyle next frame. */
+    setPie(id: any, colours: string[] | null): void;
+    /** Assemble the node `attrs` SoA the CIRCLE shader decodes — 7×vec4f (28 f32) per node. THIS is
+     * the feature surface: every node feature is a write into this layout, no Rust change needed.
+     *   [0..4]  fillCol           [4..8]  attrEx=(shapeId, imageId, innerStrokeW px, haloW px)
+     *   [8..12] strokeCol(inner)  [12..16] haloCol
+     *   [16..20] pieMeta=(pieOff, pieCount, innerStrokeMinVis, outerStrokeW px)
+     *   [20..24] outerStrokeCol   [24..28] outlineCol */
+    private _buildNodeAttrs;
+    /** Assemble the edge attr SoA the EDGE shader decodes — 2×u32 per edge: packed rgba8 colour, then
+     * (widthU16 | dash<<16 | arrows<<20 | widthScale<<22 | curvByte<<24). The edge feature surface. */
+    private _buildEdgeAttrs;
+    /** Draw one frame from the live graph. */
+    renderFrame(): void;
+    /** Hit-test a canvas-relative screen point (CSS px) → node id, or null. CPU point-in-radius
+     * against the last rendered frame's camera + positions (the inverse of the shader's mapping). */
+    pick(cssX: number, cssY: number): any;
+    /** World point → canvas-relative CSS px (the forward mapping; inverse of `pick`'s unproject). */
+    worldToScreen(wx: number, wy: number): {
+        x: number;
+        y: number;
+    };
+    /** Resize the surface to the canvas's container, then redraw. */
+    resize(): void;
+    /** Start the requestAnimationFrame loop (follows live positions + camera). */
+    start(): void;
+    stop(): void;
+}

package/types/renderers/WasmRendererAdapter.d.ts

@@ -0,0 +1,38 @@
+/**
+ * WasmRendererAdapter — bridges the live Rust renderer (WasmGraphRenderer) into the Nodus
+ * GraphicsEngine's renderer slot, so it can be selected like any other renderer
+ * (`new Nodus({ renderer: 'wasm' })`). Registered in RENDER_MAPPING as 'wasm'.
+ *
+ * The heavy wgpu module (`nodus-render-wasm`) is injected once via `setModule()` (kept out of the
+ * default bundle / lazy-loaded by the host), so this adapter carries no wgpu weight itself.
+ */
+import { RendererBase } from '../internals/rendering/RendererBase';
+export declare class WasmRendererAdapter extends RendererBase {
+    private _canvas;
+    private _nodus;
+    private _renderer;
+    private _loading;
+    private static _module;
+    private static _loader;
+    /** Inject the `WasmRenderer` class from `nodus-render-wasm` (pkg-render) directly. */
+    static setModule(WasmRendererClass: any): void;
+    /** Provide an async loader for the wgpu module (e.g. `() => import('@kortexya/nodus/render-wasm')`).
+     * Used when the module isn't injected — the adapter lazy-loads it on first render. */
+    static setModuleLoader(loader: () => Promise<any>): void;
+    /** Resolve the `WasmRenderer` class: injected module, else the loader, else the default pkg-render. */
+    private static _resolveModule;
+    static createInitData(): any;
+    static getName(): string | null;
+    static isAvailable(): boolean;
+    constructor(opts: any);
+    getDomElement(): HTMLElement;
+    /** Lazily resolve the wgpu module + create the WasmGraphRenderer once the canvas is in the DOM. */
+    private _ensure;
+    renderFrame(): void;
+    /** Hit-test for hover/click — canvas-relative CSS px → the Node, or null. */
+    extractElement(x: number, y: number): any;
+    resize(): void;
+    ensureAnimationsReady(): Promise<void>;
+    getImageData(): any;
+    destroy(): void;
+}

package/types/tools/ConnectNodesAPI.d.ts

@@ -0,0 +1,42 @@
+import { Nodus } from '../Nodus';
+import { Module } from '../internals/Module';
+import type { ConnectNodesOptions } from '../publicTypes';
+/**
+ * Connect Nodes API: functions to connect nodes by drawing edges.
+ *
+ * Enables the user to draw edges between nodes by clicking and dragging.
+ * When enabled, clicking on a node and dragging to another node creates an edge.
+ * Optionally, dragging to empty space creates a new node and connects to it.
+ */
+export declare class ConnectNodesAPI<ND = any, ED = any> extends Module {
+    private _enabled;
+    private _options;
+    private _startNode;
+    private _startPos;
+    private _endPos;
+    private _cursorEnabled;
+    private _prevSettings;
+    private _blockId;
+    private _canvasLayer;
+    private _interaction;
+    constructor(nodus: Nodus<ND, ED>);
+    private _init;
+    private _onStart;
+    private _onMove;
+    private _onStop;
+    private _getNodeAtPosition;
+    private _drawLine;
+    private _clearLine;
+    /**
+     * Enable the "connectNodes" mode, allowing the user to draw edges with the mouse.
+     */
+    enable(options?: ConnectNodesOptions<ND, ED>): this;
+    /**
+     * Disable the "connectNodes" mode.
+     */
+    disable(): this;
+    /**
+     * Indicates if the "connectNodes" mode is enabled.
+     */
+    enabled(): boolean;
+}

package/types/tools/LassoAPI.d.ts

@@ -0,0 +1,78 @@
+import { Nodus } from '../Nodus';
+import { Module } from '../internals/Module';
+import type { Color, CursorStyle, Point } from '../publicTypes';
+interface LassoInternalOptions {
+    strokeColor: Color;
+    strokeWidth: number;
+    fillColor: Color | null;
+    cursorStyle: CursorStyle;
+    callback: (payload: {
+        nodes: any;
+        edges: any;
+        points: Point[];
+    }) => void;
+    bothExtremities: boolean;
+}
+/**
+ * Simple axis-aligned bounding box for polygon point tracking.
+ */
+declare class BoundingBox {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    reset(): void;
+    extend(x: number, y: number): void;
+}
+/**
+ * Lasso API: functions to select nodes and edges by drawing a lasso.
+ *
+ * When enabled, the user can draw a freeform shape on the canvas.
+ * Nodes and edges within the lasso region are selected (or passed to a callback).
+ */
+export declare class LassoAPI<ND = any, ED = any> extends Module {
+    protected _enabled: boolean;
+    protected _options: LassoInternalOptions;
+    protected _points: Point[];
+    protected _bbox: BoundingBox;
+    protected _canvasLayer: any;
+    protected _cachedCursor: string;
+    protected _interaction: any;
+    constructor(nodus: Nodus<ND, ED>);
+    private _init;
+    private _onStart;
+    private _onProgress;
+    private _onStop;
+    protected _queryElements(minX: number, minY: number, maxX: number, maxY: number): {
+        nodes: any;
+        edges: any;
+    };
+    protected _filterNodesInPolygon(nodes: any, polygon: Point[], nodeInsideMap: Record<string, boolean>): any;
+    protected _filterEdges(edges: any, nodeInsideMap: Record<string, boolean>): any;
+    protected _savePoint(x: number, y: number, draw: boolean): void;
+    protected _clearCanvas(): void;
+    /**
+     * Enables the lasso selection tool.
+     */
+    enable(options?: {
+        strokeColor?: Color;
+        strokeWidth?: number;
+        fillColor?: Color | null;
+        cursorStyle?: CursorStyle;
+        callback?: (payload: {
+            nodes: any;
+            edges: any;
+            points: Point[];
+        }) => void;
+        bothExtremities?: boolean;
+    }): this;
+    /**
+     * Disables the lasso tool.
+     */
+    disable(): this;
+    /**
+     * Check whether the lasso tool is enabled.
+     */
+    enabled(): boolean;
+}
+export {};

package/types/tools/RectangleSelectAPI.d.ts

@@ -0,0 +1,51 @@
+import { Nodus } from '../Nodus';
+import { Module } from '../internals/Module';
+import type { Color, CursorStyle, SimpleBoundingBox } from '../publicTypes';
+/**
+ * Rectangle Select API: functions to select nodes and edges by drawing a rectangle.
+ *
+ * When enabled, the user can draw a rectangle by clicking and dragging on the canvas.
+ * Nodes within the rectangle are selected (or passed to a callback).
+ * If no nodes are found, edges within the rectangle are selected instead.
+ */
+export declare class RectangleSelectAPI<ND = any, ED = any> extends Module {
+    private _enabled;
+    private _options;
+    private _canvasLayer;
+    private _cachedCursor;
+    private _start;
+    private _interaction;
+    constructor(nodus: Nodus<ND, ED>);
+    private _onStart;
+    private _refreshRectangle;
+    private _formatRectangle;
+    private _onStop;
+    private _queryElements;
+    private _filterNodesInRectangle;
+    private _filterEdges;
+    private _clearCanvas;
+    /**
+     * Enable the selection by rectangle tool, allowing the user to select nodes
+     * by drawing a rectangle on the screen.
+     */
+    enable(options?: {
+        strokeColor?: Color;
+        strokeWidth?: number;
+        fillColor?: Color | null;
+        cursorStyle?: CursorStyle;
+        callback?: (payload: {
+            nodes: any;
+            edges: any;
+            rectangle: SimpleBoundingBox;
+        }) => void;
+        bothExtremities?: boolean;
+    }): void;
+    /**
+     * Disable the rectangle selection.
+     */
+    disable(): void;
+    /**
+     * Indicates if the rectangle selection is enabled.
+     */
+    enabled(): boolean;
+}

package/types/tools/ResizingAPI.d.ts

@@ -0,0 +1,62 @@
+import { Nodus } from '../Nodus';
+import { Module } from '../internals/Module';
+import type { Color, CursorStyle } from '../publicTypes';
+/**
+ * Resizing API: functions to resize nodes.
+ *
+ * When enabled, selected nodes display resize handles at the corners of their
+ * bounding box. Dragging a handle changes the node radius. The tool supports
+ * snapping to nearby node sizes and displays size indicator guidelines.
+ */
+export declare class ResizingAPI<ND = any, ED = any> extends Module {
+    private _enabled;
+    private _options;
+    private _nodesToHighlight;
+    private _cursorEnabled;
+    private _x;
+    private _y;
+    private _pointedNode;
+    private _nodeBeingResized;
+    private _additionalRadiuses;
+    private _canvasLayer;
+    private _engine;
+    private _interaction;
+    constructor(nodus: Nodus<ND, ED>);
+    private _init;
+    private _onSelectionChange;
+    private _displayHandlesHandler;
+    private _moveHandler;
+    private _enableCursor;
+    private _disableCursor;
+    private _detectBoundingBoxes;
+    private _getTotalRadius;
+    private _snap;
+    private _displayHandles;
+    /**
+     * Enable the "resize" mode, allowing the user to manually change the size
+     * of the selected nodes.
+     */
+    enable(options?: {
+        cursor?: CursorStyle;
+        color?: Color;
+        lineWidth?: number;
+        handleSize?: number;
+        detectionMargin?: number;
+        snappingRatio?: number;
+        nbNodesToSnapTo?: number;
+        previewColor?: Color;
+        sizeIndicatorColor?: Color;
+        sizeIndicatorOffset?: number;
+        sizeIndicatorWidth?: number;
+        sizeIndicatorThickness?: number;
+    }): void;
+    /**
+     * Disable the "resize" mode.
+     */
+    disable(): void;
+    private _reset;
+    /**
+     * Indicates if the "resize" mode is enabled.
+     */
+    enabled(): boolean;
+}

package/types/tools/RewiringAPI.d.ts

@@ -0,0 +1,78 @@
+import { Nodus } from '../Nodus';
+import { Module } from '../internals/Module';
+import type { Color, CursorStyle } from '../publicTypes';
+type HandleAnchor = 'center' | 'circumference' | 'text';
+/**
+ * Rewiring API: functions to manually change the extremities of the selected edges.
+ *
+ * When enabled, selected edges display handles at their source and target node
+ * positions. The user can drag these handles to change which node an edge connects to.
+ */
+export declare class RewiringAPI<ND = any, ED = any> extends Module {
+    private _enabled;
+    private _options;
+    private _canvasLayer;
+    private _nodesToHighlight;
+    private _edgeHandles;
+    private _hoveredHandle;
+    private _hoveredNode;
+    private _hoverHandle;
+    private _grabHandle;
+    private _x;
+    private _y;
+    private _movedEdges;
+    private _startNode;
+    private _prevSettings;
+    private _interaction;
+    private _fixedEdges;
+    private _rewirableClass;
+    private _hiddenEdgesClass;
+    constructor(nodus: Nodus<ND, ED>);
+    private _init;
+    private _getAnchor;
+    private _getAnchorPosition;
+    private _onMouseUp;
+    private _onMouseDown;
+    private _onDragProgress;
+    private _refreshCanvas;
+    private _checkForHover;
+    private _shouldInteractionStart;
+    private _onDragStart;
+    private _onDragEnd;
+    private _refreshHandles;
+    private _getNodeAtPosition;
+    private _enableCursorOnHover;
+    private _disableCursorOnHover;
+    private _restoreSettings;
+    private _drawHandleDefault;
+    /**
+     * Enable the "rewire" tool, enabling the user to manually change the
+     * extremities of the selected edges.
+     */
+    enable(options?: {
+        color?: Color;
+        radius?: number;
+        hoverRadius?: number;
+        cursorOnHover?: CursorStyle;
+        cursorOnDrag?: CursorStyle;
+        drawHandle?: (ctx: CanvasRenderingContext2D, node: any, isHovered: boolean) => void;
+        anchor?: HandleAnchor | ((node: any) => HandleAnchor);
+        edges?: any;
+        drawEdges?: boolean;
+    }): void;
+    private _displayMovedEdges;
+    /**
+     * Set the edges eligible for rewiring at runtime.
+     * Pass `undefined` to fall back to the current selection.
+     */
+    setEdgesToRewire(edges: any | undefined): void;
+    /**
+     * Disable the "rewire" tool.
+     */
+    disable(): void;
+    /**
+     * Indicates if the "rewire" tool is enabled.
+     */
+    enabled(): boolean;
+}
+export {};