import{type TemplateResult,type PropertyValues}from'lit';import type{Placement}from'@floating-ui/dom';import{LyraElement,type LyraEventDetailSnapshot}from'../../../internal/lyra-element.js';import type{PlaceStrategy,PlaceSync}from'../../../internal/positioner.js';import type{LyraPickerDetailValue,LyraPickerValue}from'../../../internal/picker-value.js';import type{LyraAppearance,LyraSize}from'../../../internal/variants.js';import type{LyraOption}from'../combobox/option.class.js';import'../combobox/option.class.js';import{type FormOwnerValue}from'../../../internal/form-associated.js';import{type LyraFormValidator}from'../form-validator.js';
/** Re-exported so a consumer importing only the select subpath can still name the shared
*  positioning vocabulary `positioningStrategy` uses. */
export type{LyraPickerDetailValue,LyraPickerValue,PlaceStrategy};
/** Renders one selected option's chip in `multiple` mode. Whatever it returns replaces the
*  built-in `[part='tag']` chip for that option, so a caller that wants the default styling
*  hooks re-declares `part="tag"` on its own root node. A returned string renders as **text**,
*  never as markup. */
export type LyraSelectTagRenderer=(option:LyraOption,index:number)=>unknown;export interface LyraSelectEventMap<Multiple extends boolean=boolean>{'lr-show':CustomEvent<null>;'lr-hide':CustomEvent<null>;'lr-after-show':CustomEvent<null>;'lr-after-hide':CustomEvent<null>;'lr-invalid':CustomEvent<null>;'lr-clear':CustomEvent<null>;input:InputEvent;change:Event;
/** `detail.data` is index-aligned with `detail.value`: `data[i]` is the opaque `data` payload
*  behind `value[i]`, by reference and never deep-cloned, or `undefined` for a value resolving
*  to no live option -- see `isUnknownValue()`. */
'lr-input':CustomEvent<LyraEventDetailSnapshot<{readonly value:LyraPickerDetailValue<Multiple>;readonly data:readonly unknown[];}>>;
/** `detail.data` is index-aligned with `detail.value`: `data[i]` is the opaque `data` payload
*  behind `value[i]`, by reference and never deep-cloned, or `undefined` for a value resolving
*  to no live option -- see `isUnknownValue()`. */
'lr-change':CustomEvent<LyraEventDetailSnapshot<{readonly value:LyraPickerDetailValue<Multiple>;readonly data:readonly unknown[];}>>;'lr-activate':CustomEvent<{value:string;}>;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 `LyraSelectEventMap`). Each narrows with the same `Multiple`
* parameter the component does: `LyraSelectChangeEvent<false>`'s `detail.value` is a `string`.
*/
export type LyraSelectChangeEvent<Multiple extends boolean=boolean> =LyraSelectEventMap<Multiple>['lr-change'];export type LyraSelectInputEvent<Multiple extends boolean=boolean> =LyraSelectEventMap<Multiple>['lr-input'];
/**
* `<lr-select>` — a plain closed-list dropdown: a direct `<lr-*>`
* counterpart to `<wa-select>`/`<wa-option>`. Trigger is a button (not a text
* input) -- click/Enter/Space/ArrowDown opens it, there's no typing-to-filter.
* A printable keypress instead jumps (or, while closed, directly selects) the
* next option whose label starts with what's been typed, like a native
* `<select>`'s type-ahead. Closed multiple mode skips selected option occurrences and keeps
* searching for a later unselected match, including another occurrence of the same value.
*
* Options are `<lr-option value>` children, the same element `<lr-combobox>`
* uses. Unlike `lr-combobox` there is no filter/source/empty-text/max-render
* surface -- see `<lr-combobox>` for the filterable case.
*
* `multiple` turns the committed `value` into a `string[]` and renders one removable chip per
* selection. The chip row is a sibling overlaid on the real trigger button, never nested inside it,
* so every remove control is valid independently-focusable interactive content. The trigger keeps
* one complete visually-hidden joined-value node for assistive technology while the painted
* built-in chip labels are hidden from it, preventing both truncation and duplicate announcement.
* Picking a selected row again still toggles it off, Backspace/Delete on the trigger removes the
* last selection, and `with-clear` removes all of them. `getTag` replaces a built-in chip entirely;
* `max-options-visible` caps how many render before the rest collapse behind a localized "+N" chip.
*
* `with-clear`'s button renders inside the trigger's inline-end padding,
* outboard of the expand icon, as a sibling of the trigger rather than a child
* of it -- for the same nesting reason.
* The trigger and overlaid multi-select tag row accept constrained allocation: long selected
* labels ellipsize and long chips wrap within a 320px LTR or RTL container instead of widening it.
*
* Reuses `lr-combobox`'s popup positioning (`internal/positioner.js`) and
* click-outside/Escape/Home/End/Arrow-key listbox navigation patterns,
* adapted to a trigger button that keeps DOM focus throughout (the listbox's
* "active" row is conveyed via `aria-activedescendant`, never actual focus),
* matching the WAI-ARIA "select-only combobox" pattern.
*
* When `autoCommitSingleOption` is set and exactly one option is available
* (neither disabled nor inert, including through an inert ancestor), the popup never
* opens at all: a click, Enter, Space, ArrowDown, or ArrowUp on the trigger
* commits that sole option directly, and the trigger renders as a plain
* `role="button"` with no chevron/`aria-haspopup`/`aria-expanded` rather than
* a combobox with a permanently inert popup state — opening a one-row list to
* pick the only available choice is pure friction with no real decision
* behind it. This never changes `value`/validity defaults on its own — an
* unselected single-option select stays unselected (and a `required` one
* stays invalid) exactly like the multi-option case, until the trigger is
* actually activated. `autoCommitSingleOption` defaults to `false`: by
* default a select always renders the normal combobox/listbox/chevron
* trigger no matter how many options are enabled, matching pre-1.3.0
* behavior — opt in explicitly if a narrowing-to-one option list should
* auto-commit.
*
* Deliberately does **not** perform implicit form submission on Enter (unlike `<lr-input>`/
* `<lr-combobox>`/`<lr-date-input>`, which route through `internal/submit-on-enter.ts`): the
* trigger is a `role="combobox"` button where Enter opens the listbox and, once open, commits the
* active option — the ARIA combobox behavior its upstream counterpart follows. Submitting there
* would shadow the only keyboard way to open the list.
*
* While the listbox is open, live option collection changes preserve the keyboard-active option
* by element identity across reorders. If that option is removed or becomes unavailable, the
* nearest available survivor takes over (preferring the following row on a tie); an empty
* available collection clears `aria-activedescendant` instead of retaining an invalid index.
*
* 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.
*
* Assigning `undefined`/`null` to `value`/`defaultValue` clears the selection; every string,
* including `''`, is instead a candidate value resolved against the current options -- an
* `<lr-option value="">` is a legitimate row and now round-trips like any other. A committed value
* matching no current option (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()`. Set `loading` while that same value's catalog simply hasn't arrived yet (an
* async fetch still in flight, say): a still-unmatched value then renders the localized `loading`
* placeholder instead, with no `unknown-value` badge, since it is not yet known to be missing. The
* same flag covers an empty selection too -- with nothing selected the trigger shows that same
* localized text in place of `placeholder`, so both halves of a pending state read the same words
* without a consumer re-localizing them.
*
* A slotted `<lr-option>`'s `start`/`end` (and the Shoelace `prefix`/`suffix` aliases) adornments
* are cloned into the corresponding `[part='option-start']`/`[part='option-end']` listbox row,
* mirroring `<lr-combobox>`.
*
* @customElement lr-select
* @slot - `<lr-option>` elements.
* @slot label - Custom label content.
* @slot hint - Custom hint content.
* @slot help-text - Shoelace alias for `hint`.
* @slot error - Custom error content.
* @slot start - Decorative adornment at the inline-start of the trigger row, before the
*   selected-value label. Its wrapper is always `aria-hidden` and inert because it lives inside
*   the native trigger button; interactive content supplied here remains deliberately unavailable.
* @slot end - Decorative adornment after the selected-value label and before the expand icon.
*   Its wrapper has the same enforced inert/`aria-hidden` contract as `start`.
* @slot prefix - Shoelace alias for `start`.
* @slot suffix - Shoelace alias for `end`.
* @slot clear-icon - Replaces the built-in clear glyph.
* @slot expand-icon - Replaces the built-in expand glyph.
* @event {Event} change - Fired when the selection changed, mirroring native
*   `<select>`'s own event name. Read the new selection from `value`.
* @event {InputEvent} input - Fired alongside `change` on every
*   selection change (native `<select>` doesn't meaningfully distinguish the two either).
* @event lr-input - Prefixed compatibility alias for `input`; `detail: { value, data }`, where
*   `data` is the opaque `data` payload of each newly committed occurrence (see `selectedData`),
*   by reference, never deep-cloned.
* @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`. Not fired for a programmatic `value` assignment. `detail.data` mirrors `lr-input`.
* @event lr-activate - Fired on every activation of an available listbox row -- a click, or
*   Enter/Space 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 (matching a native `<select>`) --
*   "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`/`lr-input`/`change`/`lr-change` are emitted first. Not fired for a programmatic
*   `value` assignment, nor by the `with-clear` button.
* @event lr-clear - The `with-clear` button emptied the selection, fired after the
*   `input`/`lr-input`/`change`/`lr-change` sequence. Never fired when there was nothing to clear.
* @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-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. Disabling the control,
*   directly or through a fieldset, force-closes it without this vetoable lifecycle because a
*   disabled control cannot retain an interactive popup.
* @event lr-after-show - The listbox finished opening and its transition settled.
* @event lr-after-hide - The listbox finished closing and its transition settled.
* @event lr-invalid - The select 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.
* @event blur - Re-dispatched from the trigger as a bubbling, composed event.
* @event focus - Re-dispatched from the trigger as a bubbling, composed event.
* @cssstate required - Matches while `required` is set. Style with `lr-select:state(required)`.
* @cssstate optional - Matches while `required` is not set — the complement of `required`.
* @cssstate valid - Matches while the control satisfies its constraints, including any
* `setCustomValidity()` error.
* @cssstate invalid - Matches while it does not — from the very first render, before the user has
* touched anything.
* @cssstate user-valid - `valid`, but only after the user has interacted: picking an option, a
* blur, `reportValidity()`, or a submission attempt. Not after a silent `checkValidity()` alone.
* @cssstate user-invalid - `invalid` after that same interaction. Style validation errors with this
* rather than `invalid`: a pristine required select is genuinely invalid, but colouring it red
* before the user has done anything is hostile.
* @cssstate blank - Matches while no option is selected.
* @csspart form-control - The outer wrapper around label, trigger, listbox, error and hint.
* @csspart form-control-label - The `<label>` element.
* @csspart label - Wrapper around the visible label content.
* @csspart form-control-input - Compatibility name for the control wrapper.
* @csspart combobox - Compatibility name for the control wrapper.
* @csspart trigger - The trigger button (positioning anchor).
* @csspart display-input - The selected-value/placeholder display inside the trigger. In populated
*   multiple mode it is visually hidden but exposes every selected label to assistive technology.
* @csspart start - Inert, decorative wrapper around the `start` adornment slot; `hidden` while
*   nothing is slotted.
* @csspart end - Inert, decorative wrapper around the `end` adornment slot; `hidden` while nothing
*   is slotted.
* @csspart prefix - Shoelace compatibility part on the `prefix` slot.
* @csspart suffix - Shoelace compatibility part on the `suffix` slot.
* @csspart tags - The `multiple`-mode chip row, rendered as a sibling overlaid on the trigger.
* @csspart tag - One selected-value chip. The "+N" overflow chip carries both `tag` and
*   `tag-overflow`, so `::part(tag)` styles every chip and `::part(tag-overflow)` only that one --
*   state after `::part()` never matches, so it is encoded in the part name instead.
* @csspart tag-label - A chip's ellipsis-safe label.
* @csspart tag__base - Compatibility name on a built-in selected-value chip.
* @csspart tag__content - Compatibility name around a built-in chip's visible label.
* @csspart tag__remove-button - A built-in chip's remove button.
* @csspart tag__remove-button__base - Compatibility name on the same remove button.
* @csspart tag-overflow - The "+N" chip standing in for the selections past `max-options-visible`.
* @csspart clear-button - The `with-clear` button.
* @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 - An option group's heading row, referenced by the enclosing `role="group"`.
* @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. Inert and aria-hidden.
* @csspart option-end - An option row's trailing adornment, cloned from the source
*   `<lr-option>`'s `end`/`suffix` slot. Inert and aria-hidden.
* @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 - The localized "not in catalog" badge on a synthetic unmatched-value row
*   (`show-unknown-option` only).
* @csspart unknown-value - Badge shown next to the trigger label or a `multiple`-mode tag when the
*   committed value matches no current `<lr-option>` (see `isUnknownValue()`).
* @csspart expand-icon - The dropdown indicator.
* @csspart error - The error message.
* @csspart hint - The hint message.
* @csspart form-control-help-text - Shoelace compatibility name for the hint message.
* @cssprop --lr-select-expand-size - Decorative expand-icon box size, scaled by `size`. The one
*   piece of this component's geometry the shared ladder does not own: it sizes a glyph, not the
*   control row.
* @cssprop --lr-select-gap - Gap between the trigger's start adornment, label, end adornment, and
*   expand icon. Doesn't vary by `size`.
* @cssprop [--lr-select-radius=var(--lr-form-control-radius)] - Trigger corner radius, from the
*   active `size` tier of the shared form-control ladder (the two tightest tiers take a smaller
*   radius).
* @cssprop --lr-select-trigger-padding - Trigger padding shorthand. Defaults to the active `size`
*   tier's `var(--lr-form-control-padding-block) var(--lr-form-control-padding-inline)` from the
*   shared ladder.
* @cssprop [--lr-select-trigger-min-height=var(--lr-form-control-height)] - Trigger block-size
*   floor, from the active `size` tier of the shared ladder, and live at every tier including the
*   default `m` -- so a select is exactly as tall as an `<lr-button>`/`<lr-input>` of that tier.
* @cssprop [--lr-select-font-size=var(--lr-form-control-font-size)] - Trigger font size, from the
*   active `size` tier.
* @cssprop --lr-select-tag-padding - Padding inside a `multiple`-mode chip. Doesn't vary by `size`.
* @cssprop --lr-select-tag-font-size - Chip text size. Doesn't vary by `size`.
* @cssprop [--lr-select-unknown-value-border-style=dashed] - Border style of an `[part='unknown-value']`
*   chip (a `multiple`-mode tag whose committed value matches no current option).
* @cssprop [--lr-select-unknown-value-border-color=var(--lr-color-border)] - Border color of the
*   same unknown-value chip.
* @cssprop [--lr-select-option-badge-bg=var(--lr-color-brand-quiet)] - Background of the
*   `[part='option-badge']` "not in catalog" badge.
* @cssprop [--tag-max-size=var(--lr-size-12rem)] - Maximum inline size of one selected-value tag.
* @cssprop [--show-duration=var(--lr-transition-fast)] - Listbox enter-transition timing.
* @cssprop [--hide-duration=var(--lr-transition-fast)] - Listbox exit-transition timing.
* @cssprop [--lr-select-trigger-hover-bg=var(--lr-color-brand-quiet)] - Trigger background while
* hovered. Accent appearance keeps its louder mixed fallback when this hook is unset.
* @cssprop [--lr-select-trigger-active-bg=color-mix(...)] - Trigger background while pressed.
* @cssprop [--lr-select-open-border-color=var(--lr-color-brand)] - Trigger border while the
* listbox is open.
* @cssprop [--lr-select-option-active-bg=var(--lr-color-brand-quiet)] - Background of the
*   hovered/keyboard-active option row. Not declared on `:host`, so a value set on any ancestor
*   is never shadowed -- retheme just this row state without hijacking the shared
*   `--lr-color-brand-quiet` token used by every other component's own hover/active state.
* @cssprop [--lr-select-option-selected-bg=transparent] - Background of the currently-selected
*   option row. Not declared on `:host`; retheme just the selected row without hijacking
*   `--lr-color-brand`.
* @cssprop [--lr-select-option-selected-border=var(--lr-color-brand)] - Border color of the
*   selected option row.
* @cssprop [--lr-select-option-selected-color=var(--lr-color-brand)] - Text color of the selected
*   option row.
* @cssprop [--lr-select-option-selected-font-weight=var(--lr-font-weight-semibold)] - Font weight
*   of the selected option row.
* @cssprop --lr-select-trigger-height - Exact trigger height. Unset by default, which leaves
*   `--lr-select-trigger-min-height` as a floor only; set it to a length to both floor and cap the
*   trigger (e.g. to pixel-match a sibling field in the same toolbar row). 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.
* @cssprop [--lr-select-trigger-fill=var(--lr-color-surface)] - Resting trigger background. Read by
* every appearance, each falling back to its own default (`--lr-color-surface-raised` for
* `filled`/`filled-outlined`, `transparent` for `plain`, `--lr-color-brand` for `accent`), so one
* value retints the trigger whichever treatment it is wearing.
* @cssprop [--lr-select-trigger-border-color=var(--lr-color-border)] - Resting trigger border
* color, `transparent` by default on the `filled`/`plain`/`accent` treatments.
* @cssprop [--lr-select-trigger-hover-border-color=var(--lr-select-trigger-border-color)] - Trigger
* border color while the pointer is over it. Unset, the border stays exactly where the resting
* state left it.
* @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. The listbox is a floating surface, so it retints with every other popup rather
* than with the trigger it drops from.
* @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 listbox.
* @cssprop --lr-positioning-strategy - Cascading `absolute`/`fixed` override for
*   {@link positioningStrategy}/`hoist`, read from computed style when the listbox is
*   (re)positioned. Set it once on `:root`, a theme, or one clipping ancestor to change every
*   unset select beneath it instead of authoring `positioning-strategy`/`hoist` on each instance;
*   an explicit value on the instance always wins over it.
* @status stable
* @since 4.0.0
*/
export declare class LyraSelect<Multiple extends boolean=boolean>extends LyraElement<LyraSelectEventMap<Multiple>>{protected static readonly immutableEventDetails:readonly string[];
/** `data` carries opaque per-option 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-input':readonly string[];'lr-change':readonly string[];}>;
/** Public WA-compatible intrinsic validator catalog. */
static get validators():LyraFormValidator<LyraSelect>[];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;};defaultValue:{attribute:string;noAccessor:boolean;};};
/** Text shown on the trigger while nothing is selected. It still names the trigger when neither
*  a host `aria-label` nor a `label` does. One exception to "an empty selection always shows
*  this": while `loading` is `true` the trigger shows the localized `loading` text instead, so a
*  consumer never has to re-localize that string in its own catalog to cover the empty half of a
*  pending state -- see {@link loading}. The trigger's accessible name is unaffected either way.
* @default '' */
placeholder:string;
/** Visible label. A host `aria-label` wins on the internal trigger by attribute presence,
* including an explicitly empty value that suppresses this label's naming fallback. */
label:string;hint:string;
/** Shoelace alias for {@link hint}. `hint` wins when both are present. */
helpText:string;
/** SSR slot-presence hints for pre-hydration form chrome. */
withLabel:boolean;withHint:boolean;errorText:string;
/** Forwarded to the internal trigger button. */
autofocus:boolean;
/** Forwarded to the internal trigger button. */
title:string;private _open;
/** Whether the listbox is open. Disabled controls synchronously normalize every opening write
*  back to `false`, including reflected-attribute writes. */
get open():boolean;set open(next:boolean);
/** Visual size on the library's one control ladder — shared with `lr-button`/`lr-input`/
*  `lr-combobox`/`lr-locale-picker`, so same-tier controls line up in a toolbar row. Accepts both
*  the canonical `'2xs'`–`'xl'` steps and Web Awesome's/Shoelace's `'small'`/`'medium'`/`'large'`
*  spellings of `s`/`m`/`l`; the two render identically. */
size:LyraSize;
/** Visual treatment of the trigger surface. */
appearance:LyraAppearance;
/** Fully-rounded trigger corners. Changes the private radius default to `--lr-radius-pill`, so
*  an inherited or direct `--lr-select-radius` remains authoritative. */
pill:boolean;
/** Preferred listbox placement. `flip`/`shift` may still override it to keep the popup in view,
*  and the `left`/`right` component is swapped under RTL. Changes reposition an already-open
*  listbox without closing it or changing overlay stack ownership. */
placement:Placement;
/**
* Copies the trigger's width, height, or both onto the listbox -- the same property
* `<lr-popup>`/`<lr-popover>`/`<lr-dropdown>`/`<lr-combobox>` spell, with the same values. 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 content clamp above no longer applies while this is set, since the trigger's own
* width is now the intentional bound. A synced listbox is still bounded by the space actually
* measured beside its anchor, so an over-wide trigger cannot push it off-screen. Changes
* reposition an already-open listbox without closing it.
* @default undefined
*/
sync?:PlaceSync;private _positioningStrategy?;
/**
* CSS positioning scheme the listbox is laid out with -- the one property `<lr-select>`,
* `<lr-dropdown>` and `<lr-popover>` all spell the same way. `absolute` (this control's mirrored
* default) positions against the nearest containing block and scrolls with it; `fixed` positions
* against the viewport and escapes most clipping ancestors. An unsupported value resolves back
* to the default. Changes apply live while open.
* This property reports only the instance's own authored value (or the mirrored default); the
* listbox is actually placed with the `--lr-positioning-strategy` cascading custom property
* honored ahead of that default when the instance itself sets nothing -- see that `@cssprop`.
* @default 'absolute'
*/
get positioningStrategy():PlaceStrategy;set positioningStrategy(next:PlaceStrategy);
/**
* Retained boolean alias of {@link positioningStrategy}: `hoist` is exactly
* `positioningStrategy === 'fixed'`, and writing either spelling updates the other so the two
* attributes can never disagree in the DOM. It is this control's established name (and
* Shoelace's own spelling on `sl-select`), so it keeps working indefinitely; prefer
* `positioning-strategy` in new code, which reads the same on every anchored surface.
* @default false
*/
get hoist():boolean;set hoist(next:boolean);
/** Shoelace boolean alias for the filled appearance. */
filled:boolean;
/** Show a button that empties the selection while there is anything selected. */
withClear:boolean;
/** Shoelace's spelling of {@link withClear}, accepted so a mechanical `sl-` → `lr-` rename does
*  not silently drop the clear button. Prefer `with-clear` in new code. */
clearable:boolean;
/** Renders a selected option's chip in `multiple` mode; see `LyraSelectTagRenderer`. */
getTag?:LyraSelectTagRenderer;
/**
* Appends every committed value that no `<lr-option>` 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. No synthetic row appears for a value `loading`
* is currently suppressing -- see that property -- since it is not yet known to be unmatched.
* @default false
*/
showUnknownOption:boolean;
/**
* Renders the label for a committed value that matches no option.
*
* `getTag` cannot serve this case: it is 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
* `loading` is `true` and the value is still unresolved -- see `loading` below -- because that
* value is not yet known to be unmatched at all.
*/
getUnknownLabel?:(value:string)=>string;
/**
* Whether a committed value's real label may still be pending -- e.g. the `<lr-option>` catalog
* behind it is still being fetched/mounted asynchronously and simply hasn't arrived yet. While
* `true`, a committed value that currently matches no option (the same condition `isUnknownValue()`
* tests) renders the localized `loading` placeholder in the trigger label or the relevant
* `multiple` tag instead of the raw value, and is not flagged with the dashed/italic
* `notInCatalog`/`[part='unknown-value']` badge a genuinely unmatched value gets, nor added to the
* synthetic `showUnknownOption` listbox row -- "not yet resolved" is a different state from "known
* to be missing". With nothing selected at all -- a create form whose catalog is still being
* fetched, or an edit form whose saved selection is legitimately empty -- the trigger shows that
* same localized `loading` text in place of `placeholder`, so one property covers the whole
* pending state rather than only its committed-value half and the two halves always read the
* same words. The trigger's accessible name is unchanged by this: a host `aria-label` still
* wins, then `label`, then `placeholder`, then the localized `select` fallback.
* A value that already matches a live option is unaffected either way. Reflected
* so `:host([loading])` is available as a styling hook. Never mutates `value`/`selectedOptions`
* itself, and does not itself disable the trigger -- pair it with `disabled` when the control
* should also be non-interactive while its catalog is pending.
* @default false
*/
loading:boolean;
/**
* Opt-in: when `true` and exactly one `<lr-option>` is enabled, the
* trigger commits that option directly (click/Enter/Space/ArrowDown/
* ArrowUp) instead of opening the listbox, and renders as a plain
* `role="button"` with no chevron. Defaults to `false`, which always
* renders the normal combobox/listbox/chevron trigger regardless of how
* many options are enabled — the pre-1.3.0 behavior. See the class doc
* above and `onlyOption` below for the full rationale.
*/
autoCommitSingleOption:boolean;private activeIndex;
/** Stable identity behind `activeIndex`, retained across collection reorder/removal and option
*  availability changes so the numeric index never silently points at a different row. */
private activeOption?;private options;private touched;
/** Whether the user has acted on this control yet, which is what gates the `user-valid`/
*  `user-invalid` custom states. Deliberately separate from `touched` (which drives the visible
*  `data-invalid`/`aria-invalid` pair and is set on blur alone): picking an option is an
*  interaction the instant it happens, and so is interactive validation — `reportValidity()` and
*  a submission attempt alike, via `installInteractionOnInvalid()` — exactly as it does for
*  native `:user-invalid`. A silent `checkValidity()` alone never counts. Not `@state`: nothing
*  in `render()` reads it. */
private hasInteracted;private readonly slotPresence;private triggerElement?;private optionsSlot?;private internals;private validityController;
/** Consumer-supplied validation message reflected through `custom-error`.
* @default null */
customError:string|null;private _fieldsetDisabled;private listId;private triggerId;private valueTextId;private cleanup?;private positioningReady;private overlayHandle?;private restoreFocusOnClose;private positionedDirection?;private pointerListenerDocument?;private pointerListener?;private _isFirstUpdate;private openVetoed;private openStateGeneration;private pendingOpenTransitionStart?;private suppressedOpenLifecycleGeneration?;private transitionToken;private transitionWaiters;private _selected;private _selectedOptions;private _selectedValuesByOption;
/** Cloned `start`/`end` adornment nodes for each option's listbox row, keyed by the option they
*  came from. Cached because `renderRows()` runs on every render pass -- mirrors lr-combobox's
*  identical cache; see `adornmentsFor()`. */
private adornmentClones;private _multiple;private _disabled;private _required;private _defaultSelected;private _defaultSelectedOptions;private _defaultCaptured;private _valueDirty;private _restoredStateActive;private _pendingInitialValue?;private _pendingInitialSelectedOptions?;private _pendingInitialDefaultValue?;private _resolvingPendingInitialSelection;private _defaultValueDirty;private typeAheadBuffer;
/** The buffer's reset debounce. Every printable keystroke restarts it, so "b" then "a" narrows
*  to "ba"; the buffer clears only once the quiet window passes. Scheduled on -- and cancelled
*  through -- the realm this select lives in at the time, and the realm it was armed in is
*  re-checked at settle, so a select adopted into another document never clears a buffer that
*  now belongs to a different realm. Supersession is the controller's own generation guard: a
*  callback already queued when a newer keystroke restarted the timer arrives inert. */
private readonly typeAheadReset;
/** Focus the internal select trigger. */
focus(options?:FocusOptions):void;
/** Blur the internal select trigger. */
blur():void;
/** Activates the internal trigger button -- `HTMLElement.prototype.click()` on a custom
*  element with no native click semantics of its own is otherwise a no-op, so a generic
*  form-submit helper or automation script calling `.click()` on the host would silently do
*  nothing without this forwarding override. Mirrors `<lr-button>`'s identical `click()`. */
click():void;private _name;private _maxOptionsVisible;constructor();
/** Browser-resolved form owner. Assigning a form id string or form element updates the `form`
* content attribute while reads remain element-valued.
* @attr form ID of an external form owner.
* @default null */
get form():HTMLFormElement|null;set form(owner:FormOwnerValue);
/** Returns the browser-resolved form owner, including an external owner selected by `form`. */
getForm():HTMLFormElement|null;get labels():NodeList;get validity():ValidityState;get validationMessage():string;get willValidate():boolean;private localDescriptionIds;private externalDescriptionLease?;private syncExternalDescription;private releaseExternalDescription;connectedCallback():void;protected willUpdate(changed:PropertyValues):void;protected firstUpdated(changed:PropertyValues):void;private applyOpenState;
/** Enforces a platform policy close without exposing an author veto point. A disabled form
* control cannot keep an interactive popup open even when an ordinary `lr-hide` listener would
* cancel a user-requested close. */
private forceCloseOpenState;
/**
* 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;
/** Submission name.
* @default '' */
get name():string;set name(next:string|null);
/** Whether several options can be selected at once. Flipping it re-shapes `value` (a string
*  becomes a `string[]`) and the submitted form entry, so it is normally set once declaratively.
*  @default false */
get multiple():boolean;set multiple(next:boolean);
/** Maximum number of selected-value chips shown before the rest collapse behind a localized
*  "+N" chip (`multiple` only). `0` removes the cap. Sanitized to a finite, non-negative
*  integer, falling back to `3`.
*  @default 3 */
get maxOptionsVisible():number;set maxOptionsVisible(next:number);
/** Whether user interaction and form participation are disabled.
* @default false */
get disabled():boolean;set disabled(next:boolean);
/** Whether at least one selected option is required for validity.
* @default false */
get required():boolean;set required(next:boolean);
/** The selected value: a single string outside `multiple` mode (empty when nothing is
*  selected), a `string[]` inside it.
*
*  Assigning `undefined` or `null` clears the selection -- the documented "unset" contract.
*  Every string, including `''`, is instead a candidate value resolved against the current
*  `<lr-option>`s: an option may legitimately declare `value=""`, and assigning `''` selects it
*  when present (mirroring what clicking that row already did). A `''`/non-array assignment that
*  matches no option still commits, exactly like any other unmatched string -- see
*  `isUnknownValue()`.
*
*  `LyraPickerValue<Multiple>` narrows to `string` on a `LyraSelect<false>` and `string[]` on a
*  `LyraSelect<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);
/** Reset value, matching the mapped native-like select contract. The `default-value` attribute
* supplies the single-mode string form; property writes may use a string array in `multiple`
* mode. Changing the default updates the live value only while it is still pristine.
* `undefined`/`null` clear the default; `''` is a candidate value like any other -- see the
* `value` setter's doc for the full contract.
* @default ''
* @type {string | string[]} */
get defaultValue():LyraPickerValue<Multiple>;set defaultValue(next:LyraPickerValue<Multiple> |null|undefined);
/** Live selected option occurrences. Writes commit the referenced live options through the
* same event-silent path as a `value` assignment; foreign/detached options are ignored and
* single mode keeps only the first occurrence. Reads return a fresh snapshot, so mutating the
* returned array never mutates the control's identity bookkeeping.
* @default [] */
get selectedOptions():LyraOption[];set selectedOptions(next:LyraOption[]);
/** The opaque `data` payload of each committed value, index-aligned with `value` -- always an
* array the same length as `value`, in both single and `multiple` mode. A committed value with
* no currently live matching option -- see `isUnknownValue()` -- fills its own slot with
* `undefined` rather than shifting the entries after it, so `selectedData[i]` always describes
* `(this.multiple ? this.value[i] : this.value)`. Reached by reference, never deep-cloned: the
* light-DOM counterpart to an async combobox source row's own `data` field, surfaced through
* `selectedRows`.
* @default [] */
get selectedData():readonly unknown[];
/**
* The single write path for the committed selection. `preferred` carries the exact
* `<lr-option>` occurrences a caller already resolved (a click routes to the row that was
* actually pressed, not to the first row sharing its value); anything missing is resolved by
* value against the current option list.
*/
private setSelection;
/** Maps each selected value onto one live `<lr-option>`, honouring a caller-supplied
*  occurrence when it is still slotted and never handing the same element to two values. */
private resolveOccurrences;
/** Same resolution as `resolveOccurrences()`, but keeps one slot per `values` entry --
*  `undefined` where nothing resolves -- so a caller needing index alignment with `values`
*  (e.g. `selectedData`) never has to guess which value a dropped occurrence belonged to. */
private resolveOccurrenceSlots;
/** Shared with every other form control: disabled (own or fieldset-cascaded) bars validation. */
private get barredFromValidation();private updateValidity;
/** Republishes the six validity custom states (`required`/`optional`, `valid`/`invalid`,
*  `user-valid`/`user-invalid`) from whatever `ElementInternals` currently holds. Called from
*  every path that can move either validity or the interaction flag. */
private reflectValidityStates;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` select 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;
/** Clears consumer-supplied validity and restores the current required/selection constraint. */
resetValidity():void;disconnectedCallback():void;adoptedCallback():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 reflectSelected;
/**
* Commits (or, in `multiple` mode, toggles off) a value that no option claims, from its own
* synthetic listbox row. In single mode the value is already the selection, so this is the
* documented re-pick case: `lr-activate` fires, `change`/`input` deliberately do not.
*/
private selectUnknownValue;
/** The matched label for one committed value, or `undefined` when no live option currently
*  declares it -- the shared lookup behind both `labelFor()` and `isUnknownValue()`. */
private resolvedLabelFor;
/** The label to show for one committed value: the selected occurrence's own label, else any
*  option sharing that value, else -- while `loading` -- the localized loading placeholder, else
*  the raw value (a programmatic write with no matching row). */
private labelFor;
/** Whether a committed value matches no currently-slotted `<lr-option>` -- a stale value from
*  before an option was removed, or a programmatic `value`/`defaultValue` 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
*  `resolvedLabelFor()` keeps the raw value itself fully reachable through `labelFor()`/`value`.
*
*  Suppressed entirely while `loading` is `true`: an unresolved value in that window simply
*  hasn't had its matching `<lr-option>` mount yet, which is "not yet known", not "genuinely
*  unknown" -- see `labelFor()`'s own loading-placeholder fallback, which this has to agree with
*  so the trigger/tag text and the "not in catalog" badge are never shown at the same time. */
private isUnknownValue;
/**
* The sole available option, when `autoCommitSingleOption` is set and
* there's exactly one. Opening a one-row popup to pick the only available choice is pure
* friction with no real decision behind it, so an opted-in single-option select skips the
* popup entirely -- see `onTriggerClick`/`onKeyDown`, which commit this option directly on
* activation instead of opening the listbox, and `render()`, which drops the popup-trigger
* ARIA semantics (`role="combobox"`, `aria-haspopup`, `aria-expanded`, the chevron) in favor
* of a plain button's, since no popup can ever appear while this getter returns a value.
* Returns `undefined` whenever `autoCommitSingleOption` is `false` (the default), regardless
* of option count, so the normal combobox trigger renders unconditionally. Does not affect
* `value`/validity defaults in any way -- an unselected single-option select stays unselected
* until the trigger is actually activated, exactly like the multi-option case.
*/
private get onlyOption();
/**
* The options arrow keys, type-ahead and the active-descendant index may land on. `inert` counts
* alongside `disabled` for the same reason it does in `<lr-menu>`'s `isNavigable()`: an inert
* element refuses interaction outright, so an active index pointing at one describes a row the
* user can neither reach nor commit. `closest('[inert]')` covers an inert ancestor, which inerts
* the option just as completely as the attribute on the option itself. The severity is lower here
* than in a menu -- this listbox keeps DOM focus on the trigger and moves only
* `aria-activedescendant` -- but the predicate has to agree across all four call sites or the
* rendered `data-active` row and the committed option can disagree.
*/
private isOptionAvailable;private navigableOptions;
/**
* Detached `<lr-option>` instances standing in for committed values no slotted option claims,
* keyed by value and rebuilt only when that set changes.
*
* Real elements rather than a parallel row shape, because everything that drives this listbox --
* `navigableOptions()`, the roving `activeIndex`, type-ahead, `renderRows()` and the delegated
* click path -- is written against `LyraOption`. Giving the synthetic row the same type is what
* makes it keyboard-reachable for free instead of a pointer-only decoration.
*
* They are deliberately NOT in `this.options`: that array is the authored option set, and
* `resolveOccurrences()` resolves `selectedOptions` out of it. Adding them there would make the
* unmatched value resolve to an option, which is precisely the condition this feature exists to
* report, and would leak a component-owned element through the public `selectedOptions`.
*/
private unknownOptionCache;private get unknownValues();private get unknownOptions();
/** The option set the listbox renders and navigates: the authored options plus any synthetic
*  unmatched-value rows. */
private get listboxOptions();
/** Updates the numeric active-descendant cursor and its stable option identity together. */
private setActiveIndex;
/** Keeps the active option by identity when possible. If it disappeared or became unavailable,
*  choose the nearest navigable row around its former raw collection position, preferring the
*  following row on an equal-distance tie, then fall back to no active descendant. */
private reconcileActiveOption;private onOptionChange;
/** 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 onDocPointer;private positionListbox;private activateListboxOverlay;private teardownListboxOverlay;private bindDocumentPointer;private unbindDocumentPointer;private reconnectOpenPopup;protected updated(changed:PropertyValues):void;private settleTransition;private waitForTransition;private resolveTransitionWaiters;
/** Dispatches the native value-change pair and prefixed aliases. `input`/`change` stay deliberately unprefixed -- this
*  control is a direct `<select>` counterpart, so its value-change events keep `<select>`'s own
*  naming instead of the `lr-` prefix `<lr-slider>` uses for its analogous rename. See the class
*  doc's `change` entry for the full rule. The prefixed aliases carry `detail: { value, data }`. */
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;private assignDefaultValue;private selectOption;
/** Removes one occurrence, rather than collapsing every row sharing its public string value. */
private removeValueAt;
/** Empties the selection from the `with-clear` button. Silent when there was nothing to
*  clear, so `lr-clear` never announces a no-op. */
private clear;private removeTag;private onTriggerClick;private onTriggerBlur;private onTriggerFocus;
/**
* Standard listbox type-ahead: moves to the next available option whose
* label starts with the accumulated buffer, cycling from just after the
* "current" option (the active row while open, the selected value while
* closed). While open this only moves `activeIndex` (a highlight, matching
* Arrow-key nav -- Enter/click still commits it); while closed there's no
* highlight to show, so it commits immediately, matching a native
* `<select>`'s closed-state type-ahead.
*/
private typeAhead;
/** Discards an armed buffer reset. `cancel()`, never `dispose()`: a disconnect here may be a
*  re-parent, and a disposed controller would refuse every later keystroke's reset for good. */
private clearTypeAheadTimer;private onKeyDown;private onListboxMouseDown;private onListboxClick;private adornmentMarkup;
/**
* `<lr-option>` documents `start`/`end` (plus the Shoelace `prefix`/`suffix` aliases) adornment
* slots, but this listbox is built from its own `[part='option']` rows rather than by exposing
* the option elements themselves, so a slotted adornment has nowhere to land on its own. Clone it
* into the row instead -- mirrors lr-combobox's identical `adornmentsFor()`.
*
* `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 the listbox.
*/
private adornmentsFor;private renderRows;
/** One selected value's chip. `getTag` replaces the whole built-in chip so a consumer owns the
* markup (and re-declares parts/removal behavior if desired); a returned string renders as text,
* never as markup. Built-in remove buttons are siblings of the trigger, never nested inside it. */
private renderTag;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-select':LyraSelect;}}