@dskripchenko/flow 0.0.0-stage → 1.0.1

package/dist/vue.d.ts

@@ -0,0 +1,1041 @@
+import { App } from 'vue';
+import { AppContext } from 'vue';
+import { Component } from 'vue';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComputedRef } from 'vue';
+import { DefineComponent } from 'vue';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+import { ShallowRef } from 'vue';
+
+declare const __VLS_base: DefineComponent<__VLS_Props, {
+    fit: () => void | undefined;
+    enter: typeof enter;
+    back: typeof back;
+    refresh: () => void | undefined;
+    select: (id: string | null) => void;
+    stack: ShallowRef<NavigationLevel[], NavigationLevel[]>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    select: (element: (ElementRef & {
+        element: FlowNode | FlowEdge;
+        path: string[];
+    }) | null) => any;
+    toggle: (change: ToggleChange) => any;
+    "update:minimap": (value: boolean) => any;
+    "toggle-error": (change: ToggleChange, error: unknown) => any;
+    navigate: (stack: NavigationLevel[]) => any;
+    "poll-error": (error: unknown) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((element: (ElementRef & {
+        element: FlowNode | FlowEdge;
+        path: string[];
+    }) | null) => any) | undefined;
+    onToggle?: ((change: ToggleChange) => any) | undefined;
+    "onUpdate:minimap"?: ((value: boolean) => any) | undefined;
+    "onToggle-error"?: ((change: ToggleChange, error: unknown) => any) | undefined;
+    onNavigate?: ((stack: NavigationLevel[]) => any) | undefined;
+    "onPoll-error"?: ((error: unknown) => any) | undefined;
+}>, {
+    state: MonitorSnapshot | MonitorState;
+    direction: "TB" | "LR" | "auto";
+    wheel: "zoom" | "pan";
+    onToggle: (change: ToggleChange) => Promise<unknown> | unknown;
+    minimap: boolean;
+    details: boolean;
+    labels: Partial<FlowLabels>;
+    registry: NodeTypeRegistry;
+    edgeStyle: "orthogonal" | "smooth";
+    controls: boolean;
+    minZoom: number;
+    maxZoom: number;
+    nodeRenderers: Record<string, Component>;
+    nodeIcons: Record<string, Component>;
+    statusTones: Record<string, string>;
+    locale: string;
+    poll: PollOptions;
+    pollParams: undefined;
+    staleAfterMs: number;
+    subgraphs: Record<string, Graph>;
+    loadSubgraph: (ref: string, node: FlowNode) => Promise<Graph>;
+    toastProvider: boolean;
+    statusBar: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_base_2: DefineComponent<__VLS_Props_2, {
+    fit: typeof fit;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    zoomTo: (k: number) => void;
+    centreOn: (id: string) => void;
+    focusElement: typeof focusElement;
+    clientToGraph: (clientX: number, clientY: number) => Point;
+    viewCentre: () => {
+        x: number;
+        y: number;
+    };
+    layout: ComputedRef<GraphLayout>;
+    nodeBoxes: ComputedRef<Map<string, NodeGeometry>>;
+    root: Ref<HTMLElement | null, HTMLElement | null>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    contextmenu: (payload: ContextPayload) => any;
+    select: (ids: string[], primary: ElementRef | null) => any;
+    toggle: (change: {
+        kind: "node" | "edge";
+        id: string;
+        enabled: boolean;
+    }) => any;
+    enter: (nodeId: string) => any;
+    "update:minimap": (value: boolean) => any;
+    activate: (ref: ElementRef) => any;
+    move: (moves: {
+        id: string;
+        position: Point;
+    }[], merge?: string | undefined) => any;
+    connect: (payload: ConnectPayload) => any;
+    reconnect: (payload: ReconnectPayload) => any;
+    detach: (edgeId: string) => any;
+    "background-dblclick": (point: Point) => any;
+    escape: () => any;
+    "focus-change": (id: string | null) => any;
+}, string, PublicProps, Readonly<__VLS_Props_2> & Readonly<{
+    onContextmenu?: ((payload: ContextPayload) => any) | undefined;
+    onSelect?: ((ids: string[], primary: ElementRef | null) => any) | undefined;
+    onToggle?: ((change: {
+        kind: "node" | "edge";
+        id: string;
+        enabled: boolean;
+    }) => any) | undefined;
+    onEnter?: ((nodeId: string) => any) | undefined;
+    "onUpdate:minimap"?: ((value: boolean) => any) | undefined;
+    onActivate?: ((ref: ElementRef) => any) | undefined;
+    onMove?: ((moves: {
+        id: string;
+        position: Point;
+    }[], merge?: string | undefined) => any) | undefined;
+    onConnect?: ((payload: ConnectPayload) => any) | undefined;
+    onReconnect?: ((payload: ReconnectPayload) => any) | undefined;
+    onDetach?: ((edgeId: string) => any) | undefined;
+    "onBackground-dblclick"?: ((point: Point) => any) | undefined;
+    onEscape?: (() => any) | undefined;
+    "onFocus-change"?: ((id: string | null) => any) | undefined;
+}>, {
+    direction: "TB" | "LR" | "auto";
+    wheel: "zoom" | "pan";
+    minimap: boolean;
+    issues: ReadonlyMap<string, "error" | "warning">;
+    drillable: (node: FlowNode) => boolean;
+    selection: readonly string[];
+    registry: NodeTypeRegistry;
+    edgeStyle: "orthogonal" | "smooth";
+    monitor: MonitorState;
+    enabledOverrides: ReadonlyMap<string, boolean>;
+    snapGrid: number;
+    controls: boolean;
+    minZoom: number;
+    maxZoom: number;
+    nodeRenderers: Record<string, Component>;
+    nodeIcons: Record<string, Component>;
+    statusTones: Record<string, string>;
+    fitKey: string | number;
+    isLocked: (node: FlowNode) => boolean;
+    ariaLabel: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_base_3: DefineComponent<__VLS_Props_4, {
+    undo: typeof undo;
+    redo: typeof redo;
+    autoLayout: typeof autoLayout;
+    fit: () => void | undefined;
+    select: typeof select;
+    history: History_2;
+    issues: ComputedRef<Issue[]>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    change: (event: ChangeEvent) => any;
+    select: (ids: string[]) => any;
+    "update:modelValue": (graph: Graph) => any;
+    validate: (issues: Issue[]) => any;
+    export: (json: string) => any;
+}, string, PublicProps, Readonly<__VLS_Props_4> & Readonly<{
+    onChange?: ((event: ChangeEvent) => any) | undefined;
+    onSelect?: ((ids: string[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((graph: Graph) => any) | undefined;
+    onValidate?: ((issues: Issue[]) => any) | undefined;
+    onExport?: ((json: string) => any) | undefined;
+}>, {
+    direction: "TB" | "LR" | "auto";
+    minimap: boolean;
+    palette: string[];
+    locked: string[];
+    labels: Partial<FlowLabels>;
+    registry: NodeTypeRegistry;
+    edgeStyle: "orthogonal" | "smooth";
+    snapGrid: number;
+    nodeRenderers: Record<string, Component>;
+    nodeIcons: Record<string, Component>;
+    locale: string;
+    toastProvider: boolean;
+    mermaid: (source: string) => Graph;
+    readonly: boolean;
+    exportName: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+
+declare const __VLS_export_2: __VLS_WithSlots_2<typeof __VLS_base_2, __VLS_Slots_2>;
+
+declare const __VLS_export_3: DefineComponent<__VLS_Props_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    enter: () => any;
+}, string, PublicProps, Readonly<__VLS_Props_3> & Readonly<{
+    onEnter?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_export_4: __VLS_WithSlots_3<typeof __VLS_base_3, __VLS_Slots_3>;
+
+declare type __VLS_Props = {
+    graph: Graph;
+    /**
+     * Monitoring for the displayed graph: a snapshot or a reduced state. With
+     * `poll` it is the initial value (e.g. rendered by the server): polled
+     * snapshots replace it. A new `state` always takes over.
+     */
+    state?: MonitorSnapshot | MonitorState;
+    /** Poll a monitoring endpoint. */
+    poll?: PollOptions;
+    /**
+     * Host parameters handed to `poll.fetch` as `context.params` (an instance
+     * id, a filter…). A change restarts polling at once, dropping the old data.
+     */
+    pollParams?: unknown;
+    /** After how long without data the overlay warns; 3 poll intervals (min 15 s) by default. */
+    staleAfterMs?: number;
+    toggleable?: boolean;
+    /** Persists a toggle; a rejection rolls it back and shows an error. */
+    onToggle?: (change: ToggleChange) => Promise<unknown> | unknown;
+    /** Graphs for string `subgraph` references. */
+    subgraphs?: Record<string, Graph>;
+    /** Loads a string `subgraph` reference not found in `subgraphs`. */
+    loadSubgraph?: (ref: string, node: FlowNode) => Promise<Graph>;
+    /** The built-in details drawer; set false to handle `select` yourself. */
+    details?: boolean;
+    minimap?: boolean;
+    controls?: boolean;
+    /** Layout direction; `auto` (the default without `meta.direction`) follows the canvas shape. */
+    direction?: 'TB' | 'LR' | 'auto';
+    /** `orthogonal` (right angles, the default) or `smooth` (curves). */
+    edgeStyle?: 'orthogonal' | 'smooth';
+    registry?: NodeTypeRegistry;
+    nodeRenderers?: Record<string, Component>;
+    nodeIcons?: Record<string, Component>;
+    statusTones?: Record<string, string>;
+    /** Interface language; by default the host's kit locale (a parent UidLocaleProvider), else English. Setting it also sets the kit's locale inside. */
+    locale?: 'en' | 'ru' | string;
+    labels?: Partial<FlowLabels>;
+    wheel?: 'zoom' | 'pan';
+    minZoom?: number;
+    maxZoom?: number;
+    /** Mount the kit's toast provider (set false when the app already has one). */
+    toastProvider?: boolean;
+    /** A status line with the last update, staleness and a summary. */
+    statusBar?: boolean;
+};
+
+declare type __VLS_Props_2 = {
+    graph: Graph;
+    labels: FlowLabels;
+    registry?: NodeTypeRegistry;
+    /** `auto` (the default without `meta.direction`) picks LR for a landscape canvas and TB for a portrait one. */
+    direction?: 'TB' | 'LR' | 'auto';
+    /** `orthogonal` (right angles, the default) or `smooth` (curves). */
+    edgeStyle?: 'orthogonal' | 'smooth';
+    monitor?: MonitorState;
+    /** Room beside edge labels for counters (keeps layout stable once counters arrive). */
+    reserveCounters?: boolean;
+    selection?: readonly string[];
+    /** Element id → worst issue severity. */
+    issues?: ReadonlyMap<string, 'error' | 'warning'>;
+    editable?: boolean;
+    toggleable?: boolean;
+    /** Ids whose enabled flag is overridden (optimistic toggles). */
+    enabledOverrides?: ReadonlyMap<string, boolean>;
+    /** Node types whose nodes the editor must not change. */
+    snapGrid?: number;
+    minimap?: boolean;
+    controls?: boolean;
+    minZoom?: number;
+    maxZoom?: number;
+    wheel?: 'zoom' | 'pan';
+    nodeRenderers?: Record<string, Component>;
+    nodeIcons?: Record<string, Component>;
+    statusTones?: Record<string, string>;
+    /** Changing it fits the graph to the view (navigation). */
+    fitKey?: string | number;
+    /** Subgraph ids the host can open (drill-down affordance). */
+    drillable?: (node: FlowNode) => boolean;
+    /** Nodes the editor must not move. */
+    isLocked?: (node: FlowNode) => boolean;
+    ariaLabel?: string;
+};
+
+declare type __VLS_Props_3 = {
+    node: FlowNode;
+    geometry: NodeGeometry;
+    def: NodeTypeDef;
+    run?: NodeRunState;
+    tone?: string;
+    disabled?: boolean;
+    selected?: boolean;
+    focused?: boolean;
+    current?: boolean;
+    onPath?: boolean;
+    issue?: 'error' | 'warning';
+    drillable?: boolean;
+    icon?: Component;
+    labels: FlowLabels;
+    /** Where a start/end label goes: under the circle (LR) or to its right (TB). */
+    labelSide?: 'below' | 'right';
+};
+
+declare type __VLS_Props_4 = {
+    modelValue: Graph;
+    registry?: NodeTypeRegistry;
+    /** Node types offered in the palette; all of the registry by default. */
+    palette?: string[];
+    readonly?: boolean;
+    /** Node types users cannot move, edit or delete (on top of `locked: true` in the registry). */
+    locked?: string[];
+    snapGrid?: number;
+    /** Layout direction; `auto` (the default without `meta.direction`) follows the canvas shape. */
+    direction?: 'TB' | 'LR' | 'auto';
+    /** `orthogonal` (right angles, the default) or `smooth` (curves). */
+    edgeStyle?: 'orthogonal' | 'smooth';
+    nodeRenderers?: Record<string, Component>;
+    nodeIcons?: Record<string, Component>;
+    /** Interface language; by default the host's kit locale (a parent UidLocaleProvider), else English. Setting it also sets the kit's locale inside. */
+    locale?: 'en' | 'ru' | string;
+    labels?: Partial<FlowLabels>;
+    minimap?: boolean;
+    /** Enables "Import Mermaid": pass `fromMermaid` from `@dskripchenko/flow/mermaid`. */
+    mermaid?: (source: string) => Graph;
+    toastProvider?: boolean;
+    /** File name for "Export JSON". */
+    exportName?: string;
+};
+
+declare type __VLS_Slots = {
+    /** Extra content in the details drawer (history, actions). */
+    details?(props: {
+        kind: 'node' | 'edge';
+        element: FlowNode | FlowEdge;
+        state?: MonitorState;
+        path: string[];
+    }): unknown;
+    /** Custom content of the details drawer header. */
+    'details-header'?(props: {
+        kind: 'node' | 'edge';
+        element: FlowNode | FlowEdge;
+    }): unknown;
+    /** Extra controls in the corner bar. */
+    controls?(): unknown;
+    /** Replaces the empty-graph message. */
+    empty?(): unknown;
+};
+
+declare type __VLS_Slots_2 = {
+    /** Extra buttons at the end of the controls bar. */
+    controls?(): unknown;
+    /** HTML overlays above the canvas (breadcrumb, status). */
+    overlay?(): unknown;
+    /** Shown instead of the graph when it has no nodes. */
+    empty?(): unknown;
+};
+
+declare type __VLS_Slots_3 = {
+    /** Extra content at the end of the toolbar. */
+    toolbar?(): unknown;
+    /** Extra content under the properties of the selection. */
+    properties?(props: {
+        selection: string[];
+        graph: Graph;
+        path: string[];
+    }): unknown;
+};
+
+declare type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithSlots_2<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithSlots_3<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare interface Anchor {
+    point: Point;
+    side: PortSide;
+}
+
+declare function autoLayout(): void;
+
+declare function back(): void;
+
+/**
+ * A framework-agnostic poller: calls `fetch` every `intervalMs`, pauses while
+ * the page is hidden, backs off after errors, and aborts the request in
+ * flight on stop. One request at a time; the next one is scheduled after the
+ * previous settles, so a slow endpoint is never hit twice at once.
+ */
+declare interface BackoffOptions {
+    /** Multiplier per consecutive failure; 2 by default. */
+    factor?: number;
+    /** Upper bound of the delay; 60 s by default. */
+    maxMs?: number;
+}
+
+/** Built-in node types; any other string is a custom type from a registry. */
+declare type BuiltinNodeType = 'start' | 'end' | 'state' | 'task' | 'decision' | 'subprocess' | 'note';
+
+export declare interface ChangeEvent {
+    /** The command at the root of the model (sub-process edits arrive as an `updateNode` of their node). */
+    command: Command;
+    /** The same command at the level it was made, and that level's path of node ids. */
+    local: {
+        command: Command;
+        path: string[];
+    };
+    description: string;
+    graph: Graph;
+    /** `undo` / `redo` when the change came from history. */
+    source: 'edit' | 'undo' | 'redo';
+}
+
+declare type Command = {
+    type: 'addNodes';
+    nodes: FlowNode[];
+    edges?: FlowEdge[];
+} | {
+    type: 'removeElements';
+    ids: string[];
+} | {
+    type: 'updateNode';
+    id: string;
+    patch: Patch<Omit<FlowNode, 'id'>>;
+} | {
+    type: 'moveNodes';
+    moves: {
+        id: string;
+        position: Point;
+    }[];
+} | {
+    type: 'addEdge';
+    edge: FlowEdge;
+} | {
+    type: 'updateEdge';
+    id: string;
+    patch: Patch<Omit<FlowEdge, 'id'>>;
+} | {
+    type: 'setEnabled';
+    kind: Exclude<ElementKind, 'group'>;
+    id: string;
+    enabled: boolean;
+} | {
+    type: 'addGroup';
+    group: FlowGroup;
+} | {
+    type: 'updateGroup';
+    id: string;
+    patch: Patch<Omit<FlowGroup, 'id'>>;
+} | {
+    type: 'updateMeta';
+    patch: Record<string, unknown>;
+} | {
+    type: 'replace';
+    graph: Graph;
+} | {
+    type: 'batch';
+    commands: Command[];
+};
+
+export declare interface ConnectPayload {
+    from: string;
+    to: string;
+    fromPort?: string;
+    toPort?: string;
+}
+
+export declare interface ContextPayload {
+    target: ElementRef | null;
+    /** Graph coordinates. */
+    point: Point;
+    /** Client coordinates, for placing a menu. */
+    client: Point;
+}
+
+/** Data values a node or an edge carries for the host: shown as key/value. */
+declare type DataValue = string | number | boolean | null | DataValue[] | {
+    [key: string]: DataValue;
+};
+
+declare type Direction = 'TB' | 'LR';
+
+declare interface EdgeGeometry {
+    id: string;
+    d: string;
+    /** The polyline the path follows. */
+    points: Point[];
+    from: Anchor;
+    to: Anchor;
+    label?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        lines: string[];
+    };
+    selfLoop?: boolean;
+}
+
+declare interface EdgeRunState {
+    count?: number;
+    traversed?: boolean;
+}
+
+declare type ElementKind = 'node' | 'edge' | 'group';
+
+/** A reference to one element of a graph. */
+declare interface ElementRef {
+    kind: ElementKind;
+    id: string;
+}
+
+export declare const en: FlowLabels;
+
+declare function enter(nodeId: string): Promise<void>;
+
+/** Shows the whole graph (the fit button). */
+declare function fit(smooth?: boolean): void;
+
+export declare const FlowCanvas: typeof __VLS_export_2;
+
+declare interface FlowEdge {
+    id: string;
+    from: string;
+    to: string;
+    fromPort?: string;
+    toPort?: string;
+    label?: string;
+    /** A guard or condition, shown in the details and, when there is no label, on the edge. */
+    condition?: string;
+    enabled?: boolean;
+    /** `association` is a dashed line without an arrow (a note to its node). */
+    kind?: 'transition' | 'association';
+    data?: Record<string, DataValue>;
+}
+
+export declare const FlowEditor: typeof __VLS_export_4;
+
+export declare interface FlowEditorHandle extends FlowHandle {
+    /** The model as edited so far. */
+    getGraph(): Graph;
+}
+
+declare interface FlowGroup {
+    id: string;
+    label?: string;
+    /** The enclosing group. */
+    parent?: string;
+}
+
+export declare interface FlowHandle {
+    /** The app created for the component; undefined when mounted into a host `appContext`. */
+    app?: App;
+    /** Merges new props (a new `graph`, `state`, …) into the mounted component. */
+    update(props: Record<string, unknown>): void;
+    unmount(): void;
+}
+
+/**
+ * Interface strings. English and Russian ship with the package; a host passes
+ * `labels` to override any of them, or a whole dictionary for another language.
+ */
+export declare interface FlowLabels {
+    graph: string;
+    zoomIn: string;
+    zoomOut: string;
+    fit: string;
+    minimap: string;
+    root: string;
+    back: string;
+    enter: string;
+    details: string;
+    enabled: string;
+    disabledTag: string;
+    id: string;
+    type: string;
+    status: string;
+    count: string;
+    instances: string;
+    traversed: string;
+    data: string;
+    condition: string;
+    from: string;
+    to: string;
+    message: string;
+    subprocess: string;
+    updated: string;
+    updatedJustNow: string;
+    updatedAgo: (seconds: number) => string;
+    stale: string;
+    paused: string;
+    live: string;
+    loading: string;
+    loadError: string;
+    retry: string;
+    refresh: string;
+    toggleFailed: string;
+    subgraphFailed: string;
+    currentPath: string;
+    empty: string;
+    emptyHint: string;
+    statuses: Record<string, string>;
+    types: Record<string, string>;
+    editor: string;
+    palette: string;
+    paletteHint: string;
+    properties: string;
+    issues: string;
+    noIssues: string;
+    issueCount: (errors: number, warnings: number) => string;
+    undo: string;
+    redo: string;
+    delete: string;
+    duplicate: string;
+    copy: string;
+    paste: string;
+    cut: string;
+    selectAll: string;
+    autoLayout: string;
+    align: string;
+    alignLeft: string;
+    alignCenter: string;
+    alignRight: string;
+    alignTop: string;
+    alignMiddle: string;
+    alignBottom: string;
+    distributeH: string;
+    distributeV: string;
+    snapToGrid: string;
+    more: string;
+    exportJson: string;
+    importJson: string;
+    importMermaid: string;
+    importApply: string;
+    importPlaceholderJson: string;
+    importPlaceholderMermaid: string;
+    importError: string;
+    cancel: string;
+    label: string;
+    description: string;
+    nodeType: string;
+    edgeKind: string;
+    transition: string;
+    association: string;
+    subgraphRef: string;
+    subgraphInline: (nodes: number) => string;
+    subgraphCreate: string;
+    subgraphOpen: string;
+    subgraphRemove: string;
+    addField: string;
+    key: string;
+    value: string;
+    removeField: string;
+    locked: string;
+    nothingSelected: string;
+    selectedCount: (n: number) => string;
+    graphTitle: string;
+    direction: string;
+    directionLR: string;
+    directionTB: string;
+    directionAuto: string;
+    addStart: string;
+    enable: string;
+    transitions: string;
+    addTransition: string;
+    disable: string;
+    addHere: string;
+    connectHint: string;
+    emptyEditorTitle: string;
+    emptyEditorHint: string;
+    edge: string;
+    node: string;
+    group: string;
+    readOnly: string;
+}
+
+declare interface FlowNode {
+    id: string;
+    type: NodeType;
+    label?: string;
+    /** The node's centre. Nodes without one are placed by the auto layout. */
+    position?: Point;
+    /** The group (frame) the node sits in. */
+    group?: string;
+    data?: Record<string, DataValue>;
+    /** `false` disables the node: drawn dimmed and struck through. Enabled by default. */
+    enabled?: boolean;
+    /**
+     * The node's own process: an inline graph, or a reference the host resolves
+     * (`subgraphs` prop or `loadSubgraph`). Makes the node drillable.
+     */
+    subgraph?: string | Graph;
+    /** Overrides the type's ports. */
+    ports?: Port[];
+    /** A short secondary line under the label. */
+    description?: string;
+}
+
+export declare const FlowNodeShape: typeof __VLS_export_3;
+
+export declare const FlowView: typeof __VLS_export;
+
+declare function focusElement(id: string): void;
+
+declare interface Graph {
+    version: typeof GRAPH_VERSION;
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+    groups?: FlowGroup[];
+    meta?: GraphMeta;
+}
+
+/** The model format this package reads and writes. */
+declare const GRAPH_VERSION = 1;
+
+declare interface GraphLayout {
+    direction: Direction;
+    routing: Routing;
+    nodes: Map<string, NodeGeometry>;
+    edges: Map<string, EdgeGeometry>;
+    groups: Map<string, GroupGeometry>;
+    /** Waypoints the layered layout chose, by edge; valid while both ends stay put. */
+    waypoints: Map<string, Point[]>;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+
+declare interface GraphMeta {
+    title?: string;
+    /** Auto-layout direction; `LR` by default. */
+    direction?: 'TB' | 'LR';
+    [key: string]: DataValue | undefined;
+}
+
+declare interface GroupGeometry extends NodeBox {
+    id: string;
+    label?: string;
+}
+
+declare class History_2 {
+    private current;
+    private past;
+    private future;
+    private readonly limit;
+    private readonly mergeWindow;
+    private readonly now;
+    constructor(current: Graph, options?: HistoryOptions);
+    get graph(): Graph;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    /** The entry `undo` would revert. */
+    get last(): HistoryEntry | undefined;
+    get next(): HistoryEntry | undefined;
+    /** Applies a command and records it. Throws CommandError and records nothing when it does not apply. */
+    execute(command: Command, mergeKey?: string): Graph;
+    undo(): HistoryEntry | undefined;
+    redo(): HistoryEntry | undefined;
+    /**
+     * Takes a graph from outside (the host changed the model). When it is the
+     * one history already holds, nothing happens; otherwise history restarts.
+     */
+    reset(graph: Graph): void;
+    /** Ends merging: the next command starts a new entry even with the same key. */
+    seal(): void;
+}
+
+declare interface HistoryEntry {
+    command: Command;
+    before: Graph;
+    after: Graph;
+    /** Entries with the same key in a row merge into one (a drag, arrow nudges). */
+    mergeKey?: string;
+    at: number;
+}
+
+declare interface HistoryOptions {
+    /** Entries kept; 200 by default. */
+    limit?: number;
+    /** Merge window for entries with the same `mergeKey`, ms; 800 by default. */
+    mergeWindowMs?: number;
+    now?: () => number;
+}
+
+declare interface Issue {
+    severity: IssueSeverity;
+    code: IssueCode;
+    message: string;
+    /** The element the issue is about, when there is one. */
+    target?: {
+        kind: ElementKind;
+        id: string;
+    };
+}
+
+declare type IssueCode = 'duplicate-id' | 'unknown-node' | 'unknown-port' | 'unknown-group' | 'group-cycle' | 'unknown-type' | 'missing-start' | 'missing-end' | 'start-incoming' | 'end-outgoing' | 'unreachable' | 'dead-end' | 'empty-label';
+
+declare type IssueSeverity = 'error' | 'warning';
+
+export declare const LOCALES: Readonly<Record<'en' | 'ru', FlowLabels>>;
+
+export declare type MonitorApi = ReturnType<typeof useMonitor>;
+
+/** One snapshot from the host: the JSON a monitoring endpoint returns. */
+declare interface MonitorSnapshot {
+    nodes?: Record<string, NodeRunState>;
+    edges?: Record<string, EdgeRunState>;
+    /** The current instance's path: node ids in the order visited. */
+    path?: string[];
+    /** Nodes the current instance is in now. */
+    current?: string[];
+    /** When the host produced the snapshot (ISO or epoch ms). */
+    updatedAt?: string | number;
+}
+
+declare interface MonitorState extends Required<Pick<MonitorSnapshot, 'nodes' | 'edges'>> {
+    path?: string[];
+    current?: string[];
+    /** Epoch ms of the last snapshot received. */
+    receivedAt?: number;
+    /** Epoch ms the host stamped on the last snapshot, if it did. */
+    updatedAt?: number;
+    /** The last polling error, cleared by the next snapshot. */
+    error?: string;
+    /** Errors in a row. */
+    failures: number;
+}
+
+export declare function mountFlow(target: string | Element, options: MountFlowOptions): FlowHandle;
+
+export declare function mountFlowEditor(target: string | Element, options: MountFlowEditorOptions): FlowEditorHandle;
+
+/** The props of FlowEditor; `modelValue` is the initial model, kept in sync by the handle. */
+export declare interface MountFlowEditorOptions {
+    modelValue: Graph;
+    /** As in MountFlowOptions. */
+    appContext?: AppContext;
+    [prop: string]: unknown;
+}
+
+/** The props of FlowView, plus event handlers as `on*` functions (`onSelect`, `onToggle`…). */
+export declare interface MountFlowOptions {
+    graph: Graph;
+    /**
+     * Render inside this Vue app's context (from `getCurrentInstance()!.appContext`
+     * or `app._context`) instead of a new app: the host's provides, plugins and
+     * global components (kit locale and theme, i18n, router) reach the component.
+     */
+    appContext?: AppContext;
+    [prop: string]: unknown;
+}
+
+export declare interface NavigationLevel {
+    /** The sub-process node entered (empty for the root). */
+    nodeId: string;
+    label: string;
+    /** The node's `subgraph` when it is a reference. */
+    ref?: string;
+    graph: Graph;
+}
+
+export declare const NODE_ICONS: Readonly<Record<string, Component>>;
+
+declare interface NodeBox {
+    /** Centre. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+declare interface NodeGeometry extends NodeBox {
+    id: string;
+    lines: string[];
+    descriptionLines: string[];
+}
+
+/** What a custom node renderer receives. */
+export declare interface NodeRendererProps {
+    node: FlowNode;
+    geometry: NodeGeometry;
+    state?: MonitorState['nodes'][string];
+    selected: boolean;
+    disabled: boolean;
+    current: boolean;
+    labels: FlowLabels;
+}
+
+declare interface NodeRunState {
+    status?: NodeStatus;
+    /** How many instances are in (or went through) the node. */
+    count?: number;
+    /** A short text or number on the node's corner (e.g. an error count). */
+    badge?: string | number;
+    /** A line for the details panel (e.g. the last error). */
+    message?: string;
+    /** ISO string or epoch milliseconds. */
+    updatedAt?: string | number;
+}
+
+/** Outlines the built-in renderer can draw. */
+declare type NodeShape = 'rect' | 'rounded' | 'circle' | 'ring' | 'diamond' | 'note' | 'pill';
+
+/** Built-in statuses; any other string is shown as a neutral status. */
+declare type NodeStatus = 'active' | 'done' | 'error' | 'waiting' | 'skipped' | (string & {});
+
+declare type NodeType = BuiltinNodeType | (string & {});
+
+declare interface NodeTypeDef {
+    /** The type's name in the UI (palette, details). */
+    title: string;
+    shape: NodeShape;
+    /** A fixed size; otherwise the label decides the width between min and max. */
+    size?: {
+        width: number;
+        height: number;
+    };
+    minWidth?: number;
+    maxWidth?: number;
+    /** Minimum height; grows with wrapped label lines. */
+    height?: number;
+    /** Default ports; without them edges attach where they meet the outline. */
+    ports?: Port[];
+    /** An icon name the renderer maps to a glyph (`play`, `square`, `cog`, …). */
+    icon?: string;
+    /** The label is drawn outside the outline (start/end circles). */
+    labelOutside?: boolean;
+    /** Edges cannot end here (`start`) or start here (`end`). */
+    noIncoming?: boolean;
+    noOutgoing?: boolean;
+    /** Not part of the flow: no reachability or dead-end checks (`note`). */
+    annotation?: boolean;
+    /** The editor does not let a user change or delete nodes of this type. */
+    locked?: boolean;
+    /** The node can be drilled into (gets a "subgraph" field in the editor). */
+    drillable?: boolean;
+}
+
+declare type NodeTypeRegistry = ReadonlyMap<string, NodeTypeDef>;
+
+/** A patch sets fields; a field set to `null` is removed. */
+declare type Patch<T> = {
+    [K in keyof T]?: T[K] | null;
+};
+
+declare interface Point {
+    x: number;
+    y: number;
+}
+
+/** Where the viewer is: the node ids of the sub-processes entered, and the reference opened last. */
+export declare interface PollContext {
+    /** Node ids from the root to the displayed graph; empty at the root. */
+    path: string[];
+    /** The `subgraph` reference of the displayed graph, when it was a string. */
+    ref?: string;
+    /** The host's `pollParams` (an instance id, a filter…); a change restarts polling at once. */
+    params?: unknown;
+}
+
+export declare interface PollOptions {
+    fetch: (signal: AbortSignal, context: PollContext) => Promise<MonitorSnapshot>;
+    intervalMs?: number;
+    backoff?: BackoffOptions | false;
+    /** Merge snapshots into the state instead of replacing it (for partial updates). */
+    merge?: boolean;
+    /** Pause while the page is hidden; on by default. */
+    visibilityPause?: boolean;
+}
+
+/** A named connection point on a node's side. */
+declare interface Port {
+    id: string;
+    side: PortSide;
+    /** Position along the side, 0…1 from its start (left or top); 0.5 by default. */
+    offset?: number;
+    /** `in` takes incoming edges only, `out` outgoing only; both by default. */
+    kind?: 'in' | 'out' | 'both';
+    label?: string;
+}
+
+declare type PortSide = 'top' | 'right' | 'bottom' | 'left';
+
+export declare interface ReconnectPayload {
+    id: string;
+    end: 'from' | 'to';
+    node: string;
+    port?: string;
+}
+
+declare function redo(): void;
+
+/** The dictionary for a locale, with the host's overrides on top. */
+export declare function resolveLabels(locale: string | undefined, overrides?: Partial<FlowLabels>): FlowLabels;
+
+declare type Routing = 'spline' | 'orthogonal';
+
+export declare const ru: FlowLabels;
+
+declare function select(ids: string[]): void;
+
+export declare const STATUS_ICONS: Readonly<Record<string, Component>>;
+
+export declare interface ToggleChange {
+    kind: 'node' | 'edge';
+    id: string;
+    enabled: boolean;
+    /** Node ids of the sub-processes entered, root first; empty at the root. */
+    path: string[];
+}
+
+declare function undo(): void;
+
+export declare function useMonitor(options: {
+    state: () => MonitorSnapshot | MonitorState | undefined;
+    poll: () => PollOptions | undefined;
+    context: () => PollContext;
+    staleAfterMs: () => number | undefined;
+    onError?: (error: unknown) => void;
+}): {
+    state: ComputedRef<MonitorState | undefined>;
+    loading: Ref<boolean, boolean>;
+    paused: Ref<boolean, boolean>;
+    stale: ComputedRef<boolean>;
+    ageSeconds: ComputedRef<number | undefined>;
+    now: Ref<number, number>;
+    refresh: () => void | undefined;
+    polling: ComputedRef<boolean>;
+};
+
+export { }