import{type PropertyDeclaration,type PropertyValues,type TemplateResult}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';
/** One candidate row — an `@`-mentionable person/entity, or a `/`-command. */
export interface LyraMentionItem{
/** Stable business id. Duplicate ids remain distinguishable through the selection index. */
readonly suggestionId:string;readonly label:string;readonly description?:string;
/** Literal icon hint (e.g. an emoji), rendered next to `label` -- same
*  "opaque string, not a registry lookup" convention as
*  `<lr-tool-call-chip>`'s/`<lr-tool-select-dialog>`'s own `icon`. */
readonly icon?:string;
/**
* Marks this row non-actionable: `aria-disabled="true"` replaces its selected/active
* affordances, activating it (click, or Enter/Tab while highlighted) commits nothing and emits
* no `lr-mention-select`, and ArrowDown/ArrowUp highlighting steps past it instead of landing on
* it. Omitted or `false` renders the row exactly as before this field existed.
*/
readonly disabled?:boolean;}
/** Predicate deciding whether `item` matches a (already-trimmed, locale-lowercased) `query`.
*  Mirrors `<lr-combobox>`'s `OptionFilter` convention -- override `filter` to replace the
*  built-in case-insensitive label/description substring match entirely. */
export type LyraMentionFilter=(item:LyraMentionItem,query:string)=>boolean;export interface LyraMentionSelectDetail{readonly suggestionId:string;
/** Occurrence in the assigned `items` collection, before query filtering. */
readonly index:number;readonly label:string;}
/** Guards an asynchronous same-tree focus transfer against stale caller ownership. */
export interface LyraMentionFocusOptions{
/** Re-evaluated immediately before focus moves and during later popover-owned navigation. */
readonly ownsFocus?:()=>boolean;}export interface LyraMentionPopoverEventMap{'lr-mention-select':CustomEvent<LyraMentionSelectDetail>;'lr-mention-close':CustomEvent<null>;}
/**
* `<lr-mention-popover>` — a caret-anchored, keyboard-navigable popover for
* `@`-mention and `/`-slash-command autocomplete inside a plain-text
* `<textarea>`/`<input>` the host owns (e.g. `<lr-chat-composer>`'s own
* textarea, though this component has no dependency on that or any other
* specific input). A textarea session keeps the native textarea's implicit
* textbox semantics: it snapshots and temporarily clears any authored role,
* expanded state, controls/active-descendant IDREF, or ARIA element reflection
* across shadow roots, leaving only autocomplete/haspopup while open. Its
* first consumed arrow key moves real focus to the active option,
* so the focus owner and option share this component's shadow tree.
*
* Integration contract (entirely the host's responsibility — this component
* never inspects the text control's value or listens to it directly):
* 1. Detect a mention/command trigger (e.g. `@`/`/` at the start of a word)
*    in the host's own `input` handling.
* 2. Set `anchor` (the `<textarea>`/`<input>` itself, or any element for
*    plain whole-element anchoring — see "Positioning" below), `items`, and
*    `query` (the text typed since the trigger character), then flip
*    `open = true`.
* 3. Forward every `keydown` the input receives, while `open`, through
*    `handleKeyDown()` — it returns `true` when it consumed the key (so the
*    host's own handler should stop, e.g. skip submitting the message on an
*    Enter that actually picked a mention) and `false` otherwise.
* 4. Set `open = false` whenever the query stops looking like an active
*    mention context (a space typed, the trigger character deleted, or focus
*    leaving both the input and this popover) — `lr-mention-close` fires
*    automatically from that (see below), there is no separate "tell it to
*    close" call needed.
* 5. For a textarea anchor, the component temporarily sets only
*    `aria-autocomplete="list"` and `aria-haspopup="listbox"`, restoring all authored ARIA/AOM
*    values it changes on close, anchor replacement, disconnect, or adoption. Call
*    `focusActiveOption()` after the first consumed navigation key. Pass an `ownsFocus` predicate
*    if the host tracks a suggestion generation or disabled/focus-exit state; it must remain true
*    while either the anchor or this popover owns that live session. A host blur handler must
*    therefore keep the popover open when `relatedTarget` is this component.
*
* Positioning: when `anchor` is a plain `<textarea>` or single-line text
* `<input>`, this component measures exactly where the caret currently
* paints (`caretClientRect()`, the standard hidden-mirror-element technique
* — see that function's own doc) and positions against that single point
* with `internal/positioner.js`'s `place()`, so the popup tracks the caret
* rather than sitting under the whole textarea. Any other `anchor` element
* (or a text control this component fails to measure, e.g. one with
* `display: none`) falls back to `place(anchor, popup)` against the whole
* element — the same whole-element anchoring `<lr-combobox>`/
* `<lr-select>` use for their own popups. Re-measures on every `anchor`/
* `query` change while open (a keystroke moves the caret, so a fresh `query`
* is the proxy for "the caret may have moved"); a caret that moves for a
* reason other than typing (e.g. a mouse click elsewhere in the text while
* the popover happens to still be open) is not separately tracked — the
* host can force a re-measure by toggling `open` or reassigning `anchor`.
*
* Filtering happens internally against `items` (mirroring `<lr-combobox>`'s
* filter-predicate convention via `filter`, rather than requiring the host to
* pre-filter): candidate rows without a string `label` are omitted before any
* predicate runs, and the default predicate is a case-insensitive substring
* match against `label`/`description`, overridable via `filter`.
*
* There is no persisted "selection" the way a real listbox has one — a
* mention is either committed (closing the popover) or the popover is
* dismissed with nothing chosen — so `aria-selected="true"` marks whichever
* row is currently *active* (what Enter/Tab would commit right now), per the
* WAI-ARIA combobox-with-list-autocomplete pattern, rather than tracking a
* separate persisted value the way `<lr-combobox>`'s own `aria-selected`
* does.
*
* @example
* ```html
* <textarea id="composer"></textarea>
* <lr-mention-popover id="mentions"></lr-mention-popover>
* <script>
*   const textarea = document.getElementById('composer');
*   const popover = document.getElementById('mentions');
*
*   textarea.addEventListener('keydown', (e) => {
*     if (popover.open && popover.handleKeyDown(e)) {
*       if (e.key === 'ArrowUp' || e.key === 'ArrowDown') void popover.focusActiveOption();
*       return; // consumed
*     }
*     // ...the host's own Enter-to-send handling, etc.
*   });
*   textarea.addEventListener('input', () => {
*     // host's own '@'/'/' + query detection, then:
*     popover.anchor = textarea;
*     popover.items = candidates;
*     popover.query = detectedQuery;
*     popover.open = detectedQuery !== null;
*   });
*   textarea.addEventListener('blur', (event) => {
*     if (event.relatedTarget !== popover) popover.open = false;
*   });
*
*   popover.addEventListener('lr-mention-select', (e) => {
*     // splice `${e.detail.label}` into the textarea at the trigger offset
*   });
* </script>
* ```
*
* An `items` entry may also set `disabled`, marking it non-actionable: `aria-disabled="true"`
* replaces its selected/active affordances, activating it (click, or Enter/Tab while highlighted)
* commits nothing and emits no `lr-mention-select`, and ArrowDown/ArrowUp highlighting steps past
* it instead of landing on it -- including the default pre-highlighted first row. Omitted or
* `false` renders the row exactly as before this field existed.
*
* @customElement lr-mention-popover
* @event lr-mention-select - An item was committed (Enter/Tab/click).
*   `detail: { suggestionId, index, label }`; `index` disambiguates repeated business ids.
* @event lr-mention-close - The popover was dismissed with no selection — Escape, or `open`
* transitioning to `false` by any other means (a direct host assignment included). Never fires
* for a close that followed a `lr-mention-select` commit.
* @csspart listbox - The popover's root element (`role="listbox"`).
* @csspart option - A candidate row (`role="option"`). Carries `aria-disabled="true"` while that
*   row's `disabled` is set.
* @csspart option-icon - A row's leading icon glyph, when `icon` is set.
* @csspart option-label - Wrapper around a row's label/description.
* @csspart option-description - A row's optional secondary line, when `description` is set.
* @csspart empty - The "no matches" message, shown when `items`/`query` produce zero rows.
* @cssprop [--lr-mention-popover-option-active-bg=var(--lr-color-brand-quiet)] - Background of the
*   hovered or `[data-active]` (keyboard-highlighted) suggestion row.
* @cssprop [--lr-mention-popover-option-disabled-opacity=0.5] - Opacity of a row whose `items` entry sets `disabled`.
* @cssprop [--lr-overlay-surface=var(--lr-color-surface-overlay)] - Shared floating-surface fill,
* on the listbox.
* @cssprop [--lr-overlay-border=var(--lr-color-border)] - Shared floating-surface edge colour, on
* the listbox.
* @cssprop [--lr-overlay-radius=var(--lr-radius)] - Shared floating-surface corner radius, on
* the listbox.
* @cssprop [--lr-overlay-shadow-anchored=var(--lr-shadow-m)] - Elevation of the anchored surface.
* @cssprop --lr-positioning-strategy - Cascading `absolute`/`fixed` override for the listbox's
*   `fixed` default, read from computed style when it is (re)positioned. Set it once on `:root`,
*   a theme, or one clipping ancestor to change every unset mention popover beneath it; an
*   unrecognized value falls back to `fixed`.
* @status stable
* @since 4.0.0
*/
export declare class LyraMentionPopover extends LyraElement<LyraMentionPopoverEventMap>{static styles:import("lit").CSSResultGroup[];static properties:{items:{attribute:boolean;noAccessor:boolean;};};private _textareaFocusSessionGeneration;requestUpdate(name?:PropertyKey,oldValue?:unknown,options?:PropertyDeclaration):void;private hasTextareaFocusSession;
/** The element to position the popup relative to. When this is a plain
*  `<textarea>`/single-line text `<input>`, positioning is caret-precise
*  (see the class doc); any other element anchors the whole popup under
*  that element's own box, the same as `<lr-combobox>`'s trigger. */
anchor?:HTMLElement;private _items;
/** The full candidate set, pre-`query`-filtering. Assignment takes a shallow frozen snapshot;
*  malformed rows without a string `label` remain in that snapshot but are omitted from every
*  filtered/rendered projection. */
get items():readonly Readonly<LyraMentionItem>[];set items(next:readonly LyraMentionItem[]);
/** The text typed since the trigger character (`@`/`/`/…) — drives the
*  built-in internal filtering (see `filter` to override it). Removing the attribute
*  uses the unfiltered empty-query behavior without changing null readback. */
query:string;
/** Whether the popover is shown. */
open:boolean;
/** Overrides the built-in case-insensitive label/description substring match. */
filter:LyraMentionFilter|null;
/** Message shown when `items` (post-`query`-filtering) is empty. `undefined` uses the localized
* default; every supplied string, including `''` and `'No matches'`, is caller-owned. */
emptyText?:string;
/** Accessible name for the `role="listbox"` popup. `undefined` uses the localized default;
*  every supplied string, including `''` and `'Suggestions'`, is caller-owned. Also settable as
*  a plain `aria-label` attribute on `<lr-mention-popover>` itself, which takes precedence over
*  this property when present -- matches `<lr-combobox>`'s/`<lr-table>`'s identical host
*  `aria-label` fallback. */
label?:string;private activeIndex;private readonly _listId;private cleanup?;private virtualAnchor;private _isFirstUpdate;private _silentClose;private _ownsFocus;private _focusOwnerPredicate?;private _focusTransferGeneration;private anchorRelationship?;private announcementSink?;private announcedResultCount?;private announcedResultPosition?;connectedCallback():void;protected willUpdate(changed:PropertyValues):void;protected updated(changed:PropertyValues):void;disconnectedCallback():void;adoptedCallback():void;private syncAnnouncementSink;private resetResultAnnouncements;private announceResultState;private snapshotAttribute;private restoreAttribute;private captureAnchorCaret;private restoreRelationshipFocus;private restoreAnchorFocus;private attachAnchorRelationship;private detachAnchorRelationship;private syncAnchorRelationship;
/** The current candidate set: runtime rows without a non-blank string `label` are omitted (a
*  blank/whitespace-only label would otherwise render a focusable `role="option"` with no
*  accessible name), then the remaining `items` are filtered by `query` via `filter` (or the
*  built-in default). */
get filteredItems():readonly Readonly<LyraMentionItem>[];
/** The internal id of the currently highlighted row, for same-tree consumers only. */
get activeDescendantId():string|null;
/** The currently highlighted shadow option. */
get activeDescendantElement():HTMLElement|null;
/**
* A textarea's active option always receives real focus; it does not use a
* string IDREF or AOM element reflection. The established single-line input
* route retains its existing element-reference behavior.
*/
syncActiveDescendant(_control:HTMLElement):boolean;
/**
* Moves real focus to the active option and returns whether it succeeded. `options.ownsFocus`, when given,
* is checked before and immediately after the awaited render, then retained while the popover
* owns navigation. A close, candidate/query/filter/anchor change, disconnect/adoption, newer
* transfer, or failed ownership check makes the pending transfer resolve `false` without moving
* focus. Once active, the popover handles its own navigation keys and restores focus to `anchor`
* when it closes.
*/
focusActiveOption(options?:LyraMentionFocusOptions):Promise<boolean>;private restoreFocus;private callFocusOwner;private fallbackFocusIsStillOwned;
/** The internal `id` of the `role="listbox"` popup. Like
*  `activeDescendantId`, it cannot form a cross-shadow string IDREF from a
*  host-owned input. */
get listboxId():string;
/**
* The host's own text-control keydown handler calls this while the
* popover is open. Returns `true` when the key was intercepted
* (`preventDefault()` already called) and the host should not also act on
* it; `false` when the host's normal handling should proceed untouched --
* including composing events and the legacy keyCode 229 marker,
* including ArrowDown/ArrowUp/Enter/Tab when there are zero filtered rows
* to act on, so e.g. the host's own textarea still moves its caret a line
* normally rather than having the keystroke silently eaten.
*/
handleKeyDown(e:KeyboardEvent):boolean;
/** Clamps `activeIndex` into range, then -- if that row is disabled -- degrades to the nearest
*  enabled row (forward first, then backward), so the pre-highlighted default (row 0, see
*  `activeIndex`'s own doc) and every other resting read of this index skip a disabled row.
*  Returns `-1` only when every row is disabled (including an empty list). Unset regression:
*  with no disabled row, this is the same `clamp(activeIndex, 0, rows.length - 1)` it always
*  computed. */
private clampedIndex;
/** Steps `from` by one row in `direction`, skipping past a disabled row without wrapping -- the
*  same roving step contract `stepEnabledIndex()` in `internal/catalog-picker.ts` implements for
*  an active-descendant listbox. Unset regression: with no disabled row, this is the same
*  `clamp(from + direction, 0, rows.length - 1)` the arrow-key handler always computed. */
private stepEnabledIndex;private rowId;
/** A `disabled` row can never be committed -- by click or by keyboard -- and activating one
*  emits nothing and changes no state, matching every other declared-non-actionable entry in
*  this library. */
private commit;private reposition;
/** Resolves what to actually hand `place()` -- a caret-precise virtual
*  point for a measurable text control, `anchor` itself otherwise. See the
*  class doc's "Positioning" section. */
private resolveAnchorElement;private onListboxMouseDown;private onListboxClick;private onListboxKeyDown;
/** Resolves `emptyText`'s effective text: an explicit override wins verbatim; left at the
*  built-in default it instead routes through `this.localize()` so a locale/`.strings`
*  override applies without requiring `emptyText` itself to be set. */
private get effectiveEmptyText();
/** Resolves `label`'s effective text: a host-level plain `aria-label` attribute on
*  `<lr-mention-popover>` itself wins first (checked via a plain `getAttribute()` read, not a
*  reactive property, matching `<lr-combobox>`'s/`<lr-table>`'s identical fallback); failing
*  that, an explicit `label` override wins verbatim; left at the built-in default it instead
*  routes through `this.localize()` so a locale/`.strings` override applies without requiring
*  `label` itself to be set. */
private get effectiveLabel();private renderRow;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-mention-popover':LyraMentionPopover;}}