@kortexya/nodus 0.1.0

package/types/modules/DebugAPI.d.ts

@@ -0,0 +1,18 @@
+/**
+ * DebugAPI — debug utilities.
+ * Binary: `DebugAPI = class extends APIModule { constructor(){ super(...arguments), this.wait=..., ... } }`
+ */
+import { APIModule } from './APIModule';
+export declare class DebugAPI extends APIModule {
+    wait: (ms: number) => Promise<void>;
+    initRandomGraph: (opts?: any) => Promise<void>;
+    initGrid: (count: number) => Promise<void>;
+    initLine: (vertical?: boolean) => any;
+    initSingleNode: () => any;
+    initContinuousRenderLoop: (opts?: any) => void;
+    appendToBody: () => void;
+    loadFile: (url: string) => Promise<void>;
+    enableLasso: () => void;
+    randomizeGraph: () => void;
+    constructor(nodus: any);
+}

package/types/modules/DisabledAPI.d.ts

@@ -0,0 +1,11 @@
+/**
+ * DisabledAPI mixin — merged into Nodus via applyMixins.
+ * Binary: `DisabledAPI = class { getDisabledNodes(){...} ... }`
+ */
+export declare class DisabledAPI<ND = any, ED = any> {
+    modules: any;
+    getDisabledNodes(): any;
+    getEnabledNodes(): any;
+    getDisabledEdges(): any;
+    getEnabledEdges(): any;
+}

package/types/modules/DomAPI.d.ts

@@ -0,0 +1,9 @@
+/**
+ * DomAPI mixin — merged into Nodus via applyMixins.
+ * Binary: `DomAPI = class { setContainer(e){...} getContainer(){...} }`
+ */
+export declare class DomAPI {
+    modules: any;
+    setContainer(container: HTMLElement | string): void;
+    getContainer(): HTMLElement | null;
+}

package/types/modules/EventsAPI.d.ts

@@ -0,0 +1,16 @@
+/**
+ * EventsAPI — public events module.
+ * Binary: `EventsAPI = class extends APIModule { constructor(){...} on(e,t){...} off(e){...} onKeyPress(e,t){...} }`
+ */
+import { APIModule } from './APIModule';
+export declare class EventsAPI extends APIModule {
+    constructor(nodus: any);
+    once: (event: string, handler: Function) => this;
+    onNodesClassAdded: (event: any, handler: any) => any;
+    onNodesClassRemoved: (event: any, handler: any) => any;
+    onEdgesClassAdded: (event: any, handler: any) => any;
+    onEdgesClassRemoved: (event: any, handler: any) => any;
+    on(event: string, handler: Function): this;
+    off(event: string): this;
+    onKeyPress(key: string, handler: Function): any;
+}

package/types/modules/ExportAPI.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ExportsAPI — exports the current graph in a variety of formats.
+ *
+ * Extends APIModule and exposes one method per supported format (csv, xlsx,
+ * gexf, graphml, json, svg, png, jpg, tiff, gif). Each method delegates to the
+ * optional `exports` module when it is available, and otherwise falls back to a
+ * lightweight built-in serializer.
+ */
+import { APIModule } from './APIModule';
+export declare class ExportsAPI extends APIModule {
+    csv: (opts?: any) => Promise<any>;
+    xlsx: (opts?: any) => Promise<any>;
+    gexf: (opts?: any) => Promise<any>;
+    graphml: (opts?: any) => Promise<any>;
+    json: (opts?: any) => Promise<any>;
+    svg: (opts?: any) => Promise<any>;
+    png: (opts?: any) => Promise<any>;
+    jpg: (opts?: any) => Promise<any>;
+    tiff: (opts?: any) => Promise<any>;
+    gif: (opts?: any) => Promise<any>;
+    constructor(nodus: any);
+}
+export { ExportsAPI as ExportAPI };

package/types/modules/GeneratorsAPI.d.ts

@@ -0,0 +1,12 @@
+import { APIModule } from './APIModule';
+export declare class GeneratorsAPI extends APIModule {
+    balancedTree: (opts?: any) => Promise<any>;
+    barabasiAlbert: (opts?: any) => Promise<any>;
+    erdosRenyi: (opts?: any) => Promise<any>;
+    flower: (opts?: any) => Promise<any>;
+    grid: (opts?: any) => Promise<any>;
+    path: (opts?: any) => Promise<any>;
+    random: (opts?: any) => Promise<any>;
+    randomTree: (opts?: any) => Promise<any>;
+    constructor(nodus: any);
+}

package/types/modules/GeoAPI.d.ts

@@ -0,0 +1,20 @@
+import { APIModule } from './APIModule';
+export declare class GeoAPI extends APIModule {
+    enable: (opts?: any) => any;
+    disable: (opts?: any) => any;
+    toggle: (opts?: any) => any;
+    setOptions: (opts: any) => any;
+    getOptions: () => any;
+    getMap: () => any;
+    enabled: () => boolean;
+    getCenter: () => any;
+    getView: () => any;
+    getZoom: () => number;
+    setZoom: (zoom: number) => any;
+    setView: (lat: number, lng: number, zoom?: number) => any;
+    setCenter: (coords: any, opts?: any) => any;
+    getUnprojectedCoordinates: () => any;
+    resetCoordinates: () => any;
+    runLayout: (opts?: any) => any;
+    constructor(nodus: any);
+}

package/types/modules/GraphAPI.d.ts

@@ -0,0 +1,26 @@
+/**
+ * GraphAPI mixin — merged into Nodus via applyMixins.
+ * Binary: `GraphAPI = class { addNodes(e,t){...} ... }`
+ */
+export declare class GraphAPI {
+    modules: any;
+    addNodes(elements: any, opts?: any): any;
+    addEdges(elements: any, opts?: any): any;
+    addNode(element: any, opts?: any): any;
+    addEdge(element: any, opts?: any): any;
+    removeNodes(elements: any, opts?: any): Promise<void>;
+    removeEdges(elements: any, opts?: any): Promise<void>;
+    removeNode(element: any, opts?: any): Promise<void>;
+    removeEdge(element: any, opts?: any): Promise<void>;
+    getNodes(filter?: any): any;
+    getEdges(filter?: any): any;
+    getNode(id: any): any;
+    getEdge(id: any): any;
+    clearGraph(): void;
+    setGraph(graph: any, opts?: any): any;
+    addGraph(graph: any, opts?: any): any;
+    createNodeList(): any;
+    createEdgeList(): any;
+    getConnectedComponents(opts?: any): any;
+    getConnectedComponentByNode(nodeId: any, opts?: any): any;
+}

package/types/modules/GraphicsAPI.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GraphicsAPI mixin — merged into Nodus via applyMixins.
+ * Binary: `GraphicsAPI = class { reloadFonts(){...} }`
+ */
+export declare class GraphicsAPI {
+    modules: any;
+    reloadFonts(): void;
+}

package/types/modules/HypergraphAPI.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Public façade for the hypergraph subsystem (Oliver et al., TVCG 2023).
+ *
+ * Usage:
+ *   nodus.hypergraph
+ *     .setData({ vertices, hyperedges })
+ *     .simplify({ alpha: 0.4, beta: 0.4, gamma: 0.2 })
+ *     .layout({ separationIters: 200, regularityIters: 300 });
+ *   nodus.hypergraph.render({ view: 'primal' });
+ */
+import { APIModule } from './APIModule';
+import type { HypergraphData, HypergraphId, HypergraphRenderOptions, InteractionEvent, LayoutOptions, QualityMetrics, SimplificationOptions, Vec2, AtomicOperationRecord } from '../hypergraph';
+export declare class HypergraphAPI extends APIModule {
+    private get _module();
+    setData(data: HypergraphData): this;
+    fromNodesAndEdges(opts: {
+        groupBy: (n: any) => Array<HypergraphId>;
+    }): this;
+    getData(): HypergraphData;
+    getDual(): HypergraphData;
+    simplify(opts?: SimplificationOptions): {
+        scales: number;
+        operations: number;
+    };
+    getScales(): ReadonlyArray<HypergraphData>;
+    getOperationStack(): ReadonlyArray<AtomicOperationRecord>;
+    layout(opts?: LayoutOptions): Promise<{
+        totalEnergy: number;
+        overlapCount: number;
+    }>;
+    getVertexPositions(): Map<HypergraphId, Vec2>;
+    getDualPositions(): Map<HypergraphId, Vec2>;
+    getHyperedgePolygon(heId: HypergraphId): Vec2[];
+    render(opts?: HypergraphRenderOptions): {
+        primal?: any;
+        dual?: any;
+    };
+    refresh(): this;
+    hide(): this;
+    show(): this;
+    destroy(): this;
+    setActiveView(view: 'primal' | 'dual' | 'both'): this;
+    getQualityMetrics(): QualityMetrics;
+    /** Hyperedge currently under the mouse, or null. */
+    getHoveredHyperedge(): HypergraphId | null;
+    /** Vertex currently under the mouse, or null. */
+    getHoveredVertex(): HypergraphId | null;
+    /** Dual-polygon hit (corresponds to a primal vertex), or null. */
+    getHoveredDual(): HypergraphId | null;
+    /** Currently selected hyperedge ids. */
+    getSelectedHyperedges(): HypergraphId[];
+    /** Currently selected vertex ids. */
+    getSelectedVertices(): HypergraphId[];
+    /** Replace the selection. Pass `replace:false` to add to existing. */
+    setSelected(opts: {
+        hyperedges?: HypergraphId[];
+        vertices?: HypergraphId[];
+        replace?: boolean;
+    }): this;
+    /** Toggle a single hyperedge or vertex in the selection. */
+    toggleSelected(opts: {
+        hyperedge?: HypergraphId;
+        vertex?: HypergraphId;
+    }): this;
+    /** Empty the selection. */
+    clearSelection(): this;
+    /** Hit-test at a world-space point, returning the first match. */
+    getHyperedgeAtPoint(world: Vec2): InteractionEvent;
+    on(event: 'simplifyStart' | 'simplifyEnd' | 'layoutStart' | 'layoutPhase' | 'layoutIter' | 'layoutEnd' | 'render' | 'viewChanged' | 'hyperedgeHover' | 'hyperedgeOut' | 'hyperedgeClick' | 'vertexHover' | 'vertexOut' | 'vertexClick' | 'selectionChanged', cb: (e: any) => void): this;
+    off(cb: (e: any) => void): this;
+}

package/types/modules/KeyboardAPI.d.ts

@@ -0,0 +1,6 @@
+import { APIModule } from './APIModule';
+export declare class KeyboardAPI extends APIModule {
+    isKeyPressed: (key: string) => boolean;
+    resetKeys: () => void;
+    constructor(nodus: any);
+}

package/types/modules/LayersAPI.d.ts

@@ -0,0 +1,7 @@
+import { APIModule } from './APIModule';
+export declare class LayersAPI extends APIModule {
+    addLayer(opts: any, position?: any): any;
+    addCanvasLayer(opts: any, draw?: Function, position?: any): any;
+    addOverlay(opts: any, position?: any): any;
+    addSVGLayer(opts: any, position?: any): any;
+}

package/types/modules/LayoutsAPI.d.ts

@@ -0,0 +1,25 @@
+/**
+ * LayoutsAPI — graph layout algorithms.
+ * Binary: `LayoutsAPI = class extends APIModule { constructor(e){ super(e), this.stop=..., ... } }`
+ * Each layout function is a factory that registers the layout with modules.layouts AND returns the API method.
+ */
+import { APIModule } from './APIModule';
+import forceFactory from '../algorithms/forceFactory';
+import forceLinkFactory from '../algorithms/forceLinkFactory';
+import gridFactory from '../algorithms/gridFactory';
+import hierarchicalFactory from '../algorithms/hierarchicalFactory';
+import sequentialFactory from '../algorithms/sequentialFactory';
+import radialFactory from '../algorithms/radialFactory';
+import concentricFactory from '../algorithms/concentricFactory';
+export { radialFactory, forceFactory, forceLinkFactory, gridFactory, hierarchicalFactory, sequentialFactory, concentricFactory, };
+export declare class LayoutsAPI extends APIModule {
+    stop: () => void;
+    concentric: (opts?: any) => Promise<void>;
+    radial: (opts?: any) => Promise<void>;
+    force: (opts?: any) => Promise<void>;
+    forceLink: (opts?: any) => Promise<void>;
+    hierarchical: (opts?: any) => Promise<void>;
+    sequential: (opts?: any) => Promise<void>;
+    grid: (opts?: any) => Promise<void>;
+    constructor(nodus: any);
+}

package/types/modules/LegendAPI.d.ts

@@ -0,0 +1,9 @@
+import { APIModule } from './APIModule';
+export declare class LegendAPI extends APIModule {
+    enable: (opts?: any) => any;
+    disable: () => any;
+    enabled: () => boolean;
+    getOptions: () => any;
+    export: (opts?: any) => any;
+    constructor(nodus: any);
+}

package/types/modules/MouseAPI.d.ts

@@ -0,0 +1,16 @@
+/**
+ * MouseAPI — virtual mouse simulation.
+ * Binary: `MouseAPI = class extends APIModule { constructor(){ super(...arguments), this.move=..., ... } }`
+ */
+import { APIModule } from './APIModule';
+export declare class MouseAPI extends APIModule {
+    move: (coords: any) => any;
+    down: (coords: any) => any;
+    up: (coords: any) => any;
+    click: (coords: any) => any;
+    rightClick: (coords: any) => any;
+    doubleclick: (coords: any) => any;
+    drag: (from: any, to: any) => any;
+    wheel: (coords: any) => any;
+    constructor(nodus: any);
+}

package/types/modules/ParseAPI.d.ts

@@ -0,0 +1,83 @@
+import type { RawGraph } from '../publicTypes';
+export interface Neo4JNodeData<Props = Record<string, unknown>> {
+    neo4jLabels: string[];
+    neo4jProperties: Props;
+}
+export interface Neo4JEdgeData<Props = Record<string, unknown>> {
+    neo4jType?: string;
+    neo4jProperties: Props;
+}
+/**
+ * Parse a GEXF XML string and return the raw graph.
+ */
+export declare function gexf<ND = unknown, ED = unknown>(content: string): Promise<RawGraph<ND, ED>>;
+/**
+ * Fetch and parse a GEXF file from a URL.
+ */
+export declare function gexfFromUrl<ND = unknown, ED = unknown>(url: string): Promise<RawGraph<ND, ED>>;
+/**
+ * Parse a JSON string and return the raw graph.
+ * If a transform function is provided, it is used to convert the parsed
+ * JSON into a RawGraph.
+ */
+export declare function json<ND = unknown, ED = unknown>(content: string, transform?: (json: Record<string, any> | unknown[]) => RawGraph<ND, ED>): Promise<RawGraph<ND, ED>>;
+/**
+ * Fetch and parse a JSON file from a URL.
+ */
+export declare function jsonFromUrl<ND = unknown, ED = unknown>(url: string, transform?: (json: Record<string, any> | unknown[]) => RawGraph<ND, ED>): Promise<RawGraph<ND, ED>>;
+/**
+ * Parse a GraphML XML string and return the raw graph.
+ */
+export declare function graphml<ND = unknown, ED = unknown>(content: string, xmlparser?: DOMParser): Promise<RawGraph<ND, ED>>;
+/**
+ * Fetch and parse a GraphML file from a URL.
+ */
+export declare function graphmlFromUrl<ND = unknown, ED = unknown>(url: string, xmlparser?: DOMParser): Promise<RawGraph<ND, ED>>;
+/**
+ * Parse a Neo4j bolt driver result into a raw graph.
+ *
+ * Expects the result of a Neo4j session.run() call. The result should have
+ * a `records` array where each record contains nodes and relationships
+ * accessible via .get() or ._fields.
+ *
+ * Nodes have: identity, labels, properties
+ * Relationships have: identity, type, start, end, properties
+ */
+export declare function neo4j<ND extends Neo4JNodeData = Neo4JNodeData, ED extends Neo4JEdgeData = Neo4JEdgeData>(content: object | string): Promise<RawGraph<ND, ED>>;
+/**
+ * Parse the result of a JanusGraph/Gremlin query into a raw graph.
+ *
+ * Expects the result of gremlin-client's `client.execute()` which returns
+ * a response with captured stores for vertices ("v") and edges ("e").
+ * Format: { result: { data: [{ v: [...], e: [...] }] } }
+ * or just an array of vertices/edges from cap("v", "e").
+ */
+export declare function janus<ND = unknown, ED = unknown>(content: string): Promise<RawGraph<ND, ED>>;
+/**
+ * Parse a Matrix Market (.mtx) format string into a raw graph.
+ *
+ * Supports the coordinate format:
+ *   %%MatrixMarket matrix coordinate [real|integer|pattern] [general|symmetric]
+ *
+ * Lines starting with % are comments.
+ * The first non-comment line is: rows cols entries
+ * Subsequent lines are: row col [value]
+ *
+ * Nodes are created for each unique row/column index.
+ * Edges are created for each non-zero entry.
+ * For symmetric matrices, edges are added in both directions.
+ */
+export declare function mtx<ND = unknown, ED = unknown>(content: string): Promise<RawGraph<ND, ED>>;
+export declare function mtxFromUrl<ND = unknown, ED = unknown>(url: string): Promise<RawGraph<ND, ED>>;
+export declare const parse: {
+    gexf: typeof gexf;
+    gexfFromUrl: typeof gexfFromUrl;
+    json: typeof json;
+    jsonFromUrl: typeof jsonFromUrl;
+    graphml: typeof graphml;
+    graphmlFromUrl: typeof graphmlFromUrl;
+    neo4j: typeof neo4j;
+    janus: typeof janus;
+    mtx: typeof mtx;
+    mtxFromUrl: typeof mtxFromUrl;
+};

package/types/modules/RulesAPI.d.ts

@@ -0,0 +1,7 @@
+import { APIModule } from './APIModule';
+export declare class RulesAPI extends APIModule {
+    map: (opts: any) => any;
+    slices: (opts: any) => any;
+    template: (opts: any) => any;
+    constructor(nodus: any);
+}

package/types/modules/SchemaAPI.d.ts

@@ -0,0 +1,9 @@
+import { APIModule } from './APIModule';
+export { PropertyInformation, NonObjectPropertyWatcher, ObjectPropertyWatcher, } from '../internals/SchemaWatchPrimitives';
+export declare class SchemaAPI extends APIModule {
+    watchNodeObjectProperty: (opts: any) => any;
+    watchEdgeObjectProperty: (opts: any) => any;
+    watchNodeNonObjectProperty: (opts: any) => any;
+    watchEdgeNonObjectProperty: (opts: any) => any;
+    constructor(nodus: any);
+}

package/types/modules/SelectionAPI.d.ts

@@ -0,0 +1,12 @@
+/**
+ * SelectionAPI mixin — merged into Nodus via applyMixins.
+ * Binary: `SelectionAPI = class { clearSelection(){...} getSelectedNodes(){...} ... }`
+ */
+export declare class SelectionAPI<ND = any, ED = any> {
+    modules: any;
+    clearSelection(): any;
+    getSelectedNodes(): any;
+    getNonSelectedNodes(): any;
+    getSelectedEdges(): any;
+    getNonSelectedEdges(): any;
+}

package/types/modules/SettingsAPI.d.ts

@@ -0,0 +1,9 @@
+/**
+ * SettingsAPI mixin — merged into Nodus via applyMixins.
+ * Binary: `SettingsAPI = class { setOptions(e){...} getOptions(){...} }`
+ */
+export declare class SettingsAPI {
+    modules: any;
+    setOptions(opts: any): any;
+    getOptions(): any;
+}

package/types/modules/StylesAPI.d.ts

@@ -0,0 +1,64 @@
+/**
+ * StylesAPI — node/edge visual style management.
+ * Provides the public surface for styling: each method delegates to the
+ * relevant internal module (styleRules, graphics, classes, hover, selection,
+ * disabled) to apply visibility, rules, classes and themed attributes.
+ */
+import { APIModule } from './APIModule';
+export declare class StylesAPI extends APIModule {
+    setNodesVisibility: (value: boolean) => void;
+    setEdgesVisibility: (value: boolean) => void;
+    setNodeTextsVisibility: (value: boolean) => void;
+    setEdgeTextsVisibility: (value: boolean) => void;
+    addRule: (opts?: any) => any;
+    getRuleList: () => any[];
+    addNodeRule: (attrsOrSelector: any, attrs?: any) => any;
+    addEdgeRule: (attrsOrSelector: any, attrs?: any) => any;
+    getNodeRules: () => any[];
+    getEdgeRules: () => any[];
+    createClass: (opts: any) => any;
+    getClass: (name: string) => any;
+    getClassList: () => any[];
+    setHoveredNodeAttributes: (attrs: any, opts?: any) => void;
+    setHoveredEdgeAttributes: (attrs: any, opts?: any) => void;
+    setHoveredEdgeExtremitiesAttributes: (attrs: any, extended?: boolean) => any;
+    setSelectedNodeAttributes: (attrs: any, extended?: boolean) => void;
+    setSelectedEdgeAttributes: (attrs: any, extended?: boolean) => void;
+    setSelectedEdgeExtremitiesAttributes: (attrs: any, extended?: boolean) => void;
+    setDisabledNodeAttributes: (attrs: any, opts?: any) => void;
+    setDisabledEdgeAttributes: (attrs: any, opts?: any) => void;
+    setTheme: (theme: any) => void;
+    fontSizeToBadgeScale: any;
+    constructor(nodus: any);
+}
+export declare class StyleRule {
+    private _module;
+    private _id;
+    private _whenApplied;
+    constructor(module: any, id: number, whenApplied: Promise<any>);
+    getId(): number;
+    whenApplied(): Promise<this>;
+    refresh(): Promise<any>;
+    getIndex(): number | null;
+    setIndex(index: number): Promise<any>;
+    update(options: any): Promise<any>;
+    getDefinition(): any;
+    destroy(): Promise<any>;
+}
+export declare class StyleClass {
+    private _classes;
+    private _name;
+    constructor(classes: any, name: string);
+    getName(): string;
+    getIndex(): number;
+    setIndex(index: number): void;
+    update(options: any): this;
+    getDefinition(): any;
+    getNodes(opts?: any): any;
+    getEdges(opts?: any): any;
+    clearNodes(opts?: any): void;
+    clearEdges(opts?: any): void;
+    add(elements: any): void;
+    remove(elements: any): void;
+    destroy(): Promise<any>;
+}

package/types/modules/ToolsAPI.d.ts

@@ -0,0 +1,68 @@
+/**
+ * ToolsAPI — aggregates tool sub-modules.
+ * Binary: `ToolsAPI = class extends APIModule { constructor(e) { super(e), this.lasso = ..., ... } }`
+ */
+import { APIModule } from './APIModule';
+import { LegendAPI } from './LegendAPI';
+import { BrandAPI } from './BrandAPI';
+declare class LassoAPI extends APIModule {
+    enable(opts?: any): any;
+    disable(): any;
+    enabled(): any;
+}
+declare class ConnectNodesAPI extends APIModule {
+    enable(opts?: any): any;
+    disable(): any;
+    enabled(): any;
+}
+declare class RectangleSelectAPI extends APIModule {
+    enable(opts?: any): any;
+    disable(): any;
+    enabled(): any;
+}
+declare class ResizingAPI extends APIModule {
+    enable(opts?: any): any;
+    disable(): any;
+    enabled(): any;
+}
+declare class RewiringAPI extends APIModule {
+    enable(opts?: any): any;
+    setEdgesToRewire(edges: any): any;
+    disable(): any;
+    enabled(): any;
+}
+declare class SnappingAPI extends APIModule {
+    enable(opts?: any): any;
+    disable(): any;
+    enabled(): any;
+}
+declare class TooltipAPI extends APIModule {
+    onNodeHover(handler: any, options?: any): any;
+    onNodeClick(handler: any, options?: any): any;
+    onNodeRightClick(handler: any, options?: any): any;
+    onNodeDoubleClick(handler: any, options?: any): any;
+    onEdgeHover(handler: any, options?: any): any;
+    onEdgeClick(handler: any, options?: any): any;
+    onEdgeRightClick(handler: any, options?: any): any;
+    onEdgeDoubleClick(handler: any, options?: any): any;
+    onBackgroundClick(handler: any, options?: any): any;
+    onBackgroundRightClick(handler: any, options?: any): any;
+    onBackgroundDoubleClick(handler: any, options?: any): any;
+    hide(): any;
+    isShown(): any;
+    refresh(): any;
+    show(content: any, options?: any): any;
+}
+export declare class ToolsAPI extends APIModule {
+    lasso: LassoAPI;
+    connectNodes: ConnectNodesAPI;
+    legend: LegendAPI;
+    rectangleSelect: RectangleSelectAPI;
+    resize: ResizingAPI;
+    rewire: RewiringAPI;
+    snapping: SnappingAPI;
+    tooltip: TooltipAPI;
+    brand: BrandAPI;
+    constructor(nodus: any);
+}
+export {};

package/types/modules/TransformationsAPI.d.ts

@@ -0,0 +1,30 @@
+import { APIModule } from './APIModule';
+export declare class TransformationsAPI extends APIModule {
+    getList: () => any[];
+    clear: () => Promise<void>;
+    getById: (id: any) => any;
+    afterNextUpdate: () => Promise<void>;
+    onGroupsUpdated: (cb: Function) => void;
+    layoutGroups: (a: any, b: any, c?: boolean) => any;
+    triggerGroupUpdated: (id: any) => void;
+    triggerGroupsUpdated: () => void;
+    constructor(nodus: any);
+    addNodeGrouping(e: any): any;
+    addNodeClustering(e: any): any;
+    addEdgeGrouping(e: any): any;
+    addDrillDown(e: any): any;
+    addDrilldown(e: any): any;
+    addNodeFilter(e: any): any;
+    addEdgeFilter(e: any): any;
+    getNodeFilters(): any;
+    getEdgeFilters(): any;
+    addNeighborGeneration(e: any): any;
+    addNeighborMerging(e: any): any;
+    addNodeCollapsing(e?: any): any;
+    addGeoClustering(e: any): any;
+    addVirtualProperties(e: any): any;
+    getXYR(e: any): any;
+    expandGroup({ node: e, computeSubNodesPosition: t, onExpand: s }: any): any;
+    collapseGroup({ node: e, onCollapse: t }: any): any;
+    setAnimation(e: any): void;
+}

package/types/modules/ViewAPI.d.ts

@@ -0,0 +1,52 @@
+/**
+ * ViewAPI — camera/viewport control.
+ * Public facade whose methods delegate to the internal camera, dom, locate, and
+ * spatial modules to handle zoom, pan, rotation, coordinate conversion, and hit testing.
+ */
+import { APIModule } from './APIModule';
+export declare class ViewAPI extends APIModule {
+    setZoom: (zoom: number, opts?: any) => any;
+    zoomIn: (opts?: any) => any;
+    zoomOut: (opts?: any) => any;
+    getZoom: () => number;
+    setCenter: (center: any, opts?: any) => any;
+    move: (delta: any, opts?: any) => any;
+    moveToBounds: (bounds: any, opts?: any) => any;
+    moveTo: (target: any, opts?: any) => any;
+    getCenter: () => {
+        x: number;
+        y: number;
+    };
+    setAngle: (angle: number, opts?: any) => any;
+    rotate: (delta: number, opts?: any) => any;
+    getAngle: () => number;
+    set: (view: any, opts?: any) => any;
+    get: () => any;
+    graphToScreenCoordinates: (pt: any) => any;
+    screenToGraphCoordinates: (pt: any) => any;
+    getImageData: () => any;
+    getElementAt: (pt: any) => any;
+    getElementsInView: () => any;
+    getBounds: () => any;
+    getElementsInside: (x1: number, y1: number, x2: number, y2: number, inGraphCoords?: boolean) => any;
+    beforeNextFrame: () => Promise<void>;
+    afterNextFrame: () => Promise<void>;
+    setFullScreen: (value: boolean) => any;
+    isFullScreen: () => boolean;
+    forceResize: () => void;
+    getSize: () => {
+        width: number;
+        height: number;
+    };
+    setSize: (size: {
+        width: number;
+        height: number;
+    }) => Promise<void>;
+    locateGraph: (opts?: any) => Promise<void>;
+    locateRawGraph: (graph: any, opts?: any) => Promise<void>;
+    getGraphBoundingBox: (opts?: any) => any;
+    animationInProgress: () => boolean;
+    getTextBoundingBox: (element: any) => any;
+    getNodeBadgeAt: (node: any, position: any) => any;
+    constructor(nodus: any);
+}