@xyflow/vue 2.0.0-next.0

package/dist/index.d.ts

@@ -0,0 +1,2208 @@
+import { Align, AriaLabelConfig, AriaLabelConfig as AriaLabelConfig$1, ColorMode, ColorMode as ColorMode$1, ColorModeClass, Connection, Connection as Connection$1, ConnectionLineType, ConnectionLineType as ConnectionLineType$1, ConnectionMode, ConnectionMode as ConnectionMode$1, ControlLinePosition, ControlLinePosition as ControlLinePosition$1, ControlPosition, ControlPosition as ControlPosition$1, CoordinateExtent, CoordinateExtent as CoordinateExtent$1, Dimensions, Dimensions as Dimensions$1, DistributivePick, EdgeBase, EdgeRemoveChange, EdgeRemoveChange as EdgeRemoveChange$1, EdgeSelectionChange, EdgeSelectionChange as EdgeSelectionChange$1, FinalConnectionState, FinalConnectionState as FinalConnectionState$1, FitViewOptionsBase, FitViewOptionsBase as FitViewOptions, GetViewport, GetViewport as GetViewport$1, HandleType, HandleType as HandleType$1, InternalNodeBase, NodeBase, NodeConnection, NodeConnection as NodeConnection$1, NodeDimensionChange, NodeDimensionChange as NodeDimensionChange$1, NodePositionChange, NodePositionChange as NodePositionChange$1, NodeRemoveChange, NodeRemoveChange as NodeRemoveChange$1, NodeSelectionChange, NodeSelectionChange as NodeSelectionChange$1, Padding, Padding as Padding$1, PaddingUnit, PaddingWithUnit, PanOnScrollMode, PanOnScrollMode as PanOnScrollMode$1, PanZoomInstance, PanelPosition, Position, Position as Position$1, Project, Project as Project$1, Rect, Rect as Rect$1, ResizeControlVariant, ResizeControlVariant as ResizeControlVariant$1, ResizeControlVariant as ResizeControlVariant$2, ResizeDragEvent, ResizeDragEvent as ResizeDragEvent$1, ResizeParams, ResizeParams as ResizeParams$1, ResizeParamsWithDirection, ResizeParamsWithDirection as ResizeParamsWithDirection$1, SelectionMode, SelectionMode as SelectionMode$1, SelectionRect, SelectionRect as SelectionRect$1, SetCenter, SetCenter as SetCenter$1, SetCenterOptions, SetViewport, SetViewport as SetViewport$1, ShouldResize, ShouldResize as ShouldResize$1, SnapGrid, SnapGrid as SnapGrid$1, Transform, Viewport, Viewport as Viewport$1, ViewportHelperFunctionOptions, ViewportHelperFunctionOptions as ViewportHelperFunctionOptions$1, XYPosition, XYPosition as XYPosition$1, ZIndexMode, ZIndexMode as ZIndexMode$1, ZoomInOut, ZoomInOut as ZoomInOut$1, ZoomTo, ZoomTo as ZoomTo$1, clamp, getBezierEdgeCenter, getBezierPath, getBoundsOfBoxes, getBoundsOfRects, getConnectedEdges, getConnectionStatus, getIncomers, getMarkerId, getNodesBounds, getNodesInside, getOutgoers, getSmoothStepPath, getStraightPath, getViewportForBounds, isEdgeBase, isInternalNodeBase, isMacOs, isNodeBase, pointToRendererPoint, rendererPointToPoint } from "@xyflow/system";
+import { CSSProperties, Component, ComputedRef, DefineComponent, HTMLAttributes, InjectionKey, MaybeRefOrGetter, SVGAttributes, ToRefs, VNode } from "vue";
+import { KeyFilter } from "@vueuse/core";
+
+//#region src/components/Background/types.d.ts
+/**
+ * The Background can be either a dotted one or a lined one
+ *
+ * @default 'dots'
+ */
+type BackgroundVariant = 'dots' | 'lines';
+interface BackgroundProps {
+  /**
+   * `<Background>` component id
+   *
+   * This is necessary when you have multiple flows with backgrounds visible at the same time.
+   * If no id is explicitly assigned, an auto-generated one is used.
+   *
+   * @default `pattern-${vueFlowId}${id ? `-${id}` : ''}`
+   */
+  id?: string;
+  /**
+   * The background pattern variant {@link BackgroundVariant}
+   *
+   * @default 'dots'
+   */
+  variant?: BackgroundVariant;
+  /**
+   * The background pattern gap
+   *
+   * Can be either a number or [xGap: number, yGap: number], defining the gap on the X and Y axis respectively
+   *
+   * @default 20
+   */
+  gap?: number | number[];
+  /**
+   * Background pattern size
+   *
+   * @default 1
+   */
+  size?: number;
+  /**
+   * @default 1
+   */
+  lineWidth?: number;
+  /**
+   * The background pattern color
+   *
+   * This only changes the color of the *pattern*, not the background color itself.
+   *
+   * If you want to change the background color itself, you can apply a bg-color to the `<VueFlow>` element instead
+   */
+  color?: string;
+  /**
+   * Background x-coordinate (offset x)
+   *
+   * @default 0
+   */
+  x?: number;
+  /**
+   * Background y-coordinate (offset y)
+   * @default 0
+   */
+  y?: number;
+  /**
+   * Background pattern offset
+   *
+   * @default 0
+   */
+  offset?: number | [number, number];
+}
+//#endregion
+//#region src/components/Background/Background.vue.d.ts
+declare const _default: typeof __VLS_export$14;
+declare const __VLS_export$14: __VLS_WithSlots$10<import("vue").DefineComponent<BackgroundProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<BackgroundProps> & Readonly<{}>, {
+  x: number;
+  y: number;
+  offset: number | [number, number];
+  size: number;
+  variant: BackgroundVariant;
+  gap: number | number[];
+  lineWidth: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  'pattern-container'?: (props: {
+    id: string;
+  }) => any;
+} & {
+  pattern?: (props: {}) => any;
+} & {
+  default?: (props: {
+    id: string;
+  }) => any;
+}>;
+type __VLS_WithSlots$10<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Controls/ControlButton.vue.d.ts
+declare const _default$2: typeof __VLS_export$13;
+declare const __VLS_export$13: __VLS_WithSlots$9<import("vue").DefineComponent<{
+  disabled?: boolean; /** accessible label; applied as both `aria-label` and `title` (mirrors xyflow) */
+  label?: string;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  click: (payload: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<{
+  disabled?: boolean; /** accessible label; applied as both `aria-label` and `title` (mirrors xyflow) */
+  label?: string;
+}> & Readonly<{
+  onClick?: ((payload: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$9<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Edges/BaseEdge.vue.d.ts
+declare const _default$1: typeof __VLS_export$12;
+declare const __VLS_export$12: import("vue").DefineComponent<BaseEdgeProps, {
+  pathEl: import("vue").ShallowRef<SVGPathElement | null, SVGPathElement | null>;
+  interactionEl: import("vue").ShallowRef<SVGPathElement | null, SVGPathElement | null>;
+  labelEl: import("vue").ShallowRef<SVGGElement | null, SVGGElement | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<BaseEdgeProps> & Readonly<{}>, {
+  interactionWidth: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+//#endregion
+//#region src/components/Edges/BezierEdge.d.ts
+declare const BezierEdge: import("vue").DefineComponent<BezierEdgeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<BezierEdgeProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+//#endregion
+//#region src/components/Edges/EdgeLabelRenderer.vue.d.ts
+declare const _default$4: typeof __VLS_export$11;
+declare const __VLS_export$11: __VLS_WithSlots$8<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$8<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Edges/EdgeText.vue.d.ts
+declare const _default$5: typeof __VLS_export$10;
+declare const __VLS_export$10: __VLS_WithSlots$7<import("vue").DefineComponent<EdgeTextProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<EdgeTextProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$7<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Edges/SimpleBezierEdge.d.ts
+interface GetSimpleBezierPathParams {
+  sourceX: number;
+  sourceY: number;
+  sourcePosition?: Position$1;
+  targetX: number;
+  targetY: number;
+  targetPosition?: Position$1;
+}
+/**
+ * Get a simple bezier path from source to target handle (no curvature)
+ * @public
+ *
+ * @param simpleBezierPathParams
+ * @param simpleBezierPathParams.sourceX - The x position of the source handle
+ * @param simpleBezierPathParams.sourceY - The y position of the source handle
+ * @param simpleBezierPathParams.sourcePosition - The position of the source handle (default: Position.Bottom)
+ * @param simpleBezierPathParams.targetX - The x position of the target handle
+ * @param simpleBezierPathParams.targetY - The y position of the target handle
+ * @param simpleBezierPathParams.targetPosition - The position of the target handle (default: Position.Top)
+ * @returns A path string you can use in an SVG, the labelX and labelY position (center of path) and offsetX, offsetY between source handle and label
+ */
+declare function getSimpleBezierPath({
+  sourceX,
+  sourceY,
+  sourcePosition,
+  targetX,
+  targetY,
+  targetPosition
+}: GetSimpleBezierPathParams): [path: string, labelX: number, labelY: number, offsetX: number, offsetY: number];
+declare const SimpleBezierEdge: import("vue").DefineComponent<SimpleBezierEdgeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SimpleBezierEdgeProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+//#endregion
+//#region src/components/Edges/SmoothStepEdge.d.ts
+declare const SmoothStepEdge: import("vue").DefineComponent<SmoothStepEdgeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SmoothStepEdgeProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+//#endregion
+//#region src/components/Edges/StepEdge.d.ts
+declare const StepEdge: import("vue").DefineComponent<StepEdgeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<StepEdgeProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+//#endregion
+//#region src/components/Edges/StraightEdge.d.ts
+declare const StraightEdge: import("vue").DefineComponent<StraightEdgeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<StraightEdgeProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+//#endregion
+//#region src/components/Handle/Handle.vue.d.ts
+declare const _default$6: typeof __VLS_export$9;
+declare const __VLS_export$9: __VLS_WithSlots$6<import("vue").DefineComponent<HandleProps, {
+  handleClick: (event: MouseEvent) => void;
+  handlePointerDown: (event: MouseTouchEvent) => void;
+  onClick: (event: MouseEvent) => void;
+  onPointerDown: (event: MouseEvent | TouchEvent) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HandleProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {
+    id: string | undefined;
+  }) => any;
+}>;
+type __VLS_WithSlots$6<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/utils/changes.d.ts
+/**
+ * Apply element changes IMMUTABLY (xyflow/react `applyNodeChanges` semantics): returns a NEW array where
+ * changed elements are NEW objects and unchanged elements are reused by reference. Immutability is required
+ * by the node split — the store re-adopts the result via `adoptUserNodes`, whose `checkEquality` reuses the
+ * existing `InternalNode` when the user-node reference is unchanged; mutating in place would keep the same
+ * reference and re-adopt a stale internal node. Reusing unchanged refs keeps re-adoption O(changed).
+ *
+ * `position`/`dimensions` changes are gated on `isNode` (user `Node`s have no `internals`, so the old
+ * `isInternalNode` guard would skip them) — edges never receive those change types anyway.
+ */
+declare function applyChanges<T extends Node | Edge = Node | Edge, C extends ElementChange = (T extends InternalNode ? NodeChange : EdgeChange)>(changes: C[], elements: T[]): T[];
+/** @deprecated Prefer the store instance's apply methods (from `useVueFlow` or the `onInit` instance). */
+declare function applyEdgeChanges(changes: EdgeChange[], edges: Edge[]): Edge[];
+/** @deprecated Prefer the store instance's apply methods (from `useVueFlow` or the `onInit` instance). */
+declare function applyNodeChanges(changes: NodeChange[], nodes: InternalNode[]): InternalNode[];
+//#endregion
+//#region src/utils/createExtendedEventHook.d.ts
+/**
+ * vue-flow's own event-hook types. We intentionally do NOT reuse `@vueuse/core`'s `EventHook*` types:
+ * since v14 its `Callback<T>` spreads array payloads (for `T extends any[]` it becomes
+ * `(...param: T) => void`), which is incompatible with vue-flow's single-array-payload hooks — e.g.
+ * `onNodesChange((changes: NodeChange[]) => void)` and `trigger(changes)`. Owning these types keeps the
+ * public hook contract stable regardless of `@vueuse/core`'s internal callback variance.
+ */
+type EventHookOn<T = any> = (fn: (param: T) => void) => {
+  off: () => void;
+};
+type EventHookOff<T = any> = (fn: (param: T) => void) => void;
+type EventHookTrigger<T = any> = (param: T) => Promise<unknown[]>;
+interface EventHook<T = any> {
+  on: EventHookOn<T>;
+  off: EventHookOff<T>;
+  trigger: EventHookTrigger<T>;
+}
+interface EventHookExtended<T> extends EventHook<T> {
+  /** true if any user listeners are registered (emitter ignored) */
+  hasListeners: () => boolean;
+  /** current user listeners (read-only; do not mutate externally) */
+  listeners: ReadonlySet<(param: T) => void>;
+  /** wire a single external emitter (e.g., for `emit`) */
+  setEmitter: (fn: (param: T) => void) => void;
+  /** remove the external emitter */
+  removeEmitter: () => void;
+  /** wire a function to detect if any emit listeners exist (e.g., for `$listeners` in Vue 2) */
+  setHasEmitListeners: (fn: () => boolean) => void;
+  /** remove the emit listeners detector */
+  removeHasEmitListeners: () => void;
+}
+//#endregion
+//#region src/utils/errors.d.ts
+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_MISSING = "EDGE_SOURCE_TARGET_MISSING",
+  USE_VUE_FLOW_OUTSIDE_PROVIDER = "USE_VUE_FLOW_OUTSIDE_PROVIDER"
+}
+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_MISSING: (id: string, source: string, target: string) => string;
+  readonly EDGE_NOT_FOUND: (id: string) => string;
+  readonly USE_VUE_FLOW_OUTSIDE_PROVIDER: () => string;
+};
+type ErrorArgs<T extends ErrorCode> = (typeof messages)[T] extends ((...args: any[]) => string) ? Parameters<(typeof messages)[T]> : never;
+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);
+}
+declare function isErrorOfType<T extends ErrorCode>(error: VueFlowError, code: T): error is VueFlowError<T>;
+//#endregion
+//#region src/utils/graph.d.ts
+declare function isEdge<EdgeType extends Edge = Edge>(element: unknown): element is EdgeType;
+declare function isNode<NodeType extends Node = Node>(element: unknown): element is NodeType;
+declare function isInternalNode<NodeType extends Node = Node>(element: unknown): element is InternalNode<NodeType>;
+declare function connectionExists(edge: Edge | Connection$1, edges: Edge[]): boolean;
+//#endregion
+//#region src/types/handle.d.ts
+interface HandleElement extends XYPosition$1, Dimensions$1 {
+  id?: string | null;
+  position: Position$1;
+  type: HandleType$1;
+  nodeId: string;
+}
+interface ConnectingHandle extends XYPosition$1 {
+  nodeId: string;
+  type: HandleType$1;
+  id?: string | null;
+  position: Position$1;
+}
+/** A valid connection function can determine if an attempted connection is valid or not, i.e. abort creating a new edge */
+type ValidConnectionFunc = (connection: Connection$1, elements: {
+  edges: Edge[];
+  nodes: Node[];
+  sourceNode: InternalNode;
+  targetNode: InternalNode;
+}) => boolean;
+type HandleConnectableFunc = (node: InternalNode, connectedEdges: Edge[]) => boolean;
+/**
+ * set to true to allow unlimited connections,
+ * single for only one connection
+ * or use a cb function to determine connect-ability
+ *
+ * if set to single and the handle already has more than one connection, it will act the same as setting it to false
+ */
+type HandleConnectable = boolean | number | 'single' | HandleConnectableFunc;
+interface HandleProps {
+  /** Unique id of handle element */
+  id?: string;
+  /** Handle type (source / target) {@link HandleType} */
+  type?: HandleType$1;
+  /** Handle position (top, bottom, left, right) {@link Position} */
+  position?: Position$1;
+  /** A valid connection func {@link ValidConnectionFunc} */
+  isValidConnection?: ValidConnectionFunc;
+  /** Enable/disable connecting to handle altogether */
+  isConnectable?: HandleConnectable;
+  /** Can this handle be used to *start* a connection */
+  connectableStart?: boolean;
+  /** Can this handle be used to *end* a connection */
+  connectableEnd?: boolean;
+}
+interface IsValidParams {
+  handle: ConnectingHandle | null;
+  connectionMode: ConnectionMode$1;
+  fromNodeId: string;
+  fromHandleId: string | null;
+  fromType: HandleType$1;
+  isValidConnection?: ValidConnectionFunc;
+  doc: Document | ShadowRoot;
+  lib: string;
+  flowId: string | null;
+}
+interface Result {
+  handleDomNode: Element | null;
+  isValid: boolean;
+  connection: Connection$1 | null;
+  toHandle: ConnectingHandle | null;
+}
+//#endregion
+//#region src/types/connection.d.ts
+interface ConnectionLineOptions {
+  type?: ConnectionLineType$1;
+  style?: CSSProperties;
+  class?: ClassValue;
+  markerEnd?: EdgeMarkerType;
+  markerStart?: EdgeMarkerType;
+}
+type Connector = (params: Connection$1) => Promise<(Connection$1 & Partial<Edge>) | false> | ((Connection$1 & Partial<Edge>) | false);
+type ConnectionStatus = 'valid' | 'invalid';
+/**
+ * An ongoing connection, mirroring xyflow/react's `ConnectionState` (returned by `useConnection`).
+ * Handles are vue-flow `ConnectingHandle`s and nodes are `InternalNode`s (the resolved `InternalNode`s).
+ */
+interface ConnectionInProgress<NodeType extends Node = Node> {
+  inProgress: true;
+  /** `true`/`false` when over a handle or inside the connection radius, otherwise `null` */
+  isValid: boolean | null;
+  /** xy start position of the connection */
+  from: XYPosition$1;
+  /** the handle the connection started from */
+  fromHandle: ConnectingHandle;
+  /** the side of the start handle */
+  fromPosition: Position$1;
+  /** the node the connection started from */
+  fromNode: InternalNode<NodeType>;
+  /** xy end position of the connection (the current pointer position) */
+  to: XYPosition$1;
+  /** the handle the connection currently ends on, or `null` */
+  toHandle: ConnectingHandle | null;
+  /** the side of the end handle, or `null` */
+  toPosition: Position$1 | null;
+  /** the node the connection currently ends on, or `null` */
+  toNode: InternalNode<NodeType> | null;
+  /** the current pointer position */
+  pointer: XYPosition$1;
+}
+/** No connection in progress — the resting `ConnectionState`. */
+interface NoConnection {
+  inProgress: false;
+  isValid: null;
+  from: null;
+  fromHandle: null;
+  fromPosition: null;
+  fromNode: null;
+  to: null;
+  toHandle: null;
+  toPosition: null;
+  toNode: null;
+  pointer: null;
+}
+/**
+ * The full connection state bundled for `useConnection`, mirroring xyflow/react's `ConnectionState`.
+ */
+type ConnectionState<NodeType extends Node = Node> = ConnectionInProgress<NodeType> | NoConnection;
+/** The source nodes params when connection is initiated */
+interface OnConnectStartParams {
+  /** Source node id */
+  nodeId?: string;
+  /** Source handle id */
+  handleId: string | null;
+  /** Source handle type */
+  handleType?: HandleType$1;
+}
+interface ConnectionLineProps<NodeType extends Node = Node> {
+  /** X start position of the connection line */
+  fromX: number;
+  /** Y start position of the connection line */
+  fromY: number;
+  /** the side of the start handle */
+  fromPosition: Position$1;
+  /** X end position of the connection line (the current pointer) */
+  toX: number;
+  /** Y end position of the connection line (the current pointer) */
+  toY: number;
+  /** the side of the end handle */
+  toPosition: Position$1;
+  /** the node the connection started from */
+  fromNode: InternalNode<NodeType>;
+  /** the handle the connection started from (not the DOM element) */
+  fromHandle: HandleElement | null;
+  /** the node the connection currently ends on, or `null` */
+  toNode: InternalNode<NodeType> | null;
+  /** the handle the connection currently ends on (not the DOM element), or `null` */
+  toHandle: HandleElement | null;
+  /** marker url */
+  markerStart?: string;
+  /** marker url */
+  markerEnd?: string;
+  /** status of the connection (valid, invalid) */
+  connectionStatus: ConnectionStatus | null;
+  /** the raw pointer position in flow coordinates (unsnapped, unlike `toX`/`toY`) */
+  pointer: XYPosition$1;
+}
+type ConnectionLookup = Map<string, Map<string, NodeConnection$1>>;
+//#endregion
+//#region src/composables/storeToRefs.d.ts
+/**
+ * Destructure the reactive state from {@link useStore} into refs without losing reactivity (Pinia's
+ * `storeToRefs`). Destructuring the reactive state object directly hands back plain values for
+ * scalar/array fields; this projects them to refs instead:
+ *
+ * ```ts
+ * const { nodes, transform } = storeToRefs(useStore()) // Ref<Node[]>, Ref<Transform>
+ * ```
+ *
+ * Reference-type fields (the `nodeLookup`/`parentLookup`/`edgeLookup`/`connectionLookup` Maps) stay
+ * reactive when destructured straight off `useStore()` — you only need this for the value-type fields.
+ *
+ * @public
+ */
+declare function storeToRefs<NodeType extends Node = Node, EdgeType extends Edge = Edge>(store: VueFlowState<NodeType, EdgeType>): ToRefs<VueFlowState<NodeType, EdgeType>>;
+//#endregion
+//#region src/composables/useEdge.d.ts
+/**
+ * Composable that provides access to an edge object and it's dom element
+ *
+ * If no edge id is provided, the edge id is injected from context
+ *
+ * If you do not provide an id, this composable has to be called in a child of your custom edge component, or it will throw
+ *
+ * @public
+ * @param id - The id of the edge to access
+ * @returns the edge id, the edge (a `ComputedRef`) and the edge dom element
+ */
+declare function useEdge<EdgeType extends Edge = Edge>(id?: string): {
+  id: string;
+  edge: import("vue").ComputedRef<EdgeType | undefined>;
+  edgeEl: import("vue").ShallowRef<SVGElement | null>;
+};
+//#endregion
+//#region src/composables/useHandle.d.ts
+interface UseHandleProps {
+  handleId: MaybeRefOrGetter<string | null>;
+  nodeId: MaybeRefOrGetter<string>;
+  type: MaybeRefOrGetter<HandleType$1>;
+  isValidConnection?: MaybeRefOrGetter<ValidConnectionFunc | null>;
+  reconnectHandleType?: MaybeRefOrGetter<HandleType$1>;
+  onReconnectStart?: (event: MouseTouchEvent) => void;
+  onReconnect?: (event: MouseTouchEvent, connection: Connection$1) => void;
+  onReconnectEnd?: (event: MouseTouchEvent, connectionState: FinalConnectionState$1<InternalNode>) => void;
+}
+/**
+ * Connection-drag composable. Drag-to-connect is delegated to `@xyflow/system`'s `XYHandle` instance
+ * (same pattern as `XYDrag` / `XYResizer`). Click-to-connect stays vue-flow specific because the click
+ * path interacts with the richer `ValidConnectionFunc` signature (which receives full source/target
+ * `InternalNode`s on top of the bare `Connection`).
+ *
+ * Generally it's recommended to use the `<Handle />` component instead of this composable.
+ *
+ * @public
+ */
+declare function useHandle({
+  handleId,
+  nodeId,
+  type,
+  isValidConnection,
+  reconnectHandleType,
+  onReconnectStart,
+  onReconnect,
+  onReconnectEnd
+}: UseHandleProps): {
+  handlePointerDown: (event: MouseTouchEvent) => void;
+  handleClick: (event: MouseEvent) => void;
+};
+//#endregion
+//#region src/composables/useInternalNode.d.ts
+/**
+ * Access the enriched {@link InternalNode} (store-computed `internals.{positionAbsolute, z, handleBounds}` +
+ * authoritative `measured`) for an id, as a `computed` that re-resolves whenever the store re-adopts the node.
+ *
+ * Mirrors xyflow/react's `useInternalNode`. If no id is given it is read from node context (call inside a
+ * custom node). Use {@link useNode} for the user-facing node + dom element + connected edges.
+ *
+ * The id accepts a ref/getter so it can track a reactive source — e.g. a custom edge resolving its
+ * endpoint with `useInternalNode(() => props.source)` stays correct after a reconnect changes the source.
+ *
+ * @public
+ * @param id - The id of the node to access (a value, ref, or getter; defaults to the node context id)
+ */
+declare function useInternalNode<NodeType extends Node = Node>(id?: MaybeRefOrGetter<string | undefined>): import("vue").ComputedRef<InternalNode<NodeType> | undefined>;
+//#endregion
+//#region src/composables/useKeyPress.d.ts
+interface UseKeyPressOptions {
+  target?: MaybeRefOrGetter<EventTarget | null | undefined>;
+  actInsideInputWithModifier?: MaybeRefOrGetter<boolean>;
+  preventDefault?: MaybeRefOrGetter<boolean>;
+}
+/**
+ * Composable that returns a boolean value if a key is pressed
+ *
+ * @public
+ * @param keyFilter - Can be a boolean, a string, an array of strings or a function that returns a boolean. If it's a boolean, it will act as if the key is always pressed. If it's a string, it will return true if a key matching that string is pressed. If it's an array of strings, it will return true if any of the strings match a key being pressed, or a combination (e.g. ['ctrl+a', 'ctrl+b'])
+ * @param options - Options object
+ */
+declare function useKeyPress(keyFilter: MaybeRefOrGetter<KeyFilter | boolean | null>, options?: UseKeyPressOptions): import("vue").ShallowRef<boolean, boolean>;
+//#endregion
+//#region src/composables/useNode.d.ts
+/**
+ * Composable that provides access to a node object, parent node object, connected edges and it's dom element
+ *
+ * If no node id is provided, the node id is injected from context
+ *
+ * If you do not provide an id, this composable has to be called in a child of your custom node component, or it will throw
+ *
+ * @public
+ * @param id - The id of the node to access
+ * @returns the node id, the node (a `ComputedRef`), the node dom element, it's parent and connected edges
+ */
+declare function useNode<NodeType extends Node = Node>(id?: string): {
+  id: string;
+  nodeEl: import("vue").ShallowRef<HTMLDivElement | null>;
+  node: import("vue").ComputedRef<InternalNode<NodeType> | undefined>;
+  parentNode: import("vue").ComputedRef<InternalNode<NodeType> | undefined>;
+  connectedEdges: import("vue").ComputedRef<Edge[]>;
+};
+//#endregion
+//#region src/composables/useStore.d.ts
+/**
+ * Access the raw reactive state of the surrounding flow — every {@link VueFlowState} field plus the
+ * lookups, read directly (`store.nodes`, `store.transform`, `store.nodeLookup`, …; no `.value`, like
+ * `xyflow/svelte`'s store). Mirrors `useStore` in `xyflow/react`+`svelte`.
+ *
+ * Reading a field inside a `computed`/`watch`/template tracks it reactively; reading it in a plain
+ * callback is just a current-value read. To destructure scalar/array fields as refs, wrap the result in
+ * `storeToRefs`; reference-type lookups (`nodeLookup`, …) can be destructured directly.
+ *
+ * For actions, getters, and event hooks use {@link useVueFlow} instead. Throws if called outside a
+ * provider (or outside a component `setup`).
+ *
+ * @public
+ * @returns the reactive state for the current context
+ */
+declare function useStore<NodeType extends Node = Node, EdgeType extends Edge = Edge>(): VueFlowState<NodeType, EdgeType>;
+//#endregion
+//#region src/composables/useViewportHelper.d.ts
+interface ViewportHelper<NodeType extends Node = Node> extends ViewportFunctions<NodeType> {
+  viewportInitialized: boolean;
+  screenToFlowPosition: Project$1;
+  flowToScreenPosition: Project$1;
+}
+//#endregion
+//#region src/composables/useVueFlow.d.ts
+/**
+ * Access the VueFlow instance for the surrounding flow — actions, computed getters, and event hooks
+ * (mirrors `useReactFlow` / `useSvelteFlow`). For the raw reactive state (`nodes`, `transform`,
+ * lookups, …) use {@link useStore} (and `storeToRefs` to destructure it).
+ *
+ * Pure context consumer — resolves the instance provided by the nearest `<VueFlow>` /
+ * `<VueFlowProvider>` ancestor. It takes **no arguments**: there is no global registry, no
+ * lookup-by-id, and no store creation here. To create/own a store, render a `<VueFlowProvider>` (or
+ * `<VueFlow>`, which provides its own); to share one across components, wrap them in a common
+ * `<VueFlowProvider>`.
+ *
+ * Throws if called outside a provider (or outside a component `setup`, where `inject` is unavailable).
+ *
+ * @public
+ * @returns the VueFlow instance for the current context
+ */
+declare function useVueFlow<NodeType extends Node = Node, EdgeType extends Edge = Edge>(): VueFlowInstance<NodeType, EdgeType>;
+//#endregion
+//#region src/types/store.d.ts
+type NodeLookup<NodeType extends Node = Node> = Map<string, InternalNode<NodeType>>;
+type EdgeLookup<EdgeType extends Edge = Edge> = Map<string, EdgeType>;
+interface UpdateNodeDimensionsParams {
+  id: string;
+  nodeElement: HTMLDivElement;
+  forceUpdate?: boolean;
+}
+interface State<NodeType extends Node = Node, EdgeType extends Edge = Edge> extends Omit<FlowProps<NodeType, EdgeType>, 'id' | 'nodes' | 'edges' | 'fitView'> {
+  /** Vue flow element ref */
+  vueFlowRef: HTMLDivElement | null;
+  /** Vue flow viewport element */
+  viewportRef: HTMLDivElement | null;
+  /** Event hooks, you can manipulate the triggers at your own peril */
+  readonly hooks: FlowHooks<NodeType, EdgeType>;
+  /** all stored nodes (the user-facing `Node`s; enriched `InternalNode`s live in `nodeLookup`) */
+  nodes: NodeType[];
+  /** all stored edges — the user-facing `Edge`s, stored verbatim (no enriched edge representation) */
+  edges: EdgeType[];
+  /** id → enriched `InternalNode` (`internals`/`measured`); the canonical source for node-derived data */
+  readonly nodeLookup: NodeLookup<NodeType>;
+  /** parentId → map of child id → child `InternalNode`. Matches `@xyflow/system`'s `ParentLookup`. */
+  readonly parentLookup: Map<string, Map<string, InternalNode<NodeType>>>;
+  /** id → user-facing `Edge` */
+  readonly edgeLookup: EdgeLookup<EdgeType>;
+  connectionLookup: ConnectionLookup;
+  /** The panzoom instance */
+  panZoom: PanZoomInstance | null;
+  /** use setMinZoom action to change minZoom */
+  minZoom: number;
+  /** use setMaxZoom action to change maxZoom */
+  maxZoom: number;
+  defaultViewport: Partial<Viewport$1>;
+  /** use setTranslateExtent action to change translateExtent */
+  translateExtent: CoordinateExtent$1;
+  nodeExtent: CoordinateExtent$1;
+  nodeOrigin: NodeOrigin;
+  colorMode: ColorMode$1;
+  /** viewport dimensions - do not change! */
+  readonly dimensions: Dimensions$1;
+  /** canonical viewport transform `[x, y, zoom]` (the `@xyflow/system` representation) - do not change! Read `viewport` for the `{ x, y, zoom }` shape. */
+  readonly transform: Transform;
+  /** if true will skip rendering any elements currently not inside viewport until they become visible */
+  onlyRenderVisibleElements: boolean;
+  nodesSelectionActive: boolean;
+  userSelectionActive: boolean;
+  multiSelectionActive: boolean;
+  deleteKeyCode: KeyFilter | null;
+  selectionKeyCode: KeyFilter | null;
+  selectionOnDrag: boolean;
+  multiSelectionKeyCode: KeyFilter | null;
+  zoomActivationKeyCode: KeyFilter | null;
+  panActivationKeyCode: KeyFilter | null;
+  connectionMode: ConnectionMode$1;
+  connectionLineOptions: ConnectionLineOptions;
+  connectionStartHandle: ConnectingHandle | null;
+  connectionEndHandle: ConnectingHandle | null;
+  connectionClickStartHandle: ConnectingHandle | null;
+  /** the raw pointer position during a connection drag (screen coords); the snapped end is `connectionEndHandle` */
+  connectionPosition: XYPosition$1;
+  connectionRadius: number;
+  connectionDragThreshold: number;
+  connectionStatus: ConnectionStatus | null;
+  isValidConnection: ValidConnectionFunc | null;
+  onBeforeDelete: OnBeforeDelete<NodeType, EdgeType> | null;
+  connectOnClick: boolean;
+  reconnectRadius: number;
+  snapToGrid: boolean;
+  snapGrid: SnapGrid$1;
+  defaultMarkerColor: string | null;
+  edgesReconnectable: EdgeReconnectable;
+  edgesFocusable: boolean;
+  nodesFocusable: boolean;
+  nodesDraggable: boolean;
+  nodesConnectable: boolean;
+  nodeDragThreshold: number;
+  elementsSelectable: boolean;
+  selectNodesOnDrag: boolean;
+  userSelectionRect: SelectionRect$1 | null;
+  selectionMode: SelectionMode$1;
+  panOnDrag: boolean | number[];
+  zoomOnScroll: boolean;
+  zoomOnPinch: boolean;
+  panOnScroll: boolean;
+  panOnScrollSpeed: number;
+  panOnScrollMode: PanOnScrollMode$1;
+  paneClickDistance: number;
+  nodeClickDistance: number;
+  zoomOnDoubleClick: boolean;
+  preventScrolling: boolean;
+  paneDragging: boolean;
+  initialized: boolean;
+  autoApplyChanges: boolean;
+  autoConnect: boolean | Connector;
+  fitViewOnInit: boolean;
+  fitViewOnInitDone: boolean;
+  noDragClassName: 'nodrag' | string;
+  noWheelClassName: 'nowheel' | string;
+  noPanClassName: 'nopan' | string;
+  defaultEdgeOptions: DefaultEdgeOptions | undefined;
+  elevateEdgesOnSelect: boolean;
+  elevateNodesOnSelect: boolean;
+  zIndexMode: ZIndexMode$1;
+  autoPanOnConnect: boolean;
+  autoPanOnNodeDrag: boolean;
+  autoPanOnNodeFocus: boolean;
+  autoPanOnSelection: boolean;
+  /**
+   * The speed at which the viewport pans while dragging a node or a selection box.
+   * @default 15
+   */
+  autoPanSpeed: number;
+  disableKeyboardA11y: boolean;
+  /** the merged aria-label / a11y text config (defaults overlaid with the `ariaLabelConfig` prop) */
+  ariaLabelConfig: AriaLabelConfig$1;
+  ariaLiveMessage: string;
+}
+type SetNodes<NodeType extends Node = Node> = (nodes: NodeType[] | ((nodes: NodeType[]) => NodeType[])) => void;
+type SetEdges<EdgeType extends Edge = Edge> = (edges: EdgeType[] | ((edges: EdgeType[]) => EdgeType[])) => void;
+type AddNodes<NodeType extends Node = Node> = (nodes: NodeType | NodeType[] | ((nodes: NodeType[]) => NodeType | NodeType[])) => void;
+type RemoveNodes<NodeType extends Node = Node> = (nodes: (string | NodeType) | (NodeType | string)[] | ((nodes: NodeType[]) => (string | NodeType) | (NodeType | string)[]), removeConnectedEdges?: boolean, removeChildren?: boolean) => void;
+type RemoveEdges<EdgeType extends Edge = Edge> = (edges: (string | EdgeType) | (EdgeType | string)[] | ((edges: EdgeType[]) => (string | EdgeType) | (EdgeType | string)[])) => void;
+/**
+ * Delete the given nodes/edges along with their connected edges and child nodes, gated by `onBeforeDelete`.
+ * Resolves to the elements actually removed. Mirrors xyflow/react's `deleteElements`.
+ */
+type DeleteElements<NodeType extends Node = Node, EdgeType extends Edge = Edge> = (elements: {
+  nodes?: (Partial<NodeType> & {
+    id: string;
+  })[];
+  edges?: (Partial<EdgeType> & {
+    id: string;
+  })[];
+}) => Promise<{
+  deletedNodes: NodeType[];
+  deletedEdges: EdgeType[];
+}>;
+type AddEdges<EdgeType extends Edge = Edge> = (edgesOrConnections: (EdgeType | Connection$1) | (EdgeType | Connection$1)[] | ((edges: EdgeType[]) => (EdgeType | Connection$1) | (EdgeType | Connection$1)[])) => void;
+type ReconnectEdge<EdgeType extends Edge = Edge> = (oldEdge: EdgeType, newConnection: Connection$1, shouldReplaceId?: boolean) => EdgeType | false;
+type UpdateEdge<EdgeType extends Edge = Edge> = (id: string, edgeUpdate: Partial<EdgeType> | ((edge: EdgeType) => Partial<EdgeType>), options?: {
+  replace: boolean;
+}) => void;
+type UpdateEdgeData<EdgeType extends Edge = Edge> = (id: string, dataUpdate: Partial<EdgeType['data']> | ((edge: EdgeType) => Partial<EdgeType['data']>), options?: {
+  replace: boolean;
+}) => void;
+type SetStateOptions<NodeType extends Node = Node, EdgeType extends Edge = Edge> = Partial<State<NodeType, EdgeType>> & Partial<Pick<FlowProps<NodeType, EdgeType>, 'fitView'>>;
+type SetState<NodeType extends Node = Node, EdgeType extends Edge = Edge> = (state: SetStateOptions<NodeType, EdgeType> | ((state: State<NodeType, EdgeType>) => SetStateOptions<NodeType, EdgeType>)) => void;
+type UpdateNodePosition = (dragItems: NodeDragItem[], changed: boolean, dragging: boolean) => void;
+type UpdateNodeDimensions = (updates: UpdateNodeDimensionsParams[]) => void;
+type UpdateNodeInternals = (nodeIds?: string[]) => void;
+type GetNode<NodeType extends Node = Node> = (id: string | undefined | null) => NodeType | undefined;
+/**
+ * Returns the enriched {@link InternalNode} (`internals.{positionAbsolute, z, handleBounds, userNode}` +
+ * authoritative `measured`) for an id, mirroring xyflow/react's `getInternalNode`. This is the accessor
+ * for store-computed data; `getNode` exposes the user-facing node.
+ */
+type GetInternalNode<NodeType extends Node = Node> = (id: string | undefined | null) => InternalNode<NodeType> | undefined;
+type GetEdge<EdgeType extends Edge = Edge> = (id: string | undefined | null) => EdgeType | undefined;
+type GetIntersectingNodes<NodeType extends Node = Node> = (node: (Partial<NodeType> & {
+  id: NodeType['id'];
+}) | Rect$1, partially?: boolean, nodes?: InternalNode<NodeType>[]) => InternalNode<NodeType>[];
+type UpdateNode<NodeType extends Node = Node> = (id: string, nodeUpdate: Partial<NodeType> | ((node: InternalNode<NodeType>) => Partial<NodeType>), options?: {
+  replace: boolean;
+}) => void;
+type UpdateNodeData<NodeType extends Node = Node> = (id: string, dataUpdate: Partial<NodeType['data']> | ((node: InternalNode<NodeType>) => Partial<NodeType['data']>), options?: {
+  replace: boolean;
+}) => void;
+type IsNodeIntersecting<NodeType extends Node = Node> = (node: (Partial<NodeType> & {
+  id: NodeType['id'];
+}) | Rect$1, area: Rect$1, partially?: boolean) => boolean;
+interface Actions<NodeType extends Node = Node, EdgeType extends Edge = Edge> extends Omit<ViewportHelper<NodeType>, 'viewportInitialized'> {
+  /** parses nodes and re-sets the state */
+  setNodes: SetNodes<NodeType>;
+  /** parses edges and re-sets the state */
+  setEdges: SetEdges<EdgeType>;
+  /** parses nodes and adds to state */
+  addNodes: AddNodes<NodeType>;
+  /** parses edges and adds to state */
+  addEdges: AddEdges<EdgeType>;
+  /** remove nodes (and possibly connected edges and children) from state */
+  removeNodes: RemoveNodes<NodeType>;
+  /** remove edges from state */
+  removeEdges: RemoveEdges<EdgeType>;
+  /** delete nodes/edges (with connected edges + children), gated by `onBeforeDelete`; mirrors xyflow/react */
+  deleteElements: DeleteElements<NodeType, EdgeType>;
+  /** find a node by id */
+  getNode: GetNode<NodeType>;
+  /** get the enriched internal node (store-computed `internals` + `measured`) by id */
+  getInternalNode: GetInternalNode<NodeType>;
+  /** find an edge by id */
+  getEdge: GetEdge<EdgeType>;
+  /** reconnects an edge to a new source/target (connection) */
+  reconnectEdge: ReconnectEdge<EdgeType>;
+  /** partially updates an edge */
+  updateEdge: UpdateEdge<EdgeType>;
+  /** updates the data of an edge */
+  updateEdgeData: UpdateEdgeData<EdgeType>;
+  /** updates a node */
+  updateNode: UpdateNode<NodeType>;
+  /** updates the data of a node */
+  updateNodeData: UpdateNodeData<NodeType>;
+  /** applies default edge change handler */
+  applyEdgeChanges: (changes: EdgeChange<EdgeType>[]) => EdgeType[];
+  /** applies default node change handler; returns the resulting user nodes */
+  applyNodeChanges: (changes: NodeChange<NodeType>[]) => NodeType[];
+  /** manually select edges and add to state */
+  addSelectedEdges: (edges: EdgeType[]) => void;
+  /** manually select nodes and add to state */
+  addSelectedNodes: (nodes: NodeType[]) => void;
+  /** manually unselect edges and remove from state */
+  removeSelectedEdges: (edges?: EdgeType[]) => void;
+  /** manually unselect nodes and remove from state */
+  removeSelectedNodes: (nodes?: NodeType[]) => void;
+  /**
+   * Clear the selection the way a pane click does — but only while `elementsSelectable` is `true`; otherwise
+   * it's a no-op, so a selection set before selection was disabled survives. Use `removeSelectedNodes`/
+   * `removeSelectedEdges` to clear unconditionally.
+   */
+  resetSelectedElements: () => void;
+  /** apply min zoom value to panzoom */
+  setMinZoom: (zoom: number) => void;
+  /** apply max zoom value to panzoom */
+  setMaxZoom: (zoom: number) => void;
+  /** apply translate extent to panzoom */
+  setTranslateExtent: (translateExtent: CoordinateExtent$1) => void;
+  /** apply extent to nodes */
+  setNodeExtent: (nodeExtent: CoordinateExtent$1) => void;
+  setPaneClickDistance: (distance: number) => void;
+  /** enable/disable node interaction (dragging, selecting etc) */
+  setInteractive: (isInteractive: boolean) => void;
+  /** set new state */
+  setState: SetState<NodeType, EdgeType>;
+  /** return an object of graph values (elements, viewport transform) for storage and re-loading a graph */
+  toObject: () => FlowExportObject;
+  /** force update node internal data, if handle bounds are incorrect, you might want to use this */
+  updateNodeInternals: UpdateNodeInternals;
+  /** start a connection */
+  startConnection: (startHandle: ConnectingHandle, position?: XYPosition$1, isClick?: boolean) => void;
+  /** update connection position */
+  updateConnection: (position: XYPosition$1, result?: ConnectingHandle | null, status?: ConnectionStatus | null) => void;
+  /** end (or cancel) a connection */
+  endConnection: (event?: MouseEvent | TouchEvent, isClick?: boolean) => void;
+  /** internal position updater, you probably don't want to use this */
+  updateNodePositions: UpdateNodePosition;
+  /** internal dimensions' updater, you probably don't want to use this */
+  updateNodeDimensions: UpdateNodeDimensions;
+  /** returns all node intersections */
+  getIntersectingNodes: GetIntersectingNodes<NodeType>;
+  /** check if a node is intersecting with a defined area */
+  isNodeIntersecting: IsNodeIntersecting<NodeType>;
+  /** get a node's connected edges (accepts any nodes — it matches by id; output is the flow's `EdgeType`) */
+  getConnectedEdges: (nodes: Node[]) => EdgeType[];
+  /** get all connections of a handle belonging to a node */
+  getHandleConnections: ({
+    id,
+    type,
+    nodeId
+  }: {
+    id?: string | null;
+    type: HandleType$1;
+    nodeId: string;
+  }) => NodeConnection$1[];
+  /** pan the viewport; return indicates if a transform has happened or not */
+  panBy: (delta: XYPosition$1) => Promise<boolean>;
+  /** whether the viewport (panzoom) is initialized — `true` once `<ZoomPane>` has mounted and measured */
+  viewportInitialized: ComputedRef<boolean>;
+  /** reset state to defaults */
+  $reset: () => void;
+  /** destroy the store instance (invalidates its effect scopes); runs the `onDestroy` hook if one was set */
+  $destroy: () => void;
+}
+interface Getters<NodeType extends Node = Node, EdgeType extends Edge = Edge> {
+  /** returns object containing current edge types */
+  getEdgeTypes: Record<keyof DefaultEdgeTypes | string, EdgeComponent<EdgeType>>;
+  /** returns object containing current node types */
+  getNodeTypes: Record<keyof DefaultNodeTypes | string, NodeComponent<NodeType | BuiltInNode>>;
+  /** all visible nodes (user-facing `Node`s; use `getInternalNode`/`nodeLookup` for enriched data) */
+  getNodes: readonly NodeType[];
+  /** all visible edges (user-facing `Edge`s) */
+  getEdges: readonly EdgeType[];
+  /** returns all currently selected nodes (user-facing `Node`s) */
+  getSelectedNodes: readonly NodeType[];
+  /** returns all currently selected edges */
+  getSelectedEdges: readonly EdgeType[];
+  /** the viewport as `{ x, y, zoom }`, derived from the canonical `transform` — read-only; set via `setViewport`/`zoom*`/`fitView` */
+  viewport: Viewport$1;
+}
+type ComputedGetters<NodeType extends Node = Node, EdgeType extends Edge = Edge> = { [key in keyof Getters<NodeType, EdgeType>]: ComputedRef<Getters<NodeType, EdgeType>[key]> };
+/**
+ * The reactive state object returned by {@link useStore} — every {@link State} field plus the lookups,
+ * read directly (`store.nodes`, no `.value`, like `xyflow/svelte`'s store / a Pinia store). Use
+ * `storeToRefs(useStore())` to destructure scalar/array fields as refs.
+ */
+type VueFlowState<NodeType extends Node = Node, EdgeType extends Edge = Edge> = State<NodeType, EdgeType>;
+/**
+ * The curated instance returned by {@link useVueFlow} — actions, computed getters, and event hooks
+ * (mirrors `useReactFlow` / `useSvelteFlow`). Raw reactive state lives on {@link useStore} instead.
+ */
+type VueFlowInstance<NodeType extends Node = Node, EdgeType extends Edge = Edge> = {
+  readonly id: string;
+  readonly emits: FlowHooksEmit<NodeType, EdgeType>; /** tear the store down (internal) */
+  $destroy: () => void;
+} & FlowHooksOn<NodeType, EdgeType> & Readonly<ComputedGetters<NodeType, EdgeType>> & Readonly<Actions<NodeType, EdgeType>>;
+/** Internal handle bundling the two views a created store exposes; provided to descendants. */
+interface VueFlowStoreHandle<NodeType extends Node = Node, EdgeType extends Edge = Edge> {
+  instance: VueFlowInstance<NodeType, EdgeType>;
+  state: VueFlowState<NodeType, EdgeType>;
+}
+//#endregion
+//#region src/types/hooks.d.ts
+type MouseTouchEvent = MouseEvent | TouchEvent;
+interface NodeMouseEvent<NodeType extends Node = Node> {
+  event: MouseTouchEvent;
+  node: NodeType;
+}
+interface NodeDragEvent<NodeType extends Node = Node> {
+  event: MouseTouchEvent;
+  node: NodeType;
+  nodes: NodeType[];
+}
+interface EdgeMouseEvent<EdgeType extends Edge = Edge> {
+  event: MouseTouchEvent;
+  edge: EdgeType;
+}
+interface EdgeReconnectEvent<EdgeType extends Edge = Edge> {
+  event: MouseTouchEvent;
+  edge: EdgeType;
+  connection: Connection$1;
+}
+/**
+ * Payload for `connectEnd`/`clickConnectEnd` — the pointer event plus the {@link FinalConnectionState}
+ * (whether the connection was valid, the from/to handles and nodes), mirroring xyflow/react's `OnConnectEnd`.
+ */
+interface ConnectEndEvent<NodeType extends Node = Node> {
+  event: MouseTouchEvent;
+  connectionState: FinalConnectionState$1<InternalNode<NodeType>>;
+}
+interface EdgeReconnectStartEvent<EdgeType extends Edge = Edge> {
+  event: MouseTouchEvent;
+  edge: EdgeType;
+  /** the type of the handle being reconnected (the fixed end, opposite the grabbed anchor), as in xyflow/react */
+  handleType: HandleType$1;
+}
+interface EdgeReconnectEndEvent<NodeType extends Node = Node, EdgeType extends Edge = Edge> {
+  event: MouseTouchEvent;
+  edge: EdgeType;
+  /** the type of the handle that was reconnected */
+  handleType: HandleType$1;
+  /** the {@link FinalConnectionState} at the moment the reconnect ended */
+  connectionState: FinalConnectionState$1<InternalNode<NodeType>>;
+}
+/** Payload for `selectionChange` — the currently selected nodes and edges, mirroring xyflow/react's `OnSelectionChange`. */
+interface SelectionChangeEvent<NodeType extends Node = Node, EdgeType extends Edge = Edge> {
+  nodes: NodeType[];
+  edges: EdgeType[];
+}
+interface FlowEvents<NodeType extends Node = Node, EdgeType extends Edge = Edge> {
+  nodesChange: NodeChange<NodeType>[];
+  edgesChange: EdgeChange<EdgeType>[];
+  nodeDoubleClick: NodeMouseEvent<NodeType>;
+  nodeClick: NodeMouseEvent<NodeType>;
+  nodeMouseEnter: NodeMouseEvent<NodeType>;
+  nodeMouseMove: NodeMouseEvent<NodeType>;
+  nodeMouseLeave: NodeMouseEvent<NodeType>;
+  nodeContextMenu: NodeMouseEvent<NodeType>;
+  nodeDragStart: NodeDragEvent<NodeType>;
+  nodeDrag: NodeDragEvent<NodeType>;
+  nodeDragStop: NodeDragEvent<NodeType>;
+  nodesInitialized: NodeType[];
+  updateNodeInternals: string[];
+  miniMapNodeClick: NodeMouseEvent<NodeType>;
+  miniMapNodeDoubleClick: NodeMouseEvent<NodeType>;
+  miniMapNodeMouseEnter: NodeMouseEvent<NodeType>;
+  miniMapNodeMouseMove: NodeMouseEvent<NodeType>;
+  miniMapNodeMouseLeave: NodeMouseEvent<NodeType>;
+  connect: Connection$1;
+  connectStart: {
+    event?: MouseEvent | TouchEvent;
+  } & OnConnectStartParams;
+  connectEnd: ConnectEndEvent<NodeType>;
+  clickConnectStart: {
+    event?: MouseEvent | TouchEvent;
+  } & OnConnectStartParams;
+  clickConnectEnd: ConnectEndEvent<NodeType>;
+  init: VueFlowInstance<NodeType, EdgeType>;
+  move: {
+    event: MouseTouchEvent | null;
+    viewport: Viewport$1;
+  };
+  moveStart: {
+    event: MouseTouchEvent | null;
+    viewport: Viewport$1;
+  };
+  moveEnd: {
+    event: MouseTouchEvent | null;
+    viewport: Viewport$1;
+  };
+  selectionDragStart: NodeDragEvent<NodeType>;
+  selectionDrag: NodeDragEvent<NodeType>;
+  selectionDragStop: NodeDragEvent<NodeType>;
+  selectionContextMenu: {
+    event: MouseEvent;
+    nodes: NodeType[];
+  };
+  selectionStart: MouseEvent;
+  selectionEnd: MouseEvent;
+  selectionChange: SelectionChangeEvent<NodeType, EdgeType>;
+  viewportChangeStart: Viewport$1;
+  viewportChange: Viewport$1;
+  viewportChangeEnd: Viewport$1;
+  paneScroll: WheelEvent | undefined;
+  paneClick: MouseEvent;
+  paneContextMenu: MouseEvent;
+  paneMouseEnter: PointerEvent;
+  paneMouseMove: PointerEvent;
+  paneMouseLeave: PointerEvent;
+  edgeContextMenu: EdgeMouseEvent<EdgeType>;
+  edgeMouseEnter: EdgeMouseEvent<EdgeType>;
+  edgeMouseMove: EdgeMouseEvent<EdgeType>;
+  edgeMouseLeave: EdgeMouseEvent<EdgeType>;
+  edgeDoubleClick: EdgeMouseEvent<EdgeType>;
+  edgeClick: EdgeMouseEvent<EdgeType>;
+  reconnectStart: EdgeReconnectStartEvent<EdgeType>;
+  reconnect: EdgeReconnectEvent<EdgeType>;
+  reconnectEnd: EdgeReconnectEndEvent<NodeType, EdgeType>;
+  error: VueFlowError;
+}
+type FlowHooks<NodeType extends Node = Node, EdgeType extends Edge = Edge> = Readonly<{ [key in keyof FlowEvents<NodeType, EdgeType>]: EventHookExtended<FlowEvents<NodeType, EdgeType>[key]> }>;
+type FlowHooksOn<NodeType extends Node = Node, EdgeType extends Edge = Edge> = Readonly<{ [key in keyof FlowEvents<NodeType, EdgeType> as `on${Capitalize<key>}`]: EventHookOn<FlowEvents<NodeType, EdgeType>[key]> }>;
+type FlowHooksEmit<NodeType extends Node = Node, EdgeType extends Edge = Edge> = Readonly<{ [key in keyof FlowEvents<NodeType, EdgeType>]: EventHookTrigger<FlowEvents<NodeType, EdgeType>[key]> }>;
+interface NodeEventsHandler<NodeType extends Node = Node> {
+  doubleClick: (event: NodeMouseEvent<NodeType>) => void | {
+    off: () => void;
+  };
+  click: (event: NodeMouseEvent<NodeType>) => void | {
+    off: () => void;
+  };
+  mouseEnter: (event: NodeMouseEvent<NodeType>) => void | {
+    off: () => void;
+  };
+  mouseMove: (event: NodeMouseEvent<NodeType>) => void | {
+    off: () => void;
+  };
+  mouseLeave: (event: NodeMouseEvent<NodeType>) => void | {
+    off: () => void;
+  };
+  contextMenu: (event: NodeMouseEvent<NodeType>) => void | {
+    off: () => void;
+  };
+  dragStart: (event: NodeDragEvent<NodeType>) => void | {
+    off: () => void;
+  };
+  drag: (event: NodeDragEvent<NodeType>) => void | {
+    off: () => void;
+  };
+  dragStop: (event: NodeDragEvent<NodeType>) => void | {
+    off: () => void;
+  };
+}
+type NodeEventsOn<NodeType extends Node = Node> = { [key in keyof NodeEventsHandler<NodeType>]: EventHookOn<NodeEventsHandler<NodeType>[key] extends ((event: infer Event) => any) ? Event : never> };
+interface EdgeEventsHandler<EdgeType extends Edge = Edge> {
+  doubleClick: (event: EdgeMouseEvent<EdgeType>) => void | {
+    off: () => void;
+  };
+  click: (event: EdgeMouseEvent<EdgeType>) => void | {
+    off: () => void;
+  };
+  mouseEnter: (event: EdgeMouseEvent<EdgeType>) => void | {
+    off: () => void;
+  };
+  mouseMove: (event: EdgeMouseEvent<EdgeType>) => void | {
+    off: () => void;
+  };
+  mouseLeave: (event: EdgeMouseEvent<EdgeType>) => void | {
+    off: () => void;
+  };
+  contextMenu: (event: EdgeMouseEvent<EdgeType>) => void | {
+    off: () => void;
+  };
+  reconnectStart: (event: EdgeReconnectStartEvent<EdgeType>) => void | {
+    off: () => void;
+  };
+  reconnect: (event: EdgeReconnectEvent<EdgeType>) => void | {
+    off: () => void;
+  };
+  reconnectEnd: (event: EdgeReconnectEndEvent<Node, EdgeType>) => void | {
+    off: () => void;
+  };
+}
+type EdgeEventsOn<EdgeType extends Edge = Edge> = { [key in keyof EdgeEventsHandler<EdgeType>]: EventHookOn<EdgeEventsHandler<EdgeType>[key] extends ((event: infer Event) => any) ? Event : never> };
+//#endregion
+//#region src/types/flow.d.ts
+/**
+ * Consulted before nodes/edges are deleted (via the delete key or `deleteElements`). Receives the full set
+ * about to be removed (the targeted nodes/edges plus connected edges and child nodes). Return `false` to
+ * cancel, `true` to delete that set, or `{ nodes, edges }` to delete only a subset. Mirrors xyflow/react.
+ */
+type OnBeforeDelete<NodeType extends Node = Node, EdgeType extends Edge = Edge> = (params: {
+  nodes: NodeType[];
+  edges: EdgeType[];
+}) => Promise<boolean | {
+  nodes: NodeType[];
+  edges: EdgeType[];
+}>;
+interface CustomThemeVars {
+  [key: string]: string | number | undefined;
+}
+/**
+ * The overridable `--xy-*` CSS custom properties, mirroring `@xyflow/system` (shared with
+ * `@xyflow/react`/`@xyflow/svelte`). Set the un-suffixed var to override; the stylesheet falls back to
+ * the shipped `--xy-*-default` value (`var(--xy-x, var(--xy-x-default))`).
+ */
+type CSSVars = '--xy-edge-stroke' | '--xy-edge-stroke-width' | '--xy-edge-stroke-selected' | '--xy-connectionline-stroke' | '--xy-connectionline-stroke-width' | '--xy-attribution-background-color' | '--xy-minimap-background-color' | '--xy-minimap-mask-background-color' | '--xy-minimap-mask-stroke-color' | '--xy-minimap-mask-stroke-width' | '--xy-minimap-node-background-color' | '--xy-minimap-node-stroke-color' | '--xy-minimap-node-stroke-width' | '--xy-background-color' | '--xy-background-pattern-color' | '--xy-resize-background-color' | '--xy-node-color' | '--xy-node-border' | '--xy-node-border-selected' | '--xy-node-background-color' | '--xy-node-boxshadow-hover' | '--xy-node-boxshadow-selected' | '--xy-node-border-radius' | '--xy-handle-background-color' | '--xy-handle-border-color' | '--xy-selection-background-color' | '--xy-selection-border' | '--xy-controls-button-background-color' | '--xy-controls-button-background-color-hover' | '--xy-controls-button-color' | '--xy-controls-button-color-hover' | '--xy-controls-button-border-color' | '--xy-controls-box-shadow' | '--xy-edge-label-background-color' | '--xy-edge-label-color';
+type ThemeVars = { [key in CSSVars]?: CSSProperties['color'] };
+type Styles = CSSProperties & ThemeVars & CustomThemeVars;
+type ClassValue = string | Record<string, boolean> | ClassValue[];
+interface FlowExportObject {
+  /** exported nodes */
+  nodes: Node[];
+  /** exported edges */
+  edges: Edge[];
+  /** exported viewport (position + zoom) */
+  viewport: Viewport$1;
+}
+type FlowOptions<NodeType extends Node = Node, EdgeType extends Edge = Edge> = FlowProps<NodeType, EdgeType>;
+interface FlowProps<NodeType extends Node = Node, EdgeType extends Edge = Edge> {
+  id?: string;
+  nodes?: NodeType[];
+  edges?: EdgeType[];
+  /** either use the edgeTypes prop to define your edge-types or use slots (<template #edge-mySpecialType="props">) */
+  edgeTypes?: EdgeTypesObject<EdgeType>;
+  /** either use the nodeTypes prop to define your node-types or use slots (<template #node-mySpecialType="props">) */
+  nodeTypes?: NodeTypesObject<NodeType>;
+  connectionMode?: ConnectionMode$1;
+  connectionLineOptions?: ConnectionLineOptions;
+  connectionRadius?: number;
+  /**
+   * The threshold in pixels that the pointer must move before a connection line starts to drag.
+   * Useful to prevent accidental connections when clicking on a handle.
+   * @default 1
+   */
+  connectionDragThreshold?: number;
+  isValidConnection?: ValidConnectionFunc | null;
+  /** consulted before delete-key/`deleteElements` removals — cancel, confirm, or filter the set */
+  onBeforeDelete?: OnBeforeDelete<NodeType, EdgeType> | null;
+  deleteKeyCode?: KeyFilter | null;
+  /** hold this key (default `'Shift'`) and drag to draw a selection box. For dragging without a key, see `selectionOnDrag` */
+  selectionKeyCode?: KeyFilter | null;
+  /**
+   * Draw a selection box on a plain pane drag (no key held). Pair it with `panOnDrag` set to a non-left
+   * button (e.g. `[1, 2]`) or `false` so a left-drag selects instead of panning. Mirrors xyflow/react.
+   * @default false
+   */
+  selectionOnDrag?: boolean;
+  multiSelectionKeyCode?: KeyFilter | null;
+  zoomActivationKeyCode?: KeyFilter | null;
+  panActivationKeyCode?: KeyFilter | null;
+  snapToGrid?: boolean;
+  snapGrid?: SnapGrid$1;
+  onlyRenderVisibleElements?: boolean;
+  edgesReconnectable?: EdgeReconnectable;
+  nodesDraggable?: boolean;
+  nodesConnectable?: boolean;
+  nodeDragThreshold?: number;
+  elementsSelectable?: boolean;
+  selectNodesOnDrag?: boolean;
+  /** move pane on drag, replaced prop `paneMovable` */
+  panOnDrag?: boolean | number[];
+  minZoom?: number;
+  maxZoom?: number;
+  /** initial viewport for an uncontrolled flow; ignored once the user pans/zooms */
+  defaultViewport?: Partial<Viewport$1>;
+  /** controlled viewport (`v-model:viewport`) — keeps the flow's transform in sync with the bound value */
+  viewport?: Viewport$1;
+  translateExtent?: CoordinateExtent$1;
+  nodeExtent?: CoordinateExtent$1;
+  /** origin of all nodes relative to their position — `[0, 0]` top-left, `[0.5, 0.5]` center, `[1, 1]` bottom-right */
+  nodeOrigin?: NodeOrigin;
+  /** light/dark/system — applies the resolved `light`/`dark` class to the flow container; `system` follows `prefers-color-scheme` @default 'light' */
+  colorMode?: ColorMode$1;
+  /** color of edge markers; pass `null` to drive the arrowhead color from the `--xy-edge-stroke` CSS variable @default '#b1b1b7' */
+  defaultMarkerColor?: string | null;
+  zoomOnScroll?: boolean;
+  zoomOnPinch?: boolean;
+  panOnScroll?: boolean;
+  panOnScrollSpeed?: number;
+  panOnScrollMode?: PanOnScrollMode$1;
+  /**
+   * Distance that the mouse can move between mousedown/up that will trigger a click
+   * @default 0
+   */
+  paneClickDistance?: number;
+  /**
+   * Distance that the mouse can move between mousedown/up on a node that will trigger a click
+   * @default 0
+   */
+  nodeClickDistance?: number;
+  zoomOnDoubleClick?: boolean;
+  /** If set to false, scrolling inside the viewport will be disabled and instead the page scroll will be used */
+  preventScrolling?: boolean;
+  selectionMode?: SelectionMode$1;
+  reconnectRadius?: number;
+  /** fit the view to the nodes once they're measured on init (xyflow/react's `fitView` prop) */
+  fitView?: boolean;
+  /** options for the initial `fitView` (padding, includeHiddenNodes, etc.) */
+  fitViewOptions?: FitViewOptionsBase<NodeType>;
+  /** allow connection with click handlers, i.e. support touch devices */
+  connectOnClick?: boolean;
+  /**
+   * Automatically apply node/edge changes (position, dimensions, add/remove, select) back to `nodes`/`edges`.
+   * Set to `false` to handle the `nodes-change` / `edges-change` events and apply the changes yourself.
+   */
+  autoApplyChanges?: boolean;
+  /**
+   * automatically create an edge when connection is triggered
+   */
+  autoConnect?: boolean | Connector;
+  noDragClassName?: string;
+  noWheelClassName?: string;
+  noPanClassName?: string;
+  /** does not work for the `addEdge` utility! */
+  defaultEdgeOptions?: DefaultEdgeOptions;
+  /** elevates edges when selected and applies z-Index to put them above their nodes */
+  elevateEdgesOnSelect?: boolean;
+  /** elevates nodes when selected and applies z-Index + 1000 */
+  elevateNodesOnSelect?: boolean;
+  /**
+   * controls how the z-index of nodes and edges is calculated.
+   * - `basic` (default): z-index is derived from the element's `zIndex`, parentage and selection state
+   * - `auto`: same as `basic`, but parented nodes are always lifted above their parent
+   * - `manual`: the element's explicit `zIndex` is used verbatim (no elevation)
+   */
+  zIndexMode?: ZIndexMode$1;
+  disableKeyboardA11y?: boolean;
+  /** customize the aria labels / a11y descriptions (node/edge descriptions, the aria-live move message, and the Controls/MiniMap/Handle labels); merged over the defaults */
+  ariaLabelConfig?: Partial<AriaLabelConfig$1>;
+  edgesFocusable?: boolean;
+  nodesFocusable?: boolean;
+  autoPanOnConnect?: boolean;
+  autoPanOnNodeDrag?: boolean;
+  /**
+   * Pan the viewport to a node when it receives keyboard focus (Tab) and isn't currently within the
+   * viewport — keeps keyboard navigation from landing on off-screen nodes.
+   * @default true
+   */
+  autoPanOnNodeFocus?: boolean;
+  /**
+   * Pan the viewport automatically when the cursor reaches the edge of the viewport while dragging a
+   * selection box.
+   * @default true
+   */
+  autoPanOnSelection?: boolean;
+  autoPanSpeed?: number;
+}
+interface FlowEmits<NodeType extends Node = Node, EdgeType extends Edge = Edge> {
+  nodesChange: [changes: NodeChange<NodeType>[]];
+  edgesChange: [changes: EdgeChange<EdgeType>[]];
+  nodesInitialized: [nodes: NodeType[]];
+  miniMapNodeClick: [nodeMouseEvent: NodeMouseEvent<NodeType>];
+  miniMapNodeDoubleClick: [nodeMouseEvent: NodeMouseEvent<NodeType>];
+  miniMapNodeMouseEnter: [nodeMouseEvent: NodeMouseEvent<NodeType>];
+  miniMapNodeMouseMove: [nodeMouseEvent: NodeMouseEvent<NodeType>];
+  miniMapNodeMouseLeave: [nodeMouseEvent: NodeMouseEvent<NodeType>];
+  connect: [connectionEvent: Connection$1];
+  connectStart: [connectionEvent: {
+    event?: MouseEvent;
+  } & OnConnectStartParams];
+  connectEnd: [connectionEvent: ConnectEndEvent<NodeType>];
+  clickConnectStart: [connectionEvent: {
+    event?: MouseEvent;
+  } & OnConnectStartParams];
+  clickConnectEnd: [connectionEvent: ConnectEndEvent<NodeType>];
+  moveStart: [moveEvent: {
+    event: MouseTouchEvent | null;
+    viewport: Viewport$1;
+  }];
+  move: [moveEvent: {
+    event: MouseTouchEvent | null;
+    viewport: Viewport$1;
+  }];
+  moveEnd: [moveEvent: {
+    event: MouseTouchEvent | null;
+    viewport: Viewport$1;
+  }];
+  selectionDragStart: [selectionEvent: NodeDragEvent<NodeType>];
+  selectionDrag: [selectionEvent: NodeDragEvent<NodeType>];
+  selectionDragStop: [selectionEvent: NodeDragEvent<NodeType>];
+  selectionContextMenu: [selectionEvent: {
+    event: MouseEvent;
+    nodes: NodeType[];
+  }];
+  selectionStart: [selectionEvent: MouseEvent];
+  selectionEnd: [selectionEvent: MouseEvent];
+  selectionChange: [selectionEvent: SelectionChangeEvent<NodeType, EdgeType>];
+  viewportChangeStart: [viewport: Viewport$1];
+  viewportChange: [viewport: Viewport$1];
+  viewportChangeEnd: [viewport: Viewport$1];
+  init: [paneEvent: VueFlowInstance<NodeType, EdgeType>];
+  paneScroll: [paneEvent: WheelEvent | undefined];
+  paneClick: [paneEvent: MouseEvent];
+  paneContextMenu: [paneEvent: MouseEvent];
+  paneMouseEnter: [paneEvent: MouseEvent];
+  paneMouseMove: [paneEvent: MouseEvent];
+  paneMouseLeave: [paneEvent: MouseEvent];
+  updateNodeInternals: [];
+  error: [error: VueFlowError];
+  edgeContextMenu: [edgeMouseEvent: EdgeMouseEvent<EdgeType>];
+  edgeMouseEnter: [edgeMouseEvent: EdgeMouseEvent<EdgeType>];
+  edgeMouseMove: [edgeMouseEvent: EdgeMouseEvent<EdgeType>];
+  edgeMouseLeave: [edgeMouseEvent: EdgeMouseEvent<EdgeType>];
+  edgeDoubleClick: [edgeMouseEvent: EdgeMouseEvent<EdgeType>];
+  edgeClick: [edgeMouseEvent: EdgeMouseEvent<EdgeType>];
+  reconnectStart: [edgeReconnectEvent: EdgeReconnectStartEvent<EdgeType>];
+  reconnect: [reconnectEvent: EdgeReconnectEvent<EdgeType>];
+  reconnectEnd: [edgeReconnectEvent: EdgeReconnectEndEvent<NodeType, EdgeType>];
+  nodeDoubleClick: [nodeMouseEvent: NodeMouseEvent<NodeType>];
+  nodeClick: [nodeMouseEvent: NodeMouseEvent<NodeType>];
+  nodeMouseEnter: [nodeMouseEvent: NodeMouseEvent<NodeType>];
+  nodeMouseMove: [nodeMouseEvent: NodeMouseEvent<NodeType>];
+  nodeMouseLeave: [nodeMouseEvent: NodeMouseEvent<NodeType>];
+  nodeContextMenu: [nodeMouseEvent: NodeMouseEvent<NodeType>];
+  nodeDragStart: [nodeDragEvent: NodeDragEvent<NodeType>];
+  nodeDrag: [nodeDragEvent: NodeDragEvent<NodeType>];
+  nodeDragStop: [nodeDragEvent: NodeDragEvent<NodeType>];
+}
+type NodeByType<NodeType extends Node, T extends string> = NodeType extends any ? (T extends NonNullable<NodeType['type']> ? NodeType : never) : never;
+type EdgeByType<EdgeType extends Edge, T extends string> = EdgeType extends any ? (T extends NonNullable<EdgeType['type']> ? EdgeType : never) : never;
+type NodeSlots<NodeType extends Node = Node> = Partial<{ [T in NonNullable<NodeType['type']> as `node-${T}`]: (nodeProps: NodeProps<NodeByType<NodeType, T>>) => any } & Record<`node-${string}`, (nodeProps: NodeProps<NodeType>) => any>>;
+type EdgeSlots<EdgeType extends Edge = Edge> = Partial<{ [T in NonNullable<EdgeType['type']> as `edge-${T}`]: (edgeProps: EdgeProps<EdgeByType<EdgeType, T>>) => any } & Record<`edge-${string}`, (edgeProps: EdgeProps<EdgeType>) => any>>;
+type FlowSlots<NodeType extends Node = Node, EdgeType extends Edge = Edge> = NodeSlots<NodeType> & EdgeSlots<EdgeType> & {
+  'connection-line'?: (connectionLineProps: ConnectionLineProps<NodeType>) => any;
+  'zoom-pane'?: () => any;
+  'default'?: () => any;
+};
+//#endregion
+//#region src/types/node.d.ts
+/**
+ * Origin of a node relative to its position. `[0, 0]` is top-left, `[0.5, 0.5]` centers it, `[1, 1]` is bottom-right.
+ *
+ * Locally defined (rather than re-exported from `@xyflow/system`) so the Vue SFC compiler stays out of the
+ * system d.ts (its `Optional<T, K>` utility trips vuejs/core#14236). Structurally identical to system's.
+ */
+type NodeOrigin = [number, number];
+interface NodeHandleBounds {
+  source: HandleElement[] | null;
+  target: HandleElement[] | null;
+}
+/**
+ * User-facing node type — reuses `@xyflow/system`'s `NodeBase`.
+ */
+type Node<NodeData extends Record<string, unknown> = Record<string, unknown>, NodeType extends string | undefined = string | undefined> = NodeBase<NodeData, NodeType> & {
+  class?: ClassValue;
+  style?: Styles;
+  resizing?: boolean;
+  focusable?: boolean;
+  ariaRole?: string;
+  domAttributes?: Omit<HTMLAttributes, 'id' | 'style' | 'className' | 'draggable' | 'aria-label' | 'onMouseenter' | 'onMousemove' | 'onMouseleave' | 'onContextmenu' | 'onClick' | 'onDblclick' | 'onKeydown'>;
+};
+/**
+ * The enriched, store-internal node — what `nodeLookup`/`getInternalNode(id)`/`useInternalNode(id)` return,
+ * once a user-provided `Node` has been processed by the store. Carries the user `Node`
+ * (`internals.userNode`) plus the store-computed `internals.{positionAbsolute, z, handleBounds}` and
+ * authoritative `measured`.
+ */
+type InternalNode<NodeType extends Node = Node> = InternalNodeBase<NodeType>;
+/**
+ * Props passed to custom node components, parameterized on a `NodeType`.
+ */
+interface NodeProps<NodeType extends Node = Node> {
+  id: string;
+  data: NodeType['data'];
+  type: NodeType['type'];
+  selected: boolean;
+  selectable: boolean;
+  deletable: boolean;
+  draggable: boolean;
+  dragging: boolean;
+  zIndex: number;
+  isConnectable: boolean;
+  positionAbsoluteX: number;
+  positionAbsoluteY: number;
+  width?: NodeType['width'];
+  height?: NodeType['height'];
+  sourcePosition?: NodeType['sourcePosition'];
+  targetPosition?: NodeType['targetPosition'];
+  dragHandle?: NodeType['dragHandle'];
+  parentId?: NodeType['parentId'];
+}
+type BuiltInNode = Node<{
+  label: string;
+}, 'input' | 'output' | 'default'> | Node<Record<string, never>, 'group'>;
+//#endregion
+//#region src/types/components.d.ts
+/** Global component names are components registered to the vue instance and are "autoloaded" by their string name */
+type GlobalComponentName = string;
+/** Node Components can either be a component definition or a string name */
+type NodeComponent<NodeType extends Node = Node> = Component<NodeProps<NodeType>> | DefineComponent<NodeProps<NodeType>, any, any, any, any> | GlobalComponentName;
+type NodeTypesObject<NodeType extends Node = Node> = { [key in keyof DefaultNodeTypes]?: NodeComponent<BuiltInNode> } & Record<string, NodeComponent<NodeType>>;
+type EdgeTypesObject<EdgeType extends Edge = Edge> = { [key in keyof DefaultEdgeTypes]?: EdgeComponent } & Record<string, EdgeComponent<EdgeType>>;
+/** Edge Components can either be a component definition or a string name */
+type EdgeComponent<EdgeType extends Edge = Edge> = Component<EdgeProps<EdgeType>> | DefineComponent<EdgeProps<EdgeType>, any, any, any, any, any> | GlobalComponentName;
+interface DefaultEdgeTypes {
+  default: typeof BezierEdge;
+  straight: typeof StraightEdge;
+  simplebezier: typeof SimpleBezierEdge;
+  step: typeof StepEdge;
+  smoothstep: typeof SmoothStepEdge;
+}
+type DefaultNodeTypes = { [key in 'input' | 'output' | 'default']: NodeComponent<BuiltInNode> };
+/** these props are passed to edge texts */
+interface EdgeTextProps {
+  x: number;
+  y: number;
+  label?: string | VNode | Component<EdgeTextProps> | object;
+  labelStyle?: CSSProperties;
+  labelShowBg?: boolean;
+  labelBgStyle?: CSSProperties;
+  labelBgPadding?: [number, number];
+  labelBgBorderRadius?: number;
+}
+//#endregion
+//#region src/types/edge.d.ts
+/** Edge markers */
+declare enum MarkerType {
+  Arrow = "arrow",
+  ArrowClosed = "arrowclosed"
+}
+/** Edge marker definition */
+interface EdgeMarker {
+  /** Unique marker id */
+  id?: string;
+  /** Marker type */
+  type: MarkerType;
+  /** Marker color */
+  color?: string;
+  /** Marker width */
+  width?: number;
+  /** Marker height */
+  height?: number;
+  /** Marker units */
+  markerUnits?: string;
+  /** Marker orientation */
+  orient?: string;
+  /** Marker stroke width */
+  strokeWidth?: number;
+}
+interface MarkerProps {
+  id: string;
+  type: MarkerType | string;
+  /** Marker color; `null`/unset lets the `--xy-edge-stroke` CSS variable drive the arrowhead color */
+  color?: string | null;
+  width?: number;
+  height?: number;
+  markerUnits?: string;
+  orient?: string;
+  strokeWidth?: number;
+}
+type EdgeMarkerType = string | EdgeMarker;
+type EdgeReconnectable = boolean | 'target' | 'source';
+interface EdgeLabelOptions {
+  /** Label styles (CSSProperties) */
+  labelStyle?: CSSProperties;
+  /** Show label bg */
+  labelShowBg?: boolean;
+  /** Label Bg styles (CSSProperties) */
+  labelBgStyle?: CSSProperties;
+  /** Label Bg padding */
+  labelBgPadding?: [number, number];
+  /** Label Bg border radius */
+  labelBgBorderRadius?: number;
+}
+/**
+ * User-facing edge type — reuses `@xyflow/system`'s `EdgeBase` (id, source/target(+handles), type,
+ * animated, markers, data, deletable/selectable/selected, hidden, zIndex, ariaLabel, interactionWidth)
+ * plus vue-flow-specific fields, mirroring how xyflow/react does `Edge = EdgeBase & EdgeLabelOptions & {…}`.
+ */
+interface DefaultEdge<Data extends Record<string, unknown> = Record<string, unknown>, Type extends string = string> extends EdgeBase<Data, Type>, EdgeLabelOptions {
+  /** An edge label */
+  label?: string | VNode | Component<EdgeTextProps>;
+  /** EdgeMarker — vue-flow's `EdgeMarkerType` (own `MarkerType` enum + `EdgeMarker`), overriding `EdgeBase`'s */
+  markerStart?: EdgeMarkerType;
+  /** EdgeMarker */
+  markerEnd?: EdgeMarkerType;
+  /** Disable/enable updating edge */
+  reconnectable?: EdgeReconnectable;
+  /** Disable/enable focusing edge (a11y) */
+  focusable?: boolean;
+  /** Additional class names */
+  class?: ClassValue;
+  /** Additional styles */
+  style?: Styles;
+  /** Overwrites current edge type */
+  template?: EdgeComponent;
+  /**
+   * General escape hatch for adding custom attributes to the edge's DOM element.
+   */
+  domAttributes?: Omit<SVGAttributes, 'id' | 'style' | 'className' | 'role' | 'aria-label' | 'onClick' | 'onMouseenter' | 'onMousemove' | 'onMouseleave' | 'onContextmenu' | 'onDblclick' | 'onKeyDown'>;
+}
+interface SmoothStepPathOptions {
+  offset?: number;
+  borderRadius?: number;
+  /** where the bend sits along the path: 0 = at source, 1 = at target, 0.5 = midpoint @default 0.5 */
+  stepPosition?: number;
+}
+type SmoothStepEdgeType<Data extends Record<string, unknown> = Record<string, unknown>> = DefaultEdge<Data> & {
+  type: 'smoothstep';
+  pathOptions?: SmoothStepPathOptions;
+};
+interface BezierPathOptions {
+  curvature?: number;
+}
+type BezierEdgeType<Data extends Record<string, unknown> = Record<string, unknown>> = DefaultEdge<Data> & {
+  type: 'default';
+  pathOptions?: BezierPathOptions;
+};
+type Edge<Data extends Record<string, unknown> = Record<string, unknown>, Type extends string = string> = DefaultEdge<Data, Type> | SmoothStepEdgeType<Data> | BezierEdgeType<Data>;
+type DefaultEdgeOptions = Omit<Edge, 'id' | 'source' | 'target' | 'sourceHandle' | 'targetHandle' | 'selected'>;
+/**
+ * The computed positions an edge renders with — a render-OUTPUT type (xyflow's `EdgePosition`),
+ * computed per render from the source/target `InternalNode`s. Never stored on an edge.
+ */
+interface EdgePositions {
+  sourceX: number;
+  sourceY: number;
+  targetX: number;
+  targetY: number;
+}
+/**
+ * Props passed to edge components. No `sourceNode`/`targetNode` (resolve them with `useInternalNode`);
+ * handles are exposed as `sourceHandleId`/`targetHandleId`; markers are pre-resolved to url strings.
+ */
+interface EdgeProps<EdgeType extends Edge = Edge> extends EdgeLabelOptions, EdgePositions {
+  id: string;
+  source: string;
+  target: string;
+  type?: EdgeType['type'];
+  label?: string | VNode | Component<EdgeTextProps> | object;
+  style?: CSSProperties;
+  selected?: boolean;
+  selectable?: boolean;
+  deletable?: boolean;
+  sourcePosition: Position$1;
+  targetPosition: Position$1;
+  sourceHandleId?: string | null;
+  targetHandleId?: string | null;
+  animated?: boolean;
+  reconnectable?: EdgeReconnectable;
+  markerStart?: string;
+  markerEnd?: string;
+  curvature?: number;
+  interactionWidth?: number;
+  data?: EdgeType['data'];
+}
+interface BaseEdgeProps extends EdgeLabelOptions {
+  id?: string;
+  labelX?: number;
+  labelY?: number;
+  path: string;
+  label?: any;
+  markerStart?: string;
+  markerEnd?: string;
+  interactionWidth?: number;
+}
+type BezierEdgeProps = EdgePositions & BezierPathOptions & Omit<BaseEdgeProps, 'labelX' | 'labelY' | 'path'> & Pick<EdgeProps, 'sourcePosition' | 'targetPosition'>;
+type SimpleBezierEdgeProps = EdgePositions & Omit<BaseEdgeProps, 'labelX' | 'labelY' | 'path'> & Pick<EdgeProps, 'sourcePosition' | 'targetPosition'>;
+type StraightEdgeProps = EdgePositions & Omit<BaseEdgeProps, 'labelX' | 'labelY' | 'path'>;
+type StepEdgeProps = EdgePositions & Omit<BaseEdgeProps, 'labelX' | 'labelY' | 'path'> & Pick<EdgeProps, 'sourcePosition' | 'targetPosition'>;
+type SmoothStepEdgeProps = EdgePositions & Omit<BaseEdgeProps, 'labelX' | 'labelY' | 'path'> & Pick<EdgeProps, 'sourcePosition' | 'targetPosition'> & SmoothStepPathOptions;
+//#endregion
+//#region src/types/changes.d.ts
+/**
+ * Drag-item shape used by the drag pipeline.
+ *
+ * Mirrors `@xyflow/system`'s `NodeDragItem` exactly so vue-flow's drag items are interchangeable with
+ * system types.
+ */
+interface NodeDragItem {
+  id: string;
+  /** relative node position (to parent) */
+  position: XYPosition$1;
+  /** distance from the mouse cursor to the node when start dragging */
+  distance: XYPosition$1;
+  measured: {
+    width: number;
+    height: number;
+  };
+  internals: {
+    positionAbsolute: XYPosition$1;
+  };
+  extent?: Node['extent'];
+  expandParent?: boolean;
+  dragging?: boolean;
+  origin?: NodeOrigin;
+  parentId?: string;
+}
+/**
+ * Node change types — mirror `@xyflow/system`'s shapes (no `replace` variant yet).
+ *
+ * Renames vs the previous vue-flow shape:
+ *   - `NodeDimensionChange.updateStyle` → `setAttributes` (truthy = set width/height on the DOM element;
+ *     `'width'` / `'height'` restricts which axis is written).
+ *   - `NodePositionChange.from` (the OLD absolute position) → dropped. Use `positionAbsolute` (the NEW
+ *     absolute position) which now matches xyflow/react / xyflow/svelte.
+ *
+ * Item shapes on add changes are the user-provided `Node` / `Edge` types (not the internal `InternalNode`).
+ */
+interface NodeAddChange<NodeType extends Node = Node> {
+  item: NodeType;
+  type: 'add';
+  index?: number;
+}
+type NodeChange<NodeType extends Node = Node> = NodeDimensionChange$1 | NodePositionChange$1 | NodeSelectionChange$1 | NodeRemoveChange$1 | NodeAddChange<NodeType>;
+interface EdgeAddChange<EdgeType extends Edge = Edge> {
+  item: EdgeType;
+  type: 'add';
+  index?: number;
+}
+type EdgeChange<EdgeType extends Edge = Edge> = EdgeSelectionChange$1 | EdgeRemoveChange$1 | EdgeAddChange<EdgeType>;
+type ElementChange = NodeChange | EdgeChange;
+//#endregion
+//#region src/types/panel.d.ts
+interface PanelProps {
+  position: PanelPosition;
+  /** accessible label for the panel container, applied as `aria-label` (used by `<Controls>`) */
+  label?: string | null;
+}
+//#endregion
+//#region src/types/reactivity-augmentation.d.ts
+declare module '@vue/reactivity' {
+  interface RefUnwrapBailTypes {
+    vueFlowNode: Pick<Node, 'id' | 'position'>;
+    vueFlowEdge: Pick<Edge, 'id' | 'source' | 'target'>;
+  }
+}
+//#endregion
+//#region src/types/zoom.d.ts
+/** vue-flow accepts the richer `Padding` here (system's `FitBoundsOptions` is `padding?: number`) */
+type FitBoundsOptions = ViewportHelperFunctionOptions$1 & {
+  padding?: Padding$1;
+};
+/** Fit the viewport around visible nodes */
+type FitView<NodeType extends Node = Node> = (fitViewOptions?: FitViewOptionsBase<NodeType>) => Promise<boolean>;
+/** fit the viewport around bounds */
+type FitBounds = (bounds: Rect$1, options?: FitBoundsOptions) => Promise<boolean>;
+interface ViewportFunctions<NodeType extends Node = Node> {
+  zoomIn: ZoomInOut$1;
+  zoomOut: ZoomInOut$1;
+  zoomTo: ZoomTo$1;
+  setViewport: SetViewport$1;
+  getViewport: GetViewport$1;
+  fitView: FitView<NodeType>;
+  setCenter: SetCenter$1;
+  fitBounds: FitBounds;
+}
+//#endregion
+//#region src/components/Controls/types.d.ts
+interface ControlProps {
+  /**
+   * Show the zoom control buttons (zoom-in and zoom-out)
+   *
+   * @default true
+   */
+  showZoom?: boolean;
+  /**
+   * Show the fit view control button
+   *
+   * @default true
+   */
+  showFitView?: boolean;
+  /**
+   * Show the interactivity toggle control button
+   *
+   * @default true
+   */
+  showInteractive?: boolean;
+  /**
+   * {@link FitViewOptionsBase Parameters} to use when the fit view control button is pressed
+   *
+   * @default undefined
+   */
+  fitViewParams?: FitViewOptionsBase<Node>;
+  /**
+   * The {@link PanelPosition position} of the `<Controls>` panel
+   *
+   * @default 'bottom-left'
+   */
+  position?: PanelPosition;
+  /**
+   * Accessible label for the controls panel; falls back to `ariaLabelConfig['controls.ariaLabel']`.
+   *
+   * @default 'Control Panel'
+   */
+  ariaLabel?: string | null;
+}
+interface ControlEmits {
+  zoomIn: [];
+  zoomOut: [];
+  fitView: [];
+  interactionChange: [isInteractive: boolean];
+}
+//#endregion
+//#region src/components/Controls/Controls.vue.d.ts
+declare const _default$3: typeof __VLS_export$8;
+declare const __VLS_export$8: __VLS_WithSlots$5<import("vue").DefineComponent<ControlProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  zoomIn: () => any;
+  zoomOut: () => any;
+  fitView: () => any;
+  interactionChange: (isInteractive: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<ControlProps> & Readonly<{
+  onZoomIn?: (() => any) | undefined;
+  onZoomOut?: (() => any) | undefined;
+  onFitView?: (() => any) | undefined;
+  onInteractionChange?: ((isInteractive: boolean) => any) | undefined;
+}>, {
+  position: import("@xyflow/system").PanelPosition;
+  showZoom: boolean;
+  showFitView: boolean;
+  showInteractive: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  top?: (props: {}) => any;
+} & {
+  'control-zoom-in'?: (props: {}) => any;
+} & {
+  'icon-zoom-in'?: (props: {}) => any;
+} & {
+  'control-zoom-out'?: (props: {}) => any;
+} & {
+  'icon-zoom-out'?: (props: {}) => any;
+} & {
+  'control-fit-view'?: (props: {}) => any;
+} & {
+  'icon-fit-view'?: (props: {}) => any;
+} & {
+  'control-interactive'?: (props: {}) => any;
+} & {
+  'icon-unlock'?: (props: {}) => any;
+} & {
+  'icon-lock'?: (props: {}) => any;
+} & {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$5<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/MiniMap/types.d.ts
+/** expects a node and returns a color value */
+type MiniMapNodeFunc = (node: InternalNode) => string;
+type ShapeRendering = CSSProperties['shapeRendering'];
+interface MiniMapProps {
+  /** Node color, can be either a string or a string func that receives the current node */
+  nodeColor?: string | MiniMapNodeFunc;
+  /** Node stroke color, can be either a string or a string func that receives the current node */
+  nodeStrokeColor?: string | MiniMapNodeFunc;
+  /** Additional node class name, can be either a string or a string func that receives the current node */
+  nodeClassName?: string | MiniMapNodeFunc;
+  /** Node border radius */
+  nodeBorderRadius?: number;
+  /** Node stroke width */
+  nodeStrokeWidth?: number;
+  /** Background color of minimap mask */
+  maskColor?: string;
+  /** Border color of minimap mask */
+  maskStrokeColor?: string;
+  /** Border width of minimap mask */
+  maskStrokeWidth?: number;
+  /** Position of the minimap {@link PanelPosition} */
+  position?: PanelPosition;
+  /** Enable drag minimap to drag viewport */
+  pannable?: boolean;
+  /** Enable zoom minimap to zoom viewport */
+  zoomable?: boolean;
+  width?: number;
+  height?: number;
+  ariaLabel?: string | null;
+  /** Enable inverse panning, i.e. drag minimap to move viewport in opposite direction */
+  inversePan?: boolean;
+  /** Specify zoom step */
+  zoomStep?: number;
+  /** Specify minimap scale */
+  offsetScale?: number;
+  /** Mask border radius */
+  maskBorderRadius?: number;
+}
+/** these props are passed to mini map node slots */
+interface MiniMapNodeProps {
+  id: string;
+  type?: string;
+  selected?: boolean;
+  dragging?: boolean;
+  position: XYPosition$1;
+  dimensions: Dimensions$1;
+  borderRadius?: number;
+  color?: string;
+  shapeRendering?: ShapeRendering;
+  strokeColor?: string;
+  strokeWidth?: number;
+  hidden?: boolean;
+}
+interface MiniMapEmits {
+  click: [params: {
+    event: MouseEvent;
+    position: XYPosition$1;
+  }];
+  nodeClick: [params: NodeMouseEvent];
+  nodeDblclick: [params: NodeMouseEvent];
+  nodeMouseenter: [params: NodeMouseEvent];
+  nodeMousemove: [params: NodeMouseEvent];
+  nodeMouseleave: [params: NodeMouseEvent];
+}
+interface MiniMapNodeEmits {
+  click: [params: MouseEvent];
+  dblclick: [params: MouseEvent];
+  mouseenter: [params: MouseEvent];
+  mousemove: [params: MouseEvent];
+  mouseleave: [params: MouseEvent];
+}
+interface MiniMapSlots extends Record<`node-${string}`, (nodeProps: MiniMapNodeProps) => any> {}
+declare const Slots: InjectionKey<MiniMapSlots>;
+//#endregion
+//#region src/components/MiniMap/MiniMap.vue.d.ts
+declare const _default$7: typeof __VLS_export$7;
+declare const __VLS_export$7: __VLS_WithSlots$4<import("vue").DefineComponent<MiniMapProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  click: (params: {
+    event: MouseEvent;
+    position: import("@xyflow/system").XYPosition;
+  }) => any;
+  nodeClick: (params: NodeMouseEvent<Node>) => any;
+  nodeDblclick: (params: NodeMouseEvent<Node>) => any;
+  nodeMouseenter: (params: NodeMouseEvent<Node>) => any;
+  nodeMousemove: (params: NodeMouseEvent<Node>) => any;
+  nodeMouseleave: (params: NodeMouseEvent<Node>) => any;
+}, string, import("vue").PublicProps, Readonly<MiniMapProps> & Readonly<{
+  onClick?: ((params: {
+    event: MouseEvent;
+    position: import("@xyflow/system").XYPosition;
+  }) => any) | undefined;
+  onNodeClick?: ((params: NodeMouseEvent<Node>) => any) | undefined;
+  onNodeDblclick?: ((params: NodeMouseEvent<Node>) => any) | undefined;
+  onNodeMouseenter?: ((params: NodeMouseEvent<Node>) => any) | undefined;
+  onNodeMousemove?: ((params: NodeMouseEvent<Node>) => any) | undefined;
+  onNodeMouseleave?: ((params: NodeMouseEvent<Node>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, MiniMapSlots>;
+type __VLS_WithSlots$4<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/MiniMap/MiniMapNode.vue.d.ts
+declare const _default$8: typeof __VLS_export$6;
+declare const __VLS_export$6: import("vue").DefineComponent<MiniMapNodeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  click: (params: MouseEvent) => any;
+  dblclick: (params: MouseEvent) => any;
+  mouseenter: (params: MouseEvent) => any;
+  mouseleave: (params: MouseEvent) => any;
+  mousemove: (params: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<MiniMapNodeProps> & Readonly<{
+  onClick?: ((params: MouseEvent) => any) | undefined;
+  onDblclick?: ((params: MouseEvent) => any) | undefined;
+  onMouseenter?: ((params: MouseEvent) => any) | undefined;
+  onMouseleave?: ((params: MouseEvent) => any) | undefined;
+  onMousemove?: ((params: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+//#endregion
+//#region src/components/NodeResizer/types.d.ts
+interface OnResizeStart {
+  event: ResizeDragEvent$1;
+  params: ResizeParams$1;
+}
+interface OnResize {
+  event: ResizeDragEvent$1;
+  params: ResizeParamsWithDirection$1;
+}
+interface OnResizeEnd {
+  event: ResizeDragEvent$1;
+  params: ResizeParams$1;
+}
+interface NodeResizerProps {
+  nodeId?: string;
+  color?: string;
+  handleClassName?: string;
+  handleStyle?: CSSProperties;
+  lineClassName?: string;
+  lineStyle?: CSSProperties;
+  isVisible?: boolean;
+  minWidth?: number;
+  minHeight?: number;
+  maxWidth?: number;
+  maxHeight?: number;
+  shouldResize?: ShouldResize$1;
+  keepAspectRatio?: boolean | number;
+  /**
+   * Scale the controls with the zoom level.
+   * @default true
+   */
+  autoScale?: boolean;
+}
+interface NodeResizerEmits {
+  resizeStart: [resizeEvent: OnResizeStart];
+  resize: [resizeEvent: OnResize];
+  resizeEnd: [resizeEvent: OnResizeStart];
+}
+interface ResizeControlProps extends NodeResizerProps {
+  nodeId?: string;
+  color?: string;
+  minWidth?: number;
+  minHeight?: number;
+  maxWidth?: number;
+  maxHeight?: number;
+  position?: ControlPosition$1;
+  variant?: ResizeControlVariant$1;
+  shouldResize?: ShouldResize$1;
+  keepAspectRatio?: boolean | number;
+  /**
+   * Scale the controls with the zoom level.
+   * @default true
+   */
+  autoScale?: boolean;
+}
+interface ResizeControlLineProps extends ResizeControlProps {
+  nodeId?: string;
+  color?: string;
+  minWidth?: number;
+  minHeight?: number;
+  maxWidth?: number;
+  maxHeight?: number;
+  variant?: ResizeControlVariant$1;
+  position?: ControlLinePosition$1;
+  keepAspectRatio?: boolean | number;
+}
+//#endregion
+//#region src/components/NodeResizer/NodeResizer.vue.d.ts
+declare const _default$10: typeof __VLS_export$5;
+declare const __VLS_export$5: import("vue").DefineComponent<NodeResizerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  resize: (resizeEvent: OnResize) => any;
+  resizeStart: (resizeEvent: OnResizeStart) => any;
+  resizeEnd: (resizeEvent: OnResizeStart) => any;
+}, string, import("vue").PublicProps, Readonly<NodeResizerProps> & Readonly<{
+  onResize?: ((resizeEvent: OnResize) => any) | undefined;
+  onResizeStart?: ((resizeEvent: OnResizeStart) => any) | undefined;
+  onResizeEnd?: ((resizeEvent: OnResizeStart) => any) | undefined;
+}>, {
+  isVisible: boolean;
+  autoScale: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+//#endregion
+//#region src/components/NodeResizer/ResizeControl.vue.d.ts
+declare const _default$9: typeof __VLS_export$4;
+declare const __VLS_export$4: __VLS_WithSlots$3<import("vue").DefineComponent<ResizeControlProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  resize: (resizeEvent: OnResize) => any;
+  resizeStart: (resizeEvent: OnResizeStart) => any;
+  resizeEnd: (resizeEvent: OnResizeStart) => any;
+}, string, import("vue").PublicProps, Readonly<ResizeControlProps> & Readonly<{
+  onResize?: ((resizeEvent: OnResize) => any) | undefined;
+  onResizeStart?: ((resizeEvent: OnResizeStart) => any) | undefined;
+  onResizeEnd?: ((resizeEvent: OnResizeStart) => any) | undefined;
+}>, {
+  variant: ResizeControlVariant$2;
+  minWidth: number;
+  minHeight: number;
+  maxWidth: number;
+  maxHeight: number;
+  keepAspectRatio: boolean | number;
+  autoScale: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$3<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/NodeToolbar/types.d.ts
+interface NodeToolbarProps {
+  nodeId?: string | string[];
+  isVisible?: boolean;
+  position?: Position$1;
+  offset?: number;
+  align?: 'center' | 'start' | 'end';
+}
+//#endregion
+//#region src/components/NodeToolbar/NodeToolbar.vue.d.ts
+declare const _default$11: typeof __VLS_export$3;
+declare const __VLS_export$3: __VLS_WithSlots$2<import("vue").DefineComponent<NodeToolbarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NodeToolbarProps> & Readonly<{}>, {
+  position: Position$1;
+  offset: number;
+  isVisible: boolean;
+  align: "center" | "start" | "end";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$2<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Panel/Panel.vue.d.ts
+declare const _default$12: typeof __VLS_export$2;
+declare const __VLS_export$2: __VLS_WithSlots$1<import("vue").DefineComponent<PanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PanelProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/composables/useConnection.d.ts
+/**
+ * Access the currently ongoing connection, composed from the store's split connection fields into a
+ * single {@link ConnectionState}.
+ *
+ * @public
+ * @returns a `ComputedRef<ConnectionState>` — `inProgress: false` (all-null fields) when idle
+ */
+declare function useConnection<NodeType extends Node = Node>(): ComputedRef<ConnectionState<NodeType>>;
+//#endregion
+//#region src/composables/useEdgesData.d.ts
+interface EdgeData<EdgeType extends Edge = Edge> {
+  id: string;
+  type: EdgeType['type'];
+  data: NonNullable<EdgeType['data']> | null;
+}
+/**
+ * Composable for receiving data of one or multiple nodes
+ *
+ * @public
+ * @param edgeId - The id (or ids) of the node to get the data from
+ * @param guard - Optional guard function to narrow down the node type
+ * @returns An array of data objects
+ */
+declare function useEdgesData<EdgeType extends Edge = Edge>(edgeId: MaybeRefOrGetter<string>): ComputedRef<EdgeData<EdgeType> | null>;
+declare function useEdgesData<EdgeType extends Edge = Edge>(edgeIds: MaybeRefOrGetter<string[]>): ComputedRef<EdgeData<EdgeType>[]>;
+declare function useEdgesData<EdgeType extends Edge = Edge>(edgeIds: MaybeRefOrGetter<string[]>, guard: (node: Edge) => node is EdgeType): ComputedRef<EdgeData<EdgeType>[]>;
+//#endregion
+//#region src/composables/useNodeConnections.d.ts
+type UseNodeConnectionsParams = {
+  /** node id - if not provided, the node id from the `useNodeId` context injection is used */id?: MaybeRefOrGetter<string | null | undefined>;
+  onConnect?: (connections: NodeConnection$1[]) => void;
+  onDisconnect?: (connections: NodeConnection$1[]) => void;
+} & ({
+  /** handle type `source` or `target` */handleType: MaybeRefOrGetter<HandleType$1 | null | undefined>; /** the handle id (only needed if the node has multiple handles of the same type). Requires `handleType` to be set. */
+  handleId?: MaybeRefOrGetter<string | null | undefined>;
+} | {
+  handleType?: MaybeRefOrGetter<HandleType$1 | null | undefined>;
+  handleId?: never;
+});
+/**
+ * Hook to retrieve all edges connected to a node. Can be filtered by handle type and id.
+ *
+ * @public
+ * @param params
+ * @param params.handleType - handle type `source` or `target`
+ * @param params.id - node id - if not provided, the node id from the `useNodeId` (meaning, the context-based injection) is used
+ * @param params.handleId - the handle id (only needed if the node has multiple handles of the same type; requires `handleType` to be set)
+ * @param params.onConnect - gets called when a connection is created
+ * @param params.onDisconnect - gets called when a connection is removed
+ *
+ * @returns An array of connections
+ */
+declare function useNodeConnections(params?: UseNodeConnectionsParams): import("vue").ComputedRef<NodeConnection$1[]>;
+//#endregion
+//#region src/composables/useNodeId.d.ts
+/**
+ * This composable returns the current node id from the ctx.
+ *
+ * It should be used inside a (custom-)node components ctx as the id is provided by the internal `NodeWrapper` component.
+ *
+ * @public
+ * @returns the current node id
+ */
+declare function useNodeId(): string;
+//#endregion
+//#region src/composables/useNodesData.d.ts
+type NodeData<NodeType extends Node = InternalNode> = DistributivePick<NodeType, 'id' | 'type' | 'data'>;
+/**
+ * Composable for receiving data of one or multiple nodes
+ *
+ * @public
+ * @param nodeId - The id (or ids) of the node to get the data from
+ * @param guard - Optional guard function to narrow down the node type
+ * @returns An array of data objects
+ */
+declare function useNodesData<NodeType extends Node = InternalNode>(nodeId: MaybeRefOrGetter<string>): ComputedRef<NodeData<NodeType> | null>;
+declare function useNodesData<NodeType extends Node = InternalNode>(nodeIds: MaybeRefOrGetter<string[]>): ComputedRef<NodeData<NodeType>[]>;
+declare function useNodesData<NodeType extends Node = InternalNode>(nodeIds: MaybeRefOrGetter<string[]>, guard: (node: Node) => node is NodeType): ComputedRef<NodeData<NodeType>[]>;
+//#endregion
+//#region src/composables/useNodesInitialized.d.ts
+interface UseNodesInitializedOptions {
+  includeHiddenNodes?: boolean;
+}
+/**
+ * Composable for getting the initialized state of all nodes.
+ *
+ * When a new node is added to the graph, it is not immediately initialized.
+ * That's because the node's bounds are not yet known.
+ * This composable will return false and then true when all nodes are initialized, i.e. when their bounds are known.
+ *
+ * @public
+ * @param options - Options
+ * @returns boolean indicating whether all nodes are initialized
+ */
+declare function useNodesInitialized(options?: UseNodesInitializedOptions): import("vue").ComputedRef<boolean>;
+//#endregion
+//#region src/container/VueFlow/VueFlow.vue.d.ts
+declare const _default$13: typeof __VLS_export$1;
+declare const __VLS_export$1: <NodeType extends Node = Node, EdgeType extends Edge = Edge>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: import("vue").PublicProps & __VLS_PrettifyLocal<(FlowProps<NodeType, EdgeType> & {
+    nodes?: NodeType[];
+    edges?: EdgeType[];
+    viewport?: Viewport$1;
+  }) & {
+    [x: `on${Capitalize<string>}`]: ((...args: any) => any) | undefined;
+  }> & (typeof globalThis extends {
+    __VLS_PROPS_FALLBACK: infer P;
+  } ? P : {});
+  expose: (exposed: import("vue").ShallowUnwrapRef<VueFlowInstance<NodeType, EdgeType>>) => void;
+  attrs: any;
+  slots: FlowSlots<NodeType, EdgeType>;
+  emit: (((evt: "error", error: VueFlowError<ErrorCode, [] | [id?: string | undefined] | [id: string | null] | [id: string, parentId: string] | [type: string] | [id: string] | [id: string] | [id: string, source: string] | [id: string, target: string] | [type: string] | [id: string, source: string, target: string] | [id: string]>) => void) & ((evt: "nodesChange", changes: NodeChange<NodeType>[]) => void) & ((evt: "edgesChange", changes: EdgeChange<EdgeType>[]) => void) & ((evt: "nodeDoubleClick", nodeMouseEvent: NodeMouseEvent<NodeType>) => void) & ((evt: "nodeClick", nodeMouseEvent: NodeMouseEvent<NodeType>) => void) & ((evt: "nodeMouseEnter", nodeMouseEvent: NodeMouseEvent<NodeType>) => void) & ((evt: "nodeMouseMove", nodeMouseEvent: NodeMouseEvent<NodeType>) => void) & ((evt: "nodeMouseLeave", nodeMouseEvent: NodeMouseEvent<NodeType>) => void) & ((evt: "nodeContextMenu", nodeMouseEvent: NodeMouseEvent<NodeType>) => void) & ((evt: "nodeDragStart", nodeDragEvent: NodeDragEvent<NodeType>) => void) & ((evt: "nodeDrag", nodeDragEvent: NodeDragEvent<NodeType>) => void) & ((evt: "nodeDragStop", nodeDragEvent: NodeDragEvent<NodeType>) => void) & ((evt: "nodesInitialized", nodes: NodeType[]) => void) & ((evt: "updateNodeInternals") => void) & ((evt: "miniMapNodeClick", nodeMouseEvent: NodeMouseEvent<NodeType>) => void) & ((evt: "miniMapNodeDoubleClick", nodeMouseEvent: NodeMouseEvent<NodeType>) => void) & ((evt: "miniMapNodeMouseEnter", nodeMouseEvent: NodeMouseEvent<NodeType>) => void) & ((evt: "miniMapNodeMouseMove", nodeMouseEvent: NodeMouseEvent<NodeType>) => void) & ((evt: "miniMapNodeMouseLeave", nodeMouseEvent: NodeMouseEvent<NodeType>) => void) & ((evt: "connect", connectionEvent: import("@xyflow/system").Connection) => void) & ((evt: "connectStart", connectionEvent: {
+    event?: MouseEvent;
+  } & OnConnectStartParams) => void) & ((evt: "connectEnd", connectionEvent: ConnectEndEvent<NodeType>) => void) & ((evt: "clickConnectStart", connectionEvent: {
+    event?: MouseEvent;
+  } & OnConnectStartParams) => void) & ((evt: "clickConnectEnd", connectionEvent: ConnectEndEvent<NodeType>) => void) & ((evt: "init", paneEvent: VueFlowInstance<NodeType, EdgeType>) => void) & ((evt: "move", moveEvent: {
+    event: MouseTouchEvent | null;
+    viewport: Viewport$1;
+  }) => void) & ((evt: "moveStart", moveEvent: {
+    event: MouseTouchEvent | null;
+    viewport: Viewport$1;
+  }) => void) & ((evt: "moveEnd", moveEvent: {
+    event: MouseTouchEvent | null;
+    viewport: Viewport$1;
+  }) => void) & ((evt: "selectionDragStart", selectionEvent: NodeDragEvent<NodeType>) => void) & ((evt: "selectionDrag", selectionEvent: NodeDragEvent<NodeType>) => void) & ((evt: "selectionDragStop", selectionEvent: NodeDragEvent<NodeType>) => void) & ((evt: "selectionContextMenu", selectionEvent: {
+    event: MouseEvent;
+    nodes: NodeType[];
+  }) => void) & ((evt: "selectionStart", selectionEvent: MouseEvent) => void) & ((evt: "selectionEnd", selectionEvent: MouseEvent) => void) & ((evt: "selectionChange", selectionEvent: SelectionChangeEvent<NodeType, EdgeType>) => void) & ((evt: "viewportChangeStart", viewport: Viewport$1) => void) & ((evt: "viewportChange", viewport: Viewport$1) => void) & ((evt: "viewportChangeEnd", viewport: Viewport$1) => void) & ((evt: "paneScroll", paneEvent: WheelEvent | undefined) => void) & ((evt: "paneClick", paneEvent: MouseEvent) => void) & ((evt: "paneContextMenu", paneEvent: MouseEvent) => void) & ((evt: "paneMouseEnter", paneEvent: MouseEvent) => void) & ((evt: "paneMouseMove", paneEvent: MouseEvent) => void) & ((evt: "paneMouseLeave", paneEvent: MouseEvent) => void) & ((evt: "edgeContextMenu", edgeMouseEvent: EdgeMouseEvent<EdgeType>) => void) & ((evt: "edgeMouseEnter", edgeMouseEvent: EdgeMouseEvent<EdgeType>) => void) & ((evt: "edgeMouseMove", edgeMouseEvent: EdgeMouseEvent<EdgeType>) => void) & ((evt: "edgeMouseLeave", edgeMouseEvent: EdgeMouseEvent<EdgeType>) => void) & ((evt: "edgeDoubleClick", edgeMouseEvent: EdgeMouseEvent<EdgeType>) => void) & ((evt: "edgeClick", edgeMouseEvent: EdgeMouseEvent<EdgeType>) => void) & ((evt: "reconnectStart", edgeReconnectEvent: EdgeReconnectStartEvent<EdgeType>) => void) & ((evt: "reconnect", reconnectEvent: EdgeReconnectEvent<EdgeType>) => void) & ((evt: "reconnectEnd", edgeReconnectEvent: EdgeReconnectEndEvent<NodeType, EdgeType>) => void)) & (((event: "update:nodes", value: NodeType[] | undefined) => void) & ((event: "update:edges", value: EdgeType[] | undefined) => void) & ((event: "update:viewport", value: Viewport$1 | undefined) => void));
+}>) => import("vue").VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
+//#endregion
+//#region src/container/VueFlowProvider/VueFlowProvider.vue.d.ts
+declare const _default$14: typeof __VLS_export;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+  id?: string;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+  id?: string;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/context/index.d.ts
+/** the curated instance (`useVueFlow()`) */
+declare const VueFlow: InjectionKey<VueFlowInstance>;
+declare const NodeId: InjectionKey<string>;
+//#endregion
+//#region src/utils/defaultNodesEdges.d.ts
+declare const defaultNodeTypes: DefaultNodeTypes;
+declare const defaultEdgeTypes: DefaultEdgeTypes;
+//#endregion
+export { Actions, AddEdges, AddNodes, type Align, type AriaLabelConfig, _default as Background, BackgroundProps, BackgroundVariant, _default$1 as BaseEdge, BaseEdgeProps, BezierEdge, BezierEdgeProps, BezierEdgeType, BezierPathOptions, BuiltInNode, CSSVars, ClassValue, type ColorMode, type ColorModeClass, ComputedGetters, ConnectEndEvent, ConnectingHandle, type Connection, ConnectionInProgress, ConnectionLineOptions, ConnectionLineProps, ConnectionLineType, ConnectionLookup, ConnectionMode, ConnectionState, ConnectionStatus, Connector, _default$2 as ControlButton, ControlEmits, type ControlLinePosition, type ControlPosition, ControlProps, _default$3 as Controls, type CoordinateExtent, CustomThemeVars, DefaultEdge, DefaultEdgeOptions, DefaultEdgeTypes, DefaultNodeTypes, DeleteElements, type Dimensions, Edge, EdgeAddChange, EdgeChange, EdgeComponent, EdgeEventsHandler, EdgeEventsOn, EdgeLabelOptions, _default$4 as EdgeLabelRenderer, EdgeLookup, EdgeMarker, EdgeMarkerType, EdgeMouseEvent, EdgePositions, EdgeProps, EdgeReconnectEndEvent, EdgeReconnectEvent, EdgeReconnectStartEvent, EdgeReconnectable, type EdgeRemoveChange, type EdgeSelectionChange, EdgeSlots, _default$5 as EdgeText, EdgeTextProps, EdgeTypesObject, ElementChange, ErrorCode, type FinalConnectionState, FitBounds, FitBoundsOptions, FitView, type FitViewOptions, FlowEmits, FlowEvents, FlowExportObject, FlowHooks, FlowHooksEmit, FlowHooksOn, FlowOptions, FlowProps, FlowSlots, GetEdge, GetInternalNode, GetIntersectingNodes, GetNode, type GetViewport, Getters, _default$6 as Handle, HandleConnectable, HandleConnectableFunc, HandleElement, HandleProps, type HandleType, InternalNode, IsNodeIntersecting, IsValidParams, MarkerProps, MarkerType, _default$7 as MiniMap, MiniMapEmits, _default$8 as MiniMapNode, MiniMapNodeEmits, MiniMapNodeFunc, MiniMapNodeProps, MiniMapProps, MiniMapSlots, MouseTouchEvent, NoConnection, Node, NodeAddChange, NodeChange, NodeComponent, type NodeConnection, type NodeDimensionChange, NodeDragEvent, NodeDragItem, NodeEventsHandler, NodeEventsOn, NodeHandleBounds, NodeId as NodeIdInjection, NodeLookup, NodeMouseEvent, NodeOrigin, type NodePositionChange, NodeProps, type NodeRemoveChange, _default$9 as NodeResizeControl, _default$10 as NodeResizer, NodeResizerEmits, NodeResizerProps, type NodeSelectionChange, NodeSlots, _default$11 as NodeToolbar, NodeToolbarProps, NodeTypesObject, OnBeforeDelete, OnConnectStartParams, OnResize, OnResizeEnd, OnResizeStart, type Padding, type PaddingUnit, type PaddingWithUnit, PanOnScrollMode, _default$12 as Panel, PanelProps, Position, type Project, ReconnectEdge, type Rect, RemoveEdges, RemoveNodes, ResizeControlLineProps, ResizeControlProps, ResizeControlVariant, type ResizeDragEvent, type ResizeParams, type ResizeParamsWithDirection, Result, SelectionChangeEvent, SelectionMode, type SelectionRect, type SetCenter, type SetCenterOptions, SetEdges, SetNodes, SetState, SetStateOptions, type SetViewport, ShapeRendering, type ShouldResize, SimpleBezierEdge, SimpleBezierEdgeProps, Slots, SmoothStepEdge, SmoothStepEdgeProps, SmoothStepEdgeType, SmoothStepPathOptions, type SnapGrid, State, StepEdge, StepEdgeProps, StraightEdge, StraightEdgeProps, Styles, ThemeVars, UpdateEdge, UpdateEdgeData, UpdateNode, UpdateNodeData, UpdateNodeDimensions, UpdateNodeDimensionsParams, UpdateNodeInternals, UpdateNodePosition, ValidConnectionFunc, type Viewport, ViewportFunctions, type ViewportHelperFunctionOptions, _default$13 as VueFlow, VueFlowError, VueFlow as VueFlowInjection, VueFlowInstance, _default$14 as VueFlowProvider, VueFlowState, VueFlowStoreHandle, type XYPosition, type ZIndexMode, type ZoomInOut, type ZoomTo, applyChanges, applyEdgeChanges, applyNodeChanges, clamp, connectionExists, defaultEdgeTypes, defaultNodeTypes, getBezierEdgeCenter, getBezierPath, getBoundsOfBoxes, getBoundsOfRects, getConnectedEdges, getConnectionStatus, getIncomers, getMarkerId, getNodesBounds, getNodesInside, getOutgoers, getSimpleBezierPath, getSmoothStepPath, getStraightPath, getViewportForBounds, isEdge, isEdgeBase, isErrorOfType, isInternalNode, isInternalNodeBase, isMacOs, isNode, isNodeBase, pointToRendererPoint, rendererPointToPoint, storeToRefs, useConnection, useEdge, useEdgesData, useHandle, useInternalNode, useKeyPress, useNode, useNodeConnections, useNodeId, useNodesData, useNodesInitialized, useStore, useVueFlow };
+//# sourceMappingURL=index.d.ts.map