import type{LyraEventDetailSnapshot}from'../../../internal/lyra-element.js';import{type PropertyValues,type TemplateResult}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import type{LyraNodeTypeStyle}from'../../../internal/node-type-style.js';export type{LyraNodeTypeStyle}from'../../../internal/node-type-style.js';import type{LyraGraphCommunity,LyraGraphFit,LyraGraphNodeLabelsMode,LyraGraphRenderer,LyraGraphLink,LyraGraphNode}from'../graph/graph.class.js';import type{LyraEntity}from'../entity-card/entity-card.class.js';import type{LyraPathElement}from'../path-strip/path-strip.class.js';export type{LyraPathElement}from'../path-strip/path-strip.class.js';import'../graph/graph.class.js';import'../graph-legend/graph-legend.class.js';import'../entity-card/entity-card.class.js';import'../neighbor-list/neighbor-list.class.js';import'../path-strip/path-strip.class.js';import'../../overlays/overlay/popover.class.js';import'../../forms/input/input.class.js';import'../../overlays/chip/chip.class.js';import'../../forms/button/button.class.js';
/** Extra `LyraEntity` fields a plain `LyraGraphNode` doesn't carry -- merged in by node id to build
*  the entity shown in the details popover and neighbor rows. A node with no entry here still
*  renders fine: `degree` falls back to a live count derived from `links`, `description`/
*  `properties` are simply omitted. */
export type LyraKnowledgeGraphEntityDetails=Pick<LyraEntity,'description'|'properties'|'degree'>;
/** What drives `<lr-knowledge-graph-explorer>`'s own `dimmedNodeIds`/`dimmedLinkIds` forwarding, on
*  top of the always-active search-match dimming -- see `highlight`'s own doc comment. */
export type KnowledgeGraphHighlight='selection'|'hover'|'none';export interface LyraKnowledgeGraphExplorerEventMap{
/** The explorer changed its self-managed selection. Fires after `selectedNodeId` is updated for
*  search, graph, neighbor, path, entity-card, invalidation, and popover-close paths. Direct
*  host assignments remain silent. */
'lr-selection-change':CustomEvent<{selectedNodeId:string|null;}>;
/** The user asked to find a path between the two currently pinned nodes (the "Find path" action,
*  only rendered once exactly two nodes are pinned). `detail: { sourceNodeId, targetNodeId }` -- this
*  component has no graph-traversal algorithm of its own (client-side, backend call, whatever the
*  host prefers); it only requests one. The host computes/fetches the path and assigns the result
*  back through `path`. */
'lr-path-request':CustomEvent<{sourceNodeId:string;targetNodeId:string;}>;
/** A node's pinned state changed by user interaction. `detail: { pinnedNodeIds }` -- the complete
*  updated array. This component already toggles its own `pinnedNodeIds` copy before emitting
*  (the same self-toggle-then-emit contract `lr-graph-legend`'s `hiddenTypes`/`lr-visibility-
*  change` already establishes), so reassigning it back is optional -- useful only for a host
*  that wants to persist or observe pins elsewhere. */
'lr-pin-change':CustomEvent<LyraEventDetailSnapshot<{pinnedNodeIds:string[];}>>;
/** The user typed in the toolbar's search box. `detail: { query, matchCount, matchCountExact }`
*  -- `query` is the canonical `LyraSearchChangeDetail` field name
*  (`internal/text-viewer-target.ts`). `matchCount` is the same live node-filter total the
*  search-result list and its own live-region announcement already compute (`0` while `query`
*  is empty). `matchCountExact` is always `true`: unlike a paginated text-search viewer, this
*  component's node filter has no ceiling, so it can never truncate. This is a live node
*  FILTER, not a cursor-based text search -- it deliberately never carries the canonical
*  `activeIndex` field, since it has no `searchNext`/`searchPrevious` active-match cursor to
*  report. The component has already applied the query to its own `searchQuery` before
*  emitting, the same self-toggle-then-emit contract `lr-pin-change` follows, so reassigning it
*  back is optional and a direct host assignment stays silent. */
'lr-search-change':CustomEvent<{query:string;matchCount:number;matchCountExact:boolean;}>;
/** A node type's visibility changed via the composed legend. `detail: { hiddenTypes }` -- the
*  complete updated array. This component already applies it to its own `hiddenTypes` before
*  emitting, the same self-toggle-then-emit contract `lr-pin-change`/`lr-search-change` follow,
*  so reassigning it back is optional and a direct host assignment stays silent. */
'lr-hidden-types-change':CustomEvent<LyraEventDetailSnapshot<{hiddenTypes:string[];}>>;'lr-node-click':CustomEvent<{nodeId:string;x:number;y:number;}>;'lr-link-click':CustomEvent<{sourceNodeId:string;targetNodeId:string;linkId?:string;}>;'lr-node-expand':CustomEvent<{nodeId:string;}>;'lr-community-click':CustomEvent<{communityId:string;}>;'lr-relation-activate':CustomEvent<{relation:string;sourceNodeId?:string;targetNodeId?:string;occurrenceIndex:number;}>;}
/**
* `<lr-knowledge-graph-explorer>` — an orchestration-level surface for exploring a knowledge
* graph: the `lr-graph` canvas plus entity search, type filters, neighborhood expansion, pinned
* nodes, path finding between pins, node selection, and a details overlay. Composes existing
* primitives rather than re-implementing graph rendering: `lr-graph` (canvas/pan-zoom/selection),
* `lr-graph-legend` (type filters), `lr-entity-card` (the details popover's default content),
* `lr-neighbor-list` (the selected entity's relationships), `lr-path-strip` (a found path), and
* `lr-popover.showAt()` (the details overlay itself).
*
* **How the details popover finds its viewport position.** `lr-graph.getNodePosition()` and the
* `lr-node-click` event's `{ x, y }` are in the graph's own *local drawing space* (pre pan/zoom),
* never viewport pixels -- passing them straight to `showAt()` would anchor the popover at the
* wrong place as soon as the graph has panned or zoomed even once. A direct node click resolves
* the correct viewport rect the way this library's own documented `lr-graph` + `lr-popover.showAt()`
* composition does: for `renderer="svg"` (the default), `event.composedPath()` (the native `click`
* that bubbles out of `lr-graph`'s shadow root) locates the actual clicked `[part="node"]` element,
* whose `getBoundingClientRect()` is already viewport-relative; for `renderer="canvas"` (no
* per-node DOM element to find), the click event's own `clientX`/`clientY` are used directly, since
* canvas hit-testing already treats those as viewport coordinates internally. While the popover
* stays open after an `renderer="svg"` click, this component re-reads that same resolved node
* element's `getBoundingClientRect()` and re-calls `showAt()` every time the composed `lr-graph`
* emits its own `lr-viewport-change` (a frame-coalesced pan/zoom/simulation-tick signal) --
* schedules no continuous popover-polling loop of its own, unlike an idle popover polling the DOM
* every frame regardless of whether anything actually moved. Selecting a node any other
* way -- a search result, a neighbor row, a path-strip element, keyboard Enter/Space on a graph
* node (which never dispatches a native `click`) -- has no click event to read a rect from, so it
* instead calls the public `lr-graph.focusNode(id)` (which centers that node in the viewport) and
* then anchors the popover at the graph element's own `getBoundingClientRect()` center once that
* settles; no continuous tracking applies to that path.
*
* **Controlled vs. self-managed state.** `nodes`/`links`/`nodeTypes`/`communities`/`entityDetails`/
* `path` are purely host-supplied data, rendered as given. `hiddenTypes`/`selectedNodeId`/
* `searchQuery`/`pinnedNodeIds` are this component's own genuinely new contribution: it wires them
* into `lr-graph`'s existing controlled props (`hiddenTypes`, `selectedNodeIds`, `dimmedNodeIds`,
* `dimmedLinkIds`) itself, toggling its own copy on interaction (the same self-toggle-then-emit
* contract `lr-graph-legend` already uses) so every feature works with zero host wiring, while
* still being presettable/observable properties and emitting events (`lr-selection-change`,
* `lr-pin-change`, `lr-path-request`, plus every composed primitive's own event bubbling straight through
* unmodified) for a host that wants to persist or react to them.
* Hidden node types are excluded from both search matches and selected-entity neighbor rows, and
* activation requests for a hidden node are ignored before selection changes.
*
* `highlight` controls what drives that dimming, on top of the always-active search-match
* dimming: `'selection'` (the default) dims by the selected node's immediate neighborhood;
* `'hover'` also dims by whichever node is currently pointer-hovered (falling back to the selected
* node's neighborhood while nothing is hovered); `'none'` turns this component's own dimming off
* entirely, forwarding empty `dimmedNodeIds`/`dimmedLinkIds` regardless of search/selection state
* -- for a host that wants to drive `lr-graph`'s dimming through a different composition instead.
*
* Public collection properties take bounded, clone-owned readonly snapshots. Create a new
* collection and reassign it after changes; mutating the assigned array does not update the view.
*
* @customElement lr-knowledge-graph-explorer
* @slot details - Overrides the details popover's default content (an `lr-entity-card` with a
*   nested `lr-neighbor-list` and a pin toggle). Receives no data -- a consumer overriding this
*   slot reads the selected entity from `selectedNodeId`/`nodes` itself. Replaces the default
*   card entirely, including `detail-body`/`detail-actions` below.
* @slot detail-body - Additive content appended inside the default `lr-entity-card`'s body,
*   alongside its `lr-neighbor-list`. No effect while `details` is overridden.
* @slot detail-actions - Additive content appended into the default `lr-entity-card`'s `actions`
*   slot, beside its built-in pin toggle. No effect while `details` is overridden.
* @event lr-selection-change - The explorer changed its self-managed selection. `detail:
*   { selectedNodeId: string | null }`. Direct host assignments do not emit.
* @event lr-path-request - `detail: { sourceNodeId, targetNodeId }`. See the class doc above.
* @event lr-pin-change - `detail: { pinnedNodeIds }`. See the class doc above.
* @event lr-search-change - The user typed in the toolbar's search box. `detail:
*   { query, matchCount, matchCountExact }`. `query` is the canonical `LyraSearchChangeDetail`
*   name; `matchCountExact` is always `true` since this component's node filter has no truncating
*   ceiling. No `activeIndex` -- this is a live node filter, not a cursor-based search.
*   Direct host assignments do not emit.
* @event lr-hidden-types-change - A node type's visibility changed via the composed legend.
*   `detail: { hiddenTypes }`. See the class doc above. Direct host assignments do not emit.
* @event lr-node-click - Bubbles straight through from the composed `lr-graph`, unmodified.
* @event lr-link-click - Bubbles straight through from the composed `lr-graph`, unmodified.
* @event lr-node-expand - Bubbles straight through from `lr-graph` and/or `lr-neighbor-list` (the
*   same event name/detail shape from either source) -- this component never appends neighbors
*   itself, only forwards the request; a host fetches/generates the expansion and assigns updated
*   `nodes`/`links` back.
* @event lr-community-click - Bubbles straight through from the composed `lr-graph`, unmodified.
* @event lr-relation-activate - Bubbles straight through from the composed `lr-path-strip`, unmodified.
* @csspart base - The root wrapper. It owns `role="group"` and the fallback name unless a
*   non-empty host `aria-label` makes the host the sole overall owner.
* @csspart toolbar - The row wrapping the search input and the type-filter legend.
* @csspart search - The composed `lr-entity-card` search `lr-input`.
* @csspart legend - The composed `lr-graph-legend`.
* @csspart search-results - The search-match list, only rendered while `searchQuery` is non-empty.
* @csspart search-result - One search-match row (`role="listitem"`, wrapping a `<button>`).
* @csspart search-empty - The "no matches" message, shown when `searchQuery` is non-empty but no node matches.
* @csspart pinned - The pinned-nodes row, only rendered while `pinnedNodeIds` is non-empty.
* @csspart pinned-heading - The pinned-nodes row's leading label.
* @csspart path - The composed `lr-path-strip`, only rendered while `path` is non-empty.
* @csspart graph - The composed `lr-graph`.
* @csspart detail-popover - The composed `lr-popover` hosting the details overlay.
* @csspart detail-card - The default-content `lr-entity-card`, only present while `selectedNodeId` resolves to a node.
* @cssprop [--lr-canvas-reserved-height=var(--lr-size-24rem)] - Default block size of both this
*   host and the composed `lr-graph`, shared with the pre-upgrade reservation stylesheet. Below
*   this in the fallback chain, the composed `lr-graph`'s own normalized `height` (forwarded from
*   this component's own `height`) sizes it instead; an explicit outer `block-size` still wins over
*   both.
* @status stable
* @since 4.1.0
*/
export declare class LyraKnowledgeGraphExplorer extends LyraElement<LyraKnowledgeGraphExplorerEventMap>{protected static readonly ownedCollectionProperties:readonly string[];static styles:import("lit").CSSResultGroup[];protected static readonly immutableEventDetails:readonly string[];
/** Nodes forwarded to the composed graph and search experience. */
nodes:readonly LyraGraphNode[];
/** Links forwarded to the composed graph and path interactions. */
links:readonly LyraGraphLink[];
/** Labels, colors, and shapes for the graph's node-type vocabulary. */
nodeTypes:readonly LyraNodeTypeStyle[];
/** Community hull definitions forwarded to the graph. */
communities:readonly LyraGraphCommunity[];
/** Extra dossier fields, keyed by node id -- see `LyraKnowledgeGraphEntityDetails`. */
entityDetails:Readonly<Record<string,Readonly<LyraKnowledgeGraphEntityDetails>>>;
/** Currently-pinned node ids. Self-toggled by the pin action in the details popover and by a
*  pinned chip's remove button (see the class doc's "controlled vs. self-managed" note); still
*  presettable/overridable like any other property. Exactly two pinned nodes reveals the "Find
*  path" action. */
pinnedNodeIds:readonly string[];
/** Host-supplied path-finding result, rendered via `lr-path-strip`. Empty (the default) renders
*  no path strip. See `lr-path-request`. */
path:readonly LyraPathElement[];
/** Currently-hidden `LyraGraphNode.type` values, forwarded to both `lr-graph.hiddenTypes` and
*  `lr-graph-legend.hiddenTypes`. Self-toggled by the composed legend; still presettable. */
hiddenTypes:readonly string[];
/** The currently-selected node id, driving both the details popover and `lr-graph`'s
*  `selectedNodeIds` visual state. Presettable (e.g. to deep-link to a specific entity) as well
*  as self-managed on every selection interaction. `null` (the default) shows no selection and
*  keeps the details popover closed. */
selectedNodeId:string|null;
/** Forwarded to `lr-graph.renderer`. `renderer="canvas"` has no per-node DOM element, which
*  narrows how the node-detail popover anchors and disables its pan/zoom tracking -- see the
*  class doc's anchoring note. */
renderer:LyraGraphRenderer;
/** Forwarded to `lr-graph.nodeLabels`. Unset (the default) leaves the composed `lr-graph` to
*  apply its own per-renderer default -- see that property's own doc. */
nodeLabels?:LyraGraphNodeLabelsMode;
/** Forwarded to `lr-graph.fitTo`. `'container'` makes the composed graph draw at exactly the
*  pane this component's own layout gave it -- the reservation minus whatever the toolbar,
*  search results, pinned row and path strip take, which is not derivable from `height` -- and
*  follow it live as the explorer is resized. `'none'` (the default) keeps forwarding the
*  numeric `width`/`height` below unchanged. */
fitTo:LyraGraphFit;
/** Requested width of the composed graph viewport in CSS pixels. Ignored by the composed graph
*  while `fitTo === 'container'`. */
width:number;
/** Requested height of the composed graph viewport in CSS pixels. Also sizes the rendered
*  `[part="graph"]`/host (see `--lr-canvas-reserved-height`'s doc) whenever neither that nor an
*  explicit outer `block-size` overrides it. */
height:number;
/** Fallback name for the root group; defaults to localized `graphExplorerLabel`. A non-empty
*  host `aria-label` makes the host the sole overall owner; an explicitly empty host label stays
*  empty on the group, and so does an explicitly empty `label`. */
label?:string;
/** What drives this component's own `dimmedNodeIds`/`dimmedLinkIds` forwarding, on top of the
*  always-active search-match dimming -- see the class doc's dedicated paragraph. */
highlight:KnowledgeGraphHighlight;
/** The search filter applied to the visible node set. A node matches when the query appears in
*  any name it can be known by -- its `id`, its `label` or its `accessibleLabel` -- each folded
*  with the active locale, so a node named only through `accessibleLabel` is findable by the
*  very name the results, chips and popover display for it. Presettable (e.g. to restore a query
*  from a URL on load) as well as self-managed on every keystroke in the toolbar's search box.
*  `''` (the default) renders no search-result list at all and applies no search dimming.
*  Removing the attribute uses this empty-filter behavior while retaining null property
*  readback. */
searchQuery:string;private pinLiveText;
/** Currently pointer-hovered node id, set only while `highlight === 'hover'` (see
*  `onGraphNodeEnter`/`onGraphNodeLeave`) -- read by `computedDimmedNodeIds`. */
private hoveredNodeId;private graphEl?;private popoverEl?;
/** Set by `onGraphNodeClick` and consumed either synchronously by the native `click` that
*  follows it on the same user gesture (a real pointer click), or, failing that, by a queued
*  microtask fallback (a keyboard Enter/Space activation, which -- unlike a native `<button>` --
*  never dispatches a synthetic `click` on a `role="button"` SVG/canvas element). */
private pendingNodeId?;
/** Invalidates focus work when a newer activation, direct selection, close, or disconnect wins. */
private activationGeneration;private internalSelectionAssignment?;
/** The exact rendered `[part="node"]` element resolved for the currently-open popover
*  (`renderer="svg"`, direct-click path only) -- re-read on every `lr-viewport-change` so the
*  popover keeps tracking a pan/zoom gesture or simulation tick while it stays open. */
private trackedNodeEl?;private nodeById;private linksByNodeId;private degreeByNodeId;private communityLabelById;private normalizedGraphModel?;private normalizedGraphSources?;private announcementSink?;private activationFrameId?;private activationFrameOwner?;private activationFrameDocument?;private activationFrameResolve?;private activationFramePageHide?;private get graphModel();private get canonicalPinnedNodeIds();private get canonicalHiddenTypes();connectedCallback():void;private syncAnnouncementSink;protected willUpdate(changed:PropertyValues):void;protected updated(changed:PropertyValues):void;private activatePresetWhenGraphReady;private waitForActivationFrame;private clearActivationFrameRecord;private cancelActivationFrame;private invalidateActivation;private resumePresetActivation;private setInternalSelectedNodeId;disconnectedCallback():void;adoptedCallback():void;private rebuildDerivedCollections;private isVisibleNode;private canActivateNode;
/** `label` beats `accessibleLabel` beats a bare fallback to `id` -- the same precedence
*  `entityFor()`'s own `label` field and the search-result list use, so every derived node name
*  agrees. */
private nodeLabel;private degreeOf;private entityFor;private communityLabelFor;private neighborRowsFor;
/** Every name a node can be known by, ordered to match `nodeLabel()`'s own precedence
*  (`label`, then `accessibleLabel`, then `id`) so `[0]` is the displayed name for any future
*  caller that wants one -- this caller only asks whether ANY of them matches, and the order is
*  irrelevant to that. `id` is included even when it is not what gets rendered (it has always
*  been searchable), and so is `accessibleLabel`: a node named only through it renders that name
*  in the search results, the pinned chips and the popover, so typing that same name has to find
*  it. A node carrying both matches either -- `accessibleLabel` is documented as the richer
*  spoken form of the very same node, not a different one, so matching it can never surface
*  something unrelated. */
private searchableNamesOf;private matchingNodes;private searchResultAnnouncement;private neighborIdsOf;
/** The same key derivation `lr-graph`'s own (private) `linkKey()` uses for `dimmedLinkIds` --
*  an explicit `id` when the link has one, else `source->target`. */
private linkKey;
/** Non-matching nodes while searching; otherwise everything outside the focus node's immediate
*  neighborhood (the selected node, or -- while `highlight === 'hover'` -- the hovered node when
*  nothing is selected); otherwise nothing while `highlight === 'none'`. Wires the search/
*  selection/hover state this component owns into `lr-graph`'s existing `dimmedNodeIds` contract
*  instead of introducing a parallel highlighting mechanism. */
private get computedDimmedNodeIds();
/** The link-side mirror of `computedDimmedNodeIds` -- a link is dimmed whenever either endpoint
*  is, so unrelated edges dim along with unrelated nodes with no extra host wiring. */
private get computedDimmedLinkIds();private togglePin;private requestPath;private onVisibilityChange;
/** The composed legend owns this cancellable proposal. Contain it without changing whether its
* listeners accepted it, so the child can still assign, announce, and send its existing post event. */
private onBeforeVisibilityChange;private onSearchInput;
/** Handles the composed entity-card/neighbor selection and path-strip entity activation. */
private onEntityActivate;
/** Selects `id` and opens its details popover without a click event to read a rect from --
*  centers the node via the public `lr-graph.focusNode()`, then anchors at the graph element's
*  own viewport rect center once that settles. Shared by search results, neighbor rows,
*  path-strip elements, `lr-entity-card`'s own built-in focus button, and the keyboard-Enter/
*  Space fallback for a direct graph node activation. */
private activateEntity;private openDetailAt;
/** Resolves the viewport rect for a direct pointer click on a graph node -- see the class doc's
*  "how the details popover finds its viewport position" note for the full reasoning. */
private resolveDirectClickAnchor;private onGraphNodeClick;private onGraphNativeClick;
/** Re-anchors the open details popover to `trackedNodeEl`'s current rect -- wired to the
*  composed `lr-graph`'s `lr-viewport-change` (see the class doc's anchoring note). A no-op
*  whenever there's nothing to track (`renderer="canvas"`, a non-direct-click selection, or the
*  popover isn't open), so this never schedules work of its own; it only reacts to `lr-graph`'s
*  already frame-coalesced signal. */
private onGraphViewportChange;private onGraphNodeEnter;private onGraphNodeLeave;private onPopoverHide;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-knowledge-graph-explorer':LyraKnowledgeGraphExplorer;}}