import{type TemplateResult,type PropertyValues}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import type{LyraFrame}from'../../../internal/variants.js';import type{LyraSelectionDirection,LyraTextWrap}from'../../../internal/shared-unions.js';
/** Whether the root draws itself as a bounded card — an alias of the shared {@linkcode LyraFrame},
*  so there is one definition. Named `frame`, not `appearance`: `appearance` is the library's
*  vocabulary for how a *control fills itself*, and using it for container chrome as well made one
*  property name mean two unrelated things. */
export type ChatComposerFrame=LyraFrame;export type ChatComposerStatus='idle'|'sending'|'streaming';export declare const CHAT_COMPOSER_STATUSES:readonly["idle","sending","streaming"];
/** Resolves untrusted status input to the public literal set. */
export declare function normalizeChatComposerStatus(value:unknown):ChatComposerStatus;
/** Retained name for the shared native `<textarea wrap>` vocabulary. */
export type ChatComposerWrap=LyraTextWrap;
/** Retained name for the shared native `selectionDirection` vocabulary. */
export type ChatComposerSelectionDirection=LyraSelectionDirection;
/** Arrangement of the `start`/`end` action slots relative to the textarea. `'inline'` is today's
*  single flex row; `'stacked'` arranges them as a compact rail beside a multi-row textarea. */
export type ChatComposerActionsLayout='inline'|'stacked';export interface LyraChatComposerEventMap{input:InputEvent;change:Event;'lr-invalid':CustomEvent<null>;'lr-input':CustomEvent<{value:string;}>;'lr-change':CustomEvent<{value:string;}>;'lr-stop':CustomEvent<null>;'lr-submit':CustomEvent<{value:string;}>;blur:FocusEvent;focus:FocusEvent;}declare class LyraChatComposerBase extends LyraElement<LyraChatComposerEventMap>{}declare const LyraChatComposer_base:typeof LyraChatComposerBase&(new(...args:any[])=>import("../../../lyra.js").FormAssociatedInterface<string> &import("../../../internal/form-associated.js").FormAssociatedSubclassInterface<string>);
/**
* `<lr-chat-composer>` — the message input for a chat/agent conversation
* surface: an auto-resizing textarea plus a send/stop button. Form-
* associated via the `FormAssociated` mixin (see `<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.
*
* Auto-resize reads the textarea's own *computed* line-height/padding/
* border at runtime (`resizeTextarea()`) rather than assuming a fixed
* px-per-row constant, so it stays correct under a consumer's own font-size/
* line-height overrides. It grows between `min-rows` and `max-rows`, then
* switches to internal scrolling. A `ResizeObserver` on the textarea itself
* re-runs the same fit whenever its *width* changes (a responsive
* breakpoint, a sidebar toggling, a window resize, an orientation change)
* even though `value`/`min-rows`/`max-rows` never did -- a narrower box
* wraps the same text across more lines, so the previously-fitted height
* would otherwise go stale and clip content with no scrollbar to reveal it.
*
* Enter-to-send (only active while `submit-on-enter` is true, the default):
* plain Enter submits and is prevented from inserting a newline; Shift+Enter
* always inserts a newline no matter what; an IME composition step (checked
* via `isComposing`, with `keyCode === 229` as a defense-in-depth fallback
* for browsers that report `isComposing` inconsistently on the
* compositionend-adjacent keydown) is never treated as a submit trigger;
* and while `status` isn't `"idle"` Enter is left alone to insert a newline
* too, rather than trying to submit again -- there is nothing meaningful to
* submit while a previous message is still sending/streaming, and the
* textarea deliberately stays interactive (see `disabled` below) so a user
* can keep composing their next message in the meantime.
*
* Deliberately no label/hint/error chrome -- a composite chat-input control, not a labeled form
* field; wrap it in your own layout for that context. A host `aria-label` is forwarded to the
* internal textarea and takes precedence over the placeholder-derived name.
*
* `lr-submit`'s `detail.value` is always the exact, untrimmed current
* value (`detail.value === value` at the moment it fires) -- trimming is
* left to the consumer so it never silently diverges from what `value`
* itself reports. Submitting does not clear `value`; the consumer clears it
* once the submission has actually been accepted (so e.g. a failed send can
* leave the text in place for retry).
* `submitDisabled` lets the consumer apply its own validation policy without
* disabling the textarea or the busy-state Stop action.
*
* @customElement lr-chat-composer
* @slot toolbar - Auxiliary controls (e.g. a model or provider picker) rendered inside the frame,
* above the chips tray and input row, sharing `[part="base"]`'s `:focus-within` affordance.
* @slot start - Content rendered before the textarea (e.g. an attach-file trigger button).
* @slot chips - An attachment tray rendered above the input row (e.g. files queued for this message).
* @slot end - Overrides the built-in send/stop button entirely when it has assigned content.
* @event input - One realm-correct native `InputEvent` relayed from the textarea for each user edit.
* @event change - One native `Event` relayed from the textarea when its edit is committed.
* @event lr-input - Fired on every user-driven edit of the textarea (not a programmatic `.value` assignment). `detail: { value }`.
* @event lr-change - Fired with `detail: { value }` beside the native `change` event.
* @event lr-submit - Fired by Enter (per `submit-on-enter`) or the built-in button while `status="idle"` and `submitDisabled` is false. `detail: { value }`.
* @event lr-stop - Fired by the built-in button while `status` is `"sending"` or `"streaming"` and `stoppable` is `true` (the default). No detail.
* @event blur - One realm-correct native `FocusEvent` relayed from the textarea, preserving `relatedTarget`.
* @event focus - One realm-correct native `FocusEvent` relayed from the textarea, preserving `relatedTarget`.
* @event lr-invalid - The composer failed a validity check. Cancelable — preventing this alias
*   also prevents the native `invalid` event that produced it.
* @csspart base - The bordered root container. Drops its card chrome (border, background, padding,
* radius) under `frame="plain"`, where the focus affordance becomes an underline on this same
* part instead of the border-color shift.
* @csspart toolbar - The wrapper around the `toolbar` slot. Hidden entirely when empty, matching
* `start`/`chips`.
* @csspart chips - The wrapper around the `chips` slot. Hidden entirely when the slot is empty.
* @csspart row - The row holding the start slot, textarea, and end slot/button.
* @csspart start - The wrapper around the `start` slot. Hidden entirely when empty.
* @csspart textarea - The auto-resizing `<textarea>` itself.
* @csspart end - The wrapper around the `end` slot and the built-in `action-button`.
* @csspart send-glyph - Directional send glyph wrapper; mirrored automatically in RTL.
* @csspart stop-glyph - Symmetric stop glyph wrapper.
* @csspart action-button - The built-in send/stop button. Absent whenever `end` has assigned content. Style its busy treatment via `:host([status='sending'])`/`:host([status='streaming'])`, or the dedicated `--lr-chat-composer-busy-bg` cssprop below.
* @cssprop [--lr-chat-composer-busy-bg=var(--lr-color-text-quiet)] - `action-button` background while `status` is `"sending"` or `"streaming"`. Scoped separately from the shared `--lr-color-text-quiet` token, which the `textarea` part's placeholder also reads -- overriding this recolors only the busy button, not the placeholder text too.
* @cssprop [--lr-chat-composer-background=var(--lr-color-surface)] - Fill of the card
*   (`[part="base"]`) while `frame="card"`. `frame="plain"` still removes the fill entirely.
* @cssprop [--lr-chat-composer-border-color=var(--lr-color-border)] - Resting colour of the card's
*   border. The `:focus-within` border stays on the brand token -- it is state paint, not chrome.
* @cssprop [--lr-chat-composer-radius=var(--lr-radius)] - Corner radius of the card.
*   `frame="plain"` still squares the corners.
* @cssprop [--lr-chat-composer-padding=var(--lr-space-s)] - Padding of the card (`[part="base"]`).
*   `frame="plain"` still zeroes it, same as the background/border-color/radius hooks above.
* @cssprop [--lr-chat-composer-gap=var(--lr-space-xs)] - Row gap between the `toolbar`, `chips` and
*   `row` sections stacked inside `[part="base"]`.
* @cssprop [--lr-chat-composer-focus-shadow=inset 0 calc(-1 * var(--lr-focus-ring-width)) 0 0 var(--lr-focus-ring-color)] -
*   The `frame="plain"` focus affordance painted on `[part="base"]:focus-within`, replacing the
*   card's border-color shift with an underline since there is no border left to recolor under
*   `plain`. Override to reshape it (a different width/color) or set to `none` to cede focus chrome
*   entirely to a consumer-drawn wrapper -- chosen over a third `frame` value, since every other
*   piece of this card's paint (background/border-color/radius above) is already a cssprop hook
*   rather than a `frame` variant, and `none` already reads naturally as "I'll draw my own".
* @status stable
* @since 4.0.0
*/
export declare class LyraChatComposer extends LyraChatComposer_base{static styles:import("lit").CSSResultGroup[];placeholder:string;minRows:number;maxRows:number;private statusValue;
/** Sending state. Invalid direct or attribute writes normalize and reflect as `idle`. */
get status():ChatComposerStatus;set status(value:ChatComposerStatus);
/** Visual chrome, on the library-wide `frame` vocabulary. `'card'` (the default) keeps the
*  bordered, filled, padded box. `'plain'` removes the border, background, padding and corner
*  radius, so a composer docked inside a chat panel, dialog footer or toolbar that already draws
*  its own border doesn't double the frame. Focus stays visible either way: `plain` swaps the
*  border-color shift for an underline across the input row, since there is no border left to
*  recolor. */
frame:ChatComposerFrame;private actionsLayoutValue;
/** Arrangement of the `start`/`end` action slots relative to the textarea, on the shared
*  literal-set pattern (`literalSetConverter`, matching `<lr-model-settings-panel>`'s `layout`).
*  `'inline'` (the default) keeps today's single flex row. `'stacked'` arranges `start` above
*  `end` as a compact rail in one column, beside a `textarea` that spans both rows -- for a
*  multi-row composer where the action buttons would otherwise stretch to the row's full
*  cross-axis height. Layout only; slot content, empty-slot hiding and the built-in button are
*  unchanged. Invalid direct or attribute values normalize and reflect as `'inline'`. */
get actionsLayout():ChatComposerActionsLayout;set actionsLayout(next:ChatComposerActionsLayout);submitOnEnter:boolean;
/** Consumer-controlled validation gate for submission. While idle, disables the built-in Send
* button and suppresses Enter/click submission without disabling the textarea. Busy Stop behavior
* remains governed by `status` and `stoppable`. */
submitDisabled:boolean;stoppable:boolean;
/** Native read-only state. The textarea remains focusable/submittable but cannot be user-edited,
* and intrinsic constraints are barred just like a native read-only textarea. */
readOnly:boolean;
/** Native minimum text length. Unset or invalid values impose no lower bound. */
minLength?:number;
/** Native maximum text length. Unset or invalid values impose no upper bound. */
maxLength?:number;
/** Accessible name for the internal textarea. Takes precedence over the placeholder-derived name. */
accessibleLabel:string|null;spellcheck:boolean;
/** Forwarded to the internal `<textarea>`'s own `autocapitalize`. Empty string omits the
*  attribute (browser default). */
autocapitalize:string;private autocorrectValue;
/** Native autocorrect state. Reads are boolean; writes accept boolean or the legacy
* `'off'`/`'false'` string vocabulary and reflect canonical `on`/`off`. */
get autocorrect():boolean;set autocorrect(next:boolean|string);
/** Native editing-assistance attributes forwarded to the internal textarea. */
wrap:ChatComposerWrap;autocomplete:string;inputMode:string;enterKeyHint:string;private hasToolbarSlot;private hasStartSlot;private hasChipsSlot;private hasEndSlot;private touched;private textareaEl?;private textareaResizeObserver?;private textareaResizeObserverDocument?;private textareaResizeObserverTarget?;private textareaResizeRaf?;private textareaResizeRafOwner?;private textareaResizeRafDocument?;private textareaResizeGeneration;private get effectiveMinRows();
/** Never less than {@link effectiveMinRows} -- an inverted min/max-rows pair (authored
*  backwards, or a live update that shrinks `max-rows` below the current `min-rows`) still
*  produces a usable, non-collapsed range instead of clipping the textarea to less than its own
*  minimum. */
private get effectiveMaxRows();private effectiveLengthLimit;constructor();
/** The internal native textarea for integrations that require direct DOM access. */
get input():HTMLTextAreaElement|null;get selectionStart():number|null;set selectionStart(value:number|null);get selectionEnd():number|null;set selectionEnd(value:number|null);get selectionDirection():ChatComposerSelectionDirection|null;set selectionDirection(value:ChatComposerSelectionDirection|null);focus(options?:FocusOptions):void;blur():void;
/** Focuses the primary textarea, matching activation of the wrapped native control. */
click():void;select():void;setSelectionRange(start:number|null,end:number|null,direction?:ChatComposerSelectionDirection):void;setRangeText(replacement:string):void;setRangeText(replacement:string,start:number,end:number,selectMode?:SelectionMode):void;protected willUpdate(changed:PropertyValues):void;protected firstUpdated(changed:PropertyValues):void;connectedCallback():void;disconnectedCallback():void;adoptedCallback():void;protected updated(changed:PropertyValues):void;protected updateValidity():void;formResetCallback():void;private hasSlotted;
/**
* Grows/shrinks the textarea between `min-rows` and `max-rows`, reading
* the *computed* line-height/padding/border back out of the element at
* call time instead of assuming a fixed px-per-row figure -- correct
* whatever font-size/line-height a consumer's own CSS ends up applying.
* Past `max-rows` the box stops growing and switches to internal
* scrolling (`overflow-y: auto`).
*/
private resizeTextarea;
/**
* Re-fits the textarea whenever its own box *width* changes, independent
* of any `value`/`min-rows`/`max-rows` update -- `updated()` above only
* reacts to those, so a pure layout change (a responsive breakpoint, a
* sidebar collapsing/expanding, a window resize, an orientation change)
* would otherwise leave the height pinned at whatever it last was, even
* though the same text now wraps across a different number of lines.
* Mirrors split.ts's `collapseResizeObserver`/virtual-list.ts's
* `containerResizeObserver`/lite-chart.ts's `resizeObserver`.
*
* Only reacts to an actual inline-size change rather than calling
* `resizeTextarea()` unconditionally on every callback: `resizeTextarea()`
* itself sets `ta.style.height`, a *block*-size change on the very element
* being observed, which would otherwise re-trigger this same observer
* every tick. Diffing against the last-seen width (same technique as
* split.ts keying its collapse state off `contentBoxSize[0].inlineSize`)
* keeps a same-width, height-only callback from doing anything.
*
* The actual recompute is deferred one animation frame rather than run
* synchronously inside the callback: `ResizeObserver`'s spec re-delivers,
* within the same notification pass, to any observed element resized by
* its own callback -- mutating `ta.style.height` synchronously here would
* do exactly that to the very box just observed, and the browser reports
* it as "ResizeObserver loop completed with undelivered notifications"
* (a real, user-visible console error, not just noise). Deferring the
* mutation to the next frame -- outside that notification pass -- avoids
* ever resizing the observed element from inside its own callback.
*/
private armTextareaResizeObserver;private resetTextareaResizeWork;private onTextareaInput;private onTextareaChange;private onTextareaKeyDown;private onActionClick;private submit;private syncToolbarSlot;private syncStartSlot;private onChipsSlotChange;private syncEndSlot;private onTextareaBlur;private onTextareaFocus;private renderActionButton;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-chat-composer':LyraChatComposer;}}export{};