import{type TemplateResult,type PropertyValues}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import type{LyraOrientation}from'../../../internal/shared-unions.js';import{type FlowEdge,type FlowLayoutChangeDetail,type FlowNode,type FlowRunDecorations,type FlowStructureSnapshot}from'./flow-types.js';export*from'./flow-types.js';export interface LyraFlowCanvasEventMap{'lr-node-activate':CustomEvent<Readonly<{nodeId:string;}>>;'lr-edge-activate':CustomEvent<Readonly<{edgeId:string;source:string;target:string;}>>;'lr-selection-change':CustomEvent<Readonly<{nodeIds:readonly string[];edgeIds:readonly string[];}>>;'lr-node-move':CustomEvent<Readonly<{readonly nodeId:string;readonly position:Readonly<{x:number;y:number;}>;readonly previous:Readonly<{x:number;y:number;}>;}>>;'lr-connect':CustomEvent<Readonly<{source:string;target:string;sourceHandle:string;targetHandle:string;}>>;'lr-node-add':CustomEvent<Readonly<{type:string;position:Readonly<{x:number;y:number;}>;}>>;'lr-selection-delete':CustomEvent<Readonly<{nodeIds:readonly string[];edgeIds:readonly string[];}>>;'lr-viewport-change':CustomEvent<Readonly<{x:number;y:number;zoom:number;}>>;'lr-layout-change':CustomEvent<FlowLayoutChangeDetail>;}
/**
* `<lr-flow-canvas>` — a pannable/zoomable DAG workflow canvas: positions HTML node cards, draws
* SVG edges between their handles, runs a shared layered auto-layout for unpositioned nodes, and owns
* all selection/drag/connect interaction. Readonly (viewer) by default; opt into editor gestures
* individually via `nodes-draggable`, `connectable`, `droppable`. `nodes` and `edges` remain
* controlled and are never mutated internally. Selection is an internally applied interaction
* state: `selectedNodeIds`/`selectedEdgeIds` can seed or replace it, and node/edge activation
* updates those arrays before emitting `lr-selection-change`. Interaction announcements are
* flushed to the document's shared light-DOM polite sink; mount is silent and repeated identical
* messages remain separate announcements. `[part="live-region"]` is only an aria-hidden mirror.
* Turning on `locked` is a live safety boundary: active pan, node-drag, connect, and palette-drop
* previews are canceled and their window listeners are retired before later pointer events can
* commit. Viewport-mutating imperative methods, including `focusNode()`, are inert while locked.
* Replacing the controlled `nodes` model similarly retires node-drag and connect gestures before
* their captured ids can outlive that model; background pan remains independent. Node and edge
* collections reject blank ids and later duplicates at assignment, so the first valid occurrence
* owns layout, focus, selection, gestures, companion snapshots, and emitted identity.
*
* A `FlowNode` may also set `disabled`, marking it non-actionable: it keeps its position and card
* content but cannot be selected or activated by click or keyboard, roving-tabindex navigation
* (arrow keys, Home/End) steps past it instead of landing on it, it cannot be dragged even while
* `nodes-draggable`, and it is excluded from starting or receiving a new connection while
* `connectable` -- an edge that already touches a since-disabled node is left alone. Omitted or
* `false` renders the node exactly as before this field existed.
*
* @customElement lr-flow-canvas
* @slot - Consumer-authored node cards matched by `node-id`. Each matching card is assigned to the
*   generated `node-{id}` slot; a declarative `lr-flow-node` fallback remains in shadow DOM and no
*   light-DOM nodes are created or removed. Non-matching children are ignored with a warning.
* @slot top-start - Floating start-side content in the wrapping top overlay rail (e.g. `lr-flow-run-status`).
* @slot top-end - Floating end-side content in the wrapping top overlay rail.
* @slot bottom-start - Floating start-side content in the wrapping bottom overlay rail (e.g. `lr-flow-controls`).
* @slot bottom-end - Floating end-side content in the wrapping bottom overlay rail (e.g. `lr-flow-minimap`).
* @event lr-node-activate - `detail: { nodeId }`.
* @event lr-edge-activate - `detail: { edgeId, source, target }`.
* @event lr-selection-change - `detail: { nodeIds, edgeIds }`.
* @event lr-node-move - `detail: { nodeId, position, previous }`.
* @event lr-connect - `detail: { source, target, sourceHandle, targetHandle }`.
* @event lr-node-add - `detail: { type, position }`.
* @event lr-selection-delete - `detail: { nodeIds, edgeIds }`.
* @event lr-viewport-change - `detail: { x, y, zoom }`.
* @event lr-layout-change - `detail: { positions, truncated }`.
* @csspart base - The root wrapper.
* @csspart viewport - The focusable pan/zoom surface.
* @csspart background - The dotted background grid.
* @csspart edges - The edges SVG.
* @csspart edge - A single edge path.
* @csspart edge-label - An edge's drawn label.
* @csspart arrowhead - A tone-matched directed-edge arrowhead marker.
* @csspart stub - A dangling-edge stub line.
* @csspart connection-line - The in-progress connect-gesture path.
* @csspart node - A node's positioned wrapper. Carries `data-selected` while selected, and
*   `aria-disabled="true"` while its `FlowNode.disabled` is set.
* @csspart node-control - The visually hidden, roving selection button for a node. Renders a
*   genuine `disabled` `<button>` while `FlowNode.disabled` is set.
* @csspart node-card - The declarative fallback card.
* @csspart node-card-base - The fallback `lr-flow-node` handle/card row.
* @csspart node-card-surface - The fallback card's bordered surface.
* @csspart node-card-header - The fallback card's header row.
* @csspart node-card-heading - The fallback card's heading.
* @csspart node-card-status - The fallback card's visible status.
* @csspart node-card-progress - The fallback card's determinate progress bar.
* @csspart node-card-body - The fallback card's body.
* @csspart node-card-toolbar - The fallback card's toolbar.
* @csspart node-card-handle - Every fallback card handle.
* @csspart node-card-handle-input - A fallback card input handle.
* @csspart node-card-handle-output - A fallback card output handle.
* Fallback cards additionally expose a normalized `node-type-<type>` part derived from
* `FlowNode.type`; wildcard part names are described here rather than published as literal CEM
* members.
* @csspart edge-hit-area - The transparent wide pointer target behind an edge.
* @csspart empty - The `lr-empty` shown when `nodes` is empty.
* @csspart layout-limit - A visible localized notice shown when layered layout reaches its bounded
*   edge-ordering work limit. Its announcement is sent through the shared light-DOM polite sink.
* @csspart live-region - An aria-hidden shadow mirror of the current item/gesture announcement;
*   the actual announcement uses the shared light-DOM polite sink.
* @csspart edge-list - A visually hidden list of dangling or otherwise unrenderable edges.
* @csspart overlay-rail - A top or bottom wrapping rail that prevents opposite-corner companions
*   from overlapping in narrow allocations.
* @cssprop [--lr-canvas-reserved-height=var(--lr-size-24rem)] - Default host block size, shared
*   with the pre-upgrade reservation stylesheet. An explicit outer `block-size` still wins.
* @cssprop [--lr-flow-canvas-grid-size=var(--lr-size-0-5rem)] - Dotted background spacing. The
*   `grid` property supplies the fallback when this hook is unset; an element or ancestor hook
*   takes precedence.
* @cssprop [--lr-flow-canvas-edge-neutral-color=var(--lr-color-border)] - Neutral edge and arrowhead color.
* @cssprop [--lr-flow-canvas-edge-brand-color=var(--lr-color-brand)] - Brand edge and arrowhead color.
* @cssprop [--lr-flow-canvas-connection-line-color=var(--lr-color-brand)] - Stroke color of
*   `[part="connection-line"]`, the in-progress connect-gesture path drawn while dragging a new
*   connection, independent of a finished edge's own `--lr-flow-canvas-edge-*-color`.
* @cssprop [--lr-flow-canvas-edge-success-color=var(--lr-color-success)] - Success edge and arrowhead color.
* @cssprop [--lr-flow-canvas-edge-warning-color=var(--lr-color-warning)] - Warning edge and arrowhead color.
* @cssprop [--lr-flow-canvas-edge-danger-color=var(--lr-color-danger)] - Danger edge and arrowhead color.
* @cssprop [--lr-flow-canvas-march-duration=var(--lr-duration-ambient)] - Running-edge march animation duration.
* @cssprop [--lr-flow-canvas-node-selected-outline-color=var(--lr-color-brand)] - Outline color of a selected node.
* @cssprop [--lr-flow-canvas-node-connect-invalid-outline-color=var(--lr-color-danger)] - Outline color
*   of a node that is an invalid connect-gesture drop target. Same `::part()` attribute-selector
*   restriction as `--lr-flow-canvas-node-selected-outline-color` above.
* @cssprop [--lr-flow-canvas-node-connect-target-outline-color=var(--lr-color-brand)] - Outline color of
*   a node that is a valid connect-gesture drop target.
* @cssprop [--lr-flow-canvas-drop-active-outline-color=var(--lr-color-brand)] - Outline color of the
*   viewport while a palette item is dragged over it (`droppable`).
* @cssprop [--lr-flow-canvas-node-hover-outline-color=var(--lr-color-border-strong)] - Outline color
*   of a node's mouse-hover preview of its own `:focus-visible` ring. Unlike the four state-scoped
*   colors above this one is `:hover`-gated rather than attribute-gated, so a `::part(node):hover`
*   override would lose to this rule's own higher internal specificity rather than to the
*   `::part()[attr]` restriction those four work around. Set to `transparent` to opt out.
* @cssprop [--lr-flow-canvas-node-disabled-opacity=var(--lr-opacity-disabled)] - Opacity of a node whose `FlowNode` entry
*   sets `disabled`.
* @status stable
* @since 4.0.0
*/
export declare class LyraFlowCanvas extends LyraElement<LyraFlowCanvasEventMap>{static styles:import("lit").CSSResultGroup[];private _nodes;
/** Controlled node model, deeply snapshotted and frozen at assignment, bounded to the first
* 10,000 source nodes and a finite nested-data budget. Blank ids and later duplicates are omitted
* first-wins. Reassign to update; replacing it cancels active node-drag and pointer/keyboard
* connect gestures and prunes selected ids that no longer exist. */
get nodes():readonly FlowNode[];set nodes(value:readonly FlowNode[]);private _edges;
/** Controlled edge model, deeply snapshotted and frozen at assignment, bounded to the first
* 10,000 source edges and a finite nested-data budget. Blank ids and later duplicates are omitted
* first-wins before every render, action, focus, selection, snapshot, and event path. Reassign
* the collection to update. */
get edges():readonly FlowEdge[];set edges(value:readonly FlowEdge[]);private _orientation;
/** Downstream layout and handle axis. Horizontal RTL reflects model coordinates while authored,
* generated and portable fallback cards retain readable content. Invalid runtime/attribute
* values normalize to horizontal. */
get orientation():LyraOrientation;set orientation(value:LyraOrientation);nodesDraggable:boolean;connectable:boolean;droppable:boolean;
/** Freezes pan/zoom/edit gestures and viewport-mutating methods. Enabling it live cancels and
* rolls back every active gesture before retiring its global listeners. */
locked:boolean;private _selectedNodeIds;
/** The last-assigned candidate ids, syntactically sanitized (capped/deduped/nonblank) but not
*  yet filtered against `nodes` -- kept separately so a selection assigned before its
*  referenced nodes exist can still resolve once `nodes` catches up, instead of being
*  permanently discarded by a filter that ran against the stale (still-empty) node set. */
private _requestedSelectedNodeIds;
/** Frozen, unique snapshot of at most the first 10,000 valid nonblank node ids. */
get selectedNodeIds():readonly string[];set selectedNodeIds(value:readonly string[]);private _selectedEdgeIds;
/** The last-assigned candidate ids, syntactically sanitized but not yet filtered against
*  `edges` -- see `_requestedSelectedNodeIds`. */
private _requestedSelectedEdgeIds;
/** Frozen, unique snapshot of at most the first 10,000 valid nonblank edge ids. */
get selectedEdgeIds():readonly string[];set selectedEdgeIds(value:readonly string[]);
/** Caps, dedupes, and drops non-string/blank candidates. Existence against the current
*  node/edge set is intentionally NOT applied here -- see `_requestedSelectedNodeIds`. */
private sanitizeSelectionCandidates;private snapshotSelectedIds;minZoom:number;maxZoom:number;
/** Snap step, in content px, for drags/nudges/drop positions; `0` disables snapping. Also the
*  dotted background's base spacing. */
grid:number;layerGap:number;nodeGap:number;private _decorations;
/** Deeply snapshotted, frozen run decorations, bounded to 10,000 keys and a finite nested-data
* budget. Invalid statuses and records with unreadable nested fields are omitted independently,
* retaining valid neighbors. Reassign the record to update. */
get decorations():FlowRunDecorations|null;set decorations(value:FlowRunDecorations|null);accessibleLabel:string|null;
/** `minZoom`/`maxZoom` normalized to finite, positive scale bounds before ever reaching
*  `clampZoom()`'s `Math.min`/`Math.max` — an invalid attribute value would otherwise poison
*  every zoom/pan computation (`viewport.zoom`, the world layer's `scale(...)` transform) with
*  `NaN`, which the browser silently drops as invalid CSS rather than surfacing as an error. */
private get safeMinZoom();private get safeMaxZoom();private get effectiveZoomBounds();
/** `grid` normalized to a finite, non-negative snap increment — `0` still means "no snapping"
*  (see `snap()`), but a negative/non-finite value can no longer reach the `value / this.grid`
*  division in `snap()`/`nudgeNode()`, nor the `--lr-flow-canvas-grid-size` custom property. */
private get safeGrid();
/** `layerGap`/`nodeGap` normalized to finite, non-negative pixel gaps before reaching
*  `layeredLayout()`'s `gapY`/`gapX` — an invalid value would otherwise flow into every
*  auto-laid-out node's computed position, producing a `NaN` `translate(...)` that silently
*  renders the card nowhere instead of at a real position. */
private get safeLayerGap();private get safeNodeGap();private readonly arrowMarkerIds;private readonly liveRegionId;private announcementSink?;private readonly announcer;private liveText;private activeItemIndex;private connecting;private layoutTruncated;private hasConnectedLayoutBaseline;private layoutLimitAnnouncementPending;private keyboardConnectSourceId;private keyboardConnectTargetIndex;
/** Auto-layout-assigned positions for nodes lacking an explicit `position`. Empty until the first
*  layout pass runs; `nodePosition()` reads from it. */
private autoPositions;
/** Per-node measured wrapper size (`ResizeObserver`-driven) — plain map, not reactive state, read
*  by every geometry helper below. */
private measuredSizes;private resizeObserver?;private readonly observedNodeEls;private authoredCardObserver?;private authoredCardObserverDocument?;private authoredCardObserverGeneration;private authoredCardSyncQueued;private readonly authoredCardSlotLeases;private layoutRaf;private connectedWindow?;private panX;private panY;private zoomLevel;private viewportEl?;private worldEl?;private viewportChangeRaf;private hasFitOnce;private wheelMeasure;private wheelMeasureRaf;private panDrag?;private nodeDrag?;private nodeIncidentEdges;
/** Per-drag snapshot of the dragged node's incident edges -- edge/node records and shadow-DOM
*  element refs resolved once at drag start, so the per-pointermove path rewrite does no
*  per-edge array scans or shadow-root-wide `querySelector` calls. */
private dragEdgeRefs?;private connectState?;private connectionLineEl?;private connectInvalidNodeId;private companionCallbacks;private companionRaf;connectedCallback():void;disconnectedCallback():void;adoptedCallback():void;private requestOwnerAnimationFrame;private cancelOwnerAnimationFrame;private releaseAnnouncementSink;private syncAnnouncementSink;private resetAuthoredCardObserver;
/** Direct-child insertion/removal and direct `node-id` changes are the only light-DOM changes
* that can alter card ownership. The observer is constructed from the element's owner realm so
* adoption does not retain an old document's callback. */
private bindAuthoredCardObserver;private scheduleAuthoredCardReconciliation;
/** Observes every node wrapper not yet tracked by the current `ResizeObserver` instance. The
*  tracking set is cleared alongside the observer itself in `disconnectedCallback()`, so a
*  reconnect re-observes each wrapper with the freshly created observer instead of treating it
*  as already watched. */
private observeNodeWrappers;protected willUpdate(changed:PropertyValues):void;private pruneNodeCaches;protected updated(changed:PropertyValues):void;
/** Reconciles only consumer-authored direct children. Default cards remain declarative named-slot
* fallback content in `renderNodes()`, so SSR and hydration never synthesize or remove light-DOM
* cards. A lease restores the last author-owned slot only if the canvas still owns its last
* assignment; a later author write always wins. */
private syncAuthoredCards;private leaseAuthoredCardSlot;private releaseAuthoredCardSlot;private restoreAuthoredCardSlots;
/** Pushes changed node/selection/decoration state onto every currently leased direct card. A
* card's property setter is consumer code, so one rejected projection cannot stop later cards. */
private pushCardPropsAll;private setCardProperty;private nodePosition;private nodeSize;private resolvedNode;
/** Evenly distributes `count` handles along a `span`-px edge (index 0-based) — matches
*  `justify-content: space-around` so `lr-flow-node`'s handle-column CSS lines up with this
*  exactly. */
private handleOffset;private handlePoint;private edgePathD;private nodeAccessibleText;private edgeAccessibleText;private onNodesResized;
/** Captures rendered wrapper boxes before the first layout request. This is also the no-
* ResizeObserver path, so a controlled host never receives a preliminary 16px-assumed layout. */
private measureNodeWrappers;private scheduleLayoutPass;
/** The first completed connected layout establishes the live-region baseline. A visible limit
* notice and `lr-layout-change` still report that result; only subsequent false-to-true changes
* are announcements. */
private setLayoutTruncated;
/** Lays out every node currently missing an explicit `position`, leaving explicitly-positioned
*  nodes exactly as given (routed through as `fixedPositions` so the shared util lays out around
*  them). A no-op when every node already has a `position`.
*
*  Axis mapping: `../../internal/layered-layout.ts` assigns coordinates top -> bottom (block
*  axis), left -> right within a layer -- i.e. its `y` is the layer/downstream axis and its `x`
*  is the in-layer sibling axis. `swap` below reconciles that frame with this canvas's: canvas
*  `orientation="vertical"` (downstream = y) already matches the util's native frame directly,
*  so only `orientation="horizontal"` (downstream = x) needs both axes swapped when talking to
*  the util, and `gapX`/`gapY` are always passed as `nodeGap`/`layerGap` respectively (never
*  swapped) since those map to the util's own fixed sibling/layer axes regardless of how the
*  *result* is later remapped into canvas space. The util also returns raw box centers, whereas
*  this canvas's own `position` convention (see `render()`'s `translate(x,y)` and
*  `[part='node']`'s `inset-block-start/inline-start: 0`) is a top-left corner -- `nodeSize()`
*  is used to convert between the two in both directions (`fixedPositions` in, the returned map
*  out). Negative or larger-than-safe-integer centers stay caller-controlled/rendered but are
*  omitted from the bounded layout utility's fixed-anchor input. */
private runAutoLayoutIfNeeded;get viewport():Readonly<{x:number;y:number;zoom:number;}>;
/**
* Read-only, derived from the live layout — {@link setViewport} is the mutator. The setter
* exists and is a documented no-op because this getter's return shape is exactly
* `setViewport()`'s input shape, which invites `.viewport=${next}` in a Lit template. A
* getter-only accessor makes that binding throw from inside lit-html's property commit on a
* *later* render, blaming framework internals rather than the offending line; degrading to a
* silent ignore is the kinder failure. Mirrors `LyraChart`'s `chartArea`.
*/
set viewport(_value:Readonly<{x:number;y:number;zoom:number;}>);setViewport(next:{x:number;y:number;zoom:number;}):void;
/** Increase viewport zoom around the canvas center, clamped to the effective zoom bounds. */
zoomIn():void;
/** Decrease viewport zoom around the canvas center, clamped to the effective zoom bounds. */
zoomOut():void;
/** Restore zoom to 1 while preserving the current pan coordinates. */
resetZoom():void;fit(options?:{padding?:number;}):void;focusNode(id:string,options?:{zoom?:number;}):void;toContentPoint(clientX:number,clientY:number):{x:number;y:number;};
/** Subscribes to rAF-coalesced structure/viewport snapshots. The viewport includes the finite,
* sorted `minZoom`/`maxZoom` bounds actually used by canvas zoom operations. */
registerCompanion(cb:(snapshot:FlowStructureSnapshot)=>void):()=>void;private scheduleCompanionNotify;private buildSnapshot;private clampZoom;private applyWorldTransform;private scheduleViewportChange;private zoomAtCenter;
/** Keeps the content point currently under `(localX, localY)` stationary on screen while zooming
*  -- `localX`/`localY` are already pre-mirror world-local coordinates (see `localWorldX()`). */
private zoomAtPoint;
/** The one place RTL needs consulting for pan/zoom: converts a raw pointer `clientX` to this
*  canvas's pre-mirror world-local X. Every other pan/zoom/drag calculation stays in plain
*  physical coordinates because `[part='viewport']`'s own CSS mirrors the whole `.world` layer
*  under RTL; panning/zoom math never needs to know about RTL beyond this one conversion. */
private localWorldX;private onWheel;private onBackgroundPointerDown;private onBackgroundPointerMove;private onBackgroundPointerUp;private endBackgroundPan;private onViewportKeyDown;private panBy;private onViewportDragOver;private onViewportDragLeave;private onViewportDrop;private spatialNodeOrder;
/** Edges `renderEdges()` actually draws a focusable `[part="edge"]` path for -- a missing source
*  node drops the edge entirely and a missing target renders a non-focusable dangling stub, so
*  neither has a roving-nav element to land on. Excluding both here keeps roving indices/count in
*  sync with what's really focusable in the DOM. */
private focusableEdges;private rovingItems;private itemCount;
/** Only a `kind: 'node'` roving item can be non-actionable; an edge item is never excluded. */
private isRovingItemDisabled;
/** Clamps to the nearest enabled roving stop, preferring forward then backward. */
private normalizedItemIndex;
/** Steps by one roving position in `direction`, skipping disabled nodes without wrapping. */
private nextEnabledItemIndex;private firstEnabledItemIndex;private lastEnabledItemIndex;private itemAccessibleText;private spatialItemIndex;private announceItem;private formatNumber;private onItemFocus;private renderedElementByDataId;private renderedNodeById;private renderedEdgeById;private focusActiveItem;private applySelection;private clearSelection;private deleteSelection;
/** A `disabled` node is non-actionable: activating it -- by click on its card, its hidden
*  `node-control` button, or Enter/Space while roving-focused -- emits nothing and changes no
*  selection state, matching every other declared-non-actionable entry in this library. */
private onNodeActivate;private onNodeClick;private onEdgeActivate;private onItemKeyDown;private setActiveItemQuiet;private itemIndexMaps;private snap;private rebuildIncidentEdgesIndex;
/** Resolves the dragged node's incident edge records and their SVG elements once, so
*  `updateIncidentEdges()` -- called on every drag pointermove -- touches only prefetched
*  references. */
private buildDragEdgeRefs;private updateIncidentEdges;private onNodePointerDown;private onNodePointerMove;private onNodePointerUp;private endNodeDrag;private nudgeNode;private nodeIdFromComposedPath;
/** Simplified duplicate check: an edge already existing from this gesture's source to the hovered
*  node counts as a duplicate target, regardless of which handles it uses -- checked in the
*  source -> target direction only, since edges are directed and a reverse edge (hovered -> source)
*  represents a different relationship, not a duplicate of this one. Matches
*  `eligibleConnectTargets()`'s equivalent one-directional rule for the keyboard connect flow, and
*  the same function's `disabled` exclusion: a disabled node is never a valid drop target either. */
private isInvalidConnectTarget;private onWorldPointerDown;private startConnectGesture;
/** `toContentPoint()` against the viewport rect and RTL resolution snapshotted at
*  connect-gesture start, so each pointermove avoids a fresh layout/style measurement. */
private connectContentPoint;private onConnectPointerMove;private onConnectPointerUp;
/** Same rule as `isInvalidConnectTarget()`, callable after `connectState` has already been
*  cleared by `endConnectGesture()` -- takes the snapshotted state explicitly instead. */
private isInvalidConnectTargetFor;
/** Ends the gesture without committing -- pointercancel/lostpointercapture mean the pointer
*  stream is gone, so there is no release target to connect to. */
private onConnectPointerCancel;private endConnectGesture;private cancelActiveGestures;private cancelModelBoundGestures;
/** A disabled node is excluded on both ends: it never appears as an eligible target (a
*  non-actionable node should not gain a new incoming connection either), and the caller-side
*  guards below refuse it as a source. An edge that already touches a since-disabled node is left
*  alone -- disabling only prevents new interactions, never retracts existing model state. */
private eligibleConnectTargets;private startKeyboardConnect;private cycleKeyboardConnectTarget;private announceKeyboardConnectTarget;private isKeyboardConnectTarget;private commitKeyboardConnect;private cancelKeyboardConnect;private statusTone;private edgeTone;private edgeIsRunning;private renderEdges;private renderNodes;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-flow-canvas':LyraFlowCanvas;}}