import{type PropertyValues,type TemplateResult}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import{type LyraMatchTarget}from'../../../internal/match-constraint.js';import type{LyraAppearance,LyraSize}from'../../../internal/variants.js';import{type LyraFormValidator}from'../form-validator.js';export type LyraInputType='text'|'password'|'email'|'number'|'time'|'search'|'date'|'datetime-local'|'tel'|'url';export interface LyraInputEventMap{input:InputEvent;change:Event;'lr-input':CustomEvent<{value:string;}>;'lr-change':CustomEvent<{value:string;}>;'lr-clear':CustomEvent<null>;'lr-input-settled':CustomEvent<{value:string;}>;blur:FocusEvent;focus:FocusEvent;'lr-invalid':CustomEvent<null>;}declare class LyraInputBase extends LyraElement<LyraInputEventMap>{}declare const LyraInput_base:typeof LyraInputBase&(new(...args:any[])=>import("../../../lyra.js").FormAssociatedInterface<string> &import("../../../internal/form-associated.js").FormAssociatedSubclassInterface<string>);
/**
* `<lr-input>` — a single-line plain-text input primitive, the `lr-*` equivalent of a plain
* `wa-input`, form-associated via the `FormAssociated` mixin (same shape as `<lr-textarea>`).
*
* Ships the same opt-in `label`/`hint`/`errorText` form-control chrome as `<lr-textarea>`/
* `<lr-select>` (props + matching named slots + `form-control`/`form-control-label`/`hint`/`error`
* parts) — left unset, the chrome stays hidden. `size` uses the same `xs`–`xl` scale as
* `<lr-select>`/`<lr-combobox>`, and `appearance` the shared fill/border vocabulary.
* `type="password"` renders a `password-toggle` eye-icon button — opt-in via the
* `password-toggle` attribute — that flips the internal native input between
* `type="password"`/`type="text"` and tracks `passwordVisible`. `type="email"`/`type="number"`
* (with `min`/`max`/`step`) delegate constraint validation to the internal native `<input>`'s own
* browser-computed `validity`, bridged into this element's `ElementInternals` by `updateValidity()`
* — as do `minlength`/`maxlength`/`pattern`, which constrain the text-bearing types.
* `type="date"`/`type="datetime-local"`/`type="search"`/`type="tel"`/`type="time"`/`type="url"`
* forward straight through to the matching native input behavior, the same as `type="text"`.
*
* A host `aria-label` is forwarded to the internal textbox via the typed `accessibleLabel` property.
* A host `aria-describedby` is resolved onto that native input, ahead of its own hint/error/
* required descriptions, so externally-owned guidance remains valid across the shadow boundary.
* Host `aria-labelledby` is deliberately not projected: the native `<label>` already owns this
* control's visible label relationship.
*
* Forwards the full native selection/editing surface (`selectionStart`/`selectionEnd`,
* `setSelectionRange()`, `setRangeText()`), the same as `<lr-textarea>`, in addition to
* `focus()`/`blur()`/`select()`, `showPicker()`, and `stepUp()`/`stepDown()`.
*
* The declarative `match` property pairs this field with a sibling one (by id, resolved in this
* element's own root, or by direct element reference) and fails validity — a localized
* `customError` — whenever the two values disagree, once every other constraint already reports
* valid; see its own doc comment for the full contract. There is no dedicated password-purpose
* preset, by deliberate decision rather than an oversight: the one platform detail a preset would
* actually save — `autocomplete` — has no single correct value for "a password field" (`new-password`
* on a set/change/reset flow, `current-password` on a login one, never derivable from the other), so
* a `purpose`/`preset` property would still take a second parameter carrying that same distinction,
* trading the existing attributes for an invented vocabulary that a migrating `wa-`/`sl-`/native
* `<input type="password">` author would have to learn instead of carrying over unchanged. Compose
* `type="password"`, `password-toggle`, `autocomplete="new-password"`, and `match` directly for a
* set/change/reset confirmation pair; a login field needs only `type="password"` and
* `autocomplete="current-password"`.
*
* Pressing Enter submits the ancestor `<form>`, the implicit submission a native `<input>`
* performs — the internal input is inside a shadow root and has no form owner of its own, so the
* platform can never do it here. The form's first enabled submit control becomes
* `SubmitEvent.submitter` (an `<lr-button type="submit">` included, via its own `click()`), a
* modifier-held or IME-composition Enter is ignored, and a form with no submit button submits only
* from a single field — all of it the platform's own rules, shared with every other lyra text
* control through `internal/submit-on-enter.ts`.
*
* Component-scoped theme inputs remain undeclared on the host, so values inherited from an
* ancestor theme wrapper override size, appearance, and pill fallbacks. A value set directly on
* the input still wins. The same inheritance contract applies to subclasses that reuse this
* stylesheet, including `<lr-number-input>` and `<lr-native-time-input>`.
*
* When a clear or password action is rendered, compact tiers grow only enough to contain its
* shared `--lr-icon-button-size` hit target. The `l` and `xl` tiers retain their larger shared
* control heights.
*
* Removing label, hint, help-text, or error-text safely omits the content while retaining
* native null property readback. Explicit empty strings remain empty.
*
* @customElement lr-input
* @event input - Native-style composed event fired on every user-driven edit.
* @event change - Native-style composed event fired at the native `change` timing.
* @event lr-input - Compatibility alias for `input`; `detail: { value }`.
* @event lr-change - Compatibility alias for `change`; `detail: { value }`.
* @event lr-clear - The built-in clear button cleared a text/search value, after the input/change events.
* @event lr-input-settled - Fires once, `debounce` ms after the last keystroke, alongside the
*   per-keystroke `input`/`lr-input` pair (which keep firing on every edit). `detail: { value }`,
*   non-cancelable. A pending debounce is flushed immediately on `change`/Enter/blur, and cancelled
*   with no stray settle on disconnect, the built-in clear button, and a programmatic `value`
*   write that actually changes the value -- a same-value write (e.g. the controlled-input pattern
*   of a framework re-binding `value` from the state its own handler just set) leaves the pending
*   debounce armed instead of silently defeating it. Never fires while `debounce` is unset, `0`, or
*   non-finite.
* @event blur - Re-dispatched from the internal native `<input>`'s own `blur` — bubbling and
*   composed (unlike the native event, which is neither).
* @event focus - Re-dispatched from the internal native `<input>`'s own `focus`, for the same reason as `blur`.
* @event lr-invalid - The input failed a validity check. Cancelable: `preventDefault()` forwards to
*   the native `invalid` event, suppressing the browser's own validation bubble and the
*   focus/scroll `reportValidity()` would otherwise perform.
* @slot label - Custom label content.
* @slot hint - Custom hint content.
* @slot error - Custom error content.
* @slot start - Adornment before the native input.
* @slot end - Adornment after the native input and built-in actions.
* @slot prefix - Shoelace alias for `start`.
* @slot suffix - Shoelace alias for `end`.
* @slot help-text - Shoelace alias for `hint`.
* @slot clear-icon - Replaces the built-in clear glyph.
* @slot show-password-icon - Replaces the glyph shown while the password is hidden.
* @slot hide-password-icon - Replaces the glyph shown while the password is visible.
* @csspart form-control - The outer wrapper around label, input, error and hint.
* @csspart form-control-label - The `<label>` element.
* @csspart label - Wrapper around the visible label content.
* @csspart base - Compatibility name for the control row; use `input-wrapper`.
* @csspart form-control-input - Compatibility name for the control row.
* @csspart input-wrapper - The row wrapping the native input and built-in actions. It is the same
*   node as `base`.
* @csspart input - The native `<input>` element.
* @csspart start - Wrapper around the `start` adornment slot. Long content shrinks and ellipsizes
*   rather than widening the control allocation.
* @csspart end - Wrapper around the `end` adornment slot, with the same containment behavior.
* @csspart prefix - Shoelace compatibility part on the `prefix` slot.
* @csspart suffix - Shoelace compatibility part on the `suffix` slot.
* @csspart clear-button - The clear action, rendered for non-empty clearable text/search inputs.
* @csspart password-toggle - The show/hide-password button, rendered only for `type="password"`
*   with `password-toggle` set.
* @csspart password-toggle-button - Wrapper around the password-toggle icon.
* @csspart hint - The hint message.
* @csspart form-control-help-text - Shoelace compatibility name for the hint message.
* @csspart error - The error message.
* @cssprop [--lr-input-control-min-height=var(--lr-form-control-height)] - Outer control height
*   floor, taken from the active `size` tier of the shared form-control ladder
*   (`internal/sizes.styles.ts`), so an input is exactly as tall as an `<lr-button>`/`<lr-select>`
*   of the same tier.
* @cssprop --lr-input-control-height - Exact outer control height. Unset by default, which leaves
*   `--lr-input-control-min-height` as a floor only; set it to a length to both floor and cap the
*   control row (e.g. to pixel-match `<lr-select>`/`<lr-combobox>` 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.
* @cssprop [--lr-input-padding-block=var(--lr-form-control-padding-block)] - Block padding of the
*   native input, from the active `size` tier of the shared ladder.
* @cssprop [--lr-input-padding-inline=var(--lr-form-control-padding-inline)] - Inline padding of
*   the control row, from the active `size` tier.
* @cssprop [--lr-input-font-size=var(--lr-form-control-font-size)] - Font size of the native input,
*   from the active `size` tier.
* @cssprop [--lr-input-gap=var(--lr-space-xs)] - Gap between the start/end adornments and the
* native input in the control row. Unlike the size knobs above it does not vary by `size` tier.
* Override it to retune without a `::part(input-wrapper)` rule.
* @cssprop [--lr-input-radius=var(--lr-form-control-radius)] - Corner radius of the control row,
* from the active `size` tier of the shared ladder (the two tightest tiers take a smaller radius).
* `pill` swaps it to `--lr-radius-pill`.
* @cssprop [--lr-input-fill=transparent] - Background of the control row. Its private default
* changes per `appearance`; the public value remains authoritative in every appearance.
* @cssprop [--lr-input-border-color=var(--lr-color-border)] - Border color of the control row,
* with a private default that changes per `appearance` in the same way as `--lr-input-fill`.
* @cssprop [--lr-input-focus-border-color=var(--lr-color-brand)] - Control-row border color while
*   focus is within the field.
* @cssprop [--lr-input-action-color=var(--lr-color-text-quiet)] - Resting clear/password/number-
*   stepper action color.
* @cssprop [--lr-input-action-hover-color=var(--lr-color-text)] - Hovered action color.
* @cssprop [--lr-input-action-active-color=var(--lr-input-action-hover-color,var(--lr-color-text))] -
*   Pressed action color.
* @cssprop [--lr-input-action-active-bg=color-mix(in oklab,var(--lr-color-surface),var(--lr-color-mix-partner) var(--lr-color-mix-active))] -
*   Pressed action background. The same hooks apply to `lr-number-input`'s stepper pair.
* @cssprop [--lr-input-time-picker-hover-bg=var(--lr-color-brand-quiet)] - Hover background for
*   the browser-native time-picker indicator when `type="time"`.
* @cssprop [--lr-input-time-picker-active-bg=var(--lr-color-brand)] - Pressed background for the
*   browser-native time-picker indicator when `type="time"`.
* @cssprop [--lr-input-time-picker-focus-bg=var(--lr-color-brand-quiet)] - Focus-visible
*   background for the native time-picker indicator.
* @cssprop [--lr-input-time-picker-focus-ring=var(--lr-focus-ring-color)] - Focus-visible outline
*   color for the native time-picker indicator.
* @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-field marker rendered after the
* label. Set it to `''` to suppress the marker, or to any other quoted string (`' (required)'`, a
* localized word) to replace it. Caller-supplied content, so it is never localized here.
* @cssprop [--lr-form-control-required-color=var(--lr-color-danger)] - Color of that marker,
* retunable without touching any other danger-coloured surface.
* @cssprop [--lr-form-control-required-offset=0] - Inline space between the label text and the
* marker.
* @cssstate blank - The live value is empty.
* @status stable
* @since 4.0.0
*/
export declare class LyraInput extends LyraInput_base{
/** Public WA-compatible intrinsic validator catalog. */
static get validators():LyraFormValidator<LyraInput>[];static styles:import("lit").CSSResultGroup[];
/** Live string value. A Web Awesome-compatible null write clears it without widening reads. */
get value():string;set value(next:string|null);private _type;
/** Native input type. Unsupported runtime strings normalize to `text` at the public boundary so
* native validity, type-dependent chrome, and the reflected host state cannot diverge. */
get type():LyraInputType;set type(next:LyraInputType);
/** Visual size on the library's one control ladder — shared with `lr-button`/`lr-select`/
*  `lr-combobox`, 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. `'2xs'` is the tightest tier, for dense
*  toolbar-embedded controls. */
size:LyraSize;
/** Visual treatment of the control row, from the library's shared field vocabulary.
*  `'outlined'` (the mapped default) draws a border without a fill; `'filled-outlined'` draws
*  the fill, `'filled'` drops the border, `'plain'` drops both, and `'accent'` tints both with
*  the brand color. Each value only swaps `--lr-input-fill`/`--lr-input-border-color`, so a
*  consumer can retune any of them without a `::part(input-wrapper)` rule. */
appearance:LyraAppearance;
/** Shoelace's boolean spelling for the filled treatment. It does not overwrite an explicit
* `appearance`; the style alias simply paints the same fill while present. */
filled:boolean;
/** Rounds the control row to a full pill by swapping `--lr-input-radius` to
*  `--lr-radius-pill`. */
pill:boolean;placeholder:string;
/** Shows a built-in clear action for non-empty `text` and `search` inputs. */
clearable:boolean;
/** Web Awesome's spelling of {@link clearable}, accepted so a mechanical `wa-` → `lr-` rename
*  does not silently drop the clear action. Prefer `clearable` in new code. */
withClear:boolean;
/** How long (ms) to wait after the last keystroke before emitting one `lr-input-settled`,
*  coalescing a burst of rapid edits into a single downstream commit -- the same predicate and
*  `DebounceController` primitive `<lr-filter-bar>`'s own per-filter `debounce` uses. Omitted,
*  `0`, or a non-finite value means no debounce at all: `input`/`lr-input` keep firing per
*  keystroke exactly as before, and `lr-input-settled` never fires. A pending debounce is
*  flushed immediately by `change`/Enter/blur (so a blur never drops the last keystroke) and
*  cancelled with no stray settle by disconnection, the built-in clear button, and a
*  programmatic `value` write that changes the value -- a same-value write does not disturb it. */
debounce?:number;
/** Forwards native read-only behavior to the internal input and disables the clear action. */
readonly:boolean;label:string;hint:string;
/** Shoelace alias for {@link hint}. `hint` wins when both are supplied. */
helpText:string;
/** SSR slot-presence hint for label content that cannot be inspected before hydration. */
withLabel:boolean;
/** SSR slot-presence hint for hint/help-text content that cannot be inspected before hydration. */
withHint:boolean;errorText:string;
/** Accessible name overriding the label/placeholder-derived default. Takes precedence over both
*  `label` and `placeholder` when set, matching `<lr-textarea>`'s `accessibleLabel`. */
accessibleLabel:string|null;autocomplete:string;
/** Forwarded to the internal native control. */
title:string;
/** Forwarded to the internal native `<input>`, so the browser's own autofocus algorithm targets
*  the real text control rather than the (non-focusable) custom-element host. */
autofocus:boolean;spellcheck:boolean;autocapitalize:string;private autocorrectValue;inputMode:string;enterKeyHint:string;
/** Native editing-assistance state forwarded as canonical `autocorrect="on"|"off"`. Reads are
* boolean. Writes accept Web Awesome's boolean IDL and Shoelace's `'on'`/`'off'` vocabulary. */
get autocorrect():boolean;set autocorrect(next:boolean|'off'|'on');get inputmode():string;set inputmode(next:string);get enterkeyhint():string;set enterkeyhint(next:string);
/** `type="number"` only — forwarded to the internal native `<input>`'s own `min`/`max`/`step`
*  and consulted by that same native input's constraint validation (see `updateValidity()`).
*  Defaults to `undefined` (no lower bound). The `min` attribute is parsed as a number here; the
*  declared type also admits a string so a subclass bound to a non-numeric native input type can
*  narrow the attribute parsing to that type's own literal form (`<lr-native-time-input>`'s `09:00`)
*  without redeclaring the whole property surface. */
min?:number|string;
/** Upper counterpart of `min`, with the same parsing and the same default of `undefined`. */
max?:number|string;
/** Accepts `'any'` (the native way to disable step validation) in addition to a numeric step. */
step?:number|'any';
/** Minimum text length, forwarded to the internal native `<input>`'s own `minlength` and
*  consulted by that same native input's constraint validation (`tooShort`, see
*  `updateValidity()`). Defaults to `undefined` (no lower bound). Like native `minlength`, an
*  empty value never violates it — pair it with `required` to also reject empty. Ignored by the
*  native input for `type="number"`/`type="time"`, exactly as the platform specifies. */
minlength?:number;
/** Upper counterpart of `minlength` (native `maxlength`/`tooLong`), with the same parsing and the
*  same default of `undefined`. Note that native `maxlength` also *prevents* typing beyond the
*  limit; it reports `tooLong` for values that arrive some other way (paste of a longer value,
*  a programmatic assignment). */
maxlength?:number;
/** A regular expression the value must match in full, forwarded to the internal native
*  `<input>`'s own `pattern` and validated by it (`patternMismatch`). Defaults to `undefined`
*  (no pattern). Compiled by the browser with the `v` flag and anchored to the whole value, so
*  no `^`/`$` is needed; an empty value never violates it. */
pattern?:string;
/** `type="password"` only — renders the built-in show/hide-password button. Opt-in: a bare
*  `type="password"` field ships no toggle at all, so a consumer whose threat model or visual
*  design excludes one is not forced to hide it with CSS. */
passwordToggle:boolean;
/** `type="password"` only — whether the field currently reveals its raw text. Toggled by the
*  built-in `password-toggle` button; also settable by a consumer up front, with or without
*  that button being rendered. */
passwordVisible:boolean;
/** `type="number"` only — suppresses the browser's own increment/decrement spin buttons. Left
*  unset, the platform's spinners render exactly as they do on a bare `<input type="number">`.
*  `<lr-number-input>` defaults it the other way, since it draws its own stepper pair. */
withoutSpinButtons:boolean;
/** Shoelace alias for {@link withoutSpinButtons}. */
noSpinButtons:boolean;
/** Declarative cross-field confirmation constraint: a sibling field to compare this one's
*  `value` against, referenced either by id (resolved in this element's own root — an idref
*  never crosses a shadow boundary, matching every other idref this library resolves) or by a
*  direct element reference (works across shadow trees, since no lookup is needed). While set
*  and resolvable, this field additionally fails validity — `customError`, with a localized
*  mismatch message — whenever its value differs from the referenced element's own `.value`.
*  Re-validates automatically whenever either field changes: this field's own edits through the
*  usual `value` write, and the referenced field's edits through a listener on its `input`/
*  `change` events. A `match` that does not resolve to a live element (a dangling id, most
*  commonly) is inert rather than a permanent block on submission — exactly like the platform's
*  own tolerance of an unresolvable `aria-describedby` idref. Pairs with a plain confirmation
*  field (`type="password"` or otherwise); the referenced element only needs a string `.value`,
*  so a native `<input>`/`<textarea>` works the same as another `lr-input`. */
match:LyraMatchTarget;set defaultValueAlias(next:string);private touched;private readonly slotPresence;private settlingValueFromInput;private readonly settledDebounce;
/** Keeps {@link match}'s referenced field resolved and re-runs `updateValidity()` whenever that
*  field's own value changes. */
private readonly matchController;private inputEl?;private externalDescriptionLease?;private requiredDescriptionLease?;private requiredDescriptionTarget?;
/** Id of the internal native `<input>` (and the `for` of its paired `<label>`), so a
*  shadow-DOM-aware password manager keys its field detection off the same id the consumer put
*  on the host, rather than a fixed literal. Falls back to `"input"` when the host carries no
*  `id`, leaving the rendered output byte-identical to before this existed. `id` is a plain
*  inherited DOM property rather than a reactive `@property`, so a host `id` set declaratively in
*  markup is picked up on first render (the native IDL reflects the parsed attribute before Lit's
*  own `render()` runs); mutating `el.id` after first render only takes effect on this component's
*  next unrelated re-render. */
private get inputId();constructor();connectedCallback():void;disconnectedCallback():void;adoptedCallback():void;
/** Resolves host-owned descriptions onto the native input without copying labelledby. */
private syncExternalDescription;private releaseExternalDescription;
/** Owns only localized requiredness text; error and hint remain baseline descriptions. */
private syncRequiredDescription;private releaseRequiredDescription;formResetCallback():void;
/** The internal native `<input>` element, for direct DOM access — mirrors `<lr-textarea>`'s own `input` getter. */
get input():HTMLInputElement|null;click():void;focus(options?:FocusOptions):void;blur():void;select():void;
/** Native date/time value view. Unsupported input types mirror the native getter and return
* `null`; assignment follows the native input's own conversion and remains event-silent. */
get valueAsDate():Date|null;set valueAsDate(next:Date|null);
/** Native numeric view (milliseconds for date/time inputs, numeric value for number inputs).
* Assignment is silent, matching `HTMLInputElement.valueAsNumber`. */
get valueAsNumber():number;set valueAsNumber(next:number);
/**
* Opens the browser's own picker for the current `type` (the time picker, the OS colour/file
* chooser on the types that have one), delegating to the internal native `<input>`.
*
* Deliberately failure-tolerant: the platform method throws for every environmental reason a
* component can neither detect up front nor usefully report — the call not being driven by user
* activation (`NotAllowedError`), a cross-origin document (`SecurityError`), a non-mutable
* control (`InvalidStateError`) — and engines that predate it don't define it at all. A picker
* that cannot open is a no-op here rather than an exception a consumer must wrap every call in.
* Also a no-op while disabled or readonly, matching every other editing entry point.
*/
showPicker():void;
/**
* Increments the value by `steps` × the effective `step`, through the native `<input>`'s own
* `stepUp()` — so `min`/`max` clamping and decimal handling stay the platform's, not a
* hand-rolled reimplementation. Pending `step`, `min`, `max`, and `value` property changes
* apply synchronously, without waiting for a render.
*
* Silent, like the native method: it updates `value`, the submitted form value, and validity,
* but emits no `input`/`change`. A stepper *button* is a user edit and emits them itself.
*/
stepUp(steps?:number):void;
/** Decrementing counterpart of `stepUp()`, with the same signature and the same silence. */
stepDown(steps?:number):void;private applyStep;
/** Cursor/selection extent, mirroring `<lr-textarea>`'s identical passthrough. `null` both when
*  the internal input hasn't rendered yet and whenever the current `type` doesn't support
*  selection at all (matching the native `<input>`'s own contract — only `text`/`search` among
*  this component's types do; `password` also supports it natively but isn't exercised here). */
get selectionStart():number|null;set selectionStart(value:number|null);get selectionEnd():number|null;set selectionEnd(value:number|null);
/** Passthrough to the native `<input>`'s own `setSelectionRange()`. No-op if the element hasn't
*  rendered yet, or throws the same native `InvalidStateError` the native `<input>` itself would
*  for a `type` that doesn't support selection (mirrors `<lr-textarea>`'s `setSelectionRange()`). */
setSelectionRange(selectionStart:number,selectionEnd:number,selectionDirection?:'forward'|'backward'|'none'):void;
/** Passthrough to the native `<input>`'s own `setRangeText()`, mirroring `<lr-textarea>`'s
*  method of the same name/signature. No-op if the element hasn't rendered yet. */
setRangeText(replacement:string,start?:number,end?:number,selectMode?:'select'|'start'|'end'|'preserve'):void;
/**
* Bridges the internal native `<input>`'s own browser-computed constraint validation (format for
* `type="email"`, range/step for `type="number"`) into this element's `ElementInternals`, instead
* of hand-rolling a second regex-based check — a real native input of the right `type` already
* computes `typeMismatch`/`rangeUnderflow`/`rangeOverflow`/`stepMismatch` correctly. Falls back to
* the base mixin's plain required-and-empty check before the first render (`inputEl` unset).
*
* A typed native input (`number`, `email`, …) also runs its own value-sanitization algorithm on
* assignment, which silently rewrites an unparseable non-empty value to `''` without setting any
* `ValidityState` flag — left unchecked, `native.validity.valid` would then read `true` (empty is
* fine when not required) while `this.value`/the bridged form value still held the literal invalid
* string. Detect that mismatch and report it as `badInput` instead of trusting native blindly.
*
* `minlength`/`maxlength` need the same kind of supplement for a different platform rule: the
* native `tooShort`/`tooLong` flags are raised only for a value the *user* edited, so an
* over-length value assigned from script would report valid. `lengthViolations()` recomputes
* both conditions from `value` and they are OR-ed into the native flags (see
* `internal/length-constraints.ts`). `patternMismatch` needs no such handling — the platform
* applies `pattern` to script-assigned values too.
*
* Barred controls short-circuit first, through the same `isBarredFromValidation()` predicate the
* base mixin uses — this override used to check `readonly` alone, so a `<lr-input required
* disabled>` (or one inside a `<fieldset disabled>`) still reported `valueMissing` and published
* `:state(invalid)`/`:state(user-invalid)`, which no native `<input required disabled>` does.
*
* The declarative `match` constraint (see its own doc comment) is checked last, and only once
* every other constraint above already reports valid — a confirm field that is merely empty (and
* `required`) reports `valueMissing`, not a mismatch, exactly like a hand-written comparison
* would prioritize "did you fill this in" over "does it agree with the other field".
*/
protected updateValidity():void;
/** Whether `match` is set, currently resolves to a live element, and that element's own value
*  differs from this one's -- see `match`'s doc comment for the full contract. A dangling or
*  unresolvable reference (including one pointed at an element with no comparable string
*  `.value`) never mismatches: an inert constraint, not a permanent block on submission. */
private matchMismatches;protected updated(changed:PropertyValues):void;
/** Whether `debounce` is a real, positive delay -- mirrors `<lr-filter-bar>`'s own predicate for
*  the same shape. Omitted, `0`, or non-finite means no debounce (today's per-keystroke
*  behavior); `finiteDuration()` also caps it at the platform's own timer ceiling. */
private get effectiveDebounceMs();private isDebounced;private onInput;private onChange;private onFocus;private onBlur;
/**
* Implicit form submission, through the shared `internal/submit-on-enter.ts` gate every other
* text-bearing control in the library now routes through — so the modifier/IME/veto rules and
* the submitter resolution (including an `<lr-button type="submit">`, which `requestSubmit()`
* refuses as a submitter) are one implementation rather than one per component.
*/
private onKeyDown;private onTogglePasswordVisible;private onClear;
/**
* Extension point for a subclass adding its own controls to the end of the control row, between
* the built-in clear/password actions and the `end` adornment slot — `<lr-number-input>`'s
* stepper pair. Renders nothing here, so `<lr-input>`'s own DOM is unchanged.
*/
protected renderControls():unknown;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-input':LyraInput;}}export{};