@html-graph/html-graph 4.0.0 → 4.1.0

package/README.md

@@ -8,85 +8,10 @@
   <img width="100%" src="https://raw.githubusercontent.com/html-graph/html-graph/master/media/full-demo.gif"/>
 </a>
 
-Visit the <a target="_blank" href="https://html-graph.github.io">DOCUMENTATION</a> for more details.
-
 ## Getting started:
 
 ```
 npm i @html-graph/html-graph
 ```
 
-```javascript
-import { CanvasBuilder } from "@html-graph/html-graph";
-
-class Application {
-  constructor(element) {
-    this.canvas = new CanvasBuilder(element)
-      .setDefaults({
-        edges: {
-          shape: {
-            hasTargetArrow: true,
-          },
-        },
-      })
-      .enableUserDraggableNodes()
-      .enableUserTransformableViewport()
-      .enableBackground()
-      .build();
-  }
-
-  initGraph() {
-    this.canvas
-      .addNode(
-        this.createNode({
-          name: "Node 1",
-          x: 200,
-          y: 400,
-          frontPortId: "node-1-in",
-          backPortId: "node-1-out",
-        }),
-      )
-      .addNode(
-        this.createNode({
-          name: "Node 2",
-          x: 600,
-          y: 500,
-          frontPortId: "node-2-in",
-          backPortId: "node-2-out",
-        }),
-      )
-      .addEdge({ from: "node-1-out", to: "node-2-in" });
-  }
-
-  createNode({ name, x, y, frontPortId, backPortId }) {
-    const nodeElement = document.createElement("div");
-    const text = document.createElement("div");
-    const frontPortElement = document.createElement("div");
-    const backPortElement = document.createElement("div");
-
-    nodeElement.classList.add("node");
-    frontPortElement.classList.add("port");
-    backPortElement.classList.add("port");
-    text.innerText = name;
-
-    nodeElement.appendChild(frontPortElement);
-    nodeElement.appendChild(text);
-    nodeElement.appendChild(backPortElement);
-
-    return {
-      element: nodeElement,
-      x: x,
-      y: y,
-      ports: [
-        { id: frontPortId, element: frontPortElement },
-        { id: backPortId, element: backPortElement },
-      ],
-    };
-  }
-}
-
-const element = document.getElementById("canvas");
-const app = new Application(element);
-
-app.initGraph();
-```
+Visit the <a target="_blank" href="https://html-graph.github.io">DOCUMENTATION</a> for examples and API reference.

package/dist/html-graph.d.ts

@@ -1,15 +1,15 @@
 export declare interface AddEdgeRequest {
-    readonly id?: unknown | undefined;
-    readonly from: unknown;
-    readonly to: unknown;
+    readonly id?: Identifier | undefined;
+    readonly from: Identifier;
+    readonly to: Identifier;
     readonly shape?: EdgeShape | undefined;
     readonly priority?: number | undefined;
 }
 
 declare interface AddEdgeRequest_2 {
-    readonly id: unknown;
-    readonly from: unknown;
-    readonly to: unknown;
+    readonly id: Identifier;
+    readonly from: Identifier;
+    readonly to: Identifier;
     readonly shape: EdgeShape;
     readonly priority: number;
 }
@@ -17,7 +17,7 @@ declare interface AddEdgeRequest_2 {
 export declare type AddNodePorts = Iterable<MarkNodePortRequest>;
 
 export declare interface AddNodeRequest {
-    readonly id?: unknown | undefined;
+    readonly id?: Identifier;
     readonly element: HTMLElement;
     readonly x: number;
     readonly y: number;
@@ -27,7 +27,7 @@ export declare interface AddNodeRequest {
 }
 
 declare interface AddNodeRequest_2 {
-    readonly id: unknown;
+    readonly id: Identifier;
     readonly element: HTMLElement;
     readonly x: number;
     readonly y: number;
@@ -36,8 +36,8 @@ declare interface AddNodeRequest_2 {
 }
 
 declare interface AddPortRequest {
-    readonly id: unknown;
-    readonly nodeId: unknown;
+    readonly id: Identifier;
+    readonly nodeId: Identifier;
     readonly element: HTMLElement;
     readonly direction: number;
 }
@@ -135,13 +135,13 @@ export declare class Canvas {
     /**
      * updates node parameters
      */
-    updateNode(nodeId: unknown, request?: UpdateNodeRequest): Canvas;
+    updateNode(nodeId: Identifier, request?: UpdateNodeRequest): Canvas;
     /**
      * removes specified node
      * all the ports of node get unmarked
      * all the edges adjacent to node get removed
      */
-    removeNode(nodeId: unknown): Canvas;
+    removeNode(nodeId: Identifier): Canvas;
     /**
      * marks specified element as a port for specified node
      */
@@ -149,12 +149,12 @@ export declare class Canvas {
     /**
      * updates port and edges attached to it
      */
-    updatePort(portId: unknown, request?: UpdatePortRequest): Canvas;
+    updatePort(portId: Identifier, request?: UpdatePortRequest): Canvas;
     /**
      * unmarks specified port
      * all the edges adjacent to the port get removed
      */
-    unmarkPort(portId: unknown): Canvas;
+    unmarkPort(portId: Identifier): Canvas;
     /**
      * adds new edge
      */
@@ -162,11 +162,11 @@ export declare class Canvas {
     /**
      * updates specified edge
      */
-    updateEdge(edgeId: unknown, request?: UpdateEdgeRequest): Canvas;
+    updateEdge(edgeId: Identifier, request?: UpdateEdgeRequest): Canvas;
     /**
      * removes specified edge
      */
-    removeEdge(edgeId: unknown): Canvas;
+    removeEdge(edgeId: Identifier): Canvas;
     /**
      * applies transformation for viewport matrix
      */
@@ -203,7 +203,9 @@ export declare class CanvasBuilder {
     private hasBackground;
     private hasUserConnectablePorts;
     private hasUserDraggableEdges;
-    private boxRenderingTrigger;
+    private readonly boxRenderingTrigger;
+    private readonly graphStore;
+    private readonly viewportStore;
     private readonly window;
     constructor(element: HTMLElement);
     /**
@@ -313,9 +315,9 @@ export declare interface ConnectablePortsConfig {
     readonly mouseUpEventVerifier?: MouseEventVerifier;
     readonly dragPortDirection?: number | undefined;
     readonly events?: {
-        readonly onAfterEdgeCreated?: (edgeId: unknown) => void;
+        readonly onAfterEdgeCreated?: (edgeId: Identifier) => void;
         readonly onEdgeCreationInterrupted?: (params: {
-            readonly staticPortId: unknown;
+            readonly staticPortId: Identifier;
             readonly isDirect: boolean;
         }) => void;
         readonly onEdgeCreationPrevented?: (request: AddEdgeRequest) => void;
@@ -330,7 +332,7 @@ export declare enum ConnectionCategory {
 
 export declare type ConnectionPreprocessor = (request: AddEdgeRequest) => AddEdgeRequest | null;
 
-export declare type ConnectionTypeResolver = (portId: unknown) => "direct" | "reverse" | null;
+export declare type ConnectionTypeResolver = (portId: Identifier) => "direct" | "reverse" | null;
 
 declare type ConstantPriority = number;
 
@@ -381,7 +383,7 @@ declare interface DraggableEdgesConfig {
     readonly draggingEdgeResolver?: DraggingEdgeResolver;
     readonly draggingEdgeShape?: EdgeShapeConfig;
     readonly events?: {
-        readonly onAfterEdgeReattached?: (edgeId: unknown) => void;
+        readonly onAfterEdgeReattached?: (edgeId: Identifier) => void;
         readonly onEdgeReattachInterrupted?: (edge: GraphEdge) => void;
         readonly onEdgeReattachPrevented?: (request: AddEdgeRequest) => void;
     };
@@ -391,32 +393,25 @@ export declare interface DraggableNodesConfig {
     readonly moveOnTop?: boolean;
     readonly moveEdgesOnTop?: boolean;
     readonly gridSize?: number | null;
-    readonly nodeDragVerifier?: (nodeId: unknown) => boolean;
+    readonly nodeDragVerifier?: (nodeId: Identifier) => boolean;
     readonly mouse?: {
         readonly dragCursor?: string | null;
         readonly mouseDownEventVerifier?: MouseEventVerifier;
         readonly mouseUpEventVerifier?: MouseEventVerifier;
     };
     readonly events?: {
-        readonly onNodeDrag?: (nodeId: unknown) => void;
-        readonly onNodeDragFinished?: (nodeId: unknown) => void;
+        readonly onNodeDrag?: (nodeId: Identifier) => void;
+        readonly onNodeDragFinished?: (nodeId: Identifier) => void;
     };
 }
 
-export declare type DraggingEdgeResolver = (portId: unknown) => unknown | null;
+export declare type DraggingEdgeResolver = (portId: Identifier) => Identifier | null;
 
 declare interface EdgePath {
     readonly path: string;
     readonly midpoint: Point;
 }
 
-declare interface EdgePayload {
-    readonly from: unknown;
-    readonly to: unknown;
-    shape: EdgeShape;
-    priority: number;
-}
-
 export declare interface EdgeRenderParams {
     readonly from: EdgeRenderPort;
     readonly to: EdgeRenderPort;
@@ -438,7 +433,7 @@ export declare interface EdgeShape {
 
 declare type EdgeShapeConfig = BezierEdgeShapeConfig | StraightEdgeShapeConfig | HorizontalEdgeShapeConfig | VerticalEdgeShapeConfig | DirectEdgeShapeConfig | EdgeShapeFactory;
 
-declare type EdgeShapeFactory = (edgeId: unknown) => EdgeShape;
+declare type EdgeShapeFactory = (edgeId: Identifier) => EdgeShape;
 
 declare interface EventHandler<T> {
     subscribe(callback: (payload: T) => void): void;
@@ -447,42 +442,42 @@ declare interface EventHandler<T> {
 
 export declare class Graph {
     private readonly graphStore;
-    readonly onAfterNodeAdded: EventHandler<unknown>;
-    readonly onAfterNodeUpdated: EventHandler<unknown>;
-    readonly onAfterNodePriorityUpdated: EventHandler<unknown>;
-    readonly onBeforeNodeRemoved: EventHandler<unknown>;
-    readonly onAfterPortMarked: EventHandler<unknown>;
-    readonly onAfterPortUpdated: EventHandler<unknown>;
-    readonly onBeforePortUnmarked: EventHandler<unknown>;
-    readonly onAfterEdgeAdded: EventHandler<unknown>;
-    readonly onAfterEdgeShapeUpdated: EventHandler<unknown>;
-    readonly onAfterEdgeUpdated: EventHandler<unknown>;
-    readonly onAfterEdgePriorityUpdated: EventHandler<unknown>;
-    readonly onBeforeEdgeRemoved: EventHandler<unknown>;
+    readonly onAfterNodeAdded: EventHandler<Identifier>;
+    readonly onAfterNodeUpdated: EventHandler<Identifier>;
+    readonly onAfterNodePriorityUpdated: EventHandler<Identifier>;
+    readonly onBeforeNodeRemoved: EventHandler<Identifier>;
+    readonly onAfterPortMarked: EventHandler<Identifier>;
+    readonly onAfterPortUpdated: EventHandler<Identifier>;
+    readonly onBeforePortUnmarked: EventHandler<Identifier>;
+    readonly onAfterEdgeAdded: EventHandler<Identifier>;
+    readonly onAfterEdgeShapeUpdated: EventHandler<Identifier>;
+    readonly onAfterEdgeUpdated: EventHandler<Identifier>;
+    readonly onAfterEdgePriorityUpdated: EventHandler<Identifier>;
+    readonly onBeforeEdgeRemoved: EventHandler<Identifier>;
     readonly onBeforeClear: EventHandler<void>;
     constructor(graphStore: GraphStore);
-    getNode(nodeId: unknown): GraphNode | null;
-    getElementNodeId(element: HTMLElement): unknown | null;
-    getAllNodeIds(): readonly unknown[];
-    getPort(portId: unknown): GraphPort | null;
-    getAllPortIds(): readonly unknown[];
-    getNodePortIds(nodeId: unknown): readonly unknown[] | null;
-    getElementPortIds(element: HTMLElement): readonly unknown[];
-    getAllEdgeIds(): readonly unknown[];
-    getEdge(edgeId: unknown): GraphEdge | null;
-    getPortIncomingEdgeIds(portId: unknown): readonly unknown[] | null;
-    getPortOutgoingEdgeIds(portId: unknown): readonly unknown[] | null;
-    getPortCycleEdgeIds(portId: unknown): readonly unknown[] | null;
-    getPortAdjacentEdgeIds(portId: unknown): readonly unknown[] | null;
-    getNodeIncomingEdgeIds(nodeId: unknown): readonly unknown[] | null;
-    getNodeOutgoingEdgeIds(nodeId: unknown): readonly unknown[] | null;
-    getNodeCycleEdgeIds(nodeId: unknown): readonly unknown[] | null;
-    getNodeAdjacentEdgeIds(nodeId: unknown): readonly unknown[] | null;
+    getNode(nodeId: Identifier): GraphNode | null;
+    getElementNodeId(element: HTMLElement): Identifier | null;
+    getAllNodeIds(): readonly Identifier[];
+    getPort(portId: Identifier): GraphPort | null;
+    getAllPortIds(): readonly Identifier[];
+    getNodePortIds(nodeId: Identifier): readonly Identifier[] | null;
+    getElementPortIds(element: HTMLElement): readonly Identifier[];
+    getAllEdgeIds(): readonly Identifier[];
+    getEdge(edgeId: Identifier): GraphEdge | null;
+    getPortIncomingEdgeIds(portId: Identifier): readonly Identifier[] | null;
+    getPortOutgoingEdgeIds(portId: Identifier): readonly Identifier[] | null;
+    getPortCycleEdgeIds(portId: Identifier): readonly Identifier[] | null;
+    getPortAdjacentEdgeIds(portId: Identifier): readonly Identifier[] | null;
+    getNodeIncomingEdgeIds(nodeId: Identifier): readonly Identifier[] | null;
+    getNodeOutgoingEdgeIds(nodeId: Identifier): readonly Identifier[] | null;
+    getNodeCycleEdgeIds(nodeId: Identifier): readonly Identifier[] | null;
+    getNodeAdjacentEdgeIds(nodeId: Identifier): readonly Identifier[] | null;
 }
 
 export declare interface GraphEdge {
-    readonly from: unknown;
-    readonly to: unknown;
+    readonly from: Identifier;
+    readonly to: Identifier;
     readonly priority: number;
     readonly shape: EdgeShape;
 }
@@ -498,7 +493,7 @@ export declare interface GraphNode {
 export declare interface GraphPort {
     readonly element: HTMLElement;
     readonly direction: number;
-    readonly nodeId: unknown;
+    readonly nodeId: Identifier;
 }
 
 declare class GraphStore {
@@ -511,59 +506,59 @@ declare class GraphStore {
     private readonly cycleEdges;
     private readonly elementPorts;
     private readonly afterNodeAddedEmitter;
-    readonly onAfterNodeAdded: EventHandler<unknown>;
+    readonly onAfterNodeAdded: EventHandler<Identifier>;
     private readonly afterNodeUpdatedEmitter;
-    readonly onAfterNodeUpdated: EventHandler<unknown>;
+    readonly onAfterNodeUpdated: EventHandler<Identifier>;
     private readonly afterNodePriorityUpdatedEmitter;
-    readonly onAfterNodePriorityUpdated: EventHandler<unknown>;
+    readonly onAfterNodePriorityUpdated: EventHandler<Identifier>;
     private readonly beforeNodeRemovedEmitter;
-    readonly onBeforeNodeRemoved: EventHandler<unknown>;
+    readonly onBeforeNodeRemoved: EventHandler<Identifier>;
     private readonly afterPortAddedEmitter;
-    readonly onAfterPortAdded: EventHandler<unknown>;
+    readonly onAfterPortAdded: EventHandler<Identifier>;
     private readonly afterPortUpdatedEmitter;
-    readonly onAfterPortUpdated: EventHandler<unknown>;
+    readonly onAfterPortUpdated: EventHandler<Identifier>;
     private readonly beforePortRemovedEmitter;
-    readonly onBeforePortRemoved: EventHandler<unknown>;
+    readonly onBeforePortRemoved: EventHandler<Identifier>;
     private readonly afterEdgeAddedEmitter;
-    readonly onAfterEdgeAdded: EventHandler<unknown>;
+    readonly onAfterEdgeAdded: EventHandler<Identifier>;
     private readonly afterEdgeShapeUpdatedEmitter;
-    readonly onAfterEdgeShapeUpdated: EventHandler<unknown>;
+    readonly onAfterEdgeShapeUpdated: EventHandler<Identifier>;
     private readonly afterEdgeUpdatedEmitter;
-    readonly onAfterEdgeUpdated: EventHandler<unknown>;
+    readonly onAfterEdgeUpdated: EventHandler<Identifier>;
     private readonly afterEdgePriorityUpdatedEmitter;
-    readonly onAfterEdgePriorityUpdated: EventHandler<unknown>;
+    readonly onAfterEdgePriorityUpdated: EventHandler<Identifier>;
     private readonly beforeEdgeRemovedEmitter;
-    readonly onBeforeEdgeRemoved: EventHandler<unknown>;
+    readonly onBeforeEdgeRemoved: EventHandler<Identifier>;
     private readonly beforeClearEmitter;
     readonly onBeforeClear: EventHandler<void>;
     constructor();
     addNode(request: AddNodeRequest_2): void;
-    getAllNodeIds(): readonly unknown[];
-    getNode(nodeId: unknown): NodePayload | undefined;
-    getElementNodeId(element: HTMLElement): unknown | undefined;
-    updateNode(nodeId: unknown, request: UpdateNodeRequest_2): void;
-    removeNode(nodeId: unknown): void;
+    getAllNodeIds(): readonly Identifier[];
+    getNode(nodeId: Identifier): StoreNode | undefined;
+    getElementNodeId(element: HTMLElement): Identifier | undefined;
+    updateNode(nodeId: Identifier, request: UpdateNodeRequest_2): void;
+    removeNode(nodeId: Identifier): void;
     addPort(request: AddPortRequest): void;
-    getPort(portId: unknown): PortPayload | undefined;
-    updatePort(portId: unknown, request: UpdatePortRequest_2): void;
-    getAllPortIds(): readonly unknown[];
-    getElementPortIds(element: HTMLElement): readonly unknown[];
-    getNodePortIds(nodeId: unknown): readonly unknown[] | undefined;
-    removePort(portId: unknown): void;
+    getPort(portId: Identifier): StorePort | undefined;
+    updatePort(portId: Identifier, request: UpdatePortRequest_2): void;
+    getAllPortIds(): readonly Identifier[];
+    getElementPortIds(element: HTMLElement): readonly Identifier[];
+    getNodePortIds(nodeId: Identifier): readonly Identifier[] | undefined;
+    removePort(portId: Identifier): void;
     addEdge(request: AddEdgeRequest_2): void;
-    updateEdge(edgeId: unknown, request: UpdateEdgeRequest_2): void;
-    getAllEdgeIds(): readonly unknown[];
-    getEdge(edgeId: unknown): EdgePayload | undefined;
-    removeEdge(edgeId: unknown): void;
+    updateEdge(edgeId: Identifier, request: UpdateEdgeRequest_2): void;
+    getAllEdgeIds(): readonly Identifier[];
+    getEdge(edgeId: Identifier): StoreEdge | undefined;
+    removeEdge(edgeId: Identifier): void;
     clear(): void;
-    getPortIncomingEdgeIds(portId: unknown): readonly unknown[];
-    getPortOutgoingEdgeIds(portId: unknown): readonly unknown[];
-    getPortCycleEdgeIds(portId: unknown): readonly unknown[];
-    getPortAdjacentEdgeIds(portId: unknown): readonly unknown[];
-    getNodeIncomingEdgeIds(nodeId: unknown): readonly unknown[];
-    getNodeOutgoingEdgeIds(nodeId: unknown): readonly unknown[];
-    getNodeCycleEdgeIds(nodeId: unknown): readonly unknown[];
-    getNodeAdjacentEdgeIds(nodeId: unknown): readonly unknown[];
+    getPortIncomingEdgeIds(portId: Identifier): readonly Identifier[];
+    getPortOutgoingEdgeIds(portId: Identifier): readonly Identifier[];
+    getPortCycleEdgeIds(portId: Identifier): readonly Identifier[];
+    getPortAdjacentEdgeIds(portId: Identifier): readonly Identifier[];
+    getNodeIncomingEdgeIds(nodeId: Identifier): readonly Identifier[];
+    getNodeOutgoingEdgeIds(nodeId: Identifier): readonly Identifier[];
+    getNodeCycleEdgeIds(nodeId: Identifier): readonly Identifier[];
+    getNodeAdjacentEdgeIds(nodeId: Identifier): readonly Identifier[];
     private addEdgeInternal;
     private removeEdgeInternal;
 }
@@ -609,19 +604,21 @@ declare type HorizontalEdgeShapeConfig = {
 } & HorizontalEdgeParams;
 
 declare interface HtmlView {
-    attachNode(nodeId: unknown): void;
-    detachNode(nodeId: unknown): void;
-    attachEdge(edgeId: unknown): void;
-    detachEdge(edgeId: unknown): void;
+    attachNode(nodeId: Identifier): void;
+    detachNode(nodeId: Identifier): void;
+    attachEdge(edgeId: Identifier): void;
+    detachEdge(edgeId: Identifier): void;
     clear(): void;
     destroy(): void;
-    updateNodePosition(nodeId: unknown): void;
-    updateNodePriority(nodeId: unknown): void;
-    updateEdgeShape(edgeId: unknown): void;
-    renderEdge(edgeId: unknown): void;
-    updateEdgePriority(edgeId: unknown): void;
+    updateNodePosition(nodeId: Identifier): void;
+    updateNodePriority(nodeId: Identifier): void;
+    updateEdgeShape(edgeId: Identifier): void;
+    renderEdge(edgeId: Identifier): void;
+    updateEdgePriority(edgeId: Identifier): void;
 }
 
+export declare type Identifier = NonNullable<unknown>;
+
 declare type IncrementalPriority = "incremental";
 
 export declare class InteractiveEdgeError extends Error {
@@ -649,15 +646,15 @@ export declare class InteractiveEdgeShape implements StructuredEdgeShape {
 }
 
 export declare type MarkNodePortRequest = {
-    readonly id?: unknown | undefined;
+    readonly id?: Identifier | undefined;
     readonly element: HTMLElement;
     readonly direction?: number | undefined;
 };
 
 export declare interface MarkPortRequest {
-    readonly id?: unknown;
+    readonly id?: Identifier;
     readonly element: HTMLElement;
-    readonly nodeId: unknown;
+    readonly nodeId: Identifier;
     readonly direction?: number;
 }
 
@@ -676,15 +673,6 @@ export declare class MidpointEdgeShape implements StructuredEdgeShape {
 
 export declare type MouseEventVerifier = (event: MouseEvent) => boolean;
 
-declare interface NodePayload {
-    readonly element: HTMLElement;
-    x: number;
-    y: number;
-    centerFn: CenterFn;
-    priority: number;
-    readonly ports: Map<unknown, HTMLElement>;
-}
-
 export declare interface PatchMatrixRequest {
     readonly scale?: number | undefined;
     readonly x?: number | undefined;
@@ -702,12 +690,6 @@ export declare interface Point {
     readonly y: number;
 }
 
-declare interface PortPayload {
-    readonly element: HTMLElement;
-    direction: number;
-    readonly nodeId: unknown;
-}
-
 declare type Priority = ConstantPriority | IncrementalPriority | CustomPriority;
 
 export declare type PriorityFn = () => number;
@@ -724,6 +706,34 @@ export declare interface ShiftLimitPreprocessorParams {
     readonly maxY: number | null;
 }
 
+declare interface StoreEdge {
+    readonly from: Identifier;
+    readonly to: Identifier;
+    readonly payload: {
+        shape: EdgeShape;
+        priority: number;
+    };
+}
+
+declare interface StoreNode {
+    readonly element: HTMLElement;
+    readonly payload: {
+        x: number;
+        y: number;
+        centerFn: CenterFn;
+        priority: number;
+    };
+    readonly ports: Map<Identifier, HTMLElement>;
+}
+
+declare interface StorePort {
+    readonly element: HTMLElement;
+    readonly payload: {
+        direction: number;
+    };
+    readonly nodeId: Identifier;
+}
+
 export declare interface StraightEdgeParams {
     readonly color?: string | undefined;
     readonly width?: number | undefined;
@@ -814,15 +824,15 @@ declare interface TransformState {
 }
 
 export declare interface UpdateEdgeRequest {
-    readonly from?: unknown | undefined;
-    readonly to?: unknown | undefined;
+    readonly from?: Identifier | undefined;
+    readonly to?: Identifier | undefined;
     readonly shape?: EdgeShape | undefined;
     readonly priority?: number | undefined;
 }
 
 declare interface UpdateEdgeRequest_2 {
-    readonly from?: unknown;
-    readonly to?: unknown;
+    readonly from?: Identifier;
+    readonly to?: Identifier;
     readonly shape?: EdgeShape;
     readonly priority?: number;
 }
@@ -937,8 +947,8 @@ export declare interface VirtualScrollConfig {
         readonly horizontal: number;
     };
     readonly events?: {
-        readonly onBeforeNodeAttached?: (nodeId: unknown) => void;
-        readonly onAfterNodeDetached?: (nodeId: unknown) => void;
+        readonly onBeforeNodeAttached?: (nodeId: Identifier) => void;
+        readonly onAfterNodeDetached?: (nodeId: Identifier) => void;
     };
 }