import{type TemplateResult,type PropertyValues}from'lit';import{LyraElement,type LyraEventDetailSnapshot}from'../../../internal/lyra-element.js';import type{LyraSize}from'../../../internal/variants.js';import type{LyraSelectionDirection}from'../../../internal/shared-unions.js';import type{LyraOption}from'./option.class.js';import'./option.class.js';import type{PlaceStrategy,PlaceSync}from'../../../internal/positioner.js';import{type FormOwnerValue}from'../../../internal/form-associated.js';import type{LyraPickerDetailValue,LyraPickerValue}from'../../../internal/picker-value.js';export type OptionFilter=(option:LyraOption,query:string)=>boolean;export type LyraComboboxPlacement='top'|'bottom';export type LyraComboboxTagRenderer=(option:LyraOption,index:number)=>unknown;
/** What a `validators` entry may return: nothing/`true` passes, a string is the message, `false` is
*  a generic failure, and an object of {@linkcode ValidityStateFlags} names the flags to raise. */
export type LyraComboboxValidatorResult=void|boolean|string|ValidityStateFlags;
/** Result shape accepted from object validators used by the upstream form-control contract. */
export interface LyraComboboxObjectValidatorResult{message:string;isValid:boolean;invalidKeys:Exclude<keyof ValidityState,'valid'>[];}
/** Structural compatibility shape for an object validator. The `never` callback input is
* intentional: it lets an array typed by another custom-element package remain assignable while
* Lyra invokes the callback with this host at runtime. Author new Lyra validators with the
* strongly typed function or `validate()` branches of {@linkcode LyraComboboxValidator}. */
export interface LyraComboboxObjectValidator{
/** Host attributes that trigger a fresh validity check when they change. */
observedAttributes?:string[];checkValidity:(input:never)=>LyraComboboxObjectValidatorResult;message?:string|((input:never)=>string);}export type LyraComboboxValidator=((value:string|string[],input:LyraCombobox)=>LyraComboboxValidatorResult)|{validate(value:string|string[],input:LyraCombobox):LyraComboboxValidatorResult;}|LyraComboboxObjectValidator;export interface ComboboxSourceRow{readonly value:string;readonly label:string;readonly sub?:string;
/** Optional decorative leading visual. Its rendered subtree is inert and aria-hidden. */
readonly icon?:unknown;
/** Leading adornment, mirroring `<lr-option>`'s `start`/`prefix` slots. Inert and aria-hidden,
*  like `icon`, so it never joins the option's accessible name. */
readonly start?:unknown;
/** Trailing adornment, mirroring `<lr-option>`'s `end`/`suffix` slots. */
readonly end?:unknown;
/** Optional trailing metadata badge. */
readonly badge?:string|number;
/** Spoken option label when the visible row needs additional context. */
readonly accessibleLabel?:string;
/** Opaque application payload retained in `selectedRows`. */
readonly data?:unknown;readonly dotColor?:string;readonly group?:string;readonly disabled?:boolean;}
/** Bounded async response envelope. `total` is the provider-side match count before its own cap. */
export interface ComboboxSourceResult{readonly rows:readonly ComboboxSourceRow[];readonly total?:number;}
/** Async row provider for a remote-backed combobox. Receives the current query and an options bag
*  carrying an `AbortSignal` and the component's hard row ceiling. Forward the signal to
*  `fetch(url, { signal })` and honor `limit` when practical. A legacy bare row array remains valid;
*  `{ rows, total }` exposes provider-side truncation truthfully.
*  The options parameter is required by the exported type so implementations can consume the
*  cancellation signal. A one-parameter `(query) => …` function remains assignable under
*  TypeScript's ordinary function-parameter compatibility rules. */
export type ComboboxSource=(query:string,options:{signal:AbortSignal;limit:number;})=>Promise<readonly ComboboxSourceRow[]|ComboboxSourceResult>;export type LyraComboboxSelectionDirection=LyraSelectionDirection;
/** Detail of `lr-filter`: the in-progress filter text, never the committed selection. */
export interface ComboboxFilterDetail{value:string;}export type{LyraPickerDetailValue,LyraPickerValue};export interface LyraComboboxEventMap<Multiple extends boolean=boolean>{'lr-invalid':CustomEvent<null>;'lr-show':CustomEvent<null>;'lr-after-show':CustomEvent<null>;'lr-hide':CustomEvent<null>;'lr-after-hide':CustomEvent<null>;'lr-clear':CustomEvent<null>;'lr-create':CustomEvent<{inputValue:string;}>;'lr-filter':CustomEvent<ComboboxFilterDetail>;
/** `detail.data` is index-aligned with `detail.value`: `data[i]` is the opaque `data` payload
*  behind `value[i]` (light-DOM `<lr-option data>` or an async source row's own `data`), by
*  reference and never deep-cloned, or `undefined` for a value resolving to no live row/option. */
'lr-change':CustomEvent<LyraEventDetailSnapshot<{readonly value:LyraPickerDetailValue<Multiple>;readonly data:readonly unknown[];}>>;'lr-activate':CustomEvent<{value:string;}>;'lr-source-error':CustomEvent<{error:unknown;query:string;}>;'lr-retry':CustomEvent<null>;input:InputEvent|CustomEvent<LyraEventDetailSnapshot<{readonly value:LyraPickerDetailValue<Multiple>;readonly data:readonly unknown[];}>>;change:CustomEvent<LyraEventDetailSnapshot<{readonly value:LyraPickerDetailValue<Multiple>;readonly data:readonly unknown[];}>>;blur:FocusEvent;focus:FocusEvent;}
/**
* Stable per-event aliases, so a host can name one event's type without restating the detail
* schema (or re-deriving it from `LyraComboboxEventMap`). Each narrows with the same `Multiple`
* parameter the component does: `LyraComboboxChangeEvent<false>`'s `detail.value` is a `string`.
*/
export type LyraComboboxChangeEvent<Multiple extends boolean=boolean> =LyraComboboxEventMap<Multiple>['lr-change'];export type LyraComboboxSourceErrorEvent=LyraComboboxEventMap['lr-source-error'];
/**
* `<lr-combobox>` — a filterable single/multi select that combines a text
* input with a listbox. Mirrors the core `<wa-combobox>` API under `lr-`.
*
* Options are `<lr-option value>` children. Emits native-style `change`/`input`
* (like Web Awesome) plus `lr-show`/`lr-hide`/`lr-clear`.
* Enter commits the highlighted option while the listbox has one; with nothing highlighted it
* performs the implicit form submission a native text field would (see
* `internal/submit-on-enter.ts` — the internal input is in a shadow root and has no form owner, so
* the platform can never do it here).
* Standard size tiers share their outer control height with sibling Lyra controls; the decorative
* expand icon scales inside that allocation without creating an independent action target.
* If local options or async rows change while a row is keyboard-active, the active descendant
* clamps to the nearest enabled survivor and clears when none remain.
* An async `source` failure renders as a disabled listbox row, not a shadow-root live region; each
* current post-mount rejection appends the localized `comboboxLoadError` message to the shared
* light-DOM assertive announcement sink. Raw caught error text is never exposed to users.
* The floating listbox is a nonmodal shared-overlay-manager entry. Visual stack order, Escape,
* outside-pointer dismissal, and focus handoff are therefore owned by only the newest Lyra
* overlay, including when another popup such as `lr-color-picker` remains open underneath it.
* The editable combobox input exposes explicit stateful `aria-invalid`: visible error chrome wins
* immediately, while intrinsic/custom invalidity is exposed only after interaction.
*
* Host `aria-describedby` targets supplement internal hint/error guidance on the semantic
* control, including live target replacement and document adoption. Removing label, hint, or
* error attributes safely omits their content while retaining native null property readback.
* Mounted option `selected` writes immediately update the live value and submission silently;
* reset defaults stay independent, and later default changes preserve a dirty selection.
*
* Composing keys stay with text editing. Inert source options and their inert ancestors are
* unavailable through popup rows; named option adornment mutations refresh their presentation.
* Single mode exposes one selected occurrence while retaining backing multiple-selection history.
*
* Assigning `undefined`/`null` to `value` clears the selection; every string, including `''`, is
* instead a candidate value resolved against the current local options/async rows -- an
* `<lr-option value="">` (or a matching row) is legitimate and now round-trips like any other. A
* committed value matching no current option/row (a stale value, or a programmatic assignment with
* a typo) still commits rather than being dropped, but renders with a dashed/italic
* `[part='unknown-value']` badge instead of silently passing the raw string off as an ordinary
* label -- see `isUnknownValue()`. Suppressed while an async `source` fetch has never yet resolved
* for this element, and never shown for an `allowCustomValue` commit, which is a sanctioned
* unmatched value, not a stale one. Over that same unresolved window the raw value itself is
* withheld too -- the trigger (and any `multiple`-mode tag for the same value) shows the
* `loadingText` placeholder instead of the raw string, since it is not yet knowable whether the
* value is even unmatched.
*
* @customElement lr-combobox
* @slot - `<lr-option>` elements.
* @slot label - Custom label content.
* @slot hint - Custom hint content.
* @slot error - Custom error content.
* @slot start - Adornment at the inline-start of the trigger row, before the selected-value tags
*   and the filter input. Slotted content is decorative chrome, not an option: `collectOptions()`
*   only ever collects `<lr-option>` elements from the default slot.
* @slot end - Adornment after the filter input and the built-in clear action, and before the
*   expand icon — so consumer content never sits outboard of the dropdown chevron.
* @slot clear-icon - Replaces the clear button's built-in icon.
* @slot expand-icon - Replaces the dropdown indicator's built-in icon.
* @event {CustomEvent<LyraEventDetailSnapshot<{ readonly value: LyraPickerDetailValue<Multiple>; readonly data: readonly unknown[]; }>>} change - The selection changed through user
* interaction. A bubbling, composed, non-cancelable event carrying `detail: { value, data }` (the
* new committed selection: a string in single mode, a string[] in `multiple` mode; `data` is
* index-aligned with `value` -- `data[i]` is the opaque `data` payload of the row/option behind
* `value[i]`, by reference and never deep-cloned, or `undefined` for a value that resolves to no
* live row/option -- see `isUnknownValue()`).
* @event {InputEvent | CustomEvent<LyraEventDetailSnapshot<{ readonly value: LyraPickerDetailValue<Multiple>; readonly data: readonly unknown[]; }>>} input - The user typed in the
* filter or changed the selection. Text edits expose the original InputEvent (no `value` detail);
* selection changes emit a bubbling, composed, non-cancelable event carrying `detail: { value, data }`.
* @event {CustomEvent<LyraEventDetailSnapshot<{ readonly value: LyraPickerDetailValue<Multiple>; readonly data: readonly unknown[]; }>>} lr-change - Prefixed compatibility alias fired
* after `input` and `change` on the same selection change, mirroring `<lr-checkbox>`'s `lr-change`.
* `detail: { value, data }`. Not fired for typing or a programmatic `value` assignment.
* @event lr-activate - Fired on every activation of an available listbox row -- a click, or
*   Enter on the active row -- whether or not the selection actually moved. `detail: { value }`
*   carries the activated option's own value, always a single string even in `multiple` mode.
*   Bubbling and composed, so a host outside the shadow tree receives it. Not cancelable: it is a
*   notification that the user picked a row, not a veto point, and nothing in this component
*   branches on it. In single-select mode, re-picking the already-selected row is the case
*   `change`/`lr-change` deliberately stay silent for -- "re-run that filter" is a real intent --
*   and it is otherwise unobservable, because the rows live in this shadow root, so a retargeted
*   `click` names no option and a keyboard commit produces no click at all. When an activation does
*   move the selection, `input`/`change`/`lr-change` are emitted first. Not fired for typing, for a
*   committed custom value that matches no row, for the clear button, or for a programmatic `value`
*   assignment.
* @event lr-source-error - An async `source` call rejected. `detail: { error, query }` carries the
*   raw rejection, so a host can log or report it (the rendered copy stays localized and never
*   shows it), plus the exact query string that call was made with -- the rejected call's own
*   query, not necessarily `this.query`/`inputValue`, which may have moved on (or been cleared by
*   closing the listbox) by the time the rejection settles. Not cancelable — the failure has
*   already happened and the error row is already what rendered, so there is nothing to veto.
* @event lr-retry - The failed-load state's `[part='retry-button']` was activated. Cancelable —
*   the built-in action calls `refresh()`, and `preventDefault()` leaves the failure on screen for
*   a host that owns its own retry timing.
* @method refresh - `refresh(): void` — re-runs the current `source` query without changing the
*   source's identity, its debounce controller, or its delay. Queues for the next open when the
*   listbox is closed; does nothing without a `source`.
* @slot source-error - Replaces the built-in failed-`source` state, retry control included. Named
*   apart from the form-control `error` slot deliberately: they are different failures and a
*   control has to be able to show both.
* @event lr-show - The listbox is about to open, however `open` became true. Cancelable —
*   `preventDefault()` leaves it closed and the reflected attribute untouched.
* @event lr-after-show - The listbox finished opening and its transition settled.
* @event lr-hide - The listbox is about to close, however `open` became false. Conditionally
*   cancelable: connected transitions can be vetoed on the same terms as `lr-show`; an
*   already-removed element closing on disconnect cannot honour a veto. A connected veto also
*   preserves the live filter query, active option, and async rows exactly.
* @event lr-after-hide - The listbox finished closing and its transition settled.
* @event lr-clear - The value was cleared.
* @event {CustomEvent<{ inputValue: string }>} lr-create - Cancelable request to create a
*   nonmatching input value. Prevent the event to supply a normalized option/value yourself.
* @event {CustomEvent<ComboboxFilterDetail>} lr-filter - The in-progress filter text changed
* through user input. `detail.value` is the live filter string, which is not the same thing as the
* host's `value` (the committed selection). User-input only: typing and the clear button announce
* it. Programmatic edits, including `setRangeText()`, are silent. `setRangeText()` preserves
* the replaced filter text and synchronizes its query/options without changing selected value.
* Picking a row, resetting the form, and dismissing the listbox also update the filter silently.
* @event {FocusEvent} blur - Re-dispatched from the internal native input as a bubbling, composed,
* non-cancelable event.
* @event {FocusEvent} focus - Re-dispatched from the internal native input as a bubbling, composed,
* non-cancelable event.
* @event lr-invalid - The combobox failed a validity check. Cancelable: calling
* `preventDefault()` also cancels the native `invalid` event behind it, suppressing the
* browser's own validation bubble so an app can present the failure its own way.
* @csspart form-control - The outer wrapper around label, combobox, listbox, error and hint.
* @csspart form-control-label - The `<label>` element.
* @csspart label - Compatibility wrapper around the visible label content.
* @csspart form-control-input - Compatibility wrapper around the editable control.
* @csspart combobox - The input container (positioning anchor).
* @csspart combobox-input - The text input.
* @csspart start - Wrapper around the `start` adornment slot; `hidden` while nothing is slotted.
* @csspart end - Wrapper around the `end` adornment slot; `hidden` while nothing is slotted.
* @csspart listbox - The managed nonmodal options popover; its stack depth comes from
*   `--lr-overlay-stack-index` with `--lr-layer-dropdown` as the standalone fallback.
* @csspart group-label - The heading of an option group (rows sharing a `group`), named as on
*   `lr-select` and `lr-emoji-picker` so one rule can style every grouped list.
* @csspart option - An option row.
* @csspart option-dot - An option row's leading status dot (when `dot-color` is set).
* @csspart option-start - An option row's leading adornment, cloned from the source
*   `<lr-option>`'s `start`/`prefix` slot (or an async row's `start`). Inert and aria-hidden.
* @csspart option-end - An option row's trailing adornment, cloned from the source
*   `<lr-option>`'s `end`/`suffix` slot (or an async row's `end`). Inert and aria-hidden.
* @csspart option-icon - An async option row's optional decorative leading visual. Its rendered
*   subtree remains visible but is inert and hidden from assistive technology.
* @csspart option-label - An option row's label/sub wrapper.
* @csspart option-sub - An option row's secondary line (when `sub` is set).
* @csspart option-badge - An async option row's optional trailing metadata badge, and the
*   localized "not in catalog" badge on a synthetic unmatched-value row (`show-unknown-option`).
* @csspart option-overflow - The "+N more" indicator shown when rows are capped by `maxRender`.
* @csspart unknown-value - Badge shown next to the closed single-select input, or a `multiple`-mode
*   tag, when the committed value matches no current option/row (see `isUnknownValue()`).
* @csspart tags - The multi-select tag container.
* @csspart tag - An individual selected tag.
* @csspart tag-label - The wrapping/ellipsis-safe selected-tag label.
* @csspart tag__content - Compatibility wrapper around a selected tag's visible content.
* @csspart tag__remove-button - A tag's remove button.
* @csspart tag__remove-button__base - Compatibility name on a tag's remove button.
* @csspart clear-button - The clear button.
* @csspart expand-icon - The dropdown indicator.
* @csspart error - Ordinary form-validation text referenced by the internal input; it is not a
*   live region, avoiding a second announcement alongside native validation/focus feedback.
* @csspart source-error-row - The listbox row holding the failed-`source` state.
* @csspart source-error - The shared failed-load state itself, with `source-error-base`,
*   `source-error-icon`, `source-error-heading`, `source-error-description` and
*   `source-error-actions` forwarded from the composed `<lr-empty>`.
* @csspart retry-button - The retry control inside the failed-load state.
* @csspart hint - The hint message.
* @cssprop --lr-combobox-trigger-padding - Padding inside the input container.
* @cssprop [--lr-combobox-trigger-min-height=var(--lr-form-control-height)] - Minimum
*   input-container block size. Reads the shared form-control height ladder, so retuning
*   `--lr-theme-form-control-height-*` moves this control and every sibling field together.
* @cssprop --lr-combobox-trigger-height - Exact input-container height. Unset by default, which
*   leaves `--lr-combobox-trigger-min-height` as a floor only; set it to a length to both floor and
*   cap the row (e.g. to pixel-match `<lr-input>`/`<lr-select>` in the same toolbar). Because it is
*   never declared by the component itself, it can be set from an ancestor or an outer-tree rule as
*   well as inline on the element. Intended for a single-row combobox: in `multiple` mode a tag row
*   long enough to wrap overflows the pinned box visibly (nothing is clipped or made unreachable),
*   so leave it unset there.
* @cssprop [--lr-combobox-font-size=var(--lr-form-control-font-size)] - Input text size, from the
*   shared form-control size ladder.
* @cssprop --lr-combobox-tag-padding - Selected-tag padding.
* @cssprop --lr-combobox-tag-font-size - Selected-tag text size.
* @cssprop [--lr-combobox-unknown-value-border-style=dashed] - Border style of a `multiple`-mode
*   tag whose committed value matches no current option/row.
* @cssprop [--lr-combobox-unknown-value-border-color=var(--lr-color-border)] - Border color of the
*   same unknown-value tag.
* @cssprop --lr-combobox-expand-size - Decorative expand-icon box size, scaled by `size`.
* @cssprop [--lr-combobox-gap=var(--lr-space-xs)] - Gap between the start/end adornments, tags,
*   and filter input inside the trigger row. Unlike the size knobs above it does not vary by
*   `size` tier. Override it to retune without a `::part(combobox)` rule.
* @cssprop [--lr-combobox-radius=var(--lr-radius)] - Corner radius of the trigger row
*   (`[part='combobox']`). Does not vary by `size` tier; the `pill` attribute swaps it for
*   `--lr-radius-pill`.
* @cssprop [--lr-combobox-option-active-bg=var(--lr-color-brand-quiet)] - Background of a hovered
*   or keyboard-active option row.
* @cssprop [--lr-combobox-option-selected-bg=transparent] - Background of the currently-selected
*   option row. Not declared on `:host`; retheme without hijacking `--lr-color-brand`.
* @cssprop [--lr-combobox-option-selected-border=var(--lr-color-brand)] - Border color of the
*   selected option row.
* @cssprop [--lr-combobox-option-selected-color=var(--lr-color-brand)] - Text color of the
*   selected option row.
* @cssprop [--lr-combobox-option-selected-font-weight=var(--lr-font-weight-semibold)] - Font
*   weight of the selected option row.
* @cssprop [--lr-combobox-option-badge-bg=var(--lr-color-brand-quiet)] - Background of the
*   `[part='option-badge']` trailing metadata badge, and the "not in catalog" badge on a
*   synthetic unmatched-value row (`show-unknown-option`).
* @cssprop [--tag-max-size=var(--lr-size-5rem)] - Maximum inline size of a built-in selected tag.
* @cssprop [--show-duration=var(--lr-transition-fast)] - Listbox enter-transition duration.
* @cssprop [--hide-duration=var(--lr-transition-fast)] - Listbox exit-transition duration.
* @cssprop [--lr-combobox-fill=var(--lr-color-surface)] - Resting background of the trigger row.
* The `filled`/`filled-outlined` treatments default it to `--lr-color-surface-raised`; a value set
* here wins over every treatment.
* @cssprop [--lr-combobox-border-color=var(--lr-color-border)] - Resting border color of the
* trigger row, `transparent` by default on the `filled` treatment.
* @cssprop [--lr-combobox-open-border-color=var(--lr-color-brand)] - Border color of the trigger
* row while it holds focus — the state the listbox opens in. Bound to `:focus-within` rather than to
* `open`, so it paints on a focused row whose listbox is closed too; the name is symmetric with
* `lr-select`'s `--lr-select-open-border-color`, which is gated on `open` itself.
* @cssprop [--lr-form-control-focus-shadow=none] - The shared field focus halo, painted as a
* `box-shadow` while this control is focused. One name for every field-shaped control in the
* library, so a halo is configured once rather than per component. Additive: the focus outline and
* border cue are the accessibility answer to focus and are never replaced by it.
* @cssprop [--lr-form-control-required-content=' *'] - The required marker appended to
* `form-control-label` while `required` is set. Set it to `''` to suppress the marker, or to any
* other quoted string (`' (required)'`, a localized word) to replace it.
* @cssprop [--lr-form-control-required-color=var(--lr-color-danger)] - Required-marker color,
* themeable independently of error text and invalid borders.
* @cssprop [--lr-form-control-required-offset=0] - Inline space between the label text and the
* required marker.
* @cssprop [--lr-overlay-surface=var(--lr-color-surface-overlay)] - Shared floating-surface fill,
* on the listbox popup. This is the public arm the popup never had: retinting it no longer means
* retinting the page surface every card and input reads.
* @cssprop [--lr-overlay-border=var(--lr-color-border)] - Shared floating-surface edge colour, on
* the listbox popup.
* @cssprop [--lr-overlay-radius=var(--lr-radius)] - Shared floating-surface corner radius, on the
* listbox popup.
* @cssprop [--lr-overlay-shadow-anchored=var(--lr-shadow-m)] - Elevation of the anchored listbox
* popup.
* @cssstate blank - Matches while no value is selected.
* @cssstate disabled - Matches while disabled directly or by an ancestor fieldset.
* @cssstate required - Matches while `required` is set, so a consumer can mark the field without
*   duplicating that flag in their own markup.
* @cssstate optional - Matches while `required` is not set (the complement of `required`).
* @cssstate valid - Matches while the control satisfies its constraints.
* @cssstate invalid - Matches while it does not — including a pristine required-and-empty
*   combobox, exactly like native `:invalid`.
* @cssstate user-valid - `valid`, but only after the user has interacted: blurred the filter
*   input, committed a selection, `reportValidity()`, or a submission attempt. Not after a
*   silent `checkValidity()` alone.
* @cssstate user-invalid - `invalid`, but only after that same interaction — a required combobox
*   nobody has touched yet is invalid without being styled as an error.
* @cssprop --lr-positioning-strategy - Cascading `absolute`/`fixed` override for
*   {@link positioningStrategy}, read from computed style when the listbox is positioned. Set it
*   once on `:root`, a theme, or one clipping ancestor to change every unset combobox beneath it
*   instead of authoring `positioning-strategy` on each instance; an explicit value on the
*   instance always wins over it.
* @status stable
* @since 4.0.0
*/
export declare class LyraCombobox<Multiple extends boolean=boolean>extends LyraElement<LyraComboboxEventMap<Multiple>>{protected static readonly immutableEventDetails:readonly string[];
/** `data` carries opaque per-row caller payload -- preserve each item's identity through the
*  frozen event envelope instead of recursively cloning unknown data, the same policy
*  `<lr-prompt-queue>`'s `lr-queue-change` detail uses for its own `items`. */
protected static readonly identityEventDetailCollectionItems:Readonly<{'lr-change':readonly string[];input:readonly string[];change:readonly string[];}>;static formAssociated:boolean;static styles:import("lit").CSSResultGroup[];static properties:{customError:{attribute:string;reflect:boolean;noAccessor:boolean;};multiple:{type:BooleanConstructor;reflect:boolean;noAccessor:boolean;};disabled:{type:BooleanConstructor;reflect:boolean;noAccessor:boolean;};required:{type:BooleanConstructor;reflect:boolean;noAccessor:boolean;};value:{noAccessor:boolean;};name:{reflect:boolean;noAccessor:boolean;converter:import("lit").ComplexAttributeConverter<string,unknown>;};maxOptionsVisible:{type:NumberConstructor;attribute:string;noAccessor:boolean;};maxRender:{type:NumberConstructor;attribute:string;noAccessor:boolean;};sourceDelay:{type:NumberConstructor;attribute:string;noAccessor:boolean;};};placeholder:string;label:string;hint:string;errorText:string;
/** Whether the listbox is open. Effectively disabled controls reject direct reopen attempts,
* including a synchronous fieldset cascade. */
get open():boolean;set open(next:boolean);
/** Allows a nonmatching query to be created as a new option through the cancelable `lr-create`
* veto point. The default action appends and selects an `<lr-option>`. */
allowCreate:boolean;
/** Lets a single-select combobox commit arbitrary text without adding an option. */
allowCustomValue:boolean;
/**
* Appends every committed value that no option or async row claims to the end of the listbox as
* a synthetic, re-selectable row badged with the localized `notInCatalog` text -- the policy
* `<lr-model-select>` already ships.
*
* Off by default, because it adds a row to a listbox that has always rendered only real options.
* Turn it on wherever a stored value can outlive its catalog entry: without it, the out-of-list
* value is visible on the trigger but absent from the listbox, so a user who opens the listbox
* has no way back to the value they arrived with.
* @default false
*/
showUnknownOption:boolean;
/**
* Renders the label for a committed value that matches no option or row.
*
* The existing tag/option renderers cannot serve this case: they are handed a matched option,
* which by definition does not exist here, so the raw value string was the only thing left to
* render. This hook applies everywhere that value's label appears -- the trigger, a `multiple`
* tag, and the synthetic listbox row -- and is used only while the value is genuinely unmatched,
* so it can never override a real option's own label. A blank return falls back to the raw
* value, exactly as no hook at all would. Caller-supplied text: it is not localized here. Not
* consulted while an async `source` fetch has never yet resolved for this element -- the value
* is not yet known to be unmatched at all, so `loadingText` renders instead (see `isUnknownValue()`).
*/
getUnknownLabel?:(value:string)=>string;
/** Visual treatment shared with other Lyra form controls. */
appearance:'filled'|'outlined'|'filled-outlined';
/** Preferred vertical side for the floating listbox. */
placement:LyraComboboxPlacement;
/**
* Copies the trigger's width, height, or both onto the listbox -- the same property
* `<lr-dropdown>`/`<lr-popup>` spell. Unset (the default), the listbox sizes to its own content,
* clamped between `--lr-size-12rem` and `--lr-size-28rem`, exactly as before. Set `sync="width"`
* so a full-width trigger with short option labels gets a listbox that aligns to its own edges
* instead of floating narrower in the middle -- the width clamp described above no longer
* applies while this is set, since the anchor's own width is now the intentional bound.
* @default undefined
*/
sync?:PlaceSync;private _positioningStrategy?;
/**
* CSS positioning scheme the listbox is laid out with -- the property `<lr-select>`,
* `<lr-popover>`, `<lr-dropdown>`, `<lr-tooltip>` and `<lr-color-picker>` all spell the same way.
* `fixed` (this control's default, and what it has always rendered) positions against the
* viewport and escapes most clipping ancestors, which is why it suits a typeahead list that
* usually lives inside a scrollable region; `absolute` positions against the nearest containing
* block and scrolls with it. An unsupported value resolves back to the default. Like
* `placement`, a change takes effect the next time the listbox opens.
*
* This reports only the instance's own authored value (or the default). When the instance sets
* nothing, the listbox is placed with the `--lr-positioning-strategy` cascading custom property
* honoured ahead of that default -- see that `@cssprop`.
*
* No `hoist` alias, deliberately, unlike `<lr-select>`. There it is Shoelace's established
* spelling; here it would be a boolean whose default is `true`, so the attribute could only ever
* express the value the control already has. Use `positioning-strategy="absolute"` to opt out.
* @default 'fixed'
*/
get positioningStrategy():PlaceStrategy;set positioningStrategy(next:PlaceStrategy);
/** Visual size — the library-wide `2xs`–`xl` ladder shared with `lr-input`/`lr-select`. The
*  Web Awesome / Shoelace spellings `small`/`medium`/`large` are accepted for `s`/`m`/`l`, so a
*  migration is a tag rename with no attribute rewrite. */
size:LyraSize;
/** Rounds the trigger row's corners to a full pill, mirroring `lr-input`'s own `pill`. It is a
*  single override of `--lr-combobox-radius`, so a consumer setting that property directly still
*  wins for a bespoke shape. */
pill:boolean;
/** Show a clear button while the combobox has something to clear on either axis: a committed
*  selection, or visible filter text (the open listbox in single-select, any time in `multiple`
*  mode — a closed single-select shows the selected label, not the query, so a stale query alone
*  never surfaces the button). Clearing a selection emits `input`/`change`/`lr-clear`; clearing
*  filter text emits `lr-filter` with an empty `value`; each fires only for the axis that
*  actually changed. Named after Shoelace's `clearable`; Web Awesome spells the same idea
*  `with-clear`, which is accepted as an alias so either migration keeps working. */
clearable:boolean;
/** Web Awesome's spelling of {@link clearable}, accepted so a mechanical `wa-` → `lr-` rename
*  does not silently drop the clear button. Prefer `clearable` in new code. */
withClear:boolean;
/** SSR slot-presence hint for label content. */
withLabel:boolean;
/** SSR slot-presence hint for hint content. */
withHint:boolean;
/** Custom selected-tag renderer in multiple mode. Returned strings stay text, never markup. */
getTag?:LyraComboboxTagRenderer;
/** Additional JavaScript validators run after the intrinsic `required` constraint — the same
* contract `lr-date-input` implements. Accepts a function, an object with
* `validate(value, input)`, or the mapped object-validator shape with `checkValidity(input)` and
* `{ isValid, message, invalidKeys }` results. Object validators can list host
* `observedAttributes` that should trigger live revalidation. */
validators:LyraComboboxValidator[];
/** Native editing-assistance attributes forwarded to the wrapped input. */
autocomplete:string;inputMode:string;enterKeyHint:string;
/** Native spellchecking forwarded to the filter input. Attribute removal restores this
* component's declared `false` default instead of the converter's native-HTML `true` fallback. */
spellcheck:boolean;autocapitalize:string;private autocorrectValue;
/** Optional no-match copy override. Omission localizes `noMatches`; a supplied string, including
* `"No matches"` or `""`, renders verbatim. */
emptyText?:string;
/** Optional loading-copy override. Omission localizes `loading`; a supplied string, including
* `"Loading…"` or `""`, renders verbatim. Shown both in the listbox's own loading row and, for a
* committed value a `source` fetch has never resolved (see `labelFor()`), in place of the raw
* value on the trigger/tags -- the same key covers both spots. */
loadingText?:string;
/** Optional capped-list copy override. Omission localizes `comboboxOverflow`; a supplied string,
* including the built-in English template or `""`, wins verbatim after `{n}` interpolation. */
overflowText?:string;filter:OptionFilter|null;
/** Optional bounded async row source. Receives `{ signal, limit: 2000 }`; may return a legacy
* readonly row array or `{ rows, total? }`. Results are clone-normalized under row/text ceilings. */
source:ComboboxSource|null;
/** Web Awesome's boolean `autocorrect` IDL; its HTML attribute uses `on`/`off`. */
get autocorrect():boolean;set autocorrect(next:boolean);
/** Lowercase mapped IDL aliases for the remaining camel-case native spellings. */
get inputmode():string;set inputmode(next:string);get enterkeyhint():string;set enterkeyhint(next:string);
/** Live text in the native filter input. Programmatic writes are event-silent.
* @default '' */
get inputValue():string;set inputValue(next:string);private query;
/** Public `inputValue` and `setRangeText()` writes remain visible while closed; stale user filter
* text left behind by a direct `open = false` write does not. */
private explicitInputValue;private activeIndex;private options;private touched;private validityRevision;private validatorAttributeObserver?;private readonly slotPresence;private loading;
/**
* True while the last `source` call rejected and the popup shows the retry state instead of rows.
*
* The popup swaps `role="listbox"` for `role="dialog"` (and the input gains the matching
* `aria-haspopup="dialog"`) for exactly that span, because the failure state's retry `button` is
* not a valid listbox child -- axe's `aria-required-children` fails outright on it. `dialog` is
* one of the four popup roles WAI-ARIA allows a `role="combobox"` to own, so the still-expanded
* `aria-controls` target keeps a valid owner; `role="presentation"` would leave the expanded
* popup with none. `aria-activedescendant` is dropped over the same span: no option row renders
* while the failure state is the only content, so any retained active index would be a dangling
* idref.
*/
private sourceFailed;
/**
* True once a `source` call has settled at least once (success or rejection) since the last
* time `source` itself was assigned. Distinguishes "not yet known" (this stays `false`, from
* mount through the debounce delay and the in-flight call) from "genuinely unknown" (a real
* settle happened and the value still matched nothing) -- see `isUnknownValue()` and
* `labelFor()`, which both key off it instead of the narrower `loading` flag so the raw value
* never leaks, badged or not, before the first real answer comes back.
*/
private sourceEverSettled;private asyncRows;private _sourceTotal;private _sourceTruncated;private sourceErrorAnnouncementSink?;private inputEl?;private optionsSlot?;
/** The debounced `source()` call. Scheduled on -- and cancelled through -- the realm this
*  combobox lives in at the time, so a combobox adopted into another document neither leaves a
*  task behind on the old realm nor loses the ability to cancel the new one. */
private readonly sourceDebounce;private sourceToken;
/** A `refresh()` asked for while the listbox was closed. Held rather than run, because a closed
*  combobox deliberately does not fetch -- the same convention that already governs the
*  open-driven first query -- and replayed on the next open. */
private refreshQueued;
/** Aborted when a newer query supersedes the in-flight one, or on disconnect, so the source's
*  own `fetch` can cancel. */
private sourceAbort?;private _sourceWarmed;private _selectedLabelCache;private _selectedRowCache;
/** A structured selection assigned before local options or async rows became available. */
private pendingSelectedRowValues?;private _rowsByValue;private internals;private _open;private validityController;
/** Consumer-supplied validation message reflected through `custom-error`. */
customError:string|null;private _fieldsetDisabled;private listId;private inputId;private cleanup?;private listboxPositioned;private positioningGeneration;private positioningReady;private resolvePositioningReady?;private overlayHandle?;private restoreFocusOnClose;private restoringOverlayFocus;private pointerListenerDocument?;private pointerListener?;private _isFirstUpdate;private openVetoed;
/** Set only by `hide()`. Cleanup is applied in `willUpdate()` after `lr-hide` accepts the close,
* so a veto remains an atomic no-op for the query, active row, and async result set. */
private closeCleanupPending;private transitionToken;private transitionWaiters;private _selected;private singleSelectedOption?;private readonly sourceOptionsByRow;private _valueDirty;private _multiple;private _disabled;private _required;private _defaultSelected;private _defaultCaptured;private _restoredStateActive;private _name;private validationTargetOverride?;
/**
* Bounds the popup to roughly this many option rows, leaving the rest reachable by scrolling.
*
* This is the third and last of three similarly-named caps, which is exactly the confusion this
* property exists to end -- each does something different:
* - `visibleOptions` (this one) caps how many suggestion rows are **visible** at once. Purely
*   presentational: every row is still rendered and still reachable by scrolling.
* - `maxOptionsVisible` caps how many **selected tags** are shown in multi-select before the
*   "+N" summary. Nothing to do with the suggestion list.
* - `maxRender` caps how many suggestion rows are **rendered into the DOM at all**, as a
*   performance ceiling; rows past it do not exist and are summarized by `option-overflow`.
*
* Unset imposes no bound of its own, leaving the listbox's existing max-height behavior exactly
* as it was. Zero, negative, and non-finite values normalize to unset rather than collapsing the
* popup.
*/
visibleOptions?:number;private _maxOptionsVisible;private _maxRender;private _sourceDelay;constructor();get form():HTMLFormElement|null;set form(owner:FormOwnerValue);
/** Returns the owning form, including an external owner selected by the `form` attribute. */
getForm():HTMLFormElement|null;get labels():NodeList;get validity():ValidityState;get validationMessage():string;get willValidate():boolean;
/** Native element used as the constraint-validation focus anchor. */
get validationTarget():HTMLElement|undefined;set validationTarget(next:HTMLElement|undefined);
/** Clears consumer-supplied validity and restores the current intrinsic constraints. */
resetValidity():void;
/** The internal native filter input, for direct DOM access when needed. */
get input():HTMLInputElement|null;get selectionStart():number|null;set selectionStart(value:number|null);get selectionEnd():number|null;set selectionEnd(value:number|null);get selectionDirection():LyraComboboxSelectionDirection|null;set selectionDirection(value:LyraComboboxSelectionDirection|null);
/** Reads both component state and the UA's synchronous fieldset cascade before public actions. */
private get liveDisabled();focus(options?:FocusOptions):void;blur():void;
/** Activates the trigger the same way a real mouse click on `[part='combobox']` would --
*  focuses the filter input and opens the listbox (mirrors `onComboMouseDown` below). Without
*  this override, `HTMLElement.prototype.click()` on the host is a no-op: a custom element has
*  no native click activation behavior of its own, so a generic form-submit helper, test
*  utility, or automation script calling `.click()` on `<lr-combobox>` directly (rather than on
*  its shadow-internal parts) would otherwise silently do nothing. */
click():void;select():void;setSelectionRange(start:number|null,end:number|null,direction?:LyraComboboxSelectionDirection):void;setRangeText(replacement:string):void;setRangeText(replacement:string,start:number,end:number,selectMode?:SelectionMode):void;private localDescriptionIds;private externalDescriptionLease?;private syncExternalDescription;private releaseExternalDescription;connectedCallback():void;adoptedCallback():void;private syncSourceErrorAnnouncementSink;private releaseSourceErrorAnnouncementSink;protected willUpdate(changed:PropertyValues):void;protected firstUpdated(changed:PropertyValues):void;
/** Submitted field name.
* @default '' */
get name():string;set name(next:string|null);
/** Enables multiple selection.
* @default false */
get multiple():boolean;set multiple(next:boolean);
/** Disables every interactive sub-control.
* @default false */
get disabled():boolean;set disabled(next:boolean);
/** Requires at least one committed selection.
* @default false */
get required():boolean;set required(next:boolean);
/** The selected value(s): a string in single mode, a string[] in `multiple` mode.
*
*  Assigning `undefined` or `null` clears the selection -- the documented "unset" contract.
*  Every string, including `''`, is instead a candidate value: `<lr-option value="">` (or a
*  matching async row) is a legitimate row, and assigning `''` selects it when present,
*  mirroring what picking that row already did. A `''`/string assignment that matches nothing
*  still commits, exactly like any other unmatched string -- see `isUnknownValue()`.
*
*  `LyraPickerValue<Multiple>` narrows to `string` on a `LyraCombobox<false>` and `string[]` on a
*  `LyraCombobox<true>`; the unnarrowed default resolves to the published union below, which is
*  why the manifest type is pinned here rather than left to the inferred alias name.
*  @type {string | string[]} */
get value():LyraPickerValue<Multiple>;set value(next:LyraPickerValue<Multiple> |null|undefined);private setValue;
/** Maximum number of selected-value **tags** shown before the rest collapse behind a "+N" tag
*  (multi-select only). Sanitized to a finite, non-negative integer.
*
*  Not to be confused with the two caps on the suggestion list: `visibleOptions` bounds how many
*  suggestion rows are visible at once, and `maxRender` bounds how many are rendered at all.
*  This one only ever concerns the tags for values already chosen.
* @default 3 */
get maxOptionsVisible():number;set maxOptionsVisible(next:number);
/** Maximum number of suggestion rows **rendered into the DOM at all** before the rest collapse
*  behind the overflow indicator (the current selection is always kept visible regardless). This
*  is a performance ceiling, not a visible-height affordance: rows past it do not exist and
*  cannot be scrolled to. Use `visibleOptions` to bound the popup's height while keeping every
*  row reachable, and `maxOptionsVisible` for the selected-tag cap. Sanitized to a finite,
*  non-negative integer capped at 1,000.
*
*  Rows render in full rather than as a recycled scroll window, because the filter input's
*  `aria-activedescendant` is an IDREF and can only resolve within its own tree scope — rows
*  hosted inside a nested windowing element would sit one shadow root deeper than the input
*  that must point at them. Raising this to cover a few-hundred-entry list (countries,
*  currencies, time zones) is the intended use; past roughly a thousand rows, `source` narrows
*  the set before it becomes DOM and is the better tool. */
get maxRender():number;
/** Debounce (ms) between the last keystroke and the `source` call. Sanitized to a finite
*  duration clamped to `[0, browser-timer-ceiling]`; `0` fires on every keystroke, a
*  non-finite value falls back to the `200` default. */
get sourceDelay():number;set sourceDelay(next:number);set maxRender(next:number);
/** Provider-side match count for the latest accepted source response, before component caps. */
get sourceTotal():number;
/** Whether the latest response contained or reported more rows than the bounded retained set. */
get sourceTruncated():boolean;
/** Structured rows corresponding to the current selection, including opaque async-row data.
* Assigning rows from the current local or async source maps their stable `value` fields back to
* controlled selection. Detached values are ignored, duplicates collapse, single mode keeps the
* first row, and the write is silent like `value`. A property binding that arrives before local
* options or async rows is deferred until that source resolves. Read rows remain detached
* snapshots. */
get selectedRows():ComboboxSourceRow[];
/** Same lookup as `selectedRows`, but keeps one slot per `_selected` entry -- `undefined` where
*  nothing resolves -- so a caller needing index alignment with `value` (the `data` field of
*  `input`/`change`/`lr-change`'s detail) never has to guess which value a dropped row
*  belonged to. */
private resolveSelectedRowSlots;set selectedRows(next:readonly ComboboxSourceRow[]);
/** Shared with every other form control: disabled (own or fieldset-cascaded) bars validation. */
private get barredFromValidation();
/** Runs `validators` in order and returns the first failure. Mirrors `lr-date-input`'s reading of
*  the same contract: a thrown validator fails closed with the generic localized message rather
*  than escaping into the caller that happened to write `value`. */
private validatorResult;
/** Watches the host attributes any object validator listed in `observedAttributes`, so changing
*  one revalidates live. Bound to the owning window so a re-parent into another document (or a
*  disconnect) can never leave the previous document's observer firing into this host. */
private syncValidatorAttributeObserver;private disconnectValidatorAttributeObserver;private updateValidity;
/**
* Publishes the six validity custom states (`:state(required)`/`optional`, `valid`/`invalid`,
* `user-valid`/`user-invalid`). The implementation is shared with every other form-associated
* control in the library — see `internal/custom-states.ts`; this component drives
* `ElementInternals` directly rather than through the `FormAssociated` mixin (its value is a
* `string[]` in `multiple` mode, which that string-value mixin cannot carry), so it calls the
* helper itself. `touched` is this component's own interaction flag, already set by the filter
* input's blur, so the `user-*` pair stays off a pristine control the way native
* `:user-invalid` does.
*/
private syncCustomStates;private syncFormValue;
/** Effective disabled state: this element's own `disabled` OR an ancestor
*  `<fieldset disabled>`'s inherited state -- mirrors native `<input>`, whose
*  own `disabled` IDL property/attribute is never mutated by a fieldset. */
get effectiveDisabled():boolean;formResetCallback():void;formStateRestoreCallback(state:string|File|FormData|null,reason:'autocomplete'|'restore'):void;
/**
* Called by the browser when an ancestor `<fieldset disabled>` toggles.
* Tracked separately from the consumer's own `disabled` (see
* `effectiveDisabled`) so a consumer's explicit `disabled` survives the
* fieldset re-enabling instead of being permanently overwritten.
*/
formDisabledCallback(disabled:boolean):void;private markInteracted;checkValidity():boolean;reportValidity():boolean;
/**
* Sets or clears a consumer-supplied validation error — the standard channel for a rejection no
* client-side constraint can express ("that option is no longer available"). A non-empty
* `message` raises `customError` and becomes `validationMessage`, so the control fails
* `checkValidity()`, blocks submission, and matches `:state(invalid)`; `''` clears it.
*
* Clearing restores the control's own computed validity rather than forcing it valid: a
* `required` combobox with nothing chosen stays `valueMissing`. The custom error also survives
* every intrinsic recomputation in between (each selection/`required` change re-runs
* `updateValidity()`) and a `form.reset()` — matching a native control, where only another
* `setCustomValidity('')` clears it.
*
* The message is caller-supplied content, so it is used verbatim and never localized here.
*/
setCustomValidity(message:string):void;disconnectedCallback():void;private collectOptions;
/**
* Reads the default slot's currently assigned `<lr-option>` elements and applies them --
* wired as the `slotchange` handler (via `collectOptions`) for every later mutation, and called
* once more from `firstUpdated()` (see `collectInitialSlotAssignment`) to cover an environment,
* or a real-browser timing race, where the slot's initial assignment never fires `slotchange`.
* Idempotent over an unchanged assigned-element set: `previous` below is an identity set of the
* options already applied, so a second call that reads back the same elements finds nothing new
* to seed and falls through to the harmless `reflectSelected()` re-sync at the end.
*/
private collectOptionsFromSlot;private refreshOptionDefaults;private onOptionChange;private reflectSelected;private labelFor;
/**
* Whether a committed value matches no currently-known row -- a stale value from before its
* option/row disappeared, or a programmatic `value` assignment that never matched anything.
* Drives the dashed/italic "not in catalog" presentation in `render()`, so a genuinely
* unresolved value never leaks its raw string with no explanation, while `labelFor()` keeps the
* raw value itself fully reachable.
*
* Suppressed entirely until a `source` combobox's async fetch has settled at least once (see
* `sourceEverSettled`): from mount through the debounce delay and the in-flight call itself,
* simply hasn't had a chance to populate `asyncRows` yet, which is "not yet known", not
* "genuinely unknown" -- `loading` alone would miss the debounce-delay span before the request
* even starts, which is exactly the window `labelFor()`'s own loading-placeholder fallback needs
* this to agree with.
*
* Checked against the same four sources as `labelFor()`, but as a plain existence test rather
* than a label lookup, so a real match with a deliberately blank label is never misreported as
* unknown. `_selectedLabelCache` also covers `allowCustomValue`'s committed text (cached against
* itself in `commitCustomValue()`) -- a sanctioned "not from the option list" value, not a stale
* one, so it must never show this badge.
*/
private isUnknownValue;
/** The current row set in a source-agnostic shape, before capping. */
/**
* Cloned adornment nodes, keyed by the option they came from. Cached because `effectiveRows` runs
* on every render pass: handing Lit a fresh clone each time would rebuild the whole popup's
* adornment DOM on every keystroke. Option notifications compare the authored markup snapshot
* before invalidating it; changes to a label or secondary text leave unchanged clones intact.
* Recollecting the option set drops the snapshots so detached edits are picked up as well.
*/
private adornmentClones;private adornmentMarkup;
/**
* `<lr-option>` documents `start`/`end` (plus the Shoelace `prefix`/`suffix` aliases) adornment
* slots, but the popup is built from row DATA rather than from the option elements, so slotted
* nodes have nowhere to land. Clone them into the row instead.
*
* `cloneNode(true)`, never `createElementNS`: the latter yields an inert, never-upgrading custom
* element (AGENTS.md), which would silently break the `<lr-flag>`/avatar case this exists for.
* Cloning also leaves the author's own subtree exactly where they put it -- moving the live node
* would empty their markup as a side effect of opening a dropdown.
*/
private adornmentsFor;private rowForOption;private get selectionSourceRows();private applySelectedRowValues;private applyPendingSelectedRows;private get effectiveRows();
/**
* Synthetic rows standing in for committed values that no option or async row claims.
*
* Opt-in, and derived fresh from the current `value` on every render -- never stored -- so the
* row appears exactly while the value is genuinely unmatched and vanishes the moment a real row
* claims it. Without it, a committed out-of-list value is visible on the trigger but absent from
* the listbox, so a user who opens the listbox has no way back to the value they arrived with.
*
* Filtered by the active query, exactly like `createRow` is: a row that survives a query it does
* not match would both mislead (the user typed `zzz` and is shown `ghost`) and suppress the
* "no matches" copy forever, since `render()` derives that branch from the rendered row count.
* An empty query keeps every unmatched value's row. The fold is the default substring one rather
* than the author's `filter` hook, which is typed against a real `<lr-option>` this row has none
* of.
*/
private get unknownRows();
/** Synthetic action shown only when the current nonempty query has no exact label/value match. */
private get createRow();
/** `effectiveRows` capped to `maxRender`, always keeping the current selection visible. */
private get renderedRows();
/** Keeps the roving index inside the current source-agnostic enabled-row set without turning an
*  untouched `-1` cursor into an implicit selection. Local slot refreshes, option property
*  changes, and async responses all pass through this one clamp. */
private normalizeActiveIndex;private get filtered();private get displayValue();
/**
* Emits the cancelable `lr-show`/`lr-hide` veto point for this update's `open` transition.
*
* It lives here rather than in `updated()` because a veto has to be answered *before* anything
* observable happens: `willUpdate()` still runs ahead of render and attribute reflection, so
* restoring `open` here leaves the listbox, the reflected attribute and the property agreeing
* with each other without a visible open-then-close flash. Keeping it on the `open` transition
* (rather than inside `show()`/`hide()`) preserves the existing rule that the lifecycle fires
* however `open` changed, including a direct `el.open = true` that bypasses both methods.
*/
private announceOpenTransition;
/** Opens the listbox and resolves after `lr-after-show`. */
show():Promise<void>;
/** Closes the listbox and resolves after `lr-after-hide`. */
hide():Promise<void>;private finalizeCloseState;private onDocPointer;private activateListboxOverlay;private invalidateListboxPositioning;private resolveCurrentPositioning;private startListboxPositioning;private teardownListboxOverlay;private bindDocumentPointer;private unbindDocumentPointer;private reconnectOpenPopup;
/**
* Applies `visibleOptions` as an inline `max-block-size` on the listbox.
*
* Measured rather than computed from a token, because a row's height varies with `sub` lines,
* adornments, and group labels -- an estimate would cut a row in half. Measuring where row N
* *starts* also naturally accounts for the listbox's own padding.
*
* The inline value keeps the positioner clamp inside its own `min()` rather than overriding the
* stylesheet's: an inline declaration beats the shadow stylesheet outright, so writing a bare
* pixel length here would let a capped listbox overflow the space the positioner actually has.
* The property is removed entirely when the cap is unset, normalizes away, or is not exceeded, so
* the stylesheet's own expression is what applies and behavior is unchanged.
*
* Deliberately NOT a custom property: `check-style-policy` forbids component runtime code writing
* a documented `@cssprop`, and rightly so -- a documented hook is consumer-owned.
*/
private syncVisibleOptionsCap;protected updated(changed:PropertyValues):void;private settleTransition;private waitForTransition;private resolveTransitionWaiters;
/** Dispatches the platform-style value events used by non-text user
* interactions: `input`, `change`, and the prefixed `lr-change` alias, each
* carrying `detail: { value, data }` (the new committed selection, and its index-aligned opaque
* `data` payload -- `data[i]` describes `value[i]`, `undefined` where that value resolves to no
* live row/option, never shifted or dropped; see `selectedRows`, which drops that slot instead
* since its own contract is "structured rows for the current selection", not index alignment).
* Text editing
* keeps and exposes the original InputEvent from the shadow input so its
* data/inputType metadata is not lost. `this.emit()` (from `LyraElement`)
* already dispatches a bubbling, composed, non-cancelable `CustomEvent`. */
private emitValueEvents;
/**
* This component's own channel for writing `value`.
*
* The public accessor is narrowed by `Multiple`, and inside the class body that parameter is
* unresolved -- so no concrete `string` or `string[]` is assignable to it, even though every
* value written here is one of the two. One documented cast in one place, rather than a dozen at
* the call sites; the runtime path is the public setter, unchanged.
*/
private assignValue;
/** Runs the cancelable option-creation contract, then performs its default append/select behavior. */
private createOption;
/** Commits arbitrary text in the single-select custom-value mode without adding an option. */
private commitCustomValue;private pickRow;private removeValue;
/**
* The clear button clears both axes the control owns — the committed selection and the
* in-progress filter text — but each announces only its own change. A query-only clear must stay
* silent on `input`/`change`/`lr-clear` (there is no selection transition to report; that early
* return is why the button used to be gated on the selection alone), while a selection-only clear
* must stay silent on `lr-filter` (the filter text never moved).
*/
private clear;private onInput;
/**
* Re-runs the current `source` query.
*
* The gap it closes: nothing else could invalidate a *stable* `source`. Reassigning the property
* is the only other route, and that is a source-IDENTITY change -- it clears `asyncRows`, the
* totals, and the pending-selection cache, which is the correct reaction to a genuinely
* different provider and the wrong one for "ask the same provider again". `refresh()` therefore
* changes nothing about the source, the debounce controller, or its delay: it simply issues one
* more request for the text already typed, bypassing the debounce wait (the caller IS the
* intent; there is no keystroke burst to coalesce).
*
* Called while the listbox is closed, it queues for the next open rather than fetching, matching
* the component's existing "only queries while open" behaviour. Without a `source` it does
* nothing at all -- local `<lr-option>` children are already live DOM.
*/
refresh():void;private runSource;
/** Runs one debounced `source()` call. The generation `token` is the guard that keeps a stale
*  result from overwriting a newer one: it is re-checked here and again in every continuation
*  below, because each `await` is another chance for a newer query, a re-parent, or a disconnect
*  to have superseded this request while it was in flight. */
private runSourceRequest;private clearSourceTimer;private onInputBlur;private onInputFocus;private onKeyDown;private onComboMouseDown;private onListboxMouseDown;private onListboxClick;private renderRows;
/** One built-in selected chip, or the consumer's safe Lit/DOM/text replacement. */
private renderTag;private statusText;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-combobox':LyraCombobox;}}