import{type PropertyValues,type TemplateResult}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import type{LyraEntity}from'../entity-card/entity-card.class.js';import'../../layout/virtual-list/virtual-list.class.js';import'../../overlays/empty/empty.class.js';export interface LyraNeighborRow{
/** Edge label, e.g. `'works_for'`. */
relation:string;direction:'in'|'out'|'both';node:LyraEntity;}export interface LyraNeighborListEventMap{
/** Canonical name for the "user picked this entity" gesture. */
'lr-entity-select':CustomEvent<{entityId:string;}>;
/** Deliberately the *same name and detail* as the `lr-graph` event, so one host handler
*  serves both ("expand this node's neighborhood"). */
'lr-node-expand':CustomEvent<{nodeId:string;}>;}
/**
* `<lr-neighbor-list>` — one entity's relationship rows: relation, direction, neighbor, with
* per-row navigate and expand-in-graph affordances. Never computes neighbors itself (the host
* derives rows from its own graph data) and never mutates a graph.
*
* 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-neighbor-list
* @event lr-entity-select - A row's node button was activated. `detail: { entityId }`.
* @event lr-node-expand - A row's expand button was activated (only rendered when `expandable`).
* `detail: { nodeId }`.
* @csspart base - The stable root wrapper across empty, populated and virtualized states. It owns
*   `role="group"` and the fallback name unless a non-empty host `aria-label` owns the component;
*   a nested list owns the row semantics in non-virtualized mode.
* @csspart group-header - A relation group header, only rendered when `groupByRelation`. Above
*   `virtualizeAt` this is the internal virtual-list's own group label, re-exported under the same
*   name so both paths present identically.
* @csspart row - One relationship row (`role="listitem"`). Above `virtualizeAt` this is the
*   internal virtual-list's own row wrapper, re-exported under the same name.
* @csspart direction - The `aria-hidden` direction glyph.
* @csspart relation - The relation text.
* @csspart node-label - The row's node `<button>`.
* @csspart node-meta - Secondary node text (type/degree), when present.
* @csspart expand-button - The per-row expand-in-graph icon button, only rendered when `expandable`.
* @csspart empty - The empty-state message, shown when `rows` is empty.
* @status stable
* @since 4.0.0
*/
export declare class LyraNeighborList extends LyraElement<LyraNeighborListEventMap>{protected static readonly ownedCollectionProperties:readonly string[];static styles:import("lit").CSSResultGroup[];
/** Neighbor relationships to render, including direction, relation, and target node data. */
rows:readonly LyraNeighborRow[];
/** Stable-sorts rows by relation and renders one group header per relation with a count. */
groupByRelation:boolean;
/** Shows a per-row expand icon-button emitting `lr-node-expand`. */
expandable:boolean;
/** Above this row count the list renders through an internal `lr-virtual-list`. */
virtualizeAt:number;
/** Accessible name for the stable group when the host has no `aria-label`; falls back to the
*  localized `neighborListLabel` default when omitted. An explicitly empty host label stays
*  empty, and so does an explicitly empty `label`. */
label?:string;
/** `virtualizeAt`, normalized to a finite non-negative integer (falling back to the property's
*  own default of `100`) -- a raw `NaN` (e.g. an invalid `virtualize-at` attribute) would
*  otherwise make `sorted.length > virtualizeAt` always false, silently disabling
*  virtualization instead of falling back to the default threshold. */
private get effectiveVirtualizeAt();private sortedRowsCache;private groupsCache;private hasComputedRows;private processedSignature;protected willUpdate(changed:PropertyValues<this>):void;private sortedRows;private computeSortedRows;private groups;private computeGroups;
/** The arrow encodes the graph edge's actual direction (outgoing vs incoming) -- real semantic
*  data about which entity points to which -- so its meaning must stay fixed regardless of
*  reading direction; it is never derived from `isRtl()`. Only the row's overall layout (icon
*  position, text order) mirrors under RTL, and it already does so for free via this row's
*  inline-axis flex flow (`neighbor-list.styles.ts`'s `[part='row']` rule) -- no code here needs
*  to reason about direction at all. See docs/agents/i18n-rtl-theming.md: "directional glyphs
*  mirror via the wrapping part, not the icon." */
private directionGlyph;private directionText;private renderRow;private readonly virtualListKeyFunction;
/** Returns only a row's *content*, not its surrounding `role="listitem"`/`part="row"` wrapper:
*  `<lr-virtual-list>` already supplies exactly such a wrapper (exported from here as `row`) for
*  every virtualized row, and a second nested one would both duplicate the `listitem` role and
*  be matched a second time by `lr-virtual-list::part(row)` -- `::part()` uses `part~=` semantics
*  and reaches any depth of the target shadow tree -- doubling the row's padding and divider
*  border. The non-virtualized path below supplies the identical wrapper itself. */
private renderNeighborRow;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-neighbor-list':LyraNeighborList;}}