@html-graph/html-graph 4.0.0 → 5.0.0

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,12 +36,33 @@ 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;
 }
 
+export declare type ArrowRenderer = (params: ArrowRenderingParams) => string;
+
+export declare type ArrowRendererConfig = {
+    readonly type?: "wedge";
+    readonly radius?: number | undefined;
+    readonly smallRadius?: number | undefined;
+    readonly angle?: number | undefined;
+} | {
+    readonly type: "triangle";
+    readonly radius?: number | undefined;
+} | {
+    readonly type: "arc";
+    readonly radius?: number | undefined;
+} | ArrowRenderer;
+
+export declare interface ArrowRenderingParams {
+    readonly direction: Point;
+    readonly shift: Point;
+    readonly arrowLength: number;
+}
+
 export declare interface BackgroundConfig {
     readonly tileDimensions?: {
         readonly width?: number;
@@ -55,7 +76,7 @@ export declare interface BezierEdgeParams {
     readonly color?: string | undefined;
     readonly width?: number | undefined;
     readonly arrowLength?: number | undefined;
-    readonly arrowWidth?: number | undefined;
+    readonly arrowRenderer?: ArrowRendererConfig | undefined;
     readonly curvature?: number | undefined;
     readonly hasSourceArrow?: boolean | undefined;
     readonly hasTargetArrow?: boolean | undefined;
@@ -73,7 +94,6 @@ export declare class BezierEdgeShape implements StructuredEdgeShape {
     readonly targetArrow: SVGPathElement | null;
     readonly onAfterRender: EventHandler<StructuredEdgeRenderModel>;
     private readonly arrowLength;
-    private readonly arrowWidth;
     private readonly curvature;
     private readonly portCycleRadius;
     private readonly portCycleSmallRadius;
@@ -135,13 +155,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 +169,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 +182,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 +223,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 +335,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 +352,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;
 
@@ -340,7 +362,7 @@ export declare interface DirectEdgeParams {
     readonly color?: string | undefined;
     readonly width?: number | undefined;
     readonly arrowLength?: number | undefined;
-    readonly arrowWidth?: number | undefined;
+    readonly arrowRenderer?: ArrowRendererConfig | undefined;
     readonly hasSourceArrow?: boolean | undefined;
     readonly hasTargetArrow?: boolean | undefined;
     readonly sourceOffset?: number | undefined;
@@ -356,11 +378,11 @@ export declare class DirectEdgeShape implements StructuredEdgeShape {
     private readonly color;
     private readonly width;
     private readonly arrowLength;
-    private readonly arrowWidth;
     private readonly sourceOffset;
     private readonly targetOffset;
     readonly onAfterRender: EventHandler<StructuredEdgeRenderModel>;
     private readonly afterRenderEmitter;
+    private readonly arrowRenderer;
     constructor(params?: DirectEdgeParams);
     render(params: EdgeRenderParams): void;
 }
@@ -381,7 +403,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 +413,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 +453,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 +462,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 +513,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 +526,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;
 }
@@ -572,7 +587,7 @@ export declare interface HorizontalEdgeParams {
     readonly color?: string | undefined;
     readonly width?: number | undefined;
     readonly arrowLength?: number | undefined;
-    readonly arrowWidth?: number | undefined;
+    readonly arrowRenderer?: ArrowRendererConfig | undefined;
     readonly arrowOffset?: number | undefined;
     readonly hasSourceArrow?: boolean | undefined;
     readonly hasTargetArrow?: boolean | undefined;
@@ -589,7 +604,6 @@ export declare class HorizontalEdgeShape implements StructuredEdgeShape {
     readonly targetArrow: SVGPathElement | null;
     readonly onAfterRender: EventHandler<StructuredEdgeRenderModel>;
     private readonly arrowLength;
-    private readonly arrowWidth;
     private readonly arrowOffset;
     private readonly roundness;
     private readonly cycleSquareSide;
@@ -609,19 +623,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 +665,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 +692,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 +709,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,12 +725,40 @@ 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;
     readonly arrowLength?: number | undefined;
-    readonly arrowWidth?: number | undefined;
     readonly arrowOffset?: number | undefined;
+    readonly arrowRenderer?: ArrowRendererConfig | undefined;
     readonly hasSourceArrow?: boolean | undefined;
     readonly hasTargetArrow?: boolean | undefined;
     readonly cycleSquareSide?: number | undefined;
@@ -746,7 +775,6 @@ export declare class StraightEdgeShape implements StructuredEdgeShape {
     readonly targetArrow: SVGPathElement | null;
     readonly onAfterRender: EventHandler<StructuredEdgeRenderModel>;
     private readonly arrowLength;
-    private readonly arrowWidth;
     private readonly arrowOffset;
     private readonly roundness;
     private readonly cycleSquareSide;
@@ -814,15 +842,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;
 }
@@ -853,8 +881,8 @@ export declare interface VerticalEdgeParams {
     readonly color?: string | undefined;
     readonly width?: number | undefined;
     readonly arrowLength?: number | undefined;
-    readonly arrowWidth?: number | undefined;
     readonly arrowOffset?: number | undefined;
+    readonly arrowRenderer?: ArrowRendererConfig | undefined;
     readonly hasSourceArrow?: boolean | undefined;
     readonly hasTargetArrow?: boolean | undefined;
     readonly cycleSquareSide?: number | undefined;
@@ -870,7 +898,6 @@ export declare class VerticalEdgeShape implements StructuredEdgeShape {
     readonly targetArrow: SVGPathElement | null;
     readonly onAfterRender: EventHandler<StructuredEdgeRenderModel>;
     private readonly arrowLength;
-    private readonly arrowWidth;
     private readonly arrowOffset;
     private readonly roundness;
     private readonly cycleSquareSide;
@@ -937,8 +964,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;
     };
 }