Implemented 2D visualization for notes using Vue Flow

node_modules/@vue-flow/core/dist/utils/a11y.d.ts

@@ -0,0 +1,7 @@
+import type { XYPosition } from '../types'
+
+export declare const ARIA_NODE_DESC_KEY = 'vue-flow__node-desc'
+export declare const ARIA_EDGE_DESC_KEY = 'vue-flow__edge-desc'
+export declare const ARIA_LIVE_MESSAGE = 'vue-flow__aria-live'
+export declare const elementSelectionKeys: string[]
+export declare const arrowKeyDiffs: Record<string, XYPosition>

node_modules/@vue-flow/core/dist/utils/autopan.d.ts

@@ -0,0 +1,8 @@
+import type { Dimensions, XYPosition } from '../types'
+
+export declare function calcAutoPan(
+  pos: XYPosition,
+  bounds: Dimensions,
+  speed?: number,
+  distance?: number,
+): [xMovement: number, yMovement: number]

node_modules/@vue-flow/core/dist/utils/changes.d.ts

@@ -0,0 +1,41 @@
+import type {
+  EdgeAddChange,
+  EdgeChange,
+  EdgeRemoveChange,
+  EdgeSelectionChange,
+  ElementChange,
+  FlowElement,
+  GraphEdge,
+  GraphNode,
+  NodeAddChange,
+  NodeChange,
+  NodeRemoveChange,
+  NodeSelectionChange,
+} from '../types'
+
+export declare function applyChanges<
+  T extends FlowElement = FlowElement,
+  C extends ElementChange = T extends GraphNode ? NodeChange : EdgeChange,
+>(changes: C[], elements: T[]): T[]
+/** @deprecated Use store instance and call `applyChanges` with template-ref or the one received by `onPaneReady` instead */
+export declare function applyEdgeChanges(changes: EdgeChange[], edges: GraphEdge[]): GraphEdge[]
+/** @deprecated Use store instance and call `applyChanges` with template-ref or the one received by `onPaneReady` instead */
+export declare function applyNodeChanges(changes: NodeChange[], nodes: GraphNode[]): GraphNode<any, any, string>[]
+export declare function createSelectionChange(id: string, selected: boolean): NodeSelectionChange | EdgeSelectionChange
+export declare function createAdditionChange<
+  T extends GraphNode | GraphEdge = GraphNode,
+  C extends NodeAddChange | EdgeAddChange = T extends GraphNode ? NodeAddChange : EdgeAddChange,
+>(item: T): C
+export declare function createNodeRemoveChange(id: string): NodeRemoveChange
+export declare function createEdgeRemoveChange(
+  id: string,
+  source: string,
+  target: string,
+  sourceHandle?: string | null,
+  targetHandle?: string | null,
+): EdgeRemoveChange
+export declare function getSelectionChanges(
+  items: Map<string, any>,
+  selectedIds?: Set<string>,
+  mutateItem?: boolean,
+): NodeSelectionChange[] | EdgeSelectionChange[]

node_modules/@vue-flow/core/dist/utils/createExtendedEventHook.d.ts

@@ -0,0 +1,12 @@
+import type { EventHook } from '@vueuse/core'
+
+/**
+ * Source code taken from https://github.com/vueuse/vueuse/blob/main/packages/shared/createEventHook/index.ts
+ *
+ * Modified to be able to check if there are any event listeners
+ */
+export interface EventHookExtended<T> extends EventHook<T> {
+  hasListeners: () => boolean
+  fns: Set<(param: T) => void>
+}
+export declare function createExtendedEventHook<T = any>(defaultHandler?: (param: T) => void): EventHookExtended<T>

node_modules/@vue-flow/core/dist/utils/defaultNodesEdges.d.ts

@@ -0,0 +1,4 @@
+import type { DefaultEdgeTypes, DefaultNodeTypes } from '../types'
+
+export declare const defaultNodeTypes: DefaultNodeTypes
+export declare const defaultEdgeTypes: DefaultEdgeTypes

node_modules/@vue-flow/core/dist/utils/drag.d.ts

@@ -0,0 +1,38 @@
+import type { Actions, CoordinateExtent, GraphNode, NodeDragItem, State, XYPosition } from '../types'
+
+export declare function hasSelector(target: Element, selector: string, node: Element): boolean
+export declare function getDragItems(
+  nodes: GraphNode[],
+  nodesDraggable: boolean,
+  mousePos: XYPosition,
+  findNode: Actions['findNode'],
+  nodeId?: string,
+): NodeDragItem[]
+export declare function getEventHandlerParams({
+  id,
+  dragItems,
+  findNode,
+}: {
+  id?: string
+  dragItems: NodeDragItem[]
+  findNode: Actions['findNode']
+}): [GraphNode, GraphNode[]]
+export declare function getExtent<T extends NodeDragItem | GraphNode>(
+  item: T,
+  triggerError: State['hooks']['error']['trigger'],
+  extent?: State['nodeExtent'],
+  parent?: GraphNode,
+): CoordinateExtent
+export declare function calcNextPosition(
+  node: GraphNode | NodeDragItem,
+  nextPosition: XYPosition,
+  triggerError: State['hooks']['error']['trigger'],
+  nodeExtent?: State['nodeExtent'],
+  parentNode?: GraphNode,
+): {
+  position: {
+    x: number
+    y: number
+  }
+  computedPosition: XYPosition
+}

node_modules/@vue-flow/core/dist/utils/edge.d.ts

@@ -0,0 +1,34 @@
+import type { Actions, GraphEdge, GraphNode, HandleElement, ViewportTransform, XYPosition } from '../types'
+import type { Position } from '../types'
+
+export declare function getHandlePosition(
+  node: GraphNode,
+  handle: HandleElement | null,
+  fallbackPosition?: Position,
+  center?: boolean,
+): XYPosition
+export declare function getEdgeHandle(bounds: HandleElement[] | null, handleId?: string | null): HandleElement | null
+interface IsEdgeVisibleParams {
+  sourcePos: XYPosition
+  targetPos: XYPosition
+  sourceWidth: number
+  sourceHeight: number
+  targetWidth: number
+  targetHeight: number
+  width: number
+  height: number
+  viewport: ViewportTransform
+}
+export declare function isEdgeVisible({
+  sourcePos,
+  targetPos,
+  sourceWidth,
+  sourceHeight,
+  targetWidth,
+  targetHeight,
+  width,
+  height,
+  viewport,
+}: IsEdgeVisibleParams): boolean
+export declare function getEdgeZIndex(edge: GraphEdge, findNode: Actions['findNode'], elevateEdgesOnSelect?: boolean): number
+export {}

node_modules/@vue-flow/core/dist/utils/errors.d.ts

@@ -0,0 +1,47 @@
+export declare enum ErrorCode {
+  MISSING_STYLES = 'MISSING_STYLES',
+  MISSING_VIEWPORT_DIMENSIONS = 'MISSING_VIEWPORT_DIMENSIONS',
+  NODE_INVALID = 'NODE_INVALID',
+  NODE_NOT_FOUND = 'NODE_NOT_FOUND',
+  NODE_MISSING_PARENT = 'NODE_MISSING_PARENT',
+  NODE_TYPE_MISSING = 'NODE_TYPE_MISSING',
+  NODE_EXTENT_INVALID = 'NODE_EXTENT_INVALID',
+  EDGE_INVALID = 'EDGE_INVALID',
+  EDGE_NOT_FOUND = 'EDGE_NOT_FOUND',
+  EDGE_SOURCE_MISSING = 'EDGE_SOURCE_MISSING',
+  EDGE_TARGET_MISSING = 'EDGE_TARGET_MISSING',
+  EDGE_TYPE_MISSING = 'EDGE_TYPE_MISSING',
+  EDGE_SOURCE_TARGET_SAME = 'EDGE_SOURCE_TARGET_SAME',
+  EDGE_SOURCE_TARGET_MISSING = 'EDGE_SOURCE_TARGET_MISSING',
+  EDGE_ORPHANED = 'EDGE_ORPHANED',
+  USEVUEFLOW_OPTIONS = 'USEVUEFLOW_OPTIONS',
+}
+declare const messages: {
+  readonly MISSING_STYLES: () => string
+  readonly MISSING_VIEWPORT_DIMENSIONS: () => string
+  readonly NODE_INVALID: (id?: string) => string
+  readonly NODE_NOT_FOUND: (id: string | null) => string
+  readonly NODE_MISSING_PARENT: (id: string, parentId: string) => string
+  readonly NODE_TYPE_MISSING: (type: string) => string
+  readonly NODE_EXTENT_INVALID: (id: string) => string
+  readonly EDGE_INVALID: (id: string) => string
+  readonly EDGE_SOURCE_MISSING: (id: string, source: string) => string
+  readonly EDGE_TARGET_MISSING: (id: string, target: string) => string
+  readonly EDGE_TYPE_MISSING: (type: string) => string
+  readonly EDGE_SOURCE_TARGET_SAME: (id: string, source: string, target: string) => string
+  readonly EDGE_SOURCE_TARGET_MISSING: (id: string, source: string, target: string) => string
+  readonly EDGE_ORPHANED: (id: string) => string
+  readonly EDGE_NOT_FOUND: (id: string) => string
+  readonly USEVUEFLOW_OPTIONS: () => string
+}
+type ErrorArgs<T extends ErrorCode> = (typeof messages)[T] extends (...args: any[]) => string
+  ? Parameters<(typeof messages)[T]>
+  : never
+export declare class VueFlowError<T extends ErrorCode = ErrorCode, Args extends ErrorArgs<T> = ErrorArgs<T>> extends Error {
+  name: string
+  code: T
+  args: Args
+  constructor(code: T, ...args: Args)
+}
+export declare function isErrorOfType<T extends ErrorCode>(error: VueFlowError, code: T): error is VueFlowError<T>
+export {}

node_modules/@vue-flow/core/dist/utils/general.d.ts

@@ -0,0 +1,18 @@
+import type { GraphNode, SnapGrid, XYPosition } from '../types'
+import type { UseDragEvent } from '../composables'
+
+export declare function isMouseEvent(event: MouseEvent | TouchEvent): event is MouseEvent
+export declare function isUseDragEvent(event: any): event is UseDragEvent
+export declare function getEventPosition(
+  event: MouseEvent | TouchEvent,
+  bounds?: DOMRect,
+): {
+  x: number
+  y: number
+}
+export declare const isMacOs: () => boolean
+export declare function getNodeDimensions(node: GraphNode): {
+  width: number
+  height: number
+}
+export declare function snapPosition(position: XYPosition, snapGrid?: SnapGrid): XYPosition

node_modules/@vue-flow/core/dist/utils/graph.d.ts

@@ -0,0 +1,132 @@
+import type {
+  Actions,
+  Box,
+  Connection,
+  CoordinateExtent,
+  DefaultEdgeOptions,
+  Dimensions,
+  Edge,
+  EdgeMarkerType,
+  ElementData,
+  Elements,
+  FlowElements,
+  GraphEdge,
+  GraphNode,
+  MaybeElement,
+  Node,
+  Rect,
+  ViewportTransform,
+  XYPosition,
+  XYZPosition,
+} from '../types'
+
+export declare function nodeToRect(node: GraphNode): Rect
+export declare function getOverlappingArea(rectA: Rect, rectB: Rect): number
+export declare function getDimensions(node: HTMLElement): Dimensions
+export declare function clamp(val: number, min?: number, max?: number): number
+export declare function clampPosition(position: XYPosition, extent: CoordinateExtent): XYPosition
+export declare function getHostForElement(element: HTMLElement): Document
+export declare function isEdge<Data = ElementData>(element: MaybeElement): element is Edge<Data>
+export declare function isGraphEdge<Data = ElementData>(element: MaybeElement): element is GraphEdge<Data>
+export declare function isNode<Data = ElementData>(element: MaybeElement): element is Node<Data>
+export declare function isGraphNode<Data = ElementData>(element: MaybeElement): element is GraphNode<Data>
+export declare function isRect(obj: any): obj is Rect
+export declare function parseNode(node: Node, existingNode?: GraphNode, parentNode?: string): GraphNode
+export declare function parseEdge(edge: Edge, existingEdge?: GraphEdge, defaultEdgeOptions?: DefaultEdgeOptions): GraphEdge
+export declare function getOutgoers<N extends Node>(
+  nodeOrId:
+    | Node
+    | {
+        id: string
+      }
+    | string,
+  nodes: N[],
+  edges: Edge[],
+): N[]
+export declare function getOutgoers<T extends Elements>(
+  nodeOrId:
+    | Node
+    | {
+        id: string
+      }
+    | string,
+  elements: T,
+): T extends FlowElements ? GraphNode[] : Node[]
+export declare function getIncomers<N extends Node>(
+  nodeOrId:
+    | Node
+    | {
+        id: string
+      }
+    | string,
+  nodes: N[],
+  edges: Edge[],
+): N[]
+export declare function getIncomers<T extends Elements>(
+  nodeOrId:
+    | Node
+    | {
+        id: string
+      }
+    | string,
+  elements: T,
+): T extends FlowElements ? GraphNode[] : Node[]
+export declare function getEdgeId({ source, sourceHandle, target, targetHandle }: Connection): string
+export declare function connectionExists(edge: Edge | Connection, elements: Elements): boolean
+/**
+ * @deprecated Use store instance and call `addEdges` with template-ref or the one received by `onPaneReady` instead
+ *
+ * Intended for options API
+ * In composition API you can access utilities from `useVueFlow`
+ */
+export declare function addEdge(edgeParams: Edge | Connection, elements: Elements, defaults?: DefaultEdgeOptions): Elements
+/**
+ * @deprecated Use store instance and call `updateEdge` with template-ref or the one received by `onPaneReady` instead
+ *
+ * Intended for options API
+ * In composition API you can access utilities from `useVueFlow`
+ */
+export declare function updateEdge(oldEdge: Edge, newConnection: Connection, elements: Elements): Elements
+export declare function rendererPointToPoint({ x, y }: XYPosition, { x: tx, y: ty, zoom: tScale }: ViewportTransform): XYPosition
+export declare function pointToRendererPoint(
+  { x, y }: XYPosition,
+  { x: tx, y: ty, zoom: tScale }: ViewportTransform,
+  snapToGrid?: boolean,
+  snapGrid?: [snapX: number, snapY: number],
+): XYPosition
+export declare function rectToBox({ x, y, width, height }: Rect): Box
+export declare function boxToRect({ x, y, x2, y2 }: Box): Rect
+export declare function getBoundsofRects(rect1: Rect, rect2: Rect): Rect
+export declare function getRectOfNodes(nodes: GraphNode[]): Rect
+export declare function getNodesInside(
+  nodes: GraphNode[],
+  rect: Rect,
+  viewport?: ViewportTransform,
+  partially?: boolean,
+  excludeNonSelectableNodes?: boolean,
+): GraphNode<any, any, string>[]
+export declare function getConnectedEdges<E extends Edge>(nodesOrId: Node[] | string, edges: E[]): E[]
+export declare function getConnectedNodes<
+  N extends
+    | Node
+    | {
+        id: string
+      }
+    | string,
+>(nodes: N[], edges: Edge[]): N[]
+export declare function getTransformForBounds(
+  bounds: Rect,
+  width: number,
+  height: number,
+  minZoom: number,
+  maxZoom: number,
+  padding?: number,
+  offset?: {
+    x?: number
+    y?: number
+  },
+): ViewportTransform
+export declare function getXYZPos(parentPos: XYZPosition, computedPosition: XYZPosition): XYZPosition
+export declare function isParentSelected(node: GraphNode, findNode: Actions['findNode']): boolean
+export declare function getMarkerId(marker: EdgeMarkerType | undefined, vueFlowId?: string): string
+export declare function wheelDelta(event: any): number

node_modules/@vue-flow/core/dist/utils/handle.d.ts

@@ -0,0 +1,60 @@
+import type { ConnectionMode, Position } from '../types'
+import type {
+  Actions,
+  ConnectionHandle,
+  ConnectionStatus,
+  GraphEdge,
+  GraphNode,
+  HandleElement,
+  HandleType,
+  IsValidParams,
+  NodeHandleBounds,
+  NodeLookup,
+  Result,
+  XYPosition,
+} from '../types'
+
+export declare function resetRecentHandle(handleDomNode: Element): void
+export declare function getHandles(
+  node: GraphNode,
+  handleBounds: NodeHandleBounds,
+  type: HandleType,
+  currentHandle: string,
+): ConnectionHandle[]
+export declare function getClosestHandle(
+  position: XYPosition,
+  connectionRadius: number,
+  nodeLookup: NodeLookup,
+  fromHandle: {
+    nodeId: string
+    type: HandleType
+    id?: string | null
+  },
+): HandleElement | null
+export declare function isValidHandle(
+  event: MouseEvent | TouchEvent,
+  { handle, connectionMode, fromNodeId, fromHandleId, fromType, doc, lib, flowId, isValidConnection }: IsValidParams,
+  edges: GraphEdge[],
+  nodes: GraphNode[],
+  findNode: Actions['findNode'],
+): Result
+export declare function getHandleType(edgeUpdaterType: HandleType | undefined, handleDomNode: Element | null): HandleType | null
+export declare function getConnectionStatus(
+  isInsideConnectionRadius: boolean,
+  isHandleValid: boolean | null,
+): ConnectionStatus | null
+export declare function isConnectionValid(isInsideConnectionRadius: boolean, isHandleValid: boolean): boolean | null
+export declare function getHandle(
+  nodeId: string,
+  handleType: HandleType,
+  handleId: string | null,
+  nodeLookup: NodeLookup,
+  connectionMode: ConnectionMode,
+  withAbsolutePosition?: boolean,
+): HandleElement | null
+export declare const oppositePosition: {
+  left: Position
+  right: Position
+  top: Position
+  bottom: Position
+}

node_modules/@vue-flow/core/dist/utils/index.d.ts

@@ -0,0 +1,13 @@
+export * from './a11y'
+export * from './autopan'
+export * from './changes'
+export * from './createExtendedEventHook'
+export * from './drag'
+export * from './edge'
+export * from './errors'
+export * from './general'
+export * from './graph'
+export * from './handle'
+export * from './log'
+export * from './node'
+export * from './store'

node_modules/@vue-flow/core/dist/utils/log.d.ts

@@ -0,0 +1,2 @@
+export declare function warn(message: string, ...args: any[]): void
+export declare function isDev(): boolean

node_modules/@vue-flow/core/dist/utils/node.d.ts

@@ -0,0 +1,19 @@
+import type { Ref } from 'vue'
+import type { Actions, GraphNode, HandleElement, HandleType } from '../types'
+
+export declare function getHandleBounds(
+  type: HandleType,
+  nodeElement: HTMLDivElement,
+  nodeBounds: DOMRect,
+  zoom: number,
+  nodeId: string,
+): HandleElement[] | null
+export declare function handleNodeClick(
+  node: GraphNode,
+  multiSelectionActive: boolean,
+  addSelectedNodes: Actions['addSelectedNodes'],
+  removeSelectedNodes: Actions['removeSelectedNodes'],
+  nodesSelectionActive: Ref<boolean>,
+  unselect: boolean | undefined,
+  nodeEl: HTMLDivElement,
+): void

node_modules/@vue-flow/core/dist/utils/storage.d.ts

@@ -0,0 +1,18 @@
+import type { FlowOptions, VueFlowStore } from '../types'
+
+/**
+ * @deprecated will be removed in the next major and replaced with a ctx based solution similar to `<ReactFlowProvider>`
+ *
+ * Stores all existing VueFlow state instances
+ */
+export declare class Storage {
+  currentId: number
+  flows: Map<string, VueFlowStore>
+  static instance: Storage
+  static getInstance(): Storage
+  set(id: string, flow: VueFlowStore): Map<string, VueFlowStore>
+  get(id: string): VueFlowStore | undefined
+  remove(id: string): boolean
+  create(id: string, preloadedState?: FlowOptions): VueFlowStore
+  getId(): string
+}

node_modules/@vue-flow/core/dist/utils/store.d.ts

@@ -0,0 +1,268 @@
+import type {
+  Actions,
+  Connection,
+  ConnectionLookup,
+  DefaultEdgeOptions,
+  Edge,
+  EdgeLookup,
+  GraphEdge,
+  GraphNode,
+  Node,
+  NodeConnection,
+  State,
+  ValidConnectionFunc,
+  VueFlowStore,
+} from '../types'
+
+type NonUndefined<T> = T extends undefined ? never : T
+export declare function isDef<T>(val: T): val is NonUndefined<T>
+export declare function addEdgeToStore(
+  edgeParams: Edge | Connection,
+  edges: Edge[],
+  triggerError: State['hooks']['error']['trigger'],
+  defaultEdgeOptions?: DefaultEdgeOptions,
+): GraphEdge | false
+export declare function updateEdgeAction(
+  edge: GraphEdge,
+  newConnection: Connection,
+  prevEdge: GraphEdge | undefined,
+  shouldReplaceId: boolean,
+  triggerError: State['hooks']['error']['trigger'],
+):
+  | false
+  | {
+      id: string
+      source: string
+      target: string
+      sourceHandle: string | null | undefined
+      targetHandle: string | null | undefined
+      label?:
+        | string
+        | import('vue').VNode<
+            import('vue').RendererNode,
+            import('vue').RendererElement,
+            {
+              [key: string]: any
+            }
+          >
+        | import('vue').Component<import('../types').EdgeTextProps>
+        | undefined
+      type: string
+      animated?: boolean | undefined
+      markerStart?: import('../types').EdgeMarkerType | undefined
+      markerEnd?: import('../types').EdgeMarkerType | undefined
+      updatable?: import('../types').EdgeUpdatable | undefined
+      selectable?: boolean | undefined
+      focusable?: boolean | undefined
+      deletable?: boolean | undefined
+      class?: string | string[] | Record<string, any> | import('../types').ClassFunc<GraphEdge<any, any, string>> | undefined
+      style?: import('../types').Styles | import('../types').StyleFunc<GraphEdge<any, any, string>> | undefined
+      hidden?: boolean | undefined
+      interactionWidth?: number | undefined
+      template?: import('../types').EdgeComponent | undefined
+      data: any
+      events: Partial<import('../types').EdgeEventsHandler<any>>
+      zIndex?: number | undefined
+      ariaLabel?: string | null | undefined
+      domAttributes?:
+        | Omit<
+            import('vue').SVGAttributes,
+            | 'id'
+            | 'style'
+            | 'className'
+            | 'role'
+            | 'aria-label'
+            | 'onClick'
+            | 'onMouseenter'
+            | 'onMousemove'
+            | 'onMouseleave'
+            | 'onContextmenu'
+            | 'onDblclick'
+            | 'onKeyDown'
+          >
+        | undefined
+      labelStyle?: import('vue').CSSProperties | undefined
+      labelShowBg?: boolean | undefined
+      labelBgStyle?: import('vue').CSSProperties | undefined
+      labelBgPadding?: [number, number] | undefined
+      labelBgBorderRadius?: number | undefined
+      selected: boolean
+      sourceNode: GraphNode<any, any, string>
+      targetNode: GraphNode<any, any, string>
+      sourceX: number
+      sourceY: number
+      targetX: number
+      targetY: number
+    }
+  | {
+      id: string
+      source: string
+      target: string
+      sourceHandle: string | null | undefined
+      targetHandle: string | null | undefined
+      label?:
+        | string
+        | import('vue').VNode<
+            import('vue').RendererNode,
+            import('vue').RendererElement,
+            {
+              [key: string]: any
+            }
+          >
+        | import('vue').Component<import('../types').EdgeTextProps>
+        | undefined
+      type: 'smoothstep'
+      animated?: boolean | undefined
+      markerStart?: import('../types').EdgeMarkerType | undefined
+      markerEnd?: import('../types').EdgeMarkerType | undefined
+      updatable?: import('../types').EdgeUpdatable | undefined
+      selectable?: boolean | undefined
+      focusable?: boolean | undefined
+      deletable?: boolean | undefined
+      class?: string | string[] | Record<string, any> | import('../types').ClassFunc<GraphEdge<any, any, string>> | undefined
+      style?: import('../types').Styles | import('../types').StyleFunc<GraphEdge<any, any, string>> | undefined
+      hidden?: boolean | undefined
+      interactionWidth?: number | undefined
+      template?: import('../types').EdgeComponent | undefined
+      data: any
+      events: Partial<import('../types').EdgeEventsHandler<any>>
+      zIndex?: number | undefined
+      ariaLabel?: string | null | undefined
+      domAttributes?:
+        | Omit<
+            import('vue').SVGAttributes,
+            | 'id'
+            | 'style'
+            | 'className'
+            | 'role'
+            | 'aria-label'
+            | 'onClick'
+            | 'onMouseenter'
+            | 'onMousemove'
+            | 'onMouseleave'
+            | 'onContextmenu'
+            | 'onDblclick'
+            | 'onKeyDown'
+          >
+        | undefined
+      labelStyle?: import('vue').CSSProperties | undefined
+      labelShowBg?: boolean | undefined
+      labelBgStyle?: import('vue').CSSProperties | undefined
+      labelBgPadding?: [number, number] | undefined
+      labelBgBorderRadius?: number | undefined
+      pathOptions?: import('../types').SmoothStepPathOptions | undefined
+      selected: boolean
+      sourceNode: GraphNode<any, any, string>
+      targetNode: GraphNode<any, any, string>
+      sourceX: number
+      sourceY: number
+      targetX: number
+      targetY: number
+    }
+  | {
+      id: string
+      source: string
+      target: string
+      sourceHandle: string | null | undefined
+      targetHandle: string | null | undefined
+      label?:
+        | string
+        | import('vue').VNode<
+            import('vue').RendererNode,
+            import('vue').RendererElement,
+            {
+              [key: string]: any
+            }
+          >
+        | import('vue').Component<import('../types').EdgeTextProps>
+        | undefined
+      type: 'default'
+      animated?: boolean | undefined
+      markerStart?: import('../types').EdgeMarkerType | undefined
+      markerEnd?: import('../types').EdgeMarkerType | undefined
+      updatable?: import('../types').EdgeUpdatable | undefined
+      selectable?: boolean | undefined
+      focusable?: boolean | undefined
+      deletable?: boolean | undefined
+      class?: string | string[] | Record<string, any> | import('../types').ClassFunc<GraphEdge<any, any, string>> | undefined
+      style?: import('../types').Styles | import('../types').StyleFunc<GraphEdge<any, any, string>> | undefined
+      hidden?: boolean | undefined
+      interactionWidth?: number | undefined
+      template?: import('../types').EdgeComponent | undefined
+      data: any
+      events: Partial<import('../types').EdgeEventsHandler<any>>
+      zIndex?: number | undefined
+      ariaLabel?: string | null | undefined
+      domAttributes?:
+        | Omit<
+            import('vue').SVGAttributes,
+            | 'id'
+            | 'style'
+            | 'className'
+            | 'role'
+            | 'aria-label'
+            | 'onClick'
+            | 'onMouseenter'
+            | 'onMousemove'
+            | 'onMouseleave'
+            | 'onContextmenu'
+            | 'onDblclick'
+            | 'onKeyDown'
+          >
+        | undefined
+      labelStyle?: import('vue').CSSProperties | undefined
+      labelShowBg?: boolean | undefined
+      labelBgStyle?: import('vue').CSSProperties | undefined
+      labelBgPadding?: [number, number] | undefined
+      labelBgBorderRadius?: number | undefined
+      pathOptions?: import('../types').BezierPathOptions | undefined
+      selected: boolean
+      sourceNode: GraphNode<any, any, string>
+      targetNode: GraphNode<any, any, string>
+      sourceX: number
+      sourceY: number
+      targetX: number
+      targetY: number
+    }
+export declare function createGraphNodes(
+  nodes: Node[],
+  findNode: Actions['findNode'],
+  triggerError: State['hooks']['error']['trigger'],
+): GraphNode<any, any, string>[]
+export declare function updateConnectionLookup(
+  connectionLookup: ConnectionLookup,
+  edgeLookup: EdgeLookup,
+  edges: GraphEdge[],
+): void
+/**
+ * We call the callback for all connections in a that are not in b
+ *
+ * @internal
+ */
+export declare function handleConnectionChange(
+  a: Map<string, NodeConnection>,
+  b: Map<string, NodeConnection>,
+  cb?: (diff: NodeConnection[]) => void,
+): void
+/**
+ * @internal
+ */
+export declare function areConnectionMapsEqual(a?: Map<string, Connection>, b?: Map<string, Connection>): boolean
+/**
+ * @internal
+ */
+export declare function areSetsEqual(a: Set<string>, b: Set<string>): boolean
+/**
+ * @internal
+ */
+export declare function createGraphEdges(
+  nextEdges: (Edge | Connection)[],
+  isValidConnection: ValidConnectionFunc | null,
+  findNode: Actions['findNode'],
+  findEdge: Actions['findEdge'],
+  onError: VueFlowStore['emits']['error'],
+  defaultEdgeOptions: DefaultEdgeOptions | undefined,
+  nodes: GraphNode[],
+  edges: GraphEdge[],
+): GraphEdge[]
+export {}