@kortexya/nodus 0.1.0

package/types/internals/Keyboard.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Keyboard — key press/release tracking and binding system.
+ *
+ * Tracks which keys are currently held, dispatches `keydown`/`keyup` events,
+ * and lets callers register key-combination handlers via `onKeyPress`. Also
+ * wires up the built-in pan/zoom keyboard controls and resets stuck keys when
+ * the window loses focus or after an idle period.
+ */
+import { Module } from './Module';
+export declare class Keyboard extends Module {
+    private _pressed;
+    private _binds;
+    private _idleTimeout;
+    private _prevEventTimeStamp;
+    private _onKeyPress;
+    private _onBlur;
+    private _onKeyUp;
+    private _onKeyDown;
+    onMounted(): void;
+    private _setupManualControls;
+    setIdleTimeout(ms: number): void;
+    resetKeys(): void;
+    onKeyPress(key: number | string | Array<number | string>, handler: (e: any) => void): this;
+    isPressed(key: number | string): boolean;
+}

package/types/internals/LabelManager.d.ts

@@ -0,0 +1,56 @@
+import { Module } from './Module';
+declare class BoundingBox {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    cx: number;
+    cy: number;
+    addPoint(x: number, y: number): this;
+}
+export declare class LabelManager extends Module {
+    private _textBBoxes;
+    private _rects;
+    private _enabled;
+    private _forceEnabled;
+    private _geoEnabled;
+    private _intersects;
+    private _textDisplacement;
+    private _textDisplacementUpdate;
+    private _skipFrames;
+    private _engine;
+    private _layer;
+    private _canvas;
+    private _concealed;
+    private _prevInsertedNodes;
+    private _prevInsertedEdges;
+    private _updateDebounced;
+    private _output;
+    private _onZoomStart;
+    private _onLayoutEnd;
+    private _onAttributesChanged;
+    private _onToggle;
+    private _update;
+    private _toggleDebug;
+    private _measureText;
+    constructor(nodus: any, options?: any);
+    onMounted(): void;
+    getCachedBB(index: number): BoundingBox;
+    getTextsBoundingBox(nodes?: any, edges?: any): BoundingBox;
+    setRate(rate: number): void;
+    forceEnable(): void;
+    update(): void;
+    forceUpdate(camera?: any): void;
+    query(x: number, y: number, w: number, h: number, result: {
+        nodes: number[];
+        edges: number[];
+    }): void;
+    private _enable;
+    private _disable;
+    private _updateLabels;
+    private _clearOverlaps;
+    private _resetOutput;
+    private _reset;
+    destroy(_nodus?: any): void;
+}
+export {};

package/types/internals/Lasso.d.ts

@@ -0,0 +1,22 @@
+import { Module } from './Module';
+import { BoundingBox } from '../geometry';
+export declare class Lasso extends Module {
+    protected _enabled: boolean;
+    protected _points: Array<{
+        x: number;
+        y: number;
+    }>;
+    protected _bbox: BoundingBox;
+    protected _layer: any;
+    protected _options: any;
+    protected _interaction: any;
+    protected _cachedCursor: string;
+    protected _onStart: ({ x: e, y: t }: any) => void;
+    protected _onStop: () => void;
+    onMounted(): void;
+    enable(e?: Record<string, any>): this;
+    disable(): this;
+    enabled(): boolean;
+    savePoint(e: number, t: number, s: boolean): void;
+    filterByExtremities(e: any[], t: Record<number, boolean>): any[];
+}

package/types/internals/Layers.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Layers — manages the stack of canvas, SVG and overlay layers rendered on top
+ * of the Nodus viewport. Each layer is kept in sync with the camera view (pan,
+ * zoom and rotation) and can be reordered, hidden, styled or exported.
+ */
+import { Module } from './Module';
+export interface LayerHandle {
+    element: HTMLElement | null;
+    type: string;
+    getLevel: () => number;
+    moveTo: (level: number) => LayerHandle;
+    moveUp: () => LayerHandle;
+    moveDown: () => LayerHandle;
+    moveToTop: () => LayerHandle;
+    moveToBottom: () => LayerHandle;
+    destroy: () => LayerHandle;
+    hide: () => LayerHandle;
+    show: () => LayerHandle;
+    isHidden: () => boolean;
+    setOpacity: (v: number) => LayerHandle;
+    getOpacity: () => number;
+    setPosition: (pt: {
+        x: number;
+        y: number;
+    }) => LayerHandle;
+    setSize: (sz: {
+        width: number;
+        height: number;
+    }) => LayerHandle;
+    refresh?: (fn?: any) => void;
+    clear?: () => void;
+    draw?: any;
+    options?: any;
+    _onViewChange?: (view?: any) => void;
+    _onDestroy?: () => void;
+}
+export declare class Layers extends Module {
+    private _elements;
+    private _layers;
+    readyCallbacks: Array<() => void>;
+    nodusLayer: LayerHandle | null;
+    private _updateDom;
+    private render;
+    private createCanvas;
+    private createSVG;
+    private _createOverlay;
+    addLayer: (el: HTMLElement | string, type?: string, level?: number) => LayerHandle;
+    addCanvasLayer: (drawFn: (ctx: CanvasRenderingContext2D) => void, opts?: {
+        isStatic?: boolean;
+        noClear?: boolean;
+    }, level?: number) => LayerHandle;
+    addOverlay: (opts: {
+        element: HTMLElement | string;
+        position: {
+            x: number;
+            y: number;
+        };
+        scaled?: boolean;
+        size?: any;
+    }, level?: number) => LayerHandle;
+    addSVGLayer: (opts: {
+        element: SVGElement;
+        draw: (el: SVGElement) => void;
+    }, level?: number) => LayerHandle;
+    canvasToImage(layer: LayerHandle, view: any): SVGImageElement;
+    exportPNG(ctx: CanvasRenderingContext2D, layers: LayerHandle[], view: any): Promise<void>;
+    exportSVG(svgRoot: SVGElement, layers: LayerHandle[], view: any, below: boolean): Promise<void>;
+    export(opts: {
+        canvas?: CanvasRenderingContext2D;
+        svg?: SVGElement;
+        view: any;
+        below?: boolean;
+    }): Promise<void>;
+    onMounted(): void;
+    runCallbacks(): void;
+    whenReady(cb: () => void): void;
+    private _removeLayer;
+    destroy(): void;
+}

package/types/internals/LayersPrimitives.d.ts

@@ -0,0 +1,5 @@
+export declare function createCanvas(width: number, height: number): HTMLCanvasElement;
+export declare function useDomLayers(container: HTMLElement): (elements: HTMLElement[]) => void;
+export declare function stopPropagation(e: Event): void;
+export declare function createSvgElement(tag: string, attrs?: Record<string, string | number>): SVGElement;
+export declare function svgToCanvas(svg: SVGElement, ctx: CanvasRenderingContext2D): Promise<void>;

package/types/internals/Layouts.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Layouts — layout algorithm runner using workers.
+ * Faithfully translated from /tmp/nodus_extracted/Layouts.js
+ */
+import { Module } from './Module';
+export declare class Layouts extends Module {
+    resolves: Map<any, any>;
+    _batchMode: boolean;
+    _batchStarted: boolean;
+    _batches: Map<string, any>;
+    _running: any[];
+    _textsHidden: boolean;
+    _layouts: Record<string, any>;
+    timers: Map<any, any>;
+    private onInteractionStart;
+    private onViewChanged;
+    private onVisibilityChange;
+    private _onWorkerUpdate;
+    private _onWorkerComplete;
+    private _onWorkerStart;
+    constructor(nodus: any);
+    onMounted(): void;
+    setWorkersIdle(e: boolean): void;
+    register(e: any): void;
+    getAvailableLayouts(): string[];
+    enableBatching(): void;
+    runBatch(): Promise<any>;
+    _addToBatch(e: string, t: any, s: (result: any) => void): void;
+    start(e: string, t?: any): Promise<any>;
+    _animateCamera(e: any, t: any, s: number): Promise<any>;
+    stop(): Promise<any>;
+    isRunning(): boolean;
+    _assignNodePositions(e: any, t: number, s: boolean, o?: string): Promise<any>;
+    collectNodesData(e: any): any;
+}

package/types/internals/LayoutsInternal.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Layouts — runs registered layout algorithms on the graph via the worker pool.
+ *
+ * Coordinates worker lifecycle (start/configure/update/complete), animates the
+ * resulting node positions, supports batching of compatible layouts (e.g. force),
+ * and emits layout lifecycle events. Implemented as a Module.
+ */
+import { Module } from './Module';
+export declare class LayoutsInternal extends Module {
+    resolves: Map<any, any>;
+    private _batchMode;
+    private _batchStarted;
+    private _batches;
+    private _running;
+    private _textsHidden;
+    private _layouts;
+    timers: Map<any, any>;
+    private onInteractionStart;
+    private onViewChanged;
+    private onVisibilityChange;
+    private _onWorkerUpdate;
+    private _onWorkerComplete;
+    private _onWorkerStart;
+    onMounted(): void;
+    setWorkersIdle(idle: boolean): void;
+    register(layout: any): void;
+    getAvailableLayouts(): string[];
+    enableBatching(): void;
+    runBatch(): Promise<any>;
+    private _addToBatch;
+    start(name: string, opts?: any): Promise<any>;
+    private _animateCamera;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    private _assignNodePositions;
+    collectNodesData(nodes: any): any;
+}

package/types/internals/LayoutsPrimitives.d.ts

@@ -0,0 +1,23 @@
+import { getCurrentTime } from './helpers';
+export declare const DEFAULT_EASING3 = "cubicOut";
+export declare const DEFAULT_OPTIONS4: {
+    duration: number;
+    skipTextDrawing: boolean;
+    locate: boolean;
+    useWebWorker: boolean;
+    easing: string;
+};
+export declare const MIN_UPDATE_INTERVAL = 16;
+export declare const WORKER_START = "worker_start";
+export declare const WORKER_CONFIGURE = "worker_configure";
+export declare const WORKER_UPDATE = "worker_update";
+export declare const canBeBatched: Set<string>;
+export { getCurrentTime };
+export declare function getDocument(): Document | {
+    hidden: boolean;
+};
+export declare function getPositionsFromData(data: any, offset?: number): Array<{
+    x: number;
+    y: number;
+}>;
+export declare function ensureGraphItems(graph: any, opts: any, includeEdges: boolean): any;

package/types/internals/Legend.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Legend — draws an attribute-mapping legend on a canvas overlay.
+ *
+ * Renders a legend layer that summarizes the active style rules (node and edge
+ * attribute mappings) into per-property widgets, so users can read how data
+ * values map to visual styles such as color, shape, radius, icon, and width.
+ */
+import { Module } from './Module';
+export declare class Legend extends Module {
+    private _enabled;
+    private _mustRefresh;
+    private _promises;
+    private _settings;
+    private _layer;
+    onMounted(): void;
+    enable(opts?: any): Promise<void>;
+    private _afterNextUpdate;
+    private _formatSettings;
+    disable(): Promise<void>;
+    enabled(): boolean;
+    refresh(): Promise<void>;
+    destroy(): void;
+    getOptions(): any;
+    getCurrentOptions(): any;
+    private _sameOptions;
+    private _drawOnCanvas;
+    exportOnCanvas(canvas: HTMLCanvasElement, opts: any, ratio: number): void;
+    export(opts?: any): Promise<HTMLCanvasElement>;
+    private _computeWidgetList;
+    private _computeWidget;
+    private _computePropertyMapping;
+    private _getRulesForAttribute;
+}

package/types/internals/LegendPrimitives.d.ts

@@ -0,0 +1,3 @@
+export declare function computeWidgetHeight(mapping: any, _prop: string, _isNode: boolean, settings: any): number;
+export declare const idenitity: (x: any) => any;
+export declare function drawWidgetList(settings: any, canvas: HTMLCanvasElement, widgets: any[]): boolean;

package/types/internals/Locate.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Locate — view location utilities: locateGraph, locateElements, getBoundingBox, etc.
+ * Faithfully translated from /tmp/nodus_extracted/Locate.js
+ */
+import { Module } from './Module';
+export declare class Locate extends Module {
+    private _isLocating;
+    private _cacheValid;
+    private _cachedGraphBoundingBox;
+    private _onLocateStart;
+    private _onLocated;
+    private _invalidCache;
+    onMounted(): void;
+    onReady(_params: any): void;
+    locateGraph(opts: any, force?: boolean): Promise<any>;
+    private _locateGraph;
+    locateElements(elements: any, opts: any): Promise<any>;
+    locateRawGraph(rawGraph: any, opts: any): Promise<any>;
+    isLocating(): boolean;
+    getGraphBoundingBox(includeText?: boolean): any;
+    forceInvalidCache(): void;
+    private _updateCache;
+    getBoundingBox(elements: any, withSize?: boolean, withText?: boolean, overrideX?: any): any;
+    private _getNodesBoundingBox;
+    private _getEdgesBoundingBox;
+    private _getEdgesBoundingBoxInternal;
+    getRawGraphBoundingBox(rawGraph: any): any;
+    private _locateBoundingBox;
+    private _moveCamera;
+    computeConfigForBounds(bbox: any, opts?: any): any;
+    layoutDataBoundingBox({ x, y, indexes }: {
+        x: any;
+        y: any;
+        indexes: any;
+    }): any;
+    isEdgeInPolygon(edge: any, polygon: any): boolean;
+    isElementInView(element: any, { margin }?: {
+        margin?: number | undefined;
+    }): boolean;
+    isNodeInRectangle(node: any, rect: any): boolean;
+    isNodeInPolygon(node: any, polygon: any): boolean;
+    isEdgeInRectangle(edge: any, rect: any): boolean;
+}

package/types/internals/LocatePrimitives.d.ts

@@ -0,0 +1,20 @@
+import { getBezierCurveBoundingBox, getQuadraticCurveBoundingBox, isPointInPolygon } from '../geometry/index';
+export declare const DEFAULT_EASING2 = "cubicOut";
+export declare const DEFAULT_MAX_NODE_SIZE_ON_SCREEN = 200;
+export declare function computeCameraConfig(bbox: any, dimensions: any, padding: any, maxNodeSize: number): {
+    x: number;
+    y: number;
+    zoom: number;
+};
+export { getBezierCurveBoundingBox };
+export { getQuadraticCurveBoundingBox };
+export declare function getSelfLoopControlPoints2(x: number, y: number, curvature: number, radius: number, offset: number, out: any): void;
+export declare function getQuadraticCurveControlPoint2(x0: number, y0: number, x1: number, y1: number, curvature: number, out: any): void;
+export declare function isCircleInRectangle(x: number, y: number, r: number, rect: any): boolean;
+export declare function isNodeInRectangle(node: any, rect: any, zoom: number): boolean;
+export declare function isEdgeInRectangle(edge: any, rect: any, zoom: number): boolean;
+export { isPointInPolygon };
+export declare function isEdgeInPolygon(edge: any, polygon: Array<{
+    x: number;
+    y: number;
+}>, zoom: number): boolean;

package/types/internals/MappingManager.d.ts

@@ -0,0 +1,27 @@
+/**
+ * MappingManager — creates qualitative/quantitative mappings and templates for style rules.
+ * Faithfully translated from /tmp/nodus_extracted/MappingManager.js
+ */
+import { Module } from './Module';
+export declare class MappingManager extends Module {
+    private _mappingList;
+    private _onStyleRuleRemoved;
+    private _onStyleRuleAdded;
+    private _refreshRulesAndLegend;
+    onMounted(): void;
+    private _recursiveGetMapping;
+    createMapping({ field, values, fallback }?: {
+        field?: any;
+        values?: any;
+        fallback?: any;
+    }): any;
+    createSlices({ field, fallback, stops, values, reverse, }?: {
+        field?: any;
+        fallback?: any;
+        stops?: any;
+        values?: any;
+        reverse?: boolean;
+    }): any;
+    private _createMappingFunction;
+    createTemplate(template: string): (element: any) => string;
+}

package/types/internals/MappingPrimitives.d.ts

@@ -0,0 +1,29 @@
+export declare function getValues(obj: any): any[];
+export declare function isRawObject(v: any): v is Record<string, any>;
+interface PropertyPathAccessor {
+    field: string[];
+    getValue: (element: any) => any;
+}
+export declare function toPropertyPath(field: any): PropertyPathAccessor;
+export declare function createQualitativeMapping(_graph: any, field: PropertyPathAccessor, opts: any, element: any): any;
+export declare function createQuantitativeMapping(graph: any, field: PropertyPathAccessor, opts: any, element: any): any;
+export declare class Mapping {
+    private readonly _createFn;
+    private readonly _evaluateFn;
+    private readonly _field;
+    private readonly _opts;
+    private readonly _graph;
+    private _invalid;
+    private _assignedRules;
+    private _nodeValues;
+    private _edgeValues;
+    constructor(createFn: any, evaluateFn: (element: any, extra?: any) => any, field?: PropertyPathAccessor, opts?: any, graph?: any);
+    assignTo(ruleId: any): void;
+    unAssignTo(ruleId: any): void;
+    getAssignedRules(): any[];
+    markAsInvalid(): void;
+    getField(): string[];
+    getValue(element: any, extra?: any): any;
+    getValues(isNode: boolean): Record<string, any> | null;
+}
+export {};

package/types/internals/Module.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Base class for all internal Nodus modules.
+ * Each module holds a reference to the owning Nodus instance and gains access
+ * to its sibling modules once construction completes. Subclasses override the
+ * lifecycle hooks (`onMounted`, `onReady`, `destroy`) as needed.
+ */
+export declare class Module {
+    _nodus: any;
+    _modules: any;
+    constructor(nodus: any);
+    /** Called by NodusModules after all modules are constructed. */
+    _setModules(modules: any): void;
+    /** Called after all modules have been constructed and `_setModules` called. */
+    onMounted(): void;
+    /** Called when Nodus instance is ready (after constructor options applied). */
+    onReady(_params: any): void;
+    /** Called when Nodus is destroyed. */
+    destroy(_nodus?: any): void;
+    /** Compatibility getter: old stub code used `this.modules` instead of `this._nodus.modules`. */
+    get modules(): any;
+    /** Compatibility getter: old stub code used `this.nodus` instead of `this._nodus`. */
+    get nodus(): any;
+}

package/types/internals/Mouse.d.ts

@@ -0,0 +1,42 @@
+import { Module } from './Module';
+export declare class Mouse extends Module {
+    private _px;
+    private _py;
+    private _pressX;
+    private _pressY;
+    private _left;
+    private _middle;
+    private _right;
+    private _clickCounter;
+    private _buttons;
+    private _skipNextMove;
+    private _domElt;
+    private _bounds;
+    private _evt;
+    private _button;
+    private _dbclickTimer;
+    private _lastMouseDownTarget;
+    private _onMove;
+    private _onEnd;
+    private _onMouseWheel;
+    private _onMouseMove;
+    private _onDocumentMouseMove;
+    private _onMouseUp;
+    private _onDocumentMouseup;
+    private _onMouseDown;
+    private _onDrop;
+    onMounted(): void;
+    get x(): number;
+    get y(): number;
+    get left(): boolean;
+    get right(): boolean;
+    get middle(): boolean;
+    _isEnabled(): boolean;
+    _isWheelEnabled(): boolean;
+    _disableWheelUntilMouseDown(): boolean;
+    _getDoubleClickTimer(): number;
+    _resetClickCounter(e?: string, value?: number): void;
+    _setXY(e: any): boolean;
+    _applyMouseWheelZoom(e: any): void;
+    _initializeListeners(): void;
+}

package/types/internals/NodusModules.d.ts

@@ -0,0 +1,99 @@
+import { Settings } from './Settings';
+import { EventsModule } from './EventsModule';
+import { DomModule } from './DomModule';
+import { Animations } from './Animations';
+import { Camera } from './Camera';
+import { Graph2 } from './Graph';
+import { DataModule } from './DataModule';
+import { IndividualAttributes } from './IndividualAttributes';
+import { Algorithms } from './Algorithms';
+import { Position } from './PositionModule';
+import { Mouse } from './Mouse';
+import { VirtualMouse } from './VirtualMouse';
+import { Touch } from './Touch';
+import { ClassModule } from './ClassModule';
+import { Hover } from './Hover';
+import { Disabled } from './Disabled';
+import { Keyboard } from './Keyboard';
+import { Selection } from './SelectionModule';
+import { StyleRulesModule } from './StyleRulesModule';
+import { Synchronizer } from './Synchronizer';
+import { MappingManager } from './MappingManager';
+import { Locate } from './Locate';
+import { CurvatureManager } from './CurvatureManager';
+import { Workers } from './Workers';
+import { WatcherModule } from './WatcherModule';
+import { LabelManager } from './LabelManager';
+import { Brand } from './Brand';
+import { Snapping } from './Snapping';
+import { Rewiring } from './Rewiring';
+import { Resizing } from './Resizing';
+import { Geo } from './Geo';
+import { Hypergraph } from './Hypergraph';
+import { PulseModule } from './PulseModule';
+import { Captor } from './Captor';
+import { Interactions } from './Interactions';
+import { CameraInteractions } from './CameraInteractions';
+import { DragModule } from './DragModule';
+import { RectangleSelect } from './RectangleSelect';
+import { Lasso } from './Lasso';
+import { Tooltip } from './Tooltip';
+import { ConnectNodes } from './ConnectNodes';
+import { Layers } from './Layers';
+import { Legend } from './Legend';
+import { Transformations } from './Transformations';
+import { Layouts } from './Layouts';
+import { Spatial } from './Spatial';
+import { Graphics } from './Graphics';
+export declare class NodusModules {
+    _nodus: any;
+    settings: Settings;
+    events: EventsModule;
+    dom: DomModule;
+    animations: Animations;
+    camera: Camera;
+    graph: Graph2;
+    data: DataModule;
+    graphics: Graphics;
+    layers: Layers;
+    individualAttributes: IndividualAttributes;
+    algorithms: Algorithms;
+    position: Position;
+    touch: Touch;
+    mouse: Mouse;
+    virtualMouse: VirtualMouse;
+    spatial: Spatial;
+    captor: Captor;
+    interactions: Interactions;
+    classes: ClassModule;
+    cameraInteractions: CameraInteractions;
+    hover: Hover;
+    disabled: Disabled;
+    keyboard: Keyboard;
+    selection: Selection;
+    styleRules: StyleRulesModule;
+    legend: Legend;
+    sync: Synchronizer;
+    rules: MappingManager;
+    transformations: Transformations;
+    locate: Locate;
+    drag: DragModule;
+    pulses: PulseModule;
+    curvatureManager: CurvatureManager;
+    workers: Workers;
+    layouts: Layouts;
+    watcher: WatcherModule;
+    rectangleSelect: RectangleSelect;
+    labels: LabelManager;
+    brand: Brand;
+    lasso: Lasso;
+    rewiring: Rewiring;
+    resizing: Resizing;
+    snapping: Snapping;
+    connectNodes: ConnectNodes;
+    tooltip: Tooltip;
+    geo: Geo;
+    hypergraph: Hypergraph;
+    constructor(nodus: any, params: any);
+    destroy(): void;
+}

package/types/internals/PositionModule.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Position — a minimal module that stores an item's x/y coordinates.
+ * Both coordinates default to 0 and are updated by layout routines.
+ */
+import { Module } from './Module';
+export declare class PositionModule extends Module {
+    x: number;
+    y: number;
+}
+export { PositionModule as Position };

package/types/internals/PulseModule.d.ts

@@ -0,0 +1,29 @@
+import { Module } from './Module';
+export declare class PulseModule extends Module {
+    private _nodePromiseMap;
+    private _edgePromiseMap;
+    private _engine;
+    private _group;
+    private _nodePulses;
+    private _edgePulses;
+    private _nodeNbPulsesRemaining;
+    private _edgeNbPulsesRemaining;
+    private _nodeFlexArrays;
+    private _edgeFlexArrays;
+    private _edgeSourceList;
+    private _edgeTargetList;
+    private _hasPulses;
+    private _nodePulseTheme;
+    private _edgePulseTheme;
+    private _onAttributeChange;
+    private _refreshPulses;
+    onMounted(): void;
+    private _onElementsAttributeChange;
+    private _removePulses;
+    private _refreshElementsPulses;
+    private _createNodePulseBlock;
+    private _createEdgePulseBlock;
+    pulse(element: any, options?: any): Promise<any>;
+    private _setPromise;
+    setTheme(nodeTheme: any, edgeTheme: any): void;
+}