import{type TemplateResult,type PropertyValues}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import type{LyraAppearance,LyraSize}from'../../../internal/variants.js';import type{LyraSelectionDirection,LyraTextWrap}from'../../../internal/shared-unions.js';import{type LyraFormValidator}from'../form-validator.js';export type TextareaResize='none'|'vertical'|'horizontal'|'both'|'auto';export type TextareaWrap=LyraTextWrap;export type TextareaSelectionDirection=LyraSelectionDirection;
/** Scroll offsets read from, or written to, the internal native `<textarea>`. */
export interface TextareaScrollPosition{top:number;left:number;}
/** Enumerated (not boolean-presence) attribute parsing for `spellcheck`, matching the native HTML
*  `spellcheck` attribute's own true/false/empty/inherit semantics -- Lit's built-in `type:
*  Boolean` converts based on attribute *presence*, which would treat a literal
*  `spellcheck="false"` as truthy (the attribute is present) instead of `false`. */
export interface LyraTextareaEventMap{input:InputEvent;change:Event;'lr-input':CustomEvent<{value:string;}>;'lr-change':CustomEvent<{value:string;}>;'lr-input-settled':CustomEvent<{value:string;}>;blur:FocusEvent;focus:FocusEvent;'lr-invalid':CustomEvent<null>;}declare class LyraTextareaBase extends LyraElement<LyraTextareaEventMap>{}declare const LyraTextarea_base:typeof LyraTextareaBase&(new(...args:any[])=>import("../../../lyra.js").FormAssociatedInterface<string> &import("../../../internal/form-associated.js").FormAssociatedSubclassInterface<string>);
/**
* `<lr-textarea>` — a multiline plain-text input primitive, form-associated via the
* `FormAssociated` mixin (see `<lr-chat-composer>`/`<lr-date-input>` for the same shape), so it
* participates in native `<form>` submission/validation/reset like any other text control --
* `name`/`value`/`disabled`/`required`/`checkValidity()`/`reportValidity()` all come from that mixin.
*
* Ships an opt-in `label`/`hint`/`errorText` form-control chrome (props + matching named slots +
* `form-control-label`/`hint`/`error` parts), mirroring `<lr-select>`'s exact pattern -- left
* unset, the chrome remains hidden. A consumer preferring their own form-field layout can still
* ignore these and wrap the element. A host `aria-label` is forwarded to the internal textbox via
* the typed `accessibleLabel` property. A host `aria-describedby` is resolved onto that native
* textarea, ahead of its own hint/error 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.
*
* `minlength`/`maxlength` are forwarded to the internal native `<textarea>` and bridged into this
* element's own `ElementInternals` as `tooShort`/`tooLong` by `updateValidity()`.
* `readonly` keeps the value focusable, selectable, copyable, and form-submittable while barring
* user edits and constraint validation, matching the native textarea contract.
*
* Removing `label`, `hint`, `help-text` or `error-text` safely omits that content while preserving
* native null property readback. Explicit empty strings stay empty; later text renders normally.
*
* @customElement lr-textarea
* @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-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 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 lr-invalid - The textarea 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.
* @event blur - Re-dispatched from the internal native `<textarea>`'s own `blur` -- bubbling and
*   composed (unlike the native event, which is neither), so a listener above the shadow boundary
*   can observe it.
* @event focus - Re-dispatched from the internal native `<textarea>`'s own `focus`, for the same
*   reason as `blur`.
* @slot label - Custom label content.
* @slot hint - Custom hint content.
* @slot help-text - Shoelace alias for `hint`.
* @slot error - Custom error content.
* @csspart form-control - The outer wrapper around label, textarea, 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 wrapper; use `textarea-wrapper`.
* @csspart form-control-input - Compatibility name for the control wrapper.
* @csspart textarea-adjuster - Compatibility name for the native-resize wrapper.
* @csspart textarea-wrapper - The wrapper around the native `<textarea>`. It is the same node as
*   `base`.
* @csspart textarea - The native `<textarea>` element.
* @csspart footer - The row below the field carrying the character count. Hidden without `with-count`.
* @csspart count - The character count, rendered only with `with-count`.
* @csspart hint - The hint message.
* @csspart form-control-help-text - Shoelace compatibility name for the hint message.
* @csspart error - The error message.
* @cssprop [--lr-textarea-max-block-size=none] - Maximum auto-grown block size before the textarea scrolls.
* @cssprop [--lr-textarea-padding=var(--lr-form-control-padding-inline)] - Padding of the native
* textarea on all four sides, from the active `size` tier of the shared form-control ladder
* (`internal/sizes.styles.ts`). The ladder's *inline* gutter is used on every side deliberately:
* its block padding is `0` at the two tightest tiers because a control row's height floor supplies
* the space there, and a textarea has no such floor -- the first line of text would sit on the
* border.
* @cssprop [--lr-textarea-font-size=var(--lr-form-control-font-size)] - Font size of the native
* textarea, from the active `size` tier of the shared ladder.
* @cssprop [--lr-textarea-radius=var(--lr-form-control-radius)] - Corner radius of the field, from
* the active `size` tier of the shared ladder (the two tightest tiers take a smaller radius).
* `pill` changes the private default to `--lr-radius-pill`; a public value still wins.
* @cssprop [--lr-textarea-fill=transparent] - Background of the field. Its private default follows
* `appearance`; the documented default is `appearance="outlined"`'s value.
* @cssprop [--lr-textarea-border-color=var(--lr-color-border)] - Border color of the field. Its
* private default follows `appearance` in the same way as `--lr-textarea-fill`.
* @cssprop [--lr-textarea-hover-border-color=var(--lr-color-brand)] - Field border color while the
* native textarea is hovered.
* @cssprop [--lr-textarea-focus-border-color=var(--lr-textarea-border-color)] - Field border color
* while the native textarea is focused. Unset, it resolves to this field's own resting border
* color, so a textarea with no override renders exactly as before this hook existed.
* @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 LyraTextarea extends LyraTextarea_base{
/** Public WA-compatible intrinsic validator catalog. */
static get validators():LyraFormValidator<LyraTextarea>[];static styles:import("lit").CSSResultGroup[];get value():string;set value(next:string|null);
/** Visible text rows. */
rows:number;
/** Native CSS `resize` behavior for the textarea (`'none'`, `'vertical'`, `'horizontal'`,
*  `'both'`), plus `'auto'`: a `ResizeObserver`-driven grow-to-content mode with no manual drag
*  handle (mirrors `wa-textarea`'s `resize="auto"`). An invalid runtime value falls back to
*  `'vertical'`. */
resize:TextareaResize;
/** Visual size on the library's one control ladder, shared with `<lr-input>`/`<lr-select>`.
*  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. Governs
*  the field's padding and font size — a textarea's own height comes from `rows`/`resize`, not
*  from the ladder's control-height floor. */
size:LyraSize;
/** Visual treatment of the field, from the library's shared vocabulary and with the same
*  meanings as `<lr-input>`'s `appearance`. Each value only swaps
*  `--lr-textarea-fill`/`--lr-textarea-border-color`. */
appearance:LyraAppearance;
/** Shoelace boolean alias for the filled treatment. */
filled:boolean;
/** Fully rounded field corners, matching `<lr-input>`'s/`<lr-select>`'s own `pill` — Shoelace and
*  Web Awesome both ship it on their textarea, so a mechanical tag rename must not drop it.
*  Changes the private radius default to `--lr-radius-pill` rather than declaring a radius on
*  `[part="textarea"]`, so an inherited or direct `--lr-textarea-radius` remains authoritative.
*  Most useful on a one-or-two-row field; a tall multi-line surface with fully rounded ends wastes
*  its first and last line's inline space, so this is opt-in rather than tied to `size`. */
pill:boolean;
/** Renders a character count below the field. With `maxlength` set it counts down the remaining
*  characters instead of up from zero. The visible count and internal shadow mirror are
*  `aria-hidden`; after user input pauses, the localized count is appended once to Lyra's shared
*  light-DOM polite announcement sink so it is not spoken over every keystroke. The sink stays
*  silent while this host or a composed ancestor is excluded from the accessibility tree. */
withCount:boolean;placeholder:string;
/** Forwards native read-only behavior to the internal textarea. The value remains focusable,
*  selectable, copyable, and form-submittable; constraint validation is suspended until the
*  property is unset. */
readonly:boolean;label:string;hint:string;
/** Shoelace alias for {@link hint}. `hint` wins when both are set. */
helpText:string;
/** SSR slot-presence hints for declarative shadow DOM and hydration. */
withLabel:boolean;withHint:boolean;errorText:string;
/** Accessible name overriding the label/placeholder-derived default. Any non-`null` value takes
*  precedence by presence—including `''`—matching `<lr-date-input>`'s `accessibleLabel`. */
accessibleLabel:string|null;
/** Forwarded to the native `<textarea>`'s own `spellcheck`. Defaults to `true`, matching the
*  native element's own default. */
spellcheck:boolean;
/** Forwarded to the internal native textarea. */
autofocus:boolean;
/** Forwarded to the internal native textarea. */
title:string;
/** Forwarded to the native `<textarea>`'s own `autocapitalize`. Empty string omits the
*  attribute (browser default). */
autocapitalize:string;private autocorrectValue;
/** Forwarded to the native `<textarea>`'s own `wrap`. */
wrap:TextareaWrap;
/** Native editing-assistance attributes forwarded to the wrapped textarea. Empty strings omit
*  the corresponding attribute and retain the browser default. */
autocomplete:string;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 string vocabulary:
* `'off'`/`'false'` normalize to false and every other string normalizes to true. */
get autocorrect():boolean;set autocorrect(next:boolean|string);
/** Lowercase mapped IDLs that delegate to the existing reactive native spellings. */
get inputmode():string;set inputmode(next:string);get enterkeyhint():string;set enterkeyhint(next:string);set defaultValueAlias(next:string);
/** Minimum text length, forwarded to the native `<textarea>`'s own `minlength` and reported as
*  `tooShort` by `updateValidity()`. Defaults to `undefined` (no lower bound). Like native
*  `minlength`, an empty value never violates it — pair it with `required` to also reject
*  empty. */
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;
/** 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, and shared
*  with `<lr-input>`'s identical property. 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 and a
*  programmatic `value` write that changes the value -- a same-value write does not disturb it. */
debounce?:number;private touched;
/** Empty until the user pauses typing, so the live region says nothing on first render. */
private announcedCountText;private readonly slotPresence;private settlingValueFromInput;private readonly settledDebounce;private textareaEl?;private resizeObserver?;private lastObservedWidth?;private resizeRaf?;private resizeRafOwner?;private countAnnounceTimer?;private countAnnounceTimerOwner?;private countAnnouncementSink?;private externalDescriptionLease?;constructor();
/** The internal native `<textarea>` element, for direct DOM access (caret position, selection,
*  `setRangeText()`) that has no first-class `lr-*` equivalent -- mirrors `wa-textarea`'s own
*  `input` getter. */
get input():HTMLTextAreaElement|null;get selectionStart():number|null;set selectionStart(value:number|null);get selectionEnd():number|null;set selectionEnd(value:number|null);get selectionDirection():TextareaSelectionDirection|null;set selectionDirection(value:TextareaSelectionDirection|null);
/** Reads both component state and the UA's synchronous fieldset cascade before public actions. */
private get liveDisabled();click():void;focus(options?:FocusOptions):void;blur():void;select():void;setSelectionRange(selectionStart:number,selectionEnd:number,selectionDirection?:'forward'|'backward'|'none'):void;
/**
* Reads or writes the internal textarea's scroll offsets — the one piece of scroll state a
* consumer restoring a draft, or pinning a long value to its end, cannot reach through any other
* public member.
*
* Called with no argument it returns the current `{ top, left }`; called with a partial position
* it writes only the axes present and returns `undefined`. Returns `undefined` either way before
* the internal textarea has rendered.
*/
scrollPosition(position?:{top?:number;left?:number;}):{top:number;left:number;}|undefined;
/** Passthrough to the native `<textarea>`'s `setRangeText()`. Mirrors `wa-textarea`'s own 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;connectedCallback():void;disconnectedCallback():void;adoptedCallback():void;
/** Resolves host-owned descriptions onto the native textarea without copying labelledby. */
private syncExternalDescription;private releaseExternalDescription;
/**
* `maxlength` as a usable non-negative integer, or `undefined` when it was never set or arrived
* unparseable — an attribute goes through `Number()`, so `maxlength="oops"` reaches this
* property as `NaN`, and subtracting from that would render a literal `NaN` in the count.
*/
private effectiveLengthLimit;private countMaxlength;
/**
* The character count's text. Lengths count UTF-16 code units (`String.length`) rather than
* grapheme clusters, deliberately: that is exactly what the native `maxlength` the count is
* reporting against enforces, and a count that disagreed with the limit it describes would be
* worse than one that disagrees with an emoji.
*
* The remaining count floors at zero. Only a script-assigned value can exceed `maxlength` (the
* native control blocks typing past it), and "-3 characters remaining" is a worse signal for
* that state than the `tooLong` validity flag already raised for it.
*/
private countText;private scheduleCountAnnouncement;
/**
* Bridges the internal native `<textarea>`'s own browser-computed constraint validation into
* this element's `ElementInternals`, mirroring `<lr-input>`'s override of the same name. Without
* it this control falls through to the base mixin's plain required-and-empty check, which leaves
* `minlength`/`maxlength` enforced while typing but absent from `validity`.
*
* `required` is evaluated here rather than read back off the native element's own `valueMissing`,
* for two reasons: the `required` attribute reaches that element only on Lit's next render (so a
* same-tick `el.required = true` would be answered from a stale attribute), and this path owns
* the localized `fieldRequired` message the base mixin already produced.
*
* 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 from `value` and they are OR-ed into the native flags (see
* `internal/length-constraints.ts`).
*
* Barred controls short-circuit first, through the same `isBarredFromValidation()` predicate the
* base mixin uses — this override used to check `readonly` alone, so a `<lr-textarea required
* disabled>` (or one inside a `<fieldset disabled>`) still reported `valueMissing` and published
* `:state(invalid)`/`:state(user-invalid)`, which no native `<textarea required disabled>` does.
*/
protected updateValidity():void;protected updated(changed:PropertyValues):void;formResetCallback():void;private armResizeObserver;private fitToContent;
/** 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;private onKeyDown;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-textarea':LyraTextarea;}}export{};