@html-graph/html-graph 3.21.0 → 4.1.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,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;
 }
@@ -94,10 +94,6 @@ declare type BezierEdgeShapeConfig = {
 } & BezierEdgeParams;
 
 export declare class Canvas {
-    /**
-     * @deprecated access element directly instead
-     */
-    readonly element: HTMLElement;
     private readonly graphStore;
     private readonly viewportStore;
     private readonly htmlView;
@@ -131,11 +127,7 @@ export declare class Canvas {
      * emits event just before destruction of canvas
      */
     readonly onBeforeDestroy: EventHandler<void>;
-    constructor(
-    /**
-     * @deprecated access element directly instead
-     */
-    element: HTMLElement, graphStore: GraphStore, viewportStore: ViewportStore, htmlView: HtmlView, params: CanvasParams);
+    constructor(graphStore: GraphStore, viewportStore: ViewportStore, htmlView: HtmlView, params: CanvasParams);
     /**
      * adds new node
      */
@@ -143,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
      */
@@ -157,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
      */
@@ -170,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
      */
@@ -196,7 +188,8 @@ export declare class Canvas {
 }
 
 export declare class CanvasBuilder {
-    private element;
+    private readonly element;
+    private used;
     private canvasDefaults;
     private dragConfig;
     private transformConfig;
@@ -210,14 +203,11 @@ 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);
-    /**
-     * @deprecated
-     * use `new CanvasBuilder(element);` instead
-     */
-    setElement(element: HTMLElement): CanvasBuilder;
+    constructor(element: HTMLElement);
     /**
      * specifies default values for graph entities
      */
@@ -230,21 +220,10 @@ export declare class CanvasBuilder {
      * enables viewport transformable by user
      */
     enableUserTransformableViewport(config?: ViewportTransformConfig): CanvasBuilder;
-    /**
-     * @deprecated
-     * use enableNodeResizeReactiveEdges instead
-     */
-    enableResizeReactiveNodes(): CanvasBuilder;
     /**
      * enables automatic edges update on node resize
      */
     enableNodeResizeReactiveEdges(): CanvasBuilder;
-    /**
-     * @deprecated
-     * do not use
-     * sets emitter for rendering graph inside bounded area
-     */
-    enableBoxAreaRendering(trigger: EventSubject<RenderingBox>): CanvasBuilder;
     /**
      * enables built-in virtual scroll behavior, when only nodes and edges close
      * to viewport are rendered
@@ -263,11 +242,10 @@ export declare class CanvasBuilder {
      * builds final canvas
      */
     build(): Canvas;
-    /**
-     * @deprecated
-     * CanvasBuilder should be single use object
-     */
-    private reset;
+}
+
+export declare class CanvasBuilderError extends Error {
+    readonly name = "CanvasBuilderError";
 }
 
 export declare interface CanvasDefaults {
@@ -309,6 +287,10 @@ export declare interface CanvasDefaults {
     };
 }
 
+export declare class CanvasError extends Error {
+    readonly name = "CanvasError";
+}
+
 declare interface CanvasParams {
     readonly nodes: {
         readonly centerFn: CenterFn;
@@ -325,7 +307,7 @@ declare interface CanvasParams {
 
 export declare type CenterFn = (width: number, height: number) => Point;
 
-declare interface ConnectablePortsConfig {
+export declare interface ConnectablePortsConfig {
     readonly edgeShape?: EdgeShapeConfig;
     readonly connectionTypeResolver?: ConnectionTypeResolver;
     readonly connectionPreprocessor?: ConnectionPreprocessor;
@@ -333,13 +315,14 @@ declare interface ConnectablePortsConfig {
     readonly mouseUpEventVerifier?: MouseEventVerifier;
     readonly dragPortDirection?: number | undefined;
     readonly events?: {
-        readonly onAfterEdgeCreated?: (edgeId: unknown) => void;
-        readonly onEdgeCreationInterrupted?: (staticPortId: unknown, isDirect: boolean) => void;
+        readonly onAfterEdgeCreated?: (edgeId: Identifier) => void;
+        readonly onEdgeCreationInterrupted?: (params: {
+            readonly staticPortId: Identifier;
+            readonly isDirect: boolean;
+        }) => void;
         readonly onEdgeCreationPrevented?: (request: AddEdgeRequest) => void;
     };
 }
-export { ConnectablePortsConfig }
-export { ConnectablePortsConfig as ConnectablePortsOptions }
 
 export declare enum ConnectionCategory {
     Line = "line",
@@ -349,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;
 
@@ -400,51 +383,35 @@ 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;
     };
 }
 
-declare interface DraggableNodesConfig {
+export declare interface DraggableNodesConfig {
     readonly moveOnTop?: boolean;
     readonly moveEdgesOnTop?: boolean;
+    readonly gridSize?: number | null;
+    readonly nodeDragVerifier?: (nodeId: Identifier) => boolean;
     readonly mouse?: {
         readonly dragCursor?: string | null;
         readonly mouseDownEventVerifier?: MouseEventVerifier;
         readonly mouseUpEventVerifier?: MouseEventVerifier;
     };
-    readonly gridSize?: number | null;
-    readonly nodeDragVerifier?: (payload: NodeDragPayload) => boolean;
     readonly events?: {
-        readonly onNodeDrag?: (payload: NodeDragPayload) => void;
-        /**
-         * @deprecated
-         * use nodeDragVerifier instead
-         */
-        readonly onBeforeNodeDrag?: (payload: NodeDragPayload) => boolean;
-        readonly onNodeDragFinished?: (payload: NodeDragPayload) => void;
+        readonly onNodeDrag?: (nodeId: Identifier) => void;
+        readonly onNodeDragFinished?: (nodeId: Identifier) => void;
     };
 }
-export { DraggableNodesConfig as DragOptions }
-export { DraggableNodesConfig }
 
-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 type EdgePathFactory = (sourceDirection: Point, targetDirection: Point, to: Point, flipX: number, flipY: number) => EdgePath;
-
-declare interface EdgePayload {
-    readonly from: unknown;
-    readonly to: unknown;
-    shape: EdgeShape;
-    priority: number;
-}
-
 export declare interface EdgeRenderParams {
     readonly from: EdgeRenderPort;
     readonly to: EdgeRenderPort;
@@ -457,16 +424,6 @@ export declare interface EdgeRenderPort {
     readonly width: number;
     readonly height: number;
     readonly direction: number;
-    /**
-     * @deprecated
-     * use category instead
-     */
-    readonly portId: unknown;
-    /**
-     * @deprecated
-     * use category instead
-     */
-    readonly nodeId: unknown;
 }
 
 export declare interface EdgeShape {
@@ -476,77 +433,51 @@ 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;
 
-export declare interface EventEmitter<T> {
-    emit(payload: T): void;
-}
-
-export declare interface EventHandler<T> {
+declare interface EventHandler<T> {
     subscribe(callback: (payload: T) => void): void;
     unsubscribe(callback: (payload: T) => void): void;
 }
 
-export declare class EventSubject<T> implements EventEmitter<T>, EventHandler<T> {
-    private readonly callbacks;
-    subscribe(callback: (payload: T) => void): void;
-    unsubscribe(callback: (payload: T) => void): void;
-    emit(payload: T): void;
-}
-
 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[];
-    /**
-     * @deprecated
-     * use getElementPortIds instead
-     */
-    getElementPortsIds(element: HTMLElement): readonly unknown[];
-    getAllEdgeIds(): readonly unknown[];
-    getEdge(edgeId: unknown): GraphEdge | null;
-    getPortIncomingEdgeIds(portId: unknown): readonly unknown[] | null;
-    getPortOutgoingEdgeIds(portId: unknown): readonly unknown[] | null;
-    /**
-     * @deprecated
-     * use getPortOutgoingEdgeIds instead
-     */
-    getPortOutcomingEdgeIds(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;
-    /**
-     * @deprecated
-     * use getNodeOutgoingEdgeIds instead
-     */
-    getNodeOutcomingEdgeIds(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;
 }
@@ -562,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 {
@@ -575,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;
 }
@@ -643,11 +574,6 @@ export declare interface HorizontalEdgeParams {
     readonly cycleSquareSide?: number | undefined;
     readonly roundness?: number | undefined;
     readonly detourDistance?: number | undefined;
-    /**
-     * @deprecated
-     * do not use
-     */
-    readonly detourDirection?: number | undefined;
 }
 
 export declare class HorizontalEdgeShape implements StructuredEdgeShape {
@@ -677,24 +603,22 @@ declare type HorizontalEdgeShapeConfig = {
     readonly type: "horizontal";
 } & HorizontalEdgeParams;
 
-export declare class HtmlGraphError extends Error {
-    readonly name = "HtmlGraphError";
-}
-
 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 {
@@ -702,10 +626,7 @@ export declare class InteractiveEdgeError extends Error {
 }
 
 export declare interface InteractiveEdgeParams {
-    /**
-     * TODO: rename to 'radius'
-     */
-    readonly width?: number;
+    readonly distance?: number;
 }
 
 export declare class InteractiveEdgeShape implements StructuredEdgeShape {
@@ -724,45 +645,20 @@ export declare class InteractiveEdgeShape implements StructuredEdgeShape {
     render(params: EdgeRenderParams): void;
 }
 
-export declare interface LineEdgeParams {
-    readonly width: number;
-    readonly color: string;
-    readonly arrowLength: number;
-    readonly arrowWidth: number;
-    readonly hasSourceArrow: boolean;
-    readonly hasTargetArrow: boolean;
-    readonly createCyclePath: EdgePathFactory;
-    readonly createDetourPath: EdgePathFactory;
-    readonly createLinePath: EdgePathFactory;
-}
-
-export declare class LineEdgeShape implements StructuredEdgeShape {
-    private readonly params;
-    readonly svg: SVGSVGElement;
-    readonly group: SVGGElement;
-    readonly line: SVGPathElement;
-    readonly sourceArrow: SVGPathElement | null;
-    readonly targetArrow: SVGPathElement | null;
-    readonly onAfterRender: EventHandler<StructuredEdgeRenderModel>;
-    private readonly afterRenderEmitter;
-    constructor(params: LineEdgeParams);
-    render(params: EdgeRenderParams): void;
-}
-
 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;
 }
 
-declare class MidpointEdgeShape implements StructuredEdgeShape {
+export declare class MidpointEdgeShape implements StructuredEdgeShape {
     private readonly baseShape;
     readonly midpointElement: SVGElement;
     readonly group: SVGGElement;
@@ -771,38 +667,12 @@ declare class MidpointEdgeShape implements StructuredEdgeShape {
     readonly targetArrow: SVGPathElement | null;
     readonly onAfterRender: EventHandler<StructuredEdgeRenderModel>;
     readonly svg: SVGSVGElement;
-    /**
-     * @deprecated
-     * use midpointElement instead
-     */
-    readonly medianElement: SVGElement;
     constructor(baseShape: StructuredEdgeShape, midpointElement: SVGElement);
     render(params: EdgeRenderParams): void;
 }
-export { MidpointEdgeShape as MedianEdgeShape }
-export { MidpointEdgeShape }
 
 export declare type MouseEventVerifier = (event: MouseEvent) => boolean;
 
-/**
- * TODO: replace with node ID
- */
-export declare interface NodeDragPayload {
-    readonly nodeId: unknown;
-    readonly element: HTMLElement;
-    readonly x: number;
-    readonly y: number;
-}
-
-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;
@@ -820,23 +690,10 @@ 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;
 
-export declare interface RenderingBox {
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-}
-
 export declare interface ScaleLimitPreprocessorParams {
     readonly minContentScale: number | null;
     readonly maxContentScale: number | null;
@@ -849,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;
@@ -939,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;
 }
@@ -985,11 +870,6 @@ export declare interface VerticalEdgeParams {
     readonly cycleSquareSide?: number | undefined;
     readonly roundness?: number | undefined;
     readonly detourDistance?: number | undefined;
-    /**
-     * @deprecated
-     * do not use
-     */
-    readonly detourDirection?: number | undefined;
 }
 
 export declare class VerticalEdgeShape implements StructuredEdgeShape {
@@ -1021,11 +901,6 @@ declare type VerticalEdgeShapeConfig = {
 
 export declare class Viewport {
     private readonly viewportStore;
-    /**
-     * @deprecated
-     * do not use
-     */
-    readonly onBeforeUpdated: EventHandler<void>;
     readonly onAfterUpdated: EventHandler<void>;
     constructor(viewportStore: ViewportStore);
     getViewportMatrix(): TransformState;
@@ -1037,12 +912,6 @@ declare class ViewportStore {
     private contentMatrix;
     private readonly afterUpdateEmitter;
     readonly onAfterUpdated: EventHandler<void>;
-    private readonly beforeUpdateEmitter;
-    /**
-     * @deprecated
-     * do not use
-     */
-    readonly onBeforeUpdated: EventHandler<void>;
     constructor();
     getViewportMatrix(): TransformState;
     getContentMatrix(): TransformState;
@@ -1050,7 +919,7 @@ declare class ViewportStore {
     patchContentMatrix(matrix: PatchTransformRequest): void;
 }
 
-declare interface ViewportTransformConfig {
+export declare interface ViewportTransformConfig {
     readonly scale?: {
         readonly mouseWheelSensitivity?: number;
         readonly mouseWheelEventVerifier?: (event: WheelEvent) => boolean;
@@ -1071,8 +940,6 @@ declare interface ViewportTransformConfig {
         readonly onResizeTransformFinished?: () => void;
     };
 }
-export { ViewportTransformConfig as TransformOptions }
-export { ViewportTransformConfig }
 
 export declare interface VirtualScrollConfig {
     readonly nodeContainingRadius: {
@@ -1080,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;
     };
 }