import type{LyraEventDetailSnapshot}from'../../../internal/lyra-element.js';import{type PropertyValues,type TemplateResult}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import type{DocumentLocator,RetrievalChunk}from'../../../ai/types.js';import type{LyraScoreThresholds}from'../graph/graph.class.js';
/** `lr-select`'s detail: the complete updated selection, both as bare ids and as one deterministic
*  canonical `RetrievalChunk` record per id. This event contract is independent of the visible
*  `dedupe` projection: duplicate rows never duplicate derived selection records. */
export interface RetrievalResultsSelectDetail{chunkIds:string[];chunks:RetrievalChunk[];}export interface LyraRetrievalResultsEventMap{'lr-select':CustomEvent<LyraEventDetailSnapshot<RetrievalResultsSelectDetail>>;'lr-load-more':CustomEvent<null>;'lr-chunk-open':CustomEvent<LyraEventDetailSnapshot<{chunkId:string;sourceId:string;anchor?:DocumentLocator;}>>;}export type RetrievalResultsGrouping='source'|'custom'|'none';export type RetrievalResultsPresentation='compact'|'expanded';
/**
* `<lr-retrieval-results>` — the orchestration-level ranked-chunk-list surface: takes raw
* `RetrievalChunk[]` (the shared retrieval-and-grounding type from `src/ai/types.ts`) and adds
* everything a single retrieval call's result set needs beyond what one chunk's own rendering
* provides -- canonical identity handling, optional grouping by source, multi-selection,
* pagination/infinite loading, and a compact/expanded presentation switch -- while composing
* existing primitives for
* every part that already has one, never re-implementing chunk/score/source rendering itself.
*
* **Composition, not reinvention.** Each rendered row wraps exactly one chunk in an internal
* `<lr-chunk-inspector>` (fed a single-element `chunks` array), reusing its score bar/tier
* coloring, title+page rendering, expandable text, and `compact` mode verbatim -- this component
* never hand-rolls chunk-card markup. `metadata` (arbitrary `Record<string, unknown>`, which no
* existing primitive renders) is the one genuinely new bit of presentation here, shown as a plain
* key/value list in `expanded` presentation only. Large result sets are windowed through an
* internal `<lr-virtual-list>`, exactly like `<lr-thread-list>`'s own data-mode rendering -- each
* row's rendered content therefore lives inside `<lr-virtual-list>`'s own shadow root, not this
* component's, whenever virtualization is active (see that component's own doc for why).
*
* **Controlled component.** `chunks`/`selectedChunkIds`/`loading`/`errorText`/`hasMore` are all
* host-owned;
* this component never fetches, retries, or mutates its own copy of `chunks`. Selecting a row
* updates `selectedChunkIds` locally *then* emits `lr-select` (the same "update own copy, then
* emit; reassign to control" convention `<lr-source-picker>` already uses) so a host can either
* accept the update as-is or override it before the next render.
*
* **Identity.** Blank chunk ids and later duplicates are always omitted first-wins before sorting,
* grouping, selection, rendering, or events. The `dedupe` switch is retained for compatibility but
* cannot reintroduce ambiguous duplicate identities. **Grouping** (`grouping="source"`) buckets the
* canonical, score-sorted list by `source.id`, each bucket
* ordered by its own best-scoring chunk first, and always renders through the internal
* `<lr-virtual-list>` (regardless of `virtualize-at`) so group headers have a single rendering path
* — `<lr-thread-list>`'s own date-bucket grouping takes the identical approach.
*
* **Pagination.** While virtualized, `has-more`/`loading` are forwarded straight to the internal
* `<lr-virtual-list>`, which fires `lr-load-more` itself on scroll-near-bottom (re-emitted here
* unchanged). Below the virtualization threshold (a short, non-grouped list), scrolling near the
* bottom isn't a meaningful gesture, so a `[part="load-more"]` button takes its place instead,
* showing a spinner in place of the button while `loading` is true.
*
* 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-retrieval-results
* @event lr-select - The selected-chunk set changed. `detail: { chunkIds, chunks }` — `chunkIds`
* is the complete updated selection (not just the toggled id), `chunks` the matching canonical
* `RetrievalChunk` records.
* @event lr-load-more - More results were requested — via the internal `<lr-virtual-list>`'s own
* scroll-near-bottom detection while virtualized, or the built-in `[part="load-more"]` button
* otherwise. Only ever fires while `has-more` is true and `loading` is false.
* @event lr-chunk-open - A row's title/open button was activated, forwarded verbatim from the
* per-row `<lr-chunk-inspector>`'s own `lr-chunk-open`. `detail: { chunkId, sourceId, anchor? }` — the
* event a host routes into `<lr-document-viewer>`.
* @csspart base - The outer container and programmatic focus fallback when a controlled
* collection/state transition removes every focused result action.
* @csspart error - The neutral, visible error message shown while `errorText` is non-empty. New
*   non-empty errors are announced through a shared assertive light-DOM region; initial and
*   reconnect content is not replayed unless `announce` is set, which reads the state present at
*   first mount once.
* @csspart spinner - The initial-load `<lr-spinner>`, shown while `loading` is true and `chunks`
* is still empty.
* @csspart empty - The `<lr-empty>` wrapper, shown when `chunks` is empty and neither `errorText` nor
* `loading` is set. A later transition into this settled state is announced through a shared
* polite light-DOM region; initial and reconnect content is not replayed unless `announce` is set,
* which reads the state present at first mount once.
* @csspart row - One result row's wrapper. Below the virtualization threshold this is a plain,
* directly-styleable element in this component's own shadow root; while virtualized it is exported
* from the internal `<lr-virtual-list>`'s own `row` part instead (`::part(row)` still reaches it
* either way).
* @csspart group-header - Exported from the internal `<lr-virtual-list>`'s `group` part —
* grouped/virtualized mode only.
* @csspart select - The per-row `<lr-checkbox>`, omitted entirely when `selectable` is false.
* @csspart row-body - The wrapper around a row's `<lr-chunk-inspector>` plus its optional
* metadata list; carries `data-selected` while that row is selected.
* @csspart row-body-selected - Additional part on a selected `row-body`. State is exposed as a
* second part name because Shadow Parts forbids an attribute selector after `::part()` —
* `::part(row-body)[data-selected]` is invalid CSS, and while virtualized `::part()` is the only
* way in. A state part is a second token in the same `part` attribute, so a `[part~="…"]` (not
* `[part="…"]`) selector is the one that matches inside a tree.
* @csspart metadata - The `<dl>` of a chunk's `metadata` entries — omitted entirely when a chunk
* has no `metadata`, or while `presentation="compact"`.
* @csspart metadata-entry - One metadata key/value pair's wrapper.
* @csspart metadata-term - The `<dt>` carrying a metadata key. Named separately because
* `::part()` matches one element and cannot be followed into its subtree.
* @csspart metadata-value - The `<dd>` carrying a metadata value.
* @csspart chunk - The per-row `<lr-chunk-inspector>`'s own `chunk` row.
* @csspart chunk-current - The row `<lr-chunk-inspector>`'s current-chunk state part.
* @csspart chunk-score - The row chunk's percent-score line.
* @csspart chunk-score-current - The current row chunk's score line.
* @csspart chunk-score-bar - The row chunk's score bar track.
* @csspart chunk-score-fill - The row chunk's score bar fill.
* @csspart chunk-score-fill-success - The row chunk's score fill in the high-score tier.
* @csspart chunk-score-fill-warning - The row chunk's score fill in the medium-score tier.
* @csspart chunk-score-fill-danger - The row chunk's score fill in the low-score tier.
* @csspart chunk-open-button - The row chunk's title/open `<button>`.
* @csspart chunk-title - The row chunk's visible title text.
* @csspart chunk-text - The row chunk's text preview (`presentation="expanded"` only).
* @csspart chunk-text-clamped - The row chunk's text preview while still collapsed.
* @csspart chunk-toggle - The row chunk's "Show more"/"Show less" button.
* @csspart load-more-row - The wrapper around the non-virtualized-mode pagination footer.
* @csspart load-more - The "Load more" button itself (non-virtualized mode, `loading` false).
* @cssprop [--lr-retrieval-results-selected-border=var(--lr-color-brand)] - Inline-start border
*   color marking a selected `[part="row-body"]`. A border rather than a fill by design (see the
*   styles file), so recoloring it carries no contrast risk for the row's own text.
* @status stable
* @since 4.1.0
*/
export declare class LyraRetrievalResults extends LyraElement<LyraRetrievalResultsEventMap>{protected static readonly ownedCollectionProperties:readonly string[];static styles:import("lit").CSSResultGroup[];protected static readonly immutableEventDetails:readonly string[];
/** The raw (not deduplicated/sorted/grouped) result set. Host-owned. */
chunks:readonly RetrievalChunk[];
/** Controlled selection, by chunk `id`. The component updates its own copy on toggle *then*
*  emits `lr-select`; reassign to control. An id with no matching chunk is harmless -- it simply
*  never renders a checked row. */
selectedChunkIds:readonly string[];
/** Shows a per-row `<lr-checkbox>`. */
selectable:boolean;
/** Retained for compatibility. Identity is always nonblank and first-wins even when false. */
dedupe:boolean;
/** `'score'` (default) sorts the canonical list descending by `score`; `'none'` preserves
*  `chunks`' own given order. */
sort:'score'|'none';
/** `'source'` buckets rows under a header per `source.id` (always rendered through the internal
*  `<lr-virtual-list>`, regardless of `virtualize-at`); `'custom'` buckets them under whatever key
*  `groupBy` returns; `'none'` (default) is a flat ranked list. */
grouping:RetrievalResultsGrouping;
/** `grouping="custom"`: derives an arbitrary group id for every visible chunk (a date bucket, a
*  relevance tier, a domain-specific bucket). Left unset, `'custom'` degrades to a flat list
*  rather than inventing a key, so the built-in identity/sort/virtualization pipeline stays usable
*  either way. Mirrors `<lr-thread-list>`'s identical escape hatch. */
groupBy?:(chunk:RetrievalChunk)=>string;
/** `grouping="custom"`: renders a group's header label from its id and the chunks in it. Left
*  unset, the group id is shown verbatim. */
groupLabel?:(id:string,chunks:RetrievalChunk[])=>string;
/** `grouping="custom"`: explicit group-id order, or a comparator. Ids missing from an array
*  follow in their first-seen order. */
groupOrder?:readonly string[]|((a:string,b:string)=>number);
/** `'expanded'` (default) shows each chunk's full `<lr-chunk-inspector>` row (score bar, text
*  preview with its own expand toggle) plus any `metadata`; `'compact'` shows title + score bar
*  only, on both. */
presentation:RetrievalResultsPresentation;
/** Forwarded verbatim to every per-row `<lr-chunk-inspector>`'s own `thresholds`. */
thresholds:LyraScoreThresholds;
/** Above this many rows (after identity canonicalization, before grouping), rendering switches
*  from a plain list to the internal `<lr-virtual-list>`. Grouped mode always virtualizes
*  regardless of this value. */
virtualizeAt:number;
/** Marks the chunk currently open in a viewer -- forwarded to each per-row `<lr-chunk-inspector>`
*  and to the internal `<lr-virtual-list>` (which scrolls the matching row into view). */
activeChunkId:string;
/** Marks retrieval as pending, selecting the initial spinner or load-more progress state. */
loading:boolean;
/** While virtualized, forwarded to the internal `<lr-virtual-list>` so scrolling near the bottom
*  fires `lr-load-more`; otherwise shows the built-in `[part="load-more"]` footer. */
hasMore:boolean;
/** Non-empty replaces the entire result view with a neutral, visible error message -- caller-
*  supplied text, not routed through `localize()` (the same stance `<lr-document-preview>`'s own
*  `error-text` takes for the same reason: this is app/network data, not library copy). New
*  non-empty values are announced through a shared assertive light-DOM region; initial and
*  reconnect content is not replayed unless `announce` is set. */
errorText:string;
/** Opts this panel into announcing the state it is already presenting the first time it mounts:
*  the verbatim `errorText` assertively, or, with no error and nothing loading, the localized
*  empty-result message politely. Set it where the panel is rendered in response to a retrieval
*  the user just ran and nothing else reports the outcome; leave it unset for a panel that is
*  part of the page a user is arriving on, whose visible error or empty state is already read
*  in document order. Read once, when the panel first mounts: a later reconnection or adoption
*  stages the existing state again rather than replaying it, and later transitions are
*  announced either way. A panel that already has chunks announces nothing -- rendered results
*  are ordinary content. Remove any host `role="status"`/`role="alert"` hand-added before this
*  property existed once it is set -- otherwise the initial state is announced twice, through
*  the native role and again through the shared sink. */
announce:boolean;
/** Fallback name for the results region. Omitting it falls back to the localized
*  `chunkInspectorLabel` ("Retrieved chunks") -- reused rather than a new key, since it already
*  says exactly what this region is. An explicit empty string clears the fallback. A non-empty
*  host `aria-label` makes the host the sole overall owner; an explicitly empty host label stays
*  empty on the region. */
label?:string;private pendingFocusTarget;private previousProcessedChunkIds;private focusRestoreGeneration;private isMounting;private initialStateAnnounced;private connectionGeneration;private errorAnnouncementSink?;private emptyAnnouncementSink?;private readonly retrievalChunkKey;private wasEmptyPresented;private processedChunksCache?;private processedGroupingLocaleSignature;connectedCallback():void;disconnectedCallback():void;private deepActiveElement;private chunkAnchor;private renderedChunkIds;protected willUpdate(changed:PropertyValues<this>):void;protected updated(changed:PropertyValues<this>):void;
/** Announce whichever state this panel is presenting right now, at that state's own urgency.
*  `errorText` wins, mirroring the render branch order; a panel still `loading`, or one already
*  showing chunks, has no announcement to make. */
private announcePresentedState;private restoreControlledFocus;private get effectiveVirtualizeAt();
/** Keeps the first valid occurrence for every nonblank chunk id. */
private canonicalChunks;private normalizedSelectedChunkIds;private get processedChunks();private computeProcessedChunks;
/** Group-id order: a comparator sorts the first-seen ids; an explicit array leads, with any
*  first-seen id it omits following in its own order (never dropped, which would silently hide
*  rows). */
private orderedGroupKeys;private bucketed;private toggleSelect;private formatMetadataValue;private renderMetadata;private renderRow;private renderLoadMoreFooter;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-retrieval-results':LyraRetrievalResults;}}