import type{LyraEventDetailSnapshot}from'../../../internal/lyra-element.js';import{type PropertyValues,type TemplateResult}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import'../../forms/input/input.class.js';import'../../layout/segmented/segmented.class.js';import'../../overlays/chip/chip.class.js';import'../../overlays/chip/chip-group.class.js';import'../../overlays/spinner/spinner.class.js';import'../../overlays/empty/empty.class.js';import type{RetrievalQuery,CancelEventDetail}from'../../../ai/types.js';import{type LyraSize}from'../../../internal/variants.js';
/** The three retrieval modes `RetrievalQuery.mode` supports, reused verbatim rather than
*  redefining the union -- see `src/ai/types.ts`'s own header for why. */
export type LyraRetrievalMode=RetrievalQuery['mode'];
/** `detail` for `lr-filters-change` -- the complete, already-updated `filters`/`scope` state
*  after a chip removal, mirroring `<lr-source-picker>`'s `lr-sources-change` "full next state"
*  convention rather than a single-item delta. */
export interface RetrievalFiltersChangeDetail{filters:Record<string,unknown>;scope:string[];}export interface LyraRetrievalSearchEventMap{'lr-search':CustomEvent<LyraEventDetailSnapshot<RetrievalQuery>>;'lr-cancel':CustomEvent<CancelEventDetail>;'lr-filters-change':CustomEvent<LyraEventDetailSnapshot<RetrievalFiltersChangeDetail>>;}
/**
* `<lr-retrieval-search>` -- the query bar for a retrieval/RAG surface: query text, an active-
* filter/scope chip row, a vector/keyword/hybrid mode selector, and loading/error/empty status
* feedback. Consumes `RetrievalQuery` (`src/ai/types.ts`) as the shape emitted on submit.
*
* Fully controlled, like every other Lyra input: `query`/`mode`/`filters`/`scope` are host-owned
* properties. This component never performs retrieval itself -- it only emits `lr-search`; the
* host owns the actual fetch and toggles `loading` around it. Because this component has no way
* to know when a request resolves (only `loading`, set from outside), submitting again (Enter, or
* clicking the button) while `loading` is already `true` is treated as **superseding** the
* in-flight request: `lr-cancel` fires immediately before the new `lr-search`. The submit button
* itself doubles as an explicit Cancel affordance while `loading` -- clicking it only emits
* `lr-cancel`, without resubmitting, the same "just stop" action `<lr-chat-composer>`'s Stop
* button offers for its own `stoppable` busy state.
*
* Composes `<lr-input type="search">` for the query field, `<lr-segmented>` for the mode
* selector (the same small-closed-set-choice-in-a-toolbar role it already fills, left at the shared
* default size so it resolves the same `--lr-form-control-height` as the query field and the submit
* button and the row reads as one flush line), `<lr-chip>`/`<lr-chip-group>` for removable active-filter/scope
* chips, `<lr-spinner>` for the loading state, and `<lr-empty>` (compact) for the empty state.
* `filters`/`scope` chip removal updates this component's own copy first, then emits
* `lr-filters-change` with the complete next state -- the same "update, then emit; reassign to
* control" round-trip `<lr-source-picker>`'s `selectedSourceIds` already establishes. `empty` is a
* host-driven flag (the last completed search returned zero results); this component holds no
* results data of its own -- see `<lr-retrieval-results>` for rendering the actual chunk list.
*
* 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-search
* @event lr-search - The query was submitted (Enter in the query field, or the submit button
*   while not `loading`). `detail`: the full `RetrievalQuery` (`{ text, mode, filters, scope }`).
* @event lr-cancel - The in-flight request should be cancelled: either the user clicked the
*   button while `loading` (`detail: {}`), or a new submission superseded the in-flight one before
*   it resolved (`detail: { reason: 'superseded' }`, fired immediately before the new `lr-search`).
* @event lr-filters-change - A `filters`/`scope` chip's remove button was activated. `detail`: the
*   complete updated `{ filters, scope }` state.
* @csspart base - The root search shell. It owns `role="search"` and the fallback name unless a
*   non-empty host `aria-label` makes the host the sole overall owner.
* @csspart row - The row holding the query field, mode selector, and submit/cancel button.
* @csspart query - The query `<lr-input type="search">`.
* @csspart mode - The vector/keyword/hybrid `<lr-segmented>`.
* @cssprop [--lr-retrieval-search-submit-min-height=var(--lr-icon-button-size)] - Minimum height of
*   the submit button. A `size` tier raises it to that tier's shared form-control height; the
*   shared tappable-target minimum always stays underneath, so no tier can shrink the button past
*   the WCAG floor.
* @csspart submit - The submit/cancel `<button>`. Reads "Search" while idle, "Cancel" while
*   `loading`.
* @csspart filters - The active-filter/scope `<lr-chip-group>`. Omitted entirely when both
*   `filters` and `scope` are empty.
* @csspart spinner - The busy `<lr-spinner>`, shown only while `loading`.
* @csspart error - The neutral, visible error message, shown only when `errorText` is non-empty and
*   not `loading`. 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 empty - The compact `<lr-empty>`, shown only when `empty` is `true` and neither
*   `loading` nor `errorText` is set. Later transitions into that settled state are announced
*   through a shared polite light-DOM region; the state present at first mount is announced only
*   when `announce` is set.
* @status stable
* @since 4.1.0
*/
export declare class LyraRetrievalSearch extends LyraElement<LyraRetrievalSearchEventMap>{protected static readonly ownedCollectionProperties:readonly string[];static styles:import("lit").CSSResultGroup[];protected static readonly immutableEventDetails:readonly string[];
/** The current query text. Controlled -- the internal `lr-input` updates this optimistically as
*  the user types (mirroring every other Lyra input's controlled-value convention), and a host
*  reassignment always wins. */
query:string;private _size?;
/** Density tier for the whole query row, on the library's one size ladder, in either spelling --
*  `2xs`/`xs`/`s`/`m`/`l`/`xl`, or Web Awesome's and Shoelace's `small`/`medium`/`large`. It is
*  one property for all three controls on purpose: the query field, the mode selector and the
*  submit button share the row's baseline, and sizing any one of them alone is what makes the
*  row ragged. Forwarding is the only way to reach the first two, which resolve their tier
*  inside their own shadow roots, and it is forwarded as a property rather than an attribute
*  because removing an already-written `size` attribute again would leave each child's own
*  `size` at `null` instead of back at its own default. Opt-in: with no size every control keeps
*  its own `m` default, exactly what the row rendered before, and the submit button keeps the
*  shared tappable-target floor at every tier. Unsupported values normalize to the omitted state
*  and remove the attribute. */
get size():LyraSize|undefined;set size(next:LyraSize|undefined);private _mode;
/** Retrieval mode. Defaults to `'hybrid'`, the common default for a search bar combining both
*  vector and keyword retrieval. */
get mode():LyraRetrievalMode;set mode(next:LyraRetrievalMode);
/** Arbitrary metadata filters, rendered as removable `"{key}: {value}"` chips. Controlled --
*  reassign to change what's shown; see the class doc's "update, then emit" round-trip. */
filters:Readonly<Record<string,unknown>>;
/** Source-scope ids/labels this query is restricted to, rendered as removable chips alongside
*  `filters`. Same controlled round-trip as `filters`. */
scope:readonly string[];
/** Host-driven busy flag. This component never performs retrieval itself and has no way to know
*  when a request resolves, so the host toggles this explicitly around its own fetch -- see the
*  class doc for the resulting submit/cancel/supersede behavior. */
loading:boolean;
/** Host-supplied error message from the last failed search, shown verbatim (caller-owned text,
*  not localized) in a neutral visible region. New non-empty values are announced through a
*  shared assertive light-DOM region; initial and reconnect content is not replayed unless
*  `announce` is set. Empty string (the default) shows nothing. */
errorText:string;
/** Host-driven flag: the last completed search returned zero results. Renders a compact
*  `<lr-empty>` beneath the search row and politely announces later transitions into that
*  settled state. Never inferred by this component itself -- see the class doc; it holds no
*  results data of its own. */
empty:boolean;
/** Opts this search 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 zero-result message politely. Set it where the search is rendered in response to a
*  query the user just ran and nothing else reports the outcome; leave it unset for a search
*  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 search first mounts: a later
*  reconnection or adoption stages the existing state again rather than replaying it, and later
*  transitions are announced either way. A search presenting neither state announces nothing.
*  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;
/** Placeholder for the query field. Empty string (the default) falls back to the localized
*  generic "Search" placeholder, which also becomes that field's accessible name (mirroring
*  `<lr-input>`'s own placeholder-as-label fallback). */
placeholder:string;
/** Accessible name for the inner search landmark when the host has no `aria-label`. Omitting it
*  falls back to the localized default; an explicit empty string clears it. */
label?:string;
/** JS-only accessible-name override for the inner search landmark. A non-empty markup
*  `aria-label` names the host as the sole overall owner instead. */
accessibleLabel:string|null;private isMounting;private initialStateAnnounced;private connectionGeneration;private errorAnnouncementSink?;private emptyAnnouncementSink?;private wasEmptyPresented;private chipFocusGeneration;connectedCallback():void;disconnectedCallback():void;protected updated(changed:PropertyValues<this>):void;
/** Announce whichever state this search is presenting right now, at that state's own urgency.
*  `errorText` wins, mirroring the render branch order; a search still `loading` has not
*  settled on either state, so it announces nothing. */
private announcePresentedState;private modeItems;private formatFilterValue;private get normalizedFilters();private get normalizedScope();private buildQuery;private submit;private cancel;private emitFiltersChange;private repairFocusAfterChipRemoval;private removeScope;private removeFilter;private onQueryInput;private onQueryKeyDown;private onModeChange;
/** The inner `<lr-segmented>`'s `lr-activate` reports a repeat pick of the mode already chosen.
*  This component owns its own event surface (`lr-search`, `lr-mode-change`, ...), so the child's
*  raw event is contained here rather than escaping as an event this tag never documented --
*  the same containment `onModeChange` already applies to the child's `lr-change`. */
private containModeEvent;private onSubmitClick;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-retrieval-search':LyraRetrievalSearch;}}