@kitn.ai/ui 0.25.2 → 0.27.0

package/dist/react/index.d.ts

@@ -92,7 +92,7 @@ export interface ArtifactProps extends WebComponentProps {
 }
 export declare const Artifact: import('react').ForwardRefExoticComponent<ArtifactProps & import('react').RefAttributes<HTMLElement>>;
 export interface AttachmentsProps extends WebComponentProps {
-    /** The attachments to render. Omit (or pass an empty array) for the empty state, which shows `emptyText` if set and nothing otherwise. Set as a JS property (array). */
+    /** The attachments to render. Omit (or pass an empty array) for the empty state, which shows `emptyText` if set and nothing otherwise. Set as a JS property (array). Each item's `url` must be a `data:` URI or an https URL, never `URL.createObjectURL`: a `blob:` URL previews here but the wire encoders (`toOpenAIMessages`/`toAnthropicMessages`) refuse it. */
     items?: {
         id: string;
         type: "file" | "source-document";
@@ -140,12 +140,14 @@ export interface AudioVisualizerProps extends WebComponentProps {
     complexity?: number;
     /** Setting this makes the element an announced image (`role="img"`) instead of decorative (`aria-hidden`). Attribute: `label`. */
     label?: string;
-    /** Live microphone or WebRTC audio to analyze. JS property only. */
+    /** Live microphone or WebRTC audio to analyze. JS property only. NOTE: amplitude renders only while state is "speaking" unless listening-amplitude is set; every other state plays its scripted animation and ignores the audio. */
     stream?: MediaStream;
-    /** An `<audio>` or `<video>` element to tap for its audio. JS property only. */
+    /** An `<audio>` or `<video>` element to tap for its audio. JS property only. NOTE: amplitude renders only while state is "speaking" unless listening-amplitude is set; every other state plays its scripted animation and ignores the audio. */
     audioElement?: HTMLMediaElement;
-    /** Pre-computed levels, 0..1. Set this and no AudioContext is ever built, which is what keeps headless/SSR rendering and browser-speech-synthesis playback (which exposes no audio node) free of Web Audio entirely. JS property only. A new array reference is required for each update; mutating the existing array in place will not re-render. */
+    /** Pre-computed levels, 0..1. Set this and no AudioContext is ever built, which is what keeps headless/SSR rendering and browser-speech-synthesis playback (which exposes no audio node) free of Web Audio entirely. JS property only. A new array reference is required for each update; mutating the existing array in place will not re-render. NOTE: amplitude renders only while state is "speaking" unless listening-amplitude is set; every other state plays its scripted animation and ignores the audio. */
     bands?: number[];
+    /** Render live amplitude during the listening state as well, using the same presentation as speaking. Off by default, which keeps LiveKit parity: amplitude from stream, audio-element or bands renders only while state is "speaking". Set it to show a real mic-level picture while the user is the one talking. Boolean. Attribute: `listening-amplitude` (a bare attribute means true; reflected, so the property reads back what the attribute set). */
+    listeningAmplitude?: boolean;
     /** Custom fragment shader for `variant="custom"`. JS property only. */
     shader?: {
         fragment: string;
@@ -253,17 +255,17 @@ export interface CardsProps extends WebComponentProps {
     schemas?: Record<string, object>;
     /** Optional CardPolicy handling child events. Property: `el.policy`. */
     policy?: {
-        onSubmit?: (cardId: string, data: unknown) => void;
-        onAction?: (cardId: string, action: string, payload?: unknown) => void;
-        onSendPrompt?: (text: string, opts: {
+        onSubmit?: ((cardId: string, data: unknown) => void);
+        onAction?: ((cardId: string, action: string, payload?: unknown) => void);
+        onSendPrompt?: ((text: string, opts: {
             mode: "compose" | "send";
             context?: unknown;
-        }) => void;
-        onOpen?: (url: string, target: "tab" | "artifact") => void;
-        onState?: (cardId: string, patch: unknown) => void;
-        onDismiss?: (cardId: string) => void;
-        onReopen?: (cardId: string) => void;
-        onError?: (cardId: string, message: string) => void;
+        }) => void);
+        onOpen?: ((url: string, target: "tab" | "artifact") => void);
+        onState?: ((cardId: string, patch: unknown) => void);
+        onDismiss?: ((cardId: string) => void);
+        onReopen?: ((cardId: string) => void);
+        onError?: ((cardId: string, message: string) => void);
         maxSendPromptMode?: "compose" | "send";
     };
     /** Validate each envelope's `data` against the schema for its type before rendering it, using a built-in's own schema or yours from `schemas`. Default `true`; set `validate-cards="false"` (or `el.validateCards = false`) to opt out. A hard failure (wrong type, a missing required field) renders a diagnostic naming the field instead of the card; a soft failure (bounds) renders the card unchanged. Both emit a contract `error` event. On in production too: a model emitting a bad shape is a production failure mode, so stripping the check there would hide it from exactly the person who needs to see it. */
@@ -311,8 +313,6 @@ export interface ChainOfThoughtProps extends WebComponentProps {
 }
 export declare const ChainOfThought: import('react').ForwardRefExoticComponent<ChainOfThoughtProps & import('react').RefAttributes<HTMLElement>>;
 export interface ChatProps extends WebComponentProps {
-    /** Show a Search (Globe) button in the input toolbar; fires a `search` event. */
-    search?: boolean;
     /** Value of the input. A **string** is controlled (the host owns the text and updates it on `kai-value-change`). A **ComposerDoc** is a one-time seed that pre-populates pills; the user then edits freely. Leave unset for uncontrolled. */
     value?: string | ({
         type: "text";
@@ -344,6 +344,10 @@ export interface ChatProps extends WebComponentProps {
     codeTheme?: string;
     /** Enable Shiki syntax highlighting in code blocks. Turn off to render plain `<pre>` blocks (lighter, no highlighter load). Default true. */
     codeHighlight?: boolean;
+    /** How `reasoning` parts render across the thread. `'full'` (default) is the current collapsible-disclosure behavior; `'compact'` shows only a shimmer loader while a reasoning part streams and nothing once it settles (no expandable detail); `'off'` renders reasoning parts not at all. Forwarded to every `MessageBody` as `reasoningMode`. */
+    reasoning?: "full" | "compact" | "off";
+    /** Seeds the reasoning disclosure open AND keeps it tracking the stream (open while streaming, closes when it settles): the pre-Task-19f `full` behavior. Default false/absent: the panel starts closed (just the "Thinking" shimmer chip) and only opens on click, the current default (owner ruling, 2026-08-26). Meaningless when `reasoning` is `'compact'` or `'off'`. Forwarded to every `MessageBody` as `reasoningDefaultOpen`. */
+    reasoningOpen?: boolean;
     /** Optional header title shown on the left of the header. */
     chatTitle?: string;
     /** Optional model list. When set (>1 model) a ModelSwitcher is shown in the header and a `kai-model-change` event fires on selection. */
@@ -382,6 +386,10 @@ export interface ChatProps extends WebComponentProps {
     composerActions?: boolean;
     /** INJECT: footer row below the composer (disclaimers, token meter, …). */
     footer?: boolean;
+    /** When `false`, hides the built-in paperclip attach button. Defaults to `true` (undeclared keeps today's behavior: attach visible), matching `DefaultPromptInput`'s own default: only an explicit `false` hides it. */
+    attach?: boolean;
+    /** Show a web-search (Globe) button in the input toolbar; calls `onWebSearch`. */
+    webSearch?: boolean;
     /** Show a Voice (Mic) button in the input toolbar; fires a `voice` event. */
     voice?: boolean;
     /** Rich entity triggers. Each `{ char, kind, items }` opens a caret-anchored menu that inserts an atomic pill (`/` skills, `@` agents/plugins). Set as a JS property; forwarded to the input. */
@@ -550,8 +558,6 @@ export interface ChatProps extends WebComponentProps {
     onModelChange?: (event: CustomEvent<{
         modelId: string;
     }>) => void;
-    /** The Search button was clicked. */
-    onSearch?: (event: CustomEvent<Record<string, never>>) => void;
     /** User submitted a message. */
     onSubmit?: (event: CustomEvent<{
         value: string;
@@ -574,8 +580,56 @@ export interface ChatProps extends WebComponentProps {
     }>) => void;
     /** The Mic / voice button was clicked. */
     onVoice?: (event: CustomEvent<Record<string, never>>) => void;
+    /** The web-search (Globe) toolbar button was clicked. */
+    onWebSearch?: (event: CustomEvent<Record<string, never>>) => void;
 }
 export declare const Chat: import('react').ForwardRefExoticComponent<ChatProps & import('react').RefAttributes<HTMLElement>>;
+export interface CheckboxProps extends WebComponentProps {
+    /** Controlled checked state. Settable and reflected to the `checked` attribute. `el.checked = true` (or `<kai-checkbox checked>`) drives it; ticking the box updates it and fires `kai-change`. Read `el.checked` for live state. */
+    checked?: boolean;
+    /** Initial checked state on mount (uncontrolled seed). Bare attribute (`<kai-checkbox default-checked>`) turns it on. */
+    defaultChecked?: boolean;
+    /** The mixed state, for a parent box whose children are partly ticked. Visual plus an accessibility hint: the box still reports `checked === false`. */
+    indeterminate?: boolean;
+    /** Disable interaction. */
+    disabled?: boolean;
+    /** Set the native `required` attribute, and nothing more. Whether an unticked box is an error is the application's rule, not the kit's. */
+    required?: boolean;
+    /** Accessible label. The visible text beside the box is the consumer's to render. */
+    label?: string;
+    /** Form-control name (paired with `value`). */
+    name?: string;
+    /** Submitted value when checked (paired with `name`). Defaults to `'on'`. */
+    value?: string;
+    /** The box was ticked or unticked. */
+    onChange?: (event: CustomEvent<{
+        checked: boolean;
+    }>) => void;
+}
+export declare const Checkbox: import('react').ForwardRefExoticComponent<CheckboxProps & import('react').RefAttributes<HTMLElement>>;
+export interface CheckboxGroupProps extends WebComponentProps {
+    /** The choices, top to bottom. Set as a JS PROPERTY (array), never an attribute. Rendered in full: the kit never truncates, re-orders or de-duplicates them. */
+    options: {
+        value: string;
+        label: string;
+        description?: undefined | string;
+        disabled?: undefined | boolean;
+    }[];
+    /** The FIRST selected value. Settable and reflected to the `value` attribute, so `:host([value])` and `el.value` see live state, and a seed can be written in markup. Writing it makes that the whole selection; to read or drive the rest, use `el.values`. */
+    value?: string;
+    /** The shared form-control name every box carries, so `FormData.getAll(name)` reads the whole selection back under one key. NO DEFAULT, unlike `<kai-radio-group>`. A radio set needs a shared `name` for the browser to make it exclusive and arrow-navigable, so one is generated when none is given; checkboxes are independent controls and behave correctly with no name at all. Generating one here would submit the selection under a random key, which is worse than submitting nothing. The element is NOT form-associated (no `ElementInternals`, no `setFormValue()`), the same known gap `<kai-input>` records: the boxes live in a shadow root, so a surrounding `<form>` collects nothing from them whether or not `name` is set. Read `el.values`. The name still lands on every inner input, so it is right the day form association arrives. */
+    name?: string;
+    /** Disable every row. Individual rows carry their own `disabled`. */
+    disabled?: boolean;
+    /** Accessible name for the group. */
+    label?: string;
+    /** A row was ticked or unticked. `values` is the whole selection after the change, which is what a multi-select control needs; `value` is the first of them (empty when nothing is selected). Both are always present, so neither shape silently loses the other. This is `<kai-select>`'s detail, deliberately. */
+    onChange?: (event: CustomEvent<{
+        value: string;
+        values: string[];
+    }>) => void;
+}
+export declare const CheckboxGroup: import('react').ForwardRefExoticComponent<CheckboxGroupProps & import('react').RefAttributes<HTMLElement>>;
 export interface CheckpointProps extends WebComponentProps {
     /** Optional text beside the icon. */
     label?: string;
@@ -664,6 +718,8 @@ export interface CodeBlockProps extends WebComponentProps {
     codeTheme?: string;
     /** Disable syntax highlighting (renders plain text, no Shiki). */
     codeHighlight?: boolean;
+    /** Show the copy button. **Defaults to ON**, because this element is documented as shipping one. Opt out with `copy="false"` or `el.copy = false`. */
+    copy?: boolean;
     /** Code text sizing. */
     proseSize?: "xs" | "sm" | "base" | "lg";
 }
@@ -807,7 +863,7 @@ export interface ComposerProps extends WebComponentProps {
     onFocus?: (event: CustomEvent<{
         originalEvent: FocusEvent;
     }>) => void;
-    /** The user submitted the composer (Enter or programmatic submit). */
+    /** The user submitted the composer (Enter or programmatic submit). Note the detail carries no `attachments`; `<kai-composer>` is the bare editing surface: no send button, toolbar, or attachments. For a drop-in composer row with all three, reach for `<kai-prompt-input>`, which is built on this. */
     onSubmit?: (event: CustomEvent<{
         doc: ({
             type: "text";
@@ -915,6 +971,19 @@ export interface ContextProps extends WebComponentProps {
     }>) => void;
 }
 export declare const Context: import('react').ForwardRefExoticComponent<ContextProps & import('react').RefAttributes<HTMLElement>>;
+export interface ConversationItemProps extends WebComponentProps {
+    /** The row's identity: the `conversation-id` attribute (host `id` is the fallback). Inside `<kai-conversations>` it is handed to the container's selection contract (`kai-conversation-select`); standalone it is the `id` in this element's own `kai-select` detail. */
+    conversationId?: string;
+    /** Selected state. Reflected as `aria-current` on the row body and a `data-active` styling hook on the row; inside a container the container drives it from its `activeId`, standalone you set it yourself. */
+    active?: boolean;
+    /** Dense single-line row padding. */
+    compact?: boolean;
+    /** STANDALONE activation only: the row was activated (click, Enter or Space on its body) while the item is NOT a direct child of `<kai-conversations>`. `id` is the row's identity: the `conversation-id` attribute, else the host `id`. Inside a container this never fires: activation surfaces once, as `kai-conversation-select` on the container. */
+    onSelect?: (event: CustomEvent<{
+        id: string;
+    }>) => void;
+}
+export declare const ConversationItem: import('react').ForwardRefExoticComponent<ConversationItemProps & import('react').RefAttributes<HTMLElement>>;
 export interface ConversationsProps extends WebComponentProps {
     /** The list's section headers (`{ id, name, sortOrder, createdAt }`), rendered in array order. A group carries no conversations of its own; it is matched against `conversations` by id, so the two props are complementary rather than alternatives. Omit for an ungrouped list. Set as a JS property. */
     groups?: {
@@ -925,12 +994,12 @@ export interface ConversationsProps extends WebComponentProps {
         sortOrder: number;
         createdAt: string;
     }[];
-    /** Every conversation the list renders, flat. Each one is filed under the group whose `id` equals its `groupId`; one with no `groupId`, or with a `groupId` matching no entry in `groups`, falls into a trailing "Ungrouped" section, so nothing you pass in is ever dropped. There is no recency bucketing. Set as a JS property. Omit to supply them as `<kai-conversation>` light-DOM children instead, or for the empty state. */
+    /** Every conversation the list renders, flat. Each one is filed under the group whose `id` equals its `groupId`; one with no `groupId`, or with a `groupId` matching no entry in `groups`, falls into a trailing "Ungrouped" section, so nothing you pass in is ever dropped. There is no recency bucketing. Set as a JS property. Omit to supply them as `<kai-conversation>` light-DOM children instead, or for the empty state. A search query that matches nothing shows a visible "No conversations match your search" state, distinct from the zero-conversations empty state. Slotted `<kai-conversation-item>` children switch the list into item mode instead: your own rows win and this array is not rendered. */
     conversations?: {
         id: string;
         title: string;
         groupId?: string;
-        scope: {
+        scope?: {
             type: "document" | "collection";
             documentId?: string;
             filters?: {
@@ -944,7 +1013,7 @@ export interface ConversationsProps extends WebComponentProps {
             };
         };
         messageCount: number;
-        lastMessageAt: string;
+        lastMessageAt?: string;
         updatedAt: string;
         trailing?: string;
     }[];
@@ -954,11 +1023,13 @@ export interface ConversationsProps extends WebComponentProps {
     collapsed?: boolean;
     /** Initial collapsed state when uncontrolled (default false). Use the `default-collapsed` attribute to start collapsed in plain HTML. */
     defaultCollapsed?: boolean;
+    /** Dense single-line rows (a leading dot + title, no message count). */
+    compact?: boolean;
     /** The rail was collapsed or expanded (via the toggle, the reopen button, or a `collapse()`/`expand()`/`toggle()` call). */
     onCollapseToggle?: (event: CustomEvent<{
         collapsed: boolean;
     }>) => void;
-    /** A conversation was selected. */
+    /** A conversation was selected. The selection event in BOTH modes: a batteries data row, or an activated `<kai-conversation-item>` child (click, Enter or Space). */
     onConversationSelect?: (event: CustomEvent<{
         id: string;
     }>) => void;
@@ -977,12 +1048,64 @@ export interface DialogProps extends WebComponentProps {
     open?: boolean;
     /** Initial open state on mount (uncontrolled seed). */
     defaultOpen?: boolean;
+    /** Accessible name for the modal, used when no `header` slot is projected: `<kai-dialog label="Delete workspace">`. A projected `header` WINS over this (it becomes `aria-labelledby`), because ARIA resolves `aria-labelledby` ahead of `aria-label` and the visible heading is the name both a sighted and a screen-reader user can be talked through. Defaults to `Dialog` so a modal is never nameless. */
+    label?: string;
     /** The dialog opened or closed (Escape, backdrop click, a driven `open`, or a method). */
     onOpenChange?: (event: CustomEvent<{
         open: boolean;
     }>) => void;
 }
 export declare const Dialog: import('react').ForwardRefExoticComponent<DialogProps & import('react').RefAttributes<HTMLElement>>;
+export interface DockProps extends WebComponentProps {
+    /** Drive/observe open state (Shoelace-style: settable + reflected to the `open` attribute; the element still self-manages on the launcher and Escape). Set `el.open = true`, or `<kai-dock open>`; listen for `kai-open-change`. */
+    open?: boolean;
+    /** Initial open state on mount (uncontrolled seed). */
+    defaultOpen?: boolean;
+    /** Which corner the dock sits in. Logical, so `-end` follows the writing direction and an RTL page docks on the left. Attribute: `position`. */
+    position?: "bottom-end" | "bottom-start" | "top-end" | "top-start";
+    /** The widget's NAME. Derives the panel's accessible name and both launcher names (`Open ${label}` / `Close ${label}`). Defaults to `Chat`. */
+    label?: string;
+    /** i18n override for the launcher's name while closed (default `Open ${label}`). */
+    openLabel?: string;
+    /** i18n override for the launcher's name while open (default `Close ${label}`). */
+    closeLabel?: string;
+    /** Show the unread dot. YOURS: it renders only while closed, and the dock never writes it back. Clear it in your `kai-open-change` handler. */
+    unread?: boolean;
+    /** Disable the launcher; `show()` and `toggle()` are gated on it. */
+    disabled?: boolean;
+    /** Suppress the dock's own built-in mobile close X. Set this when your slotted panel content supplies its own close affordance (e.g. a `<kai-chat slot="header-end">` close button), otherwise the two stack. TRADEOFF: the mobile panel reserves a padding band above its content so the built-in X never paints over slotted content; that band stays reserved unless you set this true, so only set it once your own control is actually in place. Attribute: `hide-close`. */
+    hideClose?: boolean;
+    /** Where focus lands on open: `content` (default, the first element you slotted), `panel`, or `none`. Attribute: `focus-on-open`. */
+    focusOnOpen?: "content" | "panel" | "none";
+    /** The dock opened or closed (the launcher, Escape, a driven `open`, or a method). */
+    onOpenChange?: (event: CustomEvent<{
+        open: boolean;
+    }>) => void;
+}
+export declare const Dock: import('react').ForwardRefExoticComponent<DockProps & import('react').RefAttributes<HTMLElement>>;
+export interface DropdownProps extends WebComponentProps {
+    /** Built-in trigger: leading icon (a named icon like `"plus"`, an image URL/data-URI, or text). A slotted `slot="trigger"` overrides it. */
+    triggerIcon?: string;
+    /** Built-in trigger: a text label. This is the trigger's VISIBLE text, so it is also its accessible name, and `label` does not override it: an accessible name that does not contain the visible text is unreachable by speech input (WCAG 2.5.3, Label in Name). Same rule `kai-menu` follows. */
+    triggerLabel?: string;
+    /** Built-in trigger: a trailing icon (e.g. `"chevron-down"` for a select look). */
+    triggerIconTrailing?: string;
+    /** Accessible name for a trigger with no visible label. Ignored when `triggerLabel` is set, which is already the visible name. It DOES name a slotted `slot="trigger"`, which is VISUAL content with the name supplied separately: the same two-slot distinction `kai-menu` documents. */
+    label?: string;
+    /** Stretch the trigger to the full width of its container (a block row). Attribute: `full`. */
+    full?: boolean;
+    /** Drive/observe open state (Shoelace-style: settable + reflected to the `open` attribute, the menu still self-manages on click/keyboard). Set `el.open = true`, or `<kai-dropdown open>`; listen for `kai-open-change`. */
+    open?: boolean;
+    /** Initial open state on mount (uncontrolled seed). */
+    defaultOpen?: boolean;
+    /** Disable the trigger: click/keyboard and `show()` no longer open the menu. */
+    disabled?: boolean;
+    /** The menu opened or closed (click, keyboard, Escape, outside-click, or a method). */
+    onOpenChange?: (event: CustomEvent<{
+        open: boolean;
+    }>) => void;
+}
+export declare const Dropdown: import('react').ForwardRefExoticComponent<DropdownProps & import('react').RefAttributes<HTMLElement>>;
 export interface EditableLabelProps extends WebComponentProps {
     /** The label text. Settable and reflected to the `value` attribute. Read `el.value` for live state. */
     value?: string;
@@ -1120,6 +1243,9 @@ export interface FormProps extends WebComponentProps {
             "x-kai-widget"?: "textarea" | "slider" | "rating" | "radio" | "select" | "checkbox" | "password" | "switch";
             "x-kai-placeholder"?: string;
             "x-kai-step"?: number;
+            "x-kai-format"?: "tel" | "ssn" | "credit-card" | "custom";
+            "x-kai-mask"?: string;
+            "x-kai-mask-guide"?: string;
         }>;
         "x-kai-order"?: string[];
         "x-kai-inlineMax"?: number;
@@ -1190,7 +1316,7 @@ export declare const Image: import('react').ForwardRefExoticComponent<ImageProps
 export interface InputProps extends WebComponentProps {
     /** Native input type: `text` (default) · `email` · `url` · `search` · `tel` · `password` · `number`. Single-line only. */
     type?: string;
-    /** Controlled value. Settable and reflected to the `value` attribute. `el.value = 'hi'` drives it (no event); typing updates it and fires `kai-input`. Read `el.value` for live state. */
+    /** Controlled value, and always the CANONICAL one when a mask is active: digits for `tel` / `ssn` / `credit-card`, the formatted text for `custom`. Settable and reflected to the `value` attribute. `el.value = '5551234567'` drives it (no event) and is re-fitted to the mask on the way in, so the field shows `555-123-4567`. Read `el.value` for live state; the formatted text rides along on every `kai-input` / `kai-change` detail as `formattedValue`. */
     value?: string;
     /** Placeholder shown when empty. */
     placeholder?: string;
@@ -1216,13 +1342,30 @@ export interface InputProps extends WebComponentProps {
     autocomplete?: string;
     /** Virtual-keyboard hint forwarded to the inner input (e.g. `numeric`, `email`). */
     inputmode?: string;
-    /** The value was committed (blur). */
+    /** Mask pattern: `#` a digit, `@` a letter or digit, `*` an obscurable letter or digit, and every other character a positional literal (`@@@-####` → `CHG-4821`). The literal `default` is the opt-in sentinel: it resolves to the default format of `semantic` (`tel` → `###-###-####`). A bare `semantic` never starts masking on its own, so an opt-in token is what turns tier 2 on. */
+    format?: string;
+    /** Placeholder guide shown at unfilled positions, aligned position for position with `format`: `mm/dd/yyyy` against `##/##/####`. Spaces are a valid guide character, so a guide of blanks and separators is how a phone field shows its shape without showing letters. Without a guide the field shows only up to the last typed character. A guide is a visual aid, never an accessible name: keep the `hint` text as well. */
+    guide?: string;
+    /** Semantic field type: `tel` · `ssn` · `credit-card` · `custom`. On its own it sets `inputmode` / `autocomplete` / `spellcheck` / `autocorrect` / `autocapitalize` and decides the canonical value; it never starts masking by itself. */
+    semantic?: "credit-card" | "custom" | "ssn" | "tel";
+    /** Case folding applied to typed and pasted text: `preserve` (default) · `upper` · `lower`. Attribute: `case-mode`. */
+    caseMode?: "preserve" | "upper" | "lower";
+    /** What a copy or cut of a masked field puts on the clipboard: `canonical` (default) · `formatted` · `obscured` · `blocked`. Attribute: `copy-policy`. */
+    copyPolicy?: "formatted" | "canonical" | "obscured" | "blocked";
+    /** The value was committed (blur). Same detail shape as `kai-input`. */
     onChange?: (event: CustomEvent<{
         value: string;
+        formattedValue: string;
     }>) => void;
-    /** The value changed per keystroke. */
+    /** The value changed per keystroke. `value` is the canonical value (what a backend wants); `formattedValue` is the text on screen. With no mask the two are equal. */
     onInput?: (event: CustomEvent<{
         value: string;
+        formattedValue: string;
+    }>) => void;
+    /** A mask refused, or partly refused, some content. The reasons are `full` (no free position left), `wrong-class` (a letter into a digit position), `over-capacity` (a paste longer than the mask holds; what fits was kept), and `format-change-clipped` (the `format` changed under a value that no longer fits). `data` is the content that was refused. The first three are USER-INPUT errors, and are the ones worth announcing in a polite live region. `format-change-clipped` is not one: it follows the app changing its own configuration, so it reports and nothing more. None of the four touches validity, so `invalid` and `error` stay the consumer decision. */
+    onInputRejected?: (event: CustomEvent<{
+        reason: "full" | "wrong-class" | "over-capacity" | "format-change-clipped";
+        data: string;
     }>) => void;
 }
 export declare const Input: import('react').ForwardRefExoticComponent<InputProps & import('react').RefAttributes<HTMLElement>>;
@@ -1295,6 +1438,8 @@ export interface MenuProps extends WebComponentProps {
     triggerIconTrailing?: string;
     /** Accessible name for a trigger with no visible label. Ignored when `triggerLabel` is set, which is already the visible name. It DOES name a slotted `slot="trigger"`, and that is a difference in what the two slots MEAN, not a limitation. `<kai-button>`'s slot IS the button's label, so text slotted there is the name and `label` steps aside. This slot is VISUAL content, a `+` or an `<svg>`, with the name supplied separately: decoration beside a name, never a second name competing with one. So `label` names the trigger here by design. Slotting a real WORD rather than a glyph makes that word a visible label, and an accessible name has to contain the visible text. Then either drop `label` or make it contain the word you slotted. */
     label?: string;
+    /** Stretch the trigger to the full width of the menu's container (a block row), e.g. a sidebar-footer account row. Same affordance as `<kai-button full>`. Attribute: `full`. */
+    full?: boolean;
     /** Drive/observe open state (Shoelace-style: settable + reflected to the `open` attribute, the menu still self-manages on click/keyboard). Set `el.open = true`, or `<kai-menu open>`; listen for `kai-open-change`. */
     open?: boolean;
     /** Initial open state on mount (uncontrolled seed). */
@@ -1571,6 +1716,19 @@ export interface PaneProps extends WebComponentProps {
     onSplit?: (event: CustomEvent) => void;
 }
 export declare const Pane: import('react').ForwardRefExoticComponent<PaneProps & import('react').RefAttributes<HTMLElement>>;
+export interface PaneGridProps extends WebComponentProps {
+    /** Minimum width of every pane, in px, before columns drop / the grid scrolls. Defaults to `280`. Attribute: `min-pane-width`. */
+    minPaneWidth?: number;
+    /** Minimum height of every pane, in px, before the grid scrolls vertically. Defaults to `200`. Attribute: `min-pane-height`. */
+    minPaneHeight?: number;
+    /** Column cap when the container is wide (default `3`). Attribute: `max-columns`. */
+    maxColumns?: number;
+    /** Gap between panes, any CSS length. Defaults to the kit gap (`var(--kai-pane-grid-gap, 0.5rem)`). Attribute: `gap`. */
+    gap?: string;
+    /** When set to a valid child index, render ONLY that pane full-bleed: a simple maximize hook the consumer drives (pair it with `<kai-pane>`'s `kai-maximize` event). Clear it (or point out of range) for the full tiled grid. Attribute: `maximized-index`. */
+    maximizedIndex?: number | null;
+}
+export declare const PaneGrid: import('react').ForwardRefExoticComponent<PaneGridProps & import('react').RefAttributes<HTMLElement>>;
 export interface PaneGroupProps extends WebComponentProps {
     /** The tabs to render. An array of `{ id, name, status?, needsAttention?, number? }` set as a JS PROPERTY (not an HTML attribute). */
     tabs?: {
@@ -1663,8 +1821,8 @@ export interface PromptInputProps extends WebComponentProps {
     suggestions?: string[];
     /** What clicking a suggestion does: `'submit'` (default) sends it immediately as if typed and submitted; `'fill'` just places it in the input. */
     suggestionMode?: "submit" | "fill";
-    /** Show a Search (Globe) button in the left toolbar; clicking it fires a `search` event. */
-    search?: boolean;
+    /** Show a web-search (Globe) button in the left toolbar; clicking it fires a `kai-web-search` event. Attribute: `web-search`. */
+    webSearch?: boolean;
     /** Show a Voice (Mic) button in the left toolbar; clicking it fires a `voice` event. */
     voice?: boolean;
     /** When set and `loading` is true, the send button is replaced by a Stop button (square icon, "Stop" aria-label). Clicking it fires `kai-stop`. */
@@ -1673,7 +1831,7 @@ export interface PromptInputProps extends WebComponentProps {
     submit?: "always" | "auto";
     /** When `false`, hides the built-in paperclip attach button even though the element otherwise supports attachments. Use this when a `+` menu in `toolbar-start` already exposes "Add files", to avoid a duplicate control. Defaults to `true`. */
     attach?: boolean;
-    /** Attachments to seed the input with (so a consumer can pre-populate staged files without an upload). Set as a JS property; the element then manages its own attachment state from there (add via the paperclip, remove per chip). */
+    /** Attachments to seed the input with (so a consumer can pre-populate staged files without an upload). Set as a JS property; the element then manages its own attachment state from there (add via the paperclip, remove per chip). Each item's `url` must be a `data:` URI or an https URL, never `URL.createObjectURL`: a `blob:` URL previews perfectly and is meaningless outside this tab, so `toOpenAIMessages`/`toAnthropicMessages` refuse it. (The built-in paperclip already stages files as `data:` URIs.) */
     attachments?: {
         id: string;
         type: "file" | "source-document";
@@ -1710,11 +1868,9 @@ export interface PromptInputProps extends WebComponentProps {
             title?: undefined | string;
         }[];
     }>) => void;
-    /** The Search (Globe) toolbar button was clicked. */
-    onSearch?: (event: CustomEvent<Record<string, never>>) => void;
     /** The Stop button was clicked while `stoppable` and `loading` are both true. */
     onStop?: (event: CustomEvent<Record<string, never>>) => void;
-    /** The user submitted the prompt (Enter or send button). `value` is the flattened text (back-compat); `doc` is the structured document and `entities` the inserted pills (skills/agents) for downstream expansion. */
+    /** The user submitted the prompt (Enter or send button). `value` is the flattened text (back-compat); `doc` is the structured document and `entities` the inserted pills (skills/agents) for downstream expansion. `<kai-prompt-input>` is the batteries-included composer row (send button, toolbar, attachment staging) built on `<kai-composer>`, the bare editor. */
     onSubmit?: (event: CustomEvent<{
         value: string;
         doc: ({
@@ -1784,8 +1940,32 @@ export interface PromptInputProps extends WebComponentProps {
     }>) => void;
     /** The Voice (Mic) toolbar button was clicked. */
     onVoice?: (event: CustomEvent<Record<string, never>>) => void;
+    /** The web-search (Globe) toolbar button was clicked. */
+    onWebSearch?: (event: CustomEvent<Record<string, never>>) => void;
 }
 export declare const PromptInput: import('react').ForwardRefExoticComponent<PromptInputProps & import('react').RefAttributes<HTMLElement>>;
+export interface RadioGroupProps extends WebComponentProps {
+    /** The choices, top to bottom. Set as a JS PROPERTY (array), never an attribute. */
+    options: {
+        value: string;
+        label: string;
+        description?: undefined | string;
+        disabled?: undefined | boolean;
+    }[];
+    /** Controlled selected `value`. Settable and reflected to the `value` attribute. `el.value = 'degraded'` drives it; choosing a row updates it and fires `kai-change`. Read `el.value` for live state. */
+    value?: string;
+    /** Shared form-control name for every radio in the group. Defaults to a generated id, so the group is exclusive and keyboard-navigable even when nothing is submitted. */
+    name?: string;
+    /** Disable every row. Individual rows carry their own `disabled`. */
+    disabled?: boolean;
+    /** Accessible name for the group. */
+    label?: string;
+    /** A row was chosen. */
+    onChange?: (event: CustomEvent<{
+        value: string;
+    }>) => void;
+}
+export declare const RadioGroup: import('react').ForwardRefExoticComponent<RadioGroupProps & import('react').RefAttributes<HTMLElement>>;
 export interface ReasoningProps extends WebComponentProps {
     /** The reasoning text to display. */
     text: string;
@@ -1933,6 +2113,10 @@ export interface ScrollButtonProps extends WebComponentProps {
     variant?: "outline" | "ghost" | "default";
     /** Button size token. Defaults to `'icon'` (square). */
     size?: "sm" | "md" | "lg" | "icon" | "icon-sm";
+    /** The button's accessible name. It is announced whether or not the label is visible, so the text is always localisable. Defaults to `'Scroll to bottom'`. */
+    label?: string;
+    /** Also render `label` visibly beside the icon. Defaults to `false`, which is the icon-only button. When the text is visible it IS the accessible name, so nothing gets announced twice. */
+    showLabel?: boolean;
     /** Emitted when the user clicks the button and `scrollToBottom()` is called. Carries no detail; consumers use it to know a manual scroll occurred. */
     onScroll?: (event: CustomEvent) => void;
 }
@@ -1981,6 +2165,36 @@ export interface SegmentedProps extends WebComponentProps {
     }>) => void;
 }
 export declare const Segmented: import('react').ForwardRefExoticComponent<SegmentedProps & import('react').RefAttributes<HTMLElement>>;
+export interface SelectProps extends WebComponentProps {
+    /** The choices, in display order. Set as a JS PROPERTY (array), never an attribute. Rendered in full: the kit never truncates, re-orders or de-duplicates them. */
+    options: {
+        value: string;
+        label?: undefined | string;
+        disabled?: undefined | boolean;
+    }[];
+    /** Controlled selected value. Settable and reflected to the `value` attribute. `el.value = 'high'` drives it; choosing an option updates it and fires `kai-change`. Read `el.value` for live state; for a `multiple` select read `el.values` instead. */
+    value?: string;
+    /** Text for a leading, disabled, empty option: the "nothing chosen yet" row. Omitted means no such row at all; there is no default wording, because inventing one would put words in your UI. */
+    placeholder?: string;
+    /** Allow more than one selection. Turns the control into the platform's list box, so the kit's chevron is not drawn. */
+    multiple?: boolean;
+    /** Force the invalid (destructive-border) state. */
+    invalid?: boolean;
+    /** Disable interaction. */
+    disabled?: boolean;
+    /** Set the native `required` attribute, and nothing more. Whether an empty select is an error is the application's rule, not the kit's. */
+    required?: boolean;
+    /** Accessible label for the control. */
+    label?: string;
+    /** Form-control name, for a native form submit. */
+    name?: string;
+    /** A choice was made. `value` is the first selected option (empty when nothing is selected); `values` is every selected option, which is what a `multiple` select needs. Both are always present, so neither shape silently loses the other. */
+    onChange?: (event: CustomEvent<{
+        value: string;
+        values: string[];
+    }>) => void;
+}
+export declare const Select: import('react').ForwardRefExoticComponent<SelectProps & import('react').RefAttributes<HTMLElement>>;
 export interface SeparatorProps extends WebComponentProps {
     /** `horizontal` (default, block + full-width) or `vertical` (a rule inside a flex/grid row, stretching to the row height). */
     orientation?: "horizontal" | "vertical";
@@ -2019,6 +2233,33 @@ export interface SkillsProps extends WebComponentProps {
     }[];
 }
 export declare const Skills: import('react').ForwardRefExoticComponent<SkillsProps & import('react').RefAttributes<HTMLElement>>;
+export interface SliderProps extends WebComponentProps {
+    /** Lowest selectable value. Required: a range with no bounds is a guess, and the guess belongs to whoever knows what the number means. */
+    min?: number;
+    /** Highest selectable value. Required, for the same reason as `min`. */
+    max?: number;
+    /** Granularity. Omitted means the native default of 1; `any` means continuous. */
+    step?: number | "any";
+    /** Controlled value. Settable and reflected to the `value` attribute. `el.value = 40` drives it; dragging updates it and fires `kai-input` per step, `kai-change` on release. Read `el.value` for live state. */
+    value?: number;
+    /** Disable interaction. */
+    disabled?: boolean;
+    /** Accessible label for the slider. */
+    label?: string;
+    /** Form-control name, for a native form submit. */
+    name?: string;
+    /** Show the current value beside the track. Off by default. Two ways in, because one of them is not a scalar. As a bare ATTRIBUTE (`<kai-slider value-label>`) it renders the raw number. As a JS PROPERTY it also accepts a formatter function (`el.valueLabel = (v) => v + '%'`), for a slider that is not counting bare numbers. A function cannot survive an attribute, so that half is property-only. The readout is hidden from assistive tech: the slider already reports the same number, and an exposed copy would be announced twice. */
+    valueLabel?: boolean | ((value: number) => string);
+    /** The value was committed: pointer released, or a key press finished. */
+    onChange?: (event: CustomEvent<{
+        value: number;
+    }>) => void;
+    /** The thumb moved. Fires per step during a drag or a key press. */
+    onInput?: (event: CustomEvent<{
+        value: number;
+    }>) => void;
+}
+export declare const Slider: import('react').ForwardRefExoticComponent<SliderProps & import('react').RefAttributes<HTMLElement>>;
 export interface SourceProps extends WebComponentProps {
     /** The URL this citation links to (the domain also seeds the default label/favicon). */
     href?: string;
@@ -2325,7 +2566,7 @@ export interface ThreadProps extends WebComponentProps {
 }
 export declare const Thread: import('react').ForwardRefExoticComponent<ThreadProps & import('react').RefAttributes<HTMLElement>>;
 export interface ToastRegionProps extends WebComponentProps {
-    /** The toasts to render. Newest is shown on top. Set as a JS property (array); pass a new array reference to update. Omit for an empty region, which is the normal resting state and how the imperative `toast()` API starts. */
+    /** The toasts to render. Newest is shown on top. Set as a JS property (array); pass a new array reference to update. Omit for an empty region, which is the normal resting state and how the imperative `toast()` API starts. Note the handover: the first `toast()` call ADOPTS a region you placed in markup (no second region mounts) and binds the imperative store to this property, replacing any array you set. Drive a region as data OR via `toast()`, not both at once. */
     toasts?: {
         id: string;
         message: string;
@@ -2439,6 +2680,12 @@ export interface VoiceInputProps extends WebComponentProps {
     onTranscription?: (event: CustomEvent<{
         text: string;
     }>) => void;
+    /** A voice session failed, so no failure is ever silent. `detail.source` names the failing side (`recognition` on `<kai-voice-input>`, `synthesis` on `<kai-voice-output>`), `detail.error` carries the platform error code, the thrown exception's name, or `no-result` when recognition ended with no error and no text (the user said nothing), and `detail.message` is human-readable. Deliberate cancellation does not fire. */
+    onVoiceError?: (event: CustomEvent<{
+        source: "recognition";
+        error: string;
+        message: string;
+    }>) => void;
 }
 export declare const VoiceInput: import('react').ForwardRefExoticComponent<VoiceInputProps & import('react').RefAttributes<HTMLElement>>;
 export interface VoiceOutputProps extends WebComponentProps {
@@ -2450,7 +2697,7 @@ export interface VoiceOutputProps extends WebComponentProps {
     synthesize?: (text: string) => Promise<Blob>;
     /** Disable the button (non-interactive). */
     disabled?: boolean;
-    /** Playback started or stopped. Drive your own UI in sync. Fires on real transitions only (manual click and programmatic speak()/stop()), never on mount. */
+    /** Playback started or stopped. Drive your own UI in sync. `speaking: true` fires when audio actually starts (utterance.onstart natively; audio playback beginning on the `synthesize` path), not when speak() is called; earlier releases fired it optimistically inside speak() itself. Fires on real transitions only (manual click and programmatic speak()/stop()), never on mount. */
     onSpeakingChange?: (event: CustomEvent<{
         speaking: boolean;
     }>) => void;
@@ -2458,262 +2705,38 @@ export interface VoiceOutputProps extends WebComponentProps {
     onSynthesized?: (event: CustomEvent<{
         blob: Blob;
     }>) => void;
+    /** A voice session failed, so no failure is ever silent. `detail.source` names the failing side (`recognition` on `<kai-voice-input>`, `synthesis` on `<kai-voice-output>`), `detail.error` carries the platform error code, the thrown exception's name, or `no-result` when recognition ended with no error and no text (the user said nothing), and `detail.message` is human-readable. Deliberate cancellation does not fire. */
+    onVoiceError?: (event: CustomEvent<{
+        source: "synthesis";
+        error: string;
+        message: string;
+    }>) => void;
 }
 export declare const VoiceOutput: import('react').ForwardRefExoticComponent<VoiceOutputProps & import('react').RefAttributes<HTMLElement>>;
 export interface WorkspaceProps extends WebComponentProps {
-    /** The sidebar's section headers, rendered in array order. A group carries no conversations of its own; it is matched against `conversations` by id, so the two props are complementary rather than alternatives. Omit for an ungrouped sidebar. Set as a JS property. */
-    groups?: {
-        id: string;
-        userId?: string;
-        teamId?: string;
-        name: string;
-        sortOrder: number;
-        createdAt: string;
-    }[];
-    /** Every conversation in the sidebar, flat. Each one is filed under the group whose `id` equals its `groupId`; one with no `groupId`, or with a `groupId` matching no entry in `groups`, falls into a trailing ungrouped section (headerless when `compact`), so nothing you pass in is ever dropped. There is no recency bucketing. Set as a JS property. Omit for an empty sidebar, or when `no-conversations` replaces the built-in list with your own `sidebar-header` content. */
-    conversations?: {
-        id: string;
-        title: string;
-        groupId?: string;
-        scope: {
-            type: "document" | "collection";
-            documentId?: string;
-            filters?: {
-                tags?: string[];
-                authors?: string[];
-                contentType?: "transcript" | "markdown";
-                dateRange?: {
-                    from: string;
-                    to: string;
-                };
-            };
-        };
-        messageCount: number;
-        lastMessageAt: string;
-        updatedAt: string;
-        trailing?: string;
-    }[];
-    /** Id of the open conversation, highlighted in the sidebar. */
-    activeId?: string;
-    /** The active conversation's message thread, newest last. Set as a JS property (`el.messages = [...]`); a NEW array reference per streaming chunk re-renders (mutating in place does not). Omit for an empty thread. */
-    messages?: {
-        id: string;
-        role: "user" | "assistant";
-        parts: ({
-            type: "text";
-            text: string;
-            raw?: {
-                source: string;
-                payload: unknown;
-            };
-        } | {
-            type: "reasoning";
-            text: string;
-            label?: string;
-            index?: number;
-            streamId?: string;
-            signature?: string;
-            raw?: {
-                source: string;
-                payload: unknown;
-            };
-        } | {
-            type: "tool";
-            tool: {
-                type: string;
-                kind?: "command" | "file-change" | "search" | "fetch" | "mcp" | "image" | "generic";
-                state: "input-streaming" | "input-available" | "output-available" | "output-error";
-                input?: Record<string, unknown>;
-                rawInput?: string;
-                output?: Record<string, unknown>;
-                toolCallId?: string;
-                errorText?: string;
-                raw?: {
-                    source: string;
-                    payload: unknown;
-                };
-            };
-            raw?: {
-                source: string;
-                payload: unknown;
-            };
-        } | {
-            type: "card";
-            envelope: {
-                type: string;
-                id: string;
-                data: unknown;
-                title?: string;
-                resolution?: {
-                    kind: "action";
-                    action: string;
-                    payload?: unknown;
-                    at?: string;
-                } | {
-                    kind: "submit";
-                    data: unknown;
-                    at?: string;
-                } | {
-                    kind: "dismissed";
-                    at?: string;
-                } | {
-                    kind: "expired";
-                    reason?: string;
-                    at?: string;
-                };
-            };
-            raw?: {
-                source: string;
-                payload: unknown;
-            };
-        } | {
-            type: "source";
-            source: {
-                id?: string;
-                url?: string;
-                title?: string;
-                snippet?: string;
-                index?: number;
-            };
-            raw?: {
-                source: string;
-                payload: unknown;
-            };
-        } | {
-            type: "file";
-            attachment: {
-                id: string;
-                type: "file" | "source-document";
-                filename?: string;
-                mediaType?: string;
-                url?: string;
-                title?: string;
-            };
-            raw?: {
-                source: string;
-                payload: unknown;
-            };
-        })[];
-        actions?: ("copy" | "like" | "dislike" | "regenerate" | "edit" | {
-            id: string;
-            label: string;
-            icon?: string;
-            tooltip?: string;
-        })[];
-        avatar?: {
-            src?: string;
-            fallback?: string;
-            alt?: string;
-        };
-        feedback?: "like" | "dislike";
-    }[];
-    value?: string;
-    placeholder?: string;
-    loading?: boolean;
-    suggestions?: string[];
-    suggestionMode?: "submit" | "fill";
-    proseSize?: "xs" | "sm" | "base" | "lg";
-    codeTheme?: string;
-    codeHighlight?: boolean;
-    chatTitle?: string;
-    models?: {
-        id: string;
-        name: string;
-        provider?: string;
-        description?: string;
-        group?: string;
-    }[];
-    currentModel?: string;
-    context?: {
-        usedTokens: number;
-        maxTokens: number;
-        inputTokens?: number;
-        outputTokens?: number;
-        estimatedCost?: number;
-    };
-    scrollButton?: boolean;
-    search?: boolean;
-    voice?: boolean;
-    /** Rich entity triggers (`/` skills, `@` agents/plugins) forwarded to the input. */
-    triggers?: {
-        char: string;
-        kind: string;
-        items?: {
-            id: string;
-            label: string;
-            icon?: string;
-            description?: string;
-            group?: string;
-            kind?: string;
-            promptText?: string;
-            data?: Record<string, unknown>;
-        }[];
-    }[];
-    /** Default icon per entity kind (kind → image src) forwarded to the input. */
-    kindIcons?: Record<string, string>;
-    /** Sidebar default width as a percent of the workspace (default 26). */
-    sidebarWidth?: number;
-    /** Sidebar min width in px (default 240). */
-    sidebarMinWidth?: number;
-    /** Sidebar max width in px (default 420). */
-    sidebarMaxWidth?: number;
-    /** Controlled collapsed state. Set this as a JS property (`el.sidebarCollapsed = true`) to drive the sidebar from your app, updating it in response to the `kai-sidebar-toggle` event. Omit for uncontrolled (the element manages it). */
-    sidebarCollapsed?: boolean;
-    /** Initial collapsed state when uncontrolled (default false). Use the `default-sidebar-collapsed` attribute to start collapsed in plain HTML. */
-    defaultSidebarCollapsed?: boolean;
-    /** Auto-collapse the rail when the workspace's own width drops below this many px, and re-expand when it grows back above. Uncontrolled only (it never fights an app-driven `sidebarCollapsed`); omit to disable. Fires `kai-sidebar-toggle`. Attribute: `collapse-below`. */
+    /** Controlled collapsed state of the start aside. Set this as a JS property (`el.startCollapsed = true`) to drive the aside from your app, updating it in response to the `kai-aside-toggle` event. Omit for uncontrolled (the element manages it). */
+    startCollapsed?: boolean;
+    /** Initial collapsed state of the start aside when uncontrolled (default false). Use the `default-start-collapsed` attribute to start collapsed in plain HTML. */
+    defaultStartCollapsed?: boolean;
+    /** Controlled collapsed state of the end aside. Set this as a JS property (`el.endCollapsed = true`) to drive the aside from your app, updating it in response to the `kai-aside-toggle` event. Omit for uncontrolled (the element manages it). */
+    endCollapsed?: boolean;
+    /** Initial collapsed state of the end aside when uncontrolled (default false). Use the `default-end-collapsed` attribute to start collapsed in plain HTML. */
+    defaultEndCollapsed?: boolean;
+    /** Auto-collapse both asides when the shell's own width drops below this many px, and re-expand when it grows back above. Applies to uncontrolled asides only (it never fights an app-driven collapsed prop); omit to disable. Fires `kai-aside-toggle`. Attribute: `collapse-below`. */
     collapseBelow?: number;
-    /** Render Recents as dense single-line rows (a leading dot + title, no count). */
+    /** Below this shell width in px, an expanded aside renders as an overlay drawer over the main region instead of a column beside it. Escape inside the drawer closes it and returns focus to the element focused before it opened. Omit to disable. Attribute: `drawer-below`. */
+    drawerBelow?: number;
+    /** Density hint. Reflected as a `data-compact` hook on the root (and as the `compact` attribute on the element) for your CSS and slotted content; the shell itself keeps no other opinion about density. */
     compact?: boolean;
-    /** Suppress the built-in ConversationList so the `sidebar-header` slot owns the whole rail flex region (for apps that supply their own rail nav). Default false. Attribute: `no-conversations`. */
-    noConversations?: boolean;
-    /** Optional card type -> custom-element tag overrides/additions for `card` parts (merged over the built-ins). Property: `el.cardTypes`. Typed as a plain string map (not the `CardTagMap` alias) so the generated React wrapper inlines it instead of emitting an unresolved named type. */
-    cardTypes?: Record<string, string>;
-    /** JSON Schemas for the card types this app renders, keyed by envelope type. The companion of `cardTypes`, which says what DRAWS a card while this says what a VALID one looks like. An OBJECT, so it is a JS property only: `el.cardSchemas = { 'pricing-table': pricingSchema }`, never an attribute. `createCardRegistry(...).validationSchemas` is exactly this shape. Without it the kit validates its own seven built-ins and leaves your own card type, the one your app actually cares about, as the only unchecked thing on screen. A schema here WINS over a built-in of the same name. Typed `Record<string, object>` rather than `Record<string, JsonSchema>` deliberately: an imported `.json` schema widens `"type"` to `string`, and an authored one carries `$schema`/`title`/`description`/`additionalProperties`, so the tighter type would reject both of the normal ways to supply one. */
-    cardSchemas?: Record<string, object>;
-    /** A conversation was selected in the sidebar. */
-    onConversationSelect?: (event: CustomEvent<{
-        id: string;
-    }>) => void;
-    /** An action button on a message was clicked. `state` is present only for the toggleable feedback votes: `'on'` when a like/dislike is set, `'off'` when re-tapped to clear. */
-    onMessageAction?: (event: CustomEvent<{
-        messageId: string;
-        action: string;
-        state?: undefined | "on" | "off";
-    }>) => void;
-    /** The header model switcher changed. */
-    onModelChange?: (event: CustomEvent<{
-        modelId: string;
-    }>) => void;
-    /** The "New chat" button was clicked. */
-    onNewChat?: (event: CustomEvent<Record<string, never>>) => void;
-    /** The Search button was clicked. */
-    onSearch?: (event: CustomEvent<Record<string, never>>) => void;
-    /** The sidebar was collapsed or expanded. */
-    onSidebarToggle?: (event: CustomEvent<{
+    /** The aside was resized (fires per drag step, keyboard nudge, or a handle double-click reset), width in px. */
+    onAsideResize?: (event: CustomEvent<{
+        side: "start" | "end";
+        width: number;
+    }>) => void;
+    /** An aside collapsed or expanded (a method, the breakpoint, the drawer's Escape). */
+    onAsideToggle?: (event: CustomEvent<{
+        side: "start" | "end";
         collapsed: boolean;
     }>) => void;
-    /** User submitted a message. */
-    onSubmit?: (event: CustomEvent<{
-        value: string;
-        attachments: {
-            id: string;
-            type: "file" | "source-document";
-            filename?: undefined | string;
-            mediaType?: undefined | string;
-            url?: undefined | string;
-            title?: undefined | string;
-        }[];
-    }>) => void;
-    /** A suggestion chip was clicked (only in `suggestion-mode="fill"`). */
-    onSuggestionClick?: (event: CustomEvent<{
-        value: string;
-    }>) => void;
-    /** Fired on every input change. */
-    onValueChange?: (event: CustomEvent<{
-        value: string;
-    }>) => void;
-    /** The Mic / voice button was clicked. */
-    onVoice?: (event: CustomEvent<Record<string, never>>) => void;
 }
 export declare const Workspace: import('react').ForwardRefExoticComponent<WorkspaceProps & import('react').RefAttributes<HTMLElement>>;