@djangocfg/ui-tools 2.1.381 → 2.1.382

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import react__default, { ReactNode, ComponentType, RefObject, ChangeEvent, KeyboardEvent, ClipboardEvent } from 'react';
+import react__default, { ReactNode, ComponentType, RefObject, ChangeEvent, KeyboardEvent, ClipboardEvent, CSSProperties, ButtonHTMLAttributes, MouseEvent } from 'react';
 import { Components } from 'react-markdown';
 import { ViewState } from 'react-map-gl/maplibre';
 import { Language } from 'prism-react-renderer';
@@ -13,12 +13,14 @@ export { CustomJsonSchema7, CustomJsonSchema7Type, CustomJsonUiDisabledWhenRule,
 import { CommonExternalProps } from 'react-json-tree';
 import { b as TreeRootProps } from './types-CevSbyfD.cjs';
 export { c as DEFAULT_TREE_APPEARANCE, D as DEFAULT_TREE_LABELS, F as FlatRow, R as ResolvedAppearance, m as TreeAccentIntensity, k as TreeAppearance, e as TreeContextMenuSlot, l as TreeDensity, f as TreeItemId, g as TreeLabels, j as TreeLoadChildren, T as TreeNode, n as TreeRadius, i as TreeRowRenderProps, a as TreeRowSlot, h as TreeSelectionMode, d as appearanceToStyle, r as resolveAppearance } from './types-CevSbyfD.cjs';
-import * as zustand_middleware from 'zustand/middleware';
 import * as zustand from 'zustand';
+import { AudioPrefsState } from '@djangocfg/ui-core/hooks';
 import { ConsolaInstance } from 'consola';
 import { MediaPlayerInstance } from '@vidstack/react';
 import * as monaco from 'monaco-editor';
+import { Editor as Editor$1 } from '@tiptap/react';
 export { ChildCache, ChildEntry, ChildEntryStatus, DemoNode, FlattenInput, PersistedTreeState, TreeRoot as Tree, TreeChevron, TreeChevronProps, TreeContent, TreeContentProps, TreeContextValue, TreeEmpty, TreeEmptyProps, TreeError, TreeErrorProps, TreeIcon, TreeIconProps, TreeIndentGuides, TreeIndentGuidesProps, TreeLabel, TreeLabelProps, TreeProvider, TreeProviderProps, TreeRoot, TreeRow, TreeRowProps, TreeSearchInput, TreeSearchInputProps, TreeSkeleton, TreeSkeletonProps, UseTreeKeyboardOptions, UseTreeTypeAheadOptions, clearTreeState, createChildCache, createDemoTree, flattenTree, loadTreeState, resolveChildren, saveTreeState, useTreeActions, useTreeContext, useTreeExpansion, useTreeFocus, useTreeKeyboard, useTreeLabels, useTreeRows, useTreeSearch, useTreeSelection, useTreeTypeAhead } from './tree/index.cjs';
+import * as zustand_middleware from 'zustand/middleware';
 
 interface LoadingFallbackProps {
     /** Minimum height of the loading container */
@@ -1418,12 +1420,36 @@ declare const LazyCronScheduler: react.ComponentType<CronSchedulerProps>;
 declare const LazyTree: react.ComponentType<TreeRootProps<unknown>>;
 
 /**
- * Public types for the Chat tool.
+ * Persona — display identity attached to messages and config.
  *
- * Shapes here are the contract between transport adapters, the reducer,
- * the hooks layer and the components. Keep serializable (no Date, no Map).
+ * Used by `ChatMessage.sender`, `ChatConfig.user`, `ChatConfig.assistant`.
  */
 type ChatRole = 'user' | 'assistant' | 'system';
+interface ChatPersona {
+    /** Display name. */
+    name?: string;
+    /** Avatar image URL. */
+    avatarUrl?: string;
+    /** Initials fallback when no avatar. Auto-derived from `name` if absent. */
+    initials?: string;
+    /** Tooltip / aria description. */
+    description?: string;
+}
+interface ChatUserContext extends ChatPersona {
+    email?: string;
+    language?: string;
+    role?: string;
+    /** Free-form custom data forwarded to transport metadata. */
+    custom?: Record<string, unknown>;
+}
+interface ChatAssistantContext extends ChatPersona {
+    /** Model identifier (gpt-4o, claude-opus, …). */
+    model?: string;
+}
+
+/**
+ * Tool calls — assistant-initiated function/tool invocations during a turn.
+ */
 interface ChatToolCall {
     id: string;
     name: string;
@@ -1437,6 +1463,10 @@ interface ChatToolCall {
     /** Optional grouping label for parallel/fan-out execution. */
     sourceHostname?: string;
 }
+
+/**
+ * Attachments + sources attached to a chat message.
+ */
 interface ChatAttachment {
     id: string;
     type: 'image' | 'file' | 'audio' | 'video';
@@ -1457,16 +1487,14 @@ interface ChatSource {
     snippet?: string;
     chunkIndex?: number;
 }
-interface ChatPersona {
-    /** Display name. */
-    name?: string;
-    /** Avatar image URL. */
-    avatarUrl?: string;
-    /** Initials fallback when no avatar. Auto-derived from `name` if absent. */
-    initials?: string;
-    /** Tooltip / aria description. */
-    description?: string;
-}
+
+/**
+ * The atomic unit — a single message in a chat session.
+ *
+ * Composed of role + content + optional rich-data slots (attachments,
+ * sources, tool calls). Serializable: no Date, no Map.
+ */
+
 interface ChatMessage {
     id: string;
     role: ChatRole;
@@ -1488,18 +1516,34 @@ interface ChatMessage {
     tokensIn?: number;
     tokensOut?: number;
 }
-type ChatDisplayMode = 'closed' | 'embedded' | 'floating' | 'sidebar' | 'fullscreen';
-interface ChatUserContext extends ChatPersona {
-    email?: string;
-    language?: string;
-    role?: string;
-    /** Free-form custom data forwarded to transport metadata. */
-    custom?: Record<string, unknown>;
-}
-interface ChatAssistantContext extends ChatPersona {
-    /** Model identifier (gpt-4o, claude-opus, …). */
-    model?: string;
+
+/**
+ * UI label strings — i18n is the host's job. Pass overrides via
+ * `ChatConfig.labels` and merge with `DEFAULT_LABELS`.
+ */
+interface ChatLabels {
+    send: string;
+    cancel: string;
+    copy: string;
+    regenerate: string;
+    edit: string;
+    delete: string;
+    retry: string;
+    newChat: string;
+    loadMore: string;
+    jumpToLatest: string;
+    attach: string;
+    voice: string;
+    errorGeneric: string;
+    cancelledSuffix: string;
 }
+declare const DEFAULT_LABELS: ChatLabels;
+
+/**
+ * Top-level chat configuration — placeholder, suggestions, identities, prefs.
+ */
+
+type ChatDisplayMode = 'closed' | 'embedded' | 'floating' | 'sidebar' | 'fullscreen';
 interface ChatPrefs {
     /** Submit hotkey for the composer. */
     submitOn?: 'enter' | 'cmd+enter';
@@ -1541,55 +1585,14 @@ interface ChatConfig {
     /** Visual labels (i18n is the host's job). */
     labels?: Partial<ChatLabels>;
 }
-interface ChatLabels {
-    send: string;
-    cancel: string;
-    copy: string;
-    regenerate: string;
-    edit: string;
-    delete: string;
-    retry: string;
-    newChat: string;
-    loadMore: string;
-    jumpToLatest: string;
-    attach: string;
-    voice: string;
-    errorGeneric: string;
-    cancelledSuffix: string;
-}
-declare const DEFAULT_LABELS: ChatLabels;
-interface CreateSessionOptions {
-    metadata?: Record<string, unknown>;
-}
-interface SessionInfo {
-    sessionId: string;
-    /** If the server resumed an existing session, it may return prior messages. */
-    messages?: ChatMessage[];
-    hasMore?: boolean;
-    cursor?: string | null;
-    resumed?: boolean;
-    /**
-     * Optional human-readable title (typically derived from the first
-     * user message). Hosts that render a session-list sidebar can read
-     * this directly instead of crawling messages. Plan64.
-     */
-    title?: string;
-}
-interface HistoryPage {
-    messages: ChatMessage[];
-    hasMore: boolean;
-    nextCursor: string | null;
-}
-interface StreamOptions {
-    signal: AbortSignal;
-    attachments?: ChatAttachment[];
-    metadata?: Record<string, unknown>;
-}
-interface SendOptions {
-    signal?: AbortSignal;
-    attachments?: ChatAttachment[];
-    metadata?: Record<string, unknown>;
-}
+
+/**
+ * SSE stream events — the canonical wire shape consumed by the reducer.
+ *
+ * Backend-specific shapes (e.g. pydantic-AI's `text_delta`) get normalized
+ * into this union by `mapPydanticAIEvent` and friends.
+ */
+
 type ChatStreamEvent = {
     type: 'message_start';
     messageId: string;
@@ -1628,6 +1631,51 @@ type ChatStreamEvent = {
     code: string;
     message: string;
 };
+
+/**
+ * Session info + history page shapes returned by transports.
+ */
+
+interface CreateSessionOptions {
+    metadata?: Record<string, unknown>;
+}
+interface SessionInfo {
+    sessionId: string;
+    /** If the server resumed an existing session, it may return prior messages. */
+    messages?: ChatMessage[];
+    hasMore?: boolean;
+    cursor?: string | null;
+    resumed?: boolean;
+    /**
+     * Optional human-readable title (typically derived from the first
+     * user message). Hosts that render a session-list sidebar can read
+     * this directly instead of crawling messages. Plan64.
+     */
+    title?: string;
+}
+interface HistoryPage {
+    messages: ChatMessage[];
+    hasMore: boolean;
+    nextCursor: string | null;
+}
+interface StreamOptions {
+    signal: AbortSignal;
+    attachments?: ChatAttachment[];
+    metadata?: Record<string, unknown>;
+}
+interface SendOptions {
+    signal?: AbortSignal;
+    attachments?: ChatAttachment[];
+    metadata?: Record<string, unknown>;
+}
+
+/**
+ * Transport interface — what every chat backend adapter implements.
+ *
+ * Default web implementation lives in `core/transport/http.ts`.
+ * Pydantic-AI adapter lives in `core/transport/pydantic-ai-transport.ts`.
+ */
+
 interface ChatTransport {
     createSession(opts?: CreateSessionOptions): Promise<SessionInfo>;
     loadHistory(sessionId: string, cursor?: string | null, limit?: number): Promise<HistoryPage>;
@@ -1644,6 +1692,19 @@ interface ChatAudioConfig {
     sounds?: ChatAudioSounds;
     /** Master volume 0..1. Persisted via the global prefs store. */
     volume?: number;
+    /**
+     * Per-event volume multipliers (0..1). Applied on top of `volume`.
+     * Defaults applied by `useChatAudio` if not provided:
+     *   - error: 0.25  (gentle — error UI is the loud signal, not the sound)
+     *   - mention: 1.0 (louder than baseline received)
+     *   - messageSent: 0.5  (subtle self-confirmation)
+     *   - messageReceived: 0.7
+     *   - streamStart: 0.3  (very subtle, fires often)
+     *   - notification: 0.9
+     *
+     * Pass `{}` to disable defaults; pass overrides to tweak.
+     */
+    eventVolumes?: Partial<Record<ChatAudioEvent, number>>;
     /** Master mute. */
     muted?: boolean;
     /** Custom predicate — return `false` to suppress a play call. */
@@ -1654,6 +1715,17 @@ interface ChatAudioConfig {
     respectReducedData?: boolean;
     /** Mute when host page is hidden (`visibilityState === 'hidden'`). Default: true. */
     muteWhenHidden?: boolean;
+    /**
+     * Skip web playback entirely — `play()` becomes a no-op. Pair with
+     * `onSoundEvent` for native hosts (cmdop_go / Tauri) that play sounds
+     * outside the browser.
+     */
+    silenced?: boolean;
+    /**
+     * Side-channel fired whenever `play(event)` is called. Stays active
+     * even when `silenced=true`. Use to bridge into a native audio backend.
+     */
+    onSoundEvent?: (event: ChatAudioEvent) => void;
 }
 interface UseChatAudioReturn {
     /** Play a sound for an event. No-ops if the event has no URL or is muted. */
@@ -1667,12 +1739,16 @@ interface UseChatAudioReturn {
     /** Master mute (persistent). */
     muted: boolean;
     setMuted: (m: boolean) => void;
+    /** Flip mute state — convenience. */
+    toggleMute: () => void;
     /** Master volume 0..1 (persistent). */
     volume: number;
     setVolume: (v: number) => void;
     /** Per-event opt-out (persistent). */
     isEventEnabled: (event: ChatAudioEvent) => boolean;
     setEventEnabled: (event: ChatAudioEvent, enabled: boolean) => void;
+    /** True when no sounds are configured (or `silenced`). */
+    isSilent: boolean;
 }
 
 /**
@@ -1774,6 +1850,14 @@ type ChatAction = {
 } | {
     type: 'MESSAGE_DELETE';
     id: string;
+} | {
+    type: 'MESSAGE_INJECT';
+    message: ChatMessage;
+    position?: 'append' | 'prepend';
+} | {
+    type: 'MESSAGE_PATCH';
+    id: string;
+    patch: Partial<ChatMessage>;
 } | {
     type: 'MESSAGES_CLEAR';
 } | {
@@ -1831,6 +1915,18 @@ interface UseChatReturn extends ChatState {
     loadMore: () => Promise<void>;
     newSession: () => Promise<void>;
     lastError: Error | null;
+    /**
+     * Inject a complete message from outside (push notification, admin
+     * takeover, system notice). De-duped by id. Position defaults to
+     * `append` — pass `prepend` for retroactive inserts.
+     */
+    injectMessage: (message: ChatMessage, position?: 'append' | 'prepend') => void;
+    /**
+     * Patch fields of an existing message in place (e.g. live-edit the
+     * admin's last reply, mark a message as resolved). No-op if the id
+     * doesn't exist.
+     */
+    updateMessage: (id: string, patch: Partial<ChatMessage>) => void;
 }
 declare function useChat(config: UseChatConfig): UseChatReturn;
 
@@ -1859,11 +1955,29 @@ interface UseChatLayoutReturn {
 }
 declare function useChatLayout(config?: UseChatLayoutConfig): UseChatLayoutReturn;
 
-/** Minimal handle a composer (built-in or custom) registers so other
- *  parts of the chat tree can drive it imperatively — `.focus()` is
- *  enough today; expand the surface as new needs arise. */
+/** Imperative handle a composer (built-in or custom) registers so
+ *  other parts of the chat tree can drive it without prop-drilling a
+ *  ref. `focus()` is the baseline; the rest is optional so non-textarea
+ *  hosts can keep returning `{ focus }` only.
+ *
+ *  Implemented by:
+ *   - built-in `<Composer>` — backed by `useChatComposer.textareaRef`.
+ *   - `@djangocfg/ui-tools/markdown-editor` — backed by the TipTap
+ *     editor (`editor.commands.focus('end')`).
+ *  Consumed by `VoiceComposerSlot` for the focus / move-caret behaviour
+ *  during live dictation.
+ */
 interface ComposerHandle {
     focus: () => void;
+    /** Move the caret to the very end of the input. */
+    moveCursorToEnd?: () => void;
+    /** Read the current draft text. Needed by voice dictation to anchor
+     *  partial transcripts onto the user's already-typed prefix. */
+    getValue?: () => string;
+    /** Replace the current draft text. Voice dictation uses this to push
+     *  interim + final transcripts into the composer without owning a
+     *  controlled binding. */
+    setValue?: (value: string) => void;
 }
 interface ChatContextValue extends UseChatReturn {
     layout: UseChatLayoutReturn;
@@ -2126,6 +2240,12 @@ interface ChatRootProps {
     listClassName?: string;
     /** Extra className forwarded to the `<Composer>` wrapper div. */
     composerClassName?: string;
+    /**
+     * Click in the message area → focus the composer (Slack / ChatGPT / Linear).
+     * Honours selection drag, interactive elements, and touch input.
+     * @default true
+     */
+    focusOnEmptyClick?: boolean;
 }
 declare function ChatRoot(props: ChatRootProps): react_jsx_runtime.JSX.Element;
 
@@ -2259,9 +2379,10 @@ interface RawEvent {
 }
 interface ParseSSEOptions {
     signal?: AbortSignal;
-    /** Map a raw SSE event to a ChatStreamEvent. Default: parse `data` as JSON
-     *  and assume the JSON shape already matches `ChatStreamEvent`. */
-    map?: (raw: RawEvent) => ChatStreamEvent | null;
+    /** Map a raw SSE event to zero, one, or many `ChatStreamEvent`s.
+     *  Default: parse `data` as JSON and assume the JSON shape already
+     *  matches `ChatStreamEvent`. */
+    map?: (raw: RawEvent) => ChatStreamEvent | ChatStreamEvent[] | null;
     idleTimeoutMs?: number;
 }
 declare function parseSSE(response: Response, options?: ParseSSEOptions): AsyncGenerator<ChatStreamEvent, void, void>;
@@ -2276,6 +2397,643 @@ declare class TransportError extends Error {
     constructor(message: string, code?: string);
 }
 
+/**
+ * Pydantic-AI SSE event mapper.
+ *
+ * Translates the event shape emitted by pydantic-AI–style Django backends
+ * (text_delta / tool_call / tool_result / done / error / approval_required)
+ * into the canonical `ChatStreamEvent` stream consumed by the Chat reducer.
+ *
+ * Backends that don't expose a stable `tool_call_id` are supported via a
+ * per-stream FIFO queue keyed by tool name. The earlier "Map<name, toolId>"
+ * approach lost the first toolId when a tool was invoked twice in one turn
+ * (e.g. `list_tasks` for search and again for confirmation) — using a queue
+ * keeps each call/result pair correctly matched.
+ */
+
+interface PydanticAIEvent {
+    type: 'text_delta' | 'tool_call' | 'tool_result' | 'done' | 'error' | 'approval_required';
+    delta?: string;
+    tool?: string;
+    args?: unknown;
+    result?: unknown;
+    /**
+     * Structured frontend payload — present on `tool_result` when the tool has
+     * a `result_schema`. The LLM sees only `result` (compact text); the
+     * frontend uses `data` to render rich UI (e.g. vehicle cards).
+     */
+    data?: unknown;
+    total_tokens?: number;
+    error?: string;
+    tool_call_id?: string;
+    session_id?: string;
+}
+/** Per-stream FIFO queue keyed by tool name. Created via `createToolIdQueue`. */
+interface ToolIdQueue {
+    /** Allocate a new toolId for a `tool_call` event and enqueue it under `name`. */
+    push(name: string): string;
+    /** Pop the oldest toolId for `name` (or return an orphan marker if none). */
+    shift(name: string): string;
+    /** Reset all queues (e.g. on stream close). */
+    clear(): void;
+}
+declare function createToolIdQueue(): ToolIdQueue;
+/**
+ * Translate a single pydantic-AI event into zero or more `ChatStreamEvent`s.
+ * Pass a `ToolIdQueue` shared across the lifetime of one stream so that
+ * `tool_call` / `tool_result` pairs match correctly.
+ */
+declare function mapPydanticAIEvent(ev: PydanticAIEvent, toolIds: ToolIdQueue): Generator<ChatStreamEvent>;
+/**
+ * Convenience factory: returns a `ParseSSEOptions['map']` callback that
+ * decodes raw SSE frames as `PydanticAIEvent` JSON and yields zero or
+ * more `ChatStreamEvent`s through `mapPydanticAIEvent`.
+ *
+ * Allocates an internal `ToolIdQueue` — call this once per stream.
+ */
+declare function createPydanticAISSEMap(): NonNullable<ParseSSEOptions['map']>;
+
+/**
+ * High-level transport factory for pydantic-AI–style backends.
+ *
+ * Composes:
+ *   - `parseSSE` for spec-compliant SSE framing (multi-line `data:`, comments, idle timeout).
+ *   - `createPydanticAISSEMap` for normalizing pydantic-AI events into `ChatStreamEvent`.
+ *
+ * Use when your backend speaks the canonical pydantic-AI stream shape
+ * (`text_delta` / `tool_call` / `tool_result` / `done` / `error`).
+ * URL building, auth headers, history loading, and optional session
+ * bootstrapping are caller responsibilities — pass them in.
+ */
+
+interface PydanticAIChatTransportOpts {
+    /**
+     * Build the SSE stream URL for a user message turn.
+     * @example (sessionId, message) => `${base}/stream?session_id=${sessionId}&message=${encodeURIComponent(message)}`
+     */
+    buildStreamUrl: (sessionId: string, message: string) => string | URL;
+    /** Optional history loader. If omitted, `loadHistory` returns an empty page. */
+    loadHistory?: (sessionId: string, cursor?: string | null) => Promise<HistoryPage>;
+    /**
+     * Optional session bootstrap. Called from `createSession`. Useful for
+     * backends that need a `POST /sessions` round-trip or want to pre-seed
+     * history.
+     */
+    bootstrapSession?: (opts?: CreateSessionOptions) => Promise<SessionInfo>;
+    /** Optional session teardown. */
+    closeSession?: (sessionId: string) => Promise<void>;
+    /**
+     * Optional non-streaming send (for hosts that need a buffered fallback,
+     * e.g. when the user disables streaming). Defaults to throwing — most
+     * hosts only use streaming.
+     */
+    send?: (sessionId: string, content: string, options?: SendOptions) => Promise<ChatMessage>;
+    /** Request headers (Authorization, content-type, etc.). */
+    buildHeaders?: () => HeadersInit | Promise<HeadersInit>;
+    /** Override fetch (tests, retry layers). */
+    fetchImpl?: typeof fetch;
+    /**
+     * HTTP method for the stream request. Defaults to `'POST'` with
+     * `{ content, attachments, metadata }` JSON body. Set to `'GET'` if
+     * your backend embeds the message in the URL via `buildStreamUrl`.
+     */
+    streamMethod?: 'GET' | 'POST';
+    /** Idle timeout for the SSE connection, in ms. Forwarded to `parseSSE`. */
+    idleTimeoutMs?: number;
+    /**
+     * Side-channel for events that don't translate to `ChatStreamEvent`
+     * (e.g. `approval_required` — surfaces interactive prompts outside the
+     * normal message stream). Called synchronously while parsing the SSE
+     * frame; mutate caller-owned state, don't `await` long work here.
+     */
+    onPydanticEvent?: (event: PydanticAIEvent) => void;
+}
+declare function createPydanticAIChatTransport(opts: PydanticAIChatTransportOpts): ChatTransport;
+
+type ChatFABPosition = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+type ChatFABVariant = 'simple' | 'animated' | 'glass';
+type ChatFABSize = 'sm' | 'md' | 'lg' | 'responsive';
+interface ChatFABProps {
+    /** Click handler — typically toggles a `ChatDock`. */
+    onClick: () => void;
+    /** Accessible label. */
+    ariaLabel?: string;
+    /** Icon inside the FAB. Defaults to a bot glyph. */
+    icon?: ReactNode;
+    /** Visual style. @default 'simple' */
+    variant?: ChatFABVariant;
+    /** Button size. @default 'md' */
+    size?: ChatFABSize;
+    /** Fixed-screen position. @default 'bottom-right' */
+    position?: ChatFABPosition;
+    /** Pixel offset from screen edges. @default 24 */
+    offset?: number;
+    /** z-index for the button. @default 9999 */
+    zIndex?: number;
+    /** Show a small attention dot (unread / new). */
+    pulse?: boolean;
+    /**
+     * Numeric badge — unread count. Numbers > 9 render as "9+".
+     * Overrides `pulse` when both set.
+     */
+    badge?: number;
+    /** Hover tooltip text. Shows next to the FAB on hover/focus. */
+    tooltip?: string;
+    /**
+     * Render in-place (no fixed positioning) so the FAB sits inline in the
+     * normal document flow. Useful for stories, screenshots, and previews
+     * inside a contained playground panel. @default false
+     */
+    inline?: boolean;
+    /** Override classes on the button itself. */
+    className?: string;
+    /** Extra style on the button (caller-controlled overrides). */
+    style?: CSSProperties;
+}
+/**
+ * Floating action button for opening a chat dock. Pure presentation — owns
+ * no state. Wire it to whatever toggles your dock open.
+ *
+ * For the common "FAB + dock + hotkey" composition, use `<ChatLauncher>` —
+ * this primitive is only useful when you need custom triggering.
+ */
+declare function ChatFAB({ onClick, ariaLabel, icon, variant, size, position, offset, zIndex, pulse, badge, tooltip, inline, className, style, }: ChatFABProps): react_jsx_runtime.JSX.Element;
+
+type ChatDockMode = 'popover' | 'side';
+type ChatDockSide = 'left' | 'right';
+interface ChatDockProps {
+    /** Controlled open state. */
+    open: boolean;
+    /** Called when the user clicks the close button. */
+    onClose: () => void;
+    /** Dock contents (typically a `<Chat>` component). */
+    children: ReactNode;
+    /**
+     * Visual mode.
+     * - `popover` (default): floating card anchored to a corner, fixed size, FAB-style.
+     * - `side`: docked panel pinned to the left/right edge, full viewport height.
+     */
+    mode?: ChatDockMode;
+    /** Side for `mode='side'`. @default 'right' */
+    side?: ChatDockSide;
+    /** Header title text. */
+    title?: ReactNode;
+    /** Header icon. Defaults to a bot glyph. */
+    icon?: ReactNode;
+    /**
+     * Header actions slot (right side, before the close button).
+     * Use `ChatHeaderActionButton` to keep visual consistency.
+     */
+    headerActions?: ReactNode;
+    /** Hide the header entirely (you render your own inside `children`). */
+    hideHeader?: boolean;
+    /** ARIA label for the close button. @default 'Close' */
+    closeLabel?: string;
+    /** Dock width in px. Clamped to viewport. @default 480 (popover) / 420 (side) */
+    width?: number;
+    /** Dock height in px. Only used in `popover` mode. @default 720 */
+    height?: number;
+    /** Which screen corner to dock to in `popover` mode. @default 'bottom-right' */
+    position?: ChatFABPosition;
+    /** Offset from screen edges in px (popover only). @default 24 / 96 */
+    offset?: {
+        horizontal?: number;
+        vertical?: number;
+    };
+    /** Transition duration in ms — should match CSS animation. @default 200 */
+    exitDurationMs?: number;
+    /** z-index. @default 10000 */
+    zIndex?: number;
+    /** Accessible dialog label. */
+    ariaLabel?: string;
+    /** Extra classes on the dock container. */
+    className?: string;
+    /**
+     * Take over the full viewport on mobile (< 768px). Applies to both modes.
+     * @default true
+     */
+    mobileFullscreen?: boolean;
+    /**
+     * Render in-place (not in `document.body` via a portal). Useful for stories,
+     * screenshots, or wrapping the dock inside a custom container. @default false
+     */
+    disablePortal?: boolean;
+    /**
+     * Drop fixed positioning entirely — the dock renders as a normal flow
+     * element sized by `width`/`height`. Combine with `disablePortal` for
+     * stories/previews where the dock should sit inside the panel instead
+     * of attaching to the viewport. @default false
+     */
+    inline?: boolean;
+    /**
+     * In `mode='side'`, reserve space on the document body so page content
+     * isn't covered by the dock. Sets `padding-{side}` on `<body>` while
+     * the dock is open and exposes the width via the `--chat-dock-reserve`
+     * CSS variable for custom layouts. @default true (when mode='side')
+     */
+    reserveBodySpace?: boolean;
+}
+/**
+ * Fixed-position chat surface. Two modes:
+ *
+ * - `popover` — floating card anchored to a corner. Companion to `<ChatFAB>`.
+ * - `side` — full-height panel pinned to the left/right edge. App-shell style.
+ *
+ * Renders only when `open` is true (plus the leave-transition tail). Uses
+ * `useChatPresence` for the four-phase mount/animate/unmount cycle.
+ */
+declare function ChatDock({ open, onClose, children, mode, side, title, icon, headerActions, hideHeader, closeLabel, width, height, position, offset, exitDurationMs, zIndex, ariaLabel, className, mobileFullscreen, disablePortal, inline, reserveBodySpace, }: ChatDockProps): react_jsx_runtime.JSX.Element;
+
+interface ChatHeaderProps {
+    /** Window title text. */
+    title?: ReactNode;
+    /** Icon next to the title. Defaults to a bot glyph. */
+    icon?: ReactNode;
+    /**
+     * Action slot — appears to the right of the title, before the close button.
+     * Use for reset / settings / minimize / etc. Compose with `ChatHeaderActionButton`.
+     */
+    actions?: ReactNode;
+    /** Show the close (×) button. @default true */
+    showClose?: boolean;
+    /** Close click handler. */
+    onClose?: () => void;
+    /** ARIA label for the close button. @default 'Close' */
+    closeLabel?: string;
+    /** Replace the close button entirely (rare — most hosts want the default). */
+    closeSlot?: ReactNode;
+    /** Extra classes on the `<header>` element. */
+    className?: string;
+}
+/**
+ * Standalone chat header — title + icon + action slot + close button.
+ *
+ * Used by `<ChatDock>` automatically, but can be rendered standalone when
+ * the host owns the chat container (e.g. embedded inline in a page).
+ */
+declare function ChatHeader({ title, icon, actions, showClose, onClose, closeLabel, closeSlot, className, }: ChatHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface ChatHeaderActionButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    /** Icon (required). */
+    icon: ReactNode;
+    /** Accessible label + native tooltip. */
+    ariaLabel: string;
+    /** Optional unread / status badge — small number on top-right. */
+    badge?: number;
+    /** Mark as destructive — uses destructive hover tokens. */
+    destructive?: boolean;
+    /** Optional visual loading state (e.g. while reset is in flight). */
+    loading?: boolean;
+}
+/**
+ * Compact icon button for the chat header actions slot.
+ *
+ * Standard chrome: 28×28 ghost button, hover bg-accent, focus ring, optional
+ * destructive variant, optional numeric badge for unread / pending.
+ *
+ * @example
+ * ```tsx
+ * <ChatHeader
+ *   title="Assistant"
+ *   onClose={close}
+ *   actions={
+ *     <>
+ *       <ChatHeaderActionButton
+ *         icon={<RotateCcw className="h-3.5 w-3.5" />}
+ *         ariaLabel="Clear context"
+ *         onClick={handleReset}
+ *         loading={isResetting}
+ *       />
+ *       <ChatHeaderActionButton
+ *         icon={<Settings className="h-3.5 w-3.5" />}
+ *         ariaLabel="Settings"
+ *         onClick={openSettings}
+ *       />
+ *     </>
+ *   }
+ * />
+ * ```
+ */
+declare const ChatHeaderActionButton: react.ForwardRefExoticComponent<ChatHeaderActionButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface ChatHeaderModeToggleProps {
+    /** Current dock mode. */
+    mode: ChatDockMode;
+    /** Toggle handler. Wire to `useChatDockPrefs().toggleMode`. */
+    onToggle: () => void;
+    /** Override aria/tooltip label for popover→side. */
+    expandLabel?: string;
+    /** Override aria/tooltip label for side→popover. */
+    collapseLabel?: string;
+    /**
+     * Always render — useful for stories. By default the toggle hides itself on
+     * viewports below `lg` (1024px) since side mode falls back to popover there.
+     */
+    forceVisible?: boolean;
+}
+/**
+ * "Dock to side" / "back to popover" toggle.
+ *
+ * Side mode is desktop-only — on viewports below `lg` (1024px) `<ChatDock>`
+ * silently falls back to popover anyway, so the toggle has nothing to do
+ * and auto-hides. Pass `forceVisible` to override (e.g. in stories).
+ */
+declare function ChatHeaderModeToggle({ mode, onToggle, expandLabel, collapseLabel, forceVisible, }: ChatHeaderModeToggleProps): react_jsx_runtime.JSX.Element;
+
+interface ChatHeaderAudioToggleProps {
+    /** Current muted state. */
+    muted: boolean;
+    /** Toggle handler. Wire to `useChatAudio().setMuted` or `toggleMute`. */
+    onToggle: () => void;
+    /** Override tooltip label for muted → unmuted. */
+    unmuteLabel?: string;
+    /** Override tooltip label for unmuted → muted. */
+    muteLabel?: string;
+}
+/**
+ * Mute / unmute notification sounds. Drop into a `<ChatHeader>` actions
+ * slot or into `<ChatDock headerActions>`.
+ *
+ * @example
+ * ```tsx
+ * const audio = useChatAudio({ sounds: {...} });
+ * <ChatHeaderAudioToggle muted={audio.muted} onToggle={() => audio.setMuted(!audio.muted)} />
+ * ```
+ */
+declare function ChatHeaderAudioToggle({ muted, onToggle, unmuteLabel, muteLabel, }: ChatHeaderAudioToggleProps): react_jsx_runtime.JSX.Element;
+
+interface ChatHeaderResetButtonProps {
+    /**
+     * Backend reset call. Should resolve to `true` on success.
+     * Plugged into `useChatReset` for in-flight state.
+     */
+    onReset: () => Promise<boolean>;
+    /** Called after a successful reset (e.g. clear local messages, refetch). */
+    onSuccess?: () => void;
+    /** Called when reset fails (returned `false` or threw). */
+    onError?: (error?: unknown) => void;
+    /**
+     * Show a `window.dialog.confirm` before calling `onReset`. @default true
+     *
+     * Requires the host to mount `<DialogProvider>` from `@djangocfg/ui-core`
+     * — it installs the `window.dialog` API used here.
+     */
+    confirm?: boolean;
+    /** Confirm dialog title. */
+    confirmTitle?: string;
+    /** Confirm dialog message. */
+    confirmMessage?: string;
+    /** Override tooltip / aria label. */
+    ariaLabel?: string;
+}
+/**
+ * Standard chat-reset action: prompts the user via `window.dialog.confirm`,
+ * then runs the backend reset call through `useChatReset` so the button
+ * spins while it's in flight.
+ *
+ * @example
+ * ```tsx
+ * <ChatHeaderResetButton
+ *   onReset={api.clearChat}
+ *   onSuccess={() => chat.clearMessages()}
+ * />
+ * ```
+ */
+declare function ChatHeaderResetButton({ onReset, onSuccess, onError, confirm, confirmTitle, confirmMessage, ariaLabel, }: ChatHeaderResetButtonProps): react_jsx_runtime.JSX.Element;
+
+interface ChatGreetingProps {
+    /** Controlled visibility — usually `!chatOpen && !userDismissed`. */
+    open: boolean;
+    /** Greeting text. Pass a string for the default bubble, or any ReactNode. */
+    children: ReactNode;
+    /** Click handler — typically opens the chat. Bubble is clickable when set. */
+    onClick?: () => void;
+    /** Close (×) button handler — typically marks the greeting as dismissed. */
+    onDismiss?: () => void;
+    /** Anchor relative to a FAB on the same side. @default 'bottom-right' */
+    position?: ChatFABPosition;
+    /**
+     * Horizontal pixel offset matching the FAB's `offset` prop, so the greeting
+     * lines up under the FAB. @default 24
+     */
+    fabOffset?: number;
+    /**
+     * Vertical pixel offset above/below the FAB centerline. @default 96
+     * (room for an `md` FAB plus a small gap).
+     */
+    fabClearance?: number;
+    /** Delay before the greeting appears, in ms. @default 1500 */
+    delayMs?: number;
+    /** z-index. @default 9998 (just below the default FAB at 9999). */
+    zIndex?: number;
+    /** Override classes on the bubble. */
+    className?: string;
+    /** Override styles on the bubble. */
+    style?: CSSProperties;
+    /** Optional sender avatar / icon shown on the left. */
+    avatar?: ReactNode;
+    /** Optional sender label rendered above the text. */
+    senderName?: string;
+    /** ARIA label for the dismiss button. @default 'Dismiss' */
+    dismissLabel?: string;
+    /**
+     * Render in-place (no fixed positioning). Useful for stories and inline previews.
+     * @default false
+     */
+    inline?: boolean;
+}
+/**
+ * Greeting bubble shown next to a `ChatFAB` to invite the user to start a
+ * conversation (LiveChat / Intercom-style proactive prompt).
+ *
+ * Renders fixed-position, anchored to the same corner as the FAB. Owns its
+ * own delayed-mount + presence animation. Hide on chat open and/or after
+ * user dismissal.
+ *
+ * @example
+ * ```tsx
+ * const [open, setOpen] = useState(false);
+ * const [dismissed, setDismissed] = useState(false);
+ *
+ * <ChatLauncher
+ *   open={open}
+ *   onOpenChange={setOpen}
+ *   fab={{ variant: 'animated' }}
+ *   dock={{ title: 'Support' }}
+ * >
+ *   <SupportChat />
+ * </ChatLauncher>
+ *
+ * <ChatGreeting
+ *   open={!open && !dismissed}
+ *   onClick={() => setOpen(true)}
+ *   onDismiss={() => setDismissed(true)}
+ *   senderName="Anna from Support"
+ *   delayMs={2000}
+ * >
+ *   Hi! 👋 Got a question? I'm here to help.
+ * </ChatGreeting>
+ * ```
+ */
+declare function ChatGreeting({ open, children, onClick, onDismiss, position, fabOffset, fabClearance, delayMs, zIndex, className, style, avatar, senderName, dismissLabel, inline, }: ChatGreetingProps): react_jsx_runtime.JSX.Element;
+
+interface ChatUnreadPreviewProps {
+    /** Controlled — usually `!dockOpen && !!message`. */
+    open: boolean;
+    /** Inbound message to preview. `null` hides the bubble. */
+    message: ChatMessage | null;
+    /** Tap → open chat + mark read. */
+    onClick?: () => void;
+    /** × → mark read without opening. */
+    onDismiss?: () => void;
+    /** Anchor corner — match the FAB so the bubble sits above it. @default 'bottom-right' */
+    position?: ChatFABPosition;
+    /** Horizontal offset from screen edge, matches the FAB. @default 24 */
+    fabOffset?: number;
+    /** Vertical clearance above/below the FAB. @default 96 */
+    fabClearance?: number;
+    /** Lines of body text before ellipsis. @default 2 */
+    truncate?: number;
+    /** z-index. @default 9998 */
+    zIndex?: number;
+    /** Render in-place (stories / previews). @default false */
+    inline?: boolean;
+    /** Override classes on the bubble. */
+    className?: string;
+    /** Override styles on the bubble. */
+    style?: CSSProperties;
+    /** ARIA label for the dismiss button. @default 'Mark as read' */
+    dismissLabel?: string;
+    /** Override the avatar — defaults to derived from `message.sender`. */
+    avatar?: ReactNode;
+    /** Override the sender label — defaults to `message.sender?.name`. */
+    senderName?: string;
+}
+/**
+ * Push-notification bubble next to the chat FAB.
+ *
+ * Shows the last inbound message while the chat is closed —
+ * Intercom / LiveChat-style. Tap → open chat (host wires `onClick`).
+ * Dismiss × → keep chat closed but stop nagging.
+ *
+ * Pair with `useChatUnread()` (inside `<ChatProvider>`) for state.
+ */
+declare function ChatUnreadPreview({ open, message, onClick, onDismiss, position, fabOffset, fabClearance, truncate, zIndex, inline, className, style, dismissLabel, avatar, senderName, }: ChatUnreadPreviewProps): react_jsx_runtime.JSX.Element;
+
+interface ChatLauncherHotkey {
+    /** Key (case-sensitive single char or named like 'Escape'). */
+    key: string;
+    /** Require Cmd (mac) or Ctrl (other). */
+    meta?: boolean;
+    /** Require Shift. */
+    shift?: boolean;
+    /** Require Alt. */
+    alt?: boolean;
+}
+interface ChatLauncherGreeting extends Omit<ChatGreetingProps, 'open' | 'onClick' | 'onDismiss' | 'position' | 'fabOffset' | 'children'> {
+    /** Greeting body — string for the default style, or any ReactNode. */
+    content: ReactNode;
+    /** Persistence key for "user dismissed this greeting" in `localStorage`. Pass `null` to disable persistence. @default null */
+    dismissStorageKey?: string | null;
+    /** Hide the greeting once the user opens the chat. @default true */
+    hideOnOpen?: boolean;
+}
+interface ChatLauncherProps {
+    /** Dock contents — typically a `<Chat>` instance. */
+    children: ReactNode;
+    /** FAB customization (icon, position, label, pulse, badge, tooltip, variant, size). */
+    fab?: Omit<ChatFABProps, 'onClick'>;
+    /** Dock customization (size, title, position, transition, mobileFullscreen). */
+    dock?: Omit<ChatDockProps, 'open' | 'onClose' | 'children'>;
+    /**
+     * Proactive greeting bubble shown next to the FAB before the user opens the chat.
+     * Set to a string or full config object. Omit to disable.
+     */
+    greeting?: string | ChatLauncherGreeting;
+    /** Open/close via a keyboard shortcut. */
+    hotkey?: ChatLauncherHotkey;
+    /** Initial open state for uncontrolled mode. @default false */
+    defaultOpen?: boolean;
+    /** Controlled open state (pair with `onOpenChange`). */
+    open?: boolean;
+    /** Controlled open state setter. */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Focus the composer textarea when the dock opens. Saves a click for
+     * every "FAB → start typing" interaction. @default true
+     */
+    autoFocusComposerOnOpen?: boolean;
+    /**
+     * Close the dock on `Escape`. Mirrors standard popover / drawer UX.
+     * Set to `false` to disable (e.g. if you want Escape to do something
+     * else inside the chat). @default true
+     */
+    closeOnEscape?: boolean;
+    /**
+     * Last inbound message (admin reply / system notice / agent push) the
+     * user hasn't seen yet. Drives the `<ChatUnreadPreview>` bubble next
+     * to the FAB and (by default) the FAB badge.
+     *
+     * Source it from `useChatUnread()` inside your `<ChatProvider>`.
+     */
+    unreadMessage?: ChatMessage | null;
+    /**
+     * Called when the user opens the chat via FAB/preview/hotkey or
+     * dismisses the preview with ×. Wire to `useChatUnread().markRead`.
+     */
+    onMarkRead?: () => void;
+    /**
+     * Customize the unread bubble (`truncate`, `dismissLabel`, …).
+     * `open`/`message`/`onClick`/`onDismiss`/`position`/`fabOffset` are
+     * wired automatically.
+     */
+    unreadPreview?: Omit<ChatUnreadPreviewProps, 'open' | 'message' | 'onClick' | 'onDismiss' | 'position' | 'fabOffset'>;
+    /**
+     * Auto-inject a mute / unmute button into the header. Pass the
+     * `useChatAudio()` (or any compatible `{ muted, toggleMute }`)
+     * instance — the launcher renders `<ChatHeaderAudioToggle>` in the
+     * header's actions slot when audio is actually configured (not silent).
+     *
+     * Hosts that manage their own header can ignore this prop and render
+     * `<ChatHeaderAudioToggle>` directly.
+     */
+    audio?: {
+        muted: boolean;
+        toggleMute: () => void;
+        isSilent?: boolean;
+    } | null;
+    /**
+     * Suppress the auto-injected audio toggle even when `audio` is passed.
+     * @default false
+     */
+    hideAudioToggle?: boolean;
+}
+/**
+ * Floating chat launcher = FAB + Dock + presence + optional greeting + hotkey.
+ *
+ * 99% of hosts use this directly. For non-FAB triggers (e.g. an inline
+ * link in the page) compose `<ChatDock>` with your own button.
+ */
+declare function ChatLauncher({ children, fab, dock, greeting, hotkey, defaultOpen, open: controlledOpen, onOpenChange, autoFocusComposerOnOpen, closeOnEscape, unreadMessage, onMarkRead, unreadPreview, audio, hideAudioToggle, }: ChatLauncherProps): react_jsx_runtime.JSX.Element;
+
+type ChatPresencePhase = 'hidden' | 'entering' | 'visible' | 'leaving';
+/**
+ * Presence state machine for floating popovers.
+ *
+ * Drives a four-phase lifecycle so enter/leave CSS transitions actually fire:
+ *
+ *   hidden → entering (mount, transition class starts) → visible
+ *   visible → leaving (transition runs) → hidden (unmount)
+ *
+ * Mounting in `entering` and ticking to `visible` on the next paint is what
+ * lets transition classes animate. Without it the element appears already
+ * at its final state and CSS transitions never observe a change.
+ *
+ * @param open - controlled open state
+ * @param exitDurationMs - how long the leave transition runs; should match CSS
+ */
+declare function useChatPresence(open: boolean, exitDurationMs?: number): ChatPresencePhase;
+
 /**
  * @deprecated Plan64. As of ui-tools 2.1.369, `<MessageList>` is
  * virtualized via react-virtuoso and owns its own scroll viewport.
@@ -2319,6 +3077,11 @@ interface UseChatHistoryOptions {
  *  bump scrollTop by the delta so the previously-visible message stays put. */
 declare function useChatHistory(options: UseChatHistoryOptions): void;
 
+/**
+ * Chat-specific audio facade. Thin wrapper over `useNotificationSounds`
+ * from `@djangocfg/ui-core` — keeps the `ChatAudioEvent` typing while
+ * the underlying bus / prefs / Safari-unlock logic lives in ui-core.
+ */
 declare function useChatAudio(config?: ChatAudioConfig): UseChatAudioReturn;
 
 interface ChatLightboxState {
@@ -2404,32 +3167,167 @@ declare function useAutoFocusOnStreamEnd(options?: UseAutoFocusOnStreamEndOption
  *
  * No-op when called outside a `<ChatProvider>`.
  */
-declare function useRegisterComposer(focus: () => void): void;
+declare function useRegisterComposer(handle: ComposerHandle): void;
 
-interface ChatAudioPrefsState {
-    /** 0..1 master volume. */
-    volume: number;
-    /** Master mute (overrides per-event toggles). */
-    muted: boolean;
-    /** Per-event opt-out — `false` silences a single trigger. */
-    enabled: Partial<Record<ChatAudioEvent, boolean>>;
-    setVolume: (v: number) => void;
-    setMuted: (m: boolean) => void;
-    setEventEnabled: (event: ChatAudioEvent, enabled: boolean) => void;
+interface UseChatResetOptions {
+    /**
+     * Backend call that performs the actual reset (e.g. POST /chat/reset).
+     * Should resolve to `true` on success, `false` on failure.
+     * Throwing also counts as failure — caught and logged.
+     */
+    onReset: () => Promise<boolean>;
+    /**
+     * Called after a successful reset (status === true). Use to clear the
+     * local message list, navigate, or fire analytics.
+     */
+    onSuccess?: () => void;
+    /**
+     * Called when reset fails (returned `false` or threw). Defaults to no-op
+     * — wire to a toast/banner if you want to surface it.
+     */
+    onError?: (error?: unknown) => void;
 }
-declare const useChatAudioPrefs: zustand.UseBoundStore<Omit<zustand.StoreApi<ChatAudioPrefsState>, "setState" | "persist"> & {
-    setState(partial: ChatAudioPrefsState | Partial<ChatAudioPrefsState> | ((state: ChatAudioPrefsState) => ChatAudioPrefsState | Partial<ChatAudioPrefsState>), replace?: false): unknown;
-    setState(state: ChatAudioPrefsState | ((state: ChatAudioPrefsState) => ChatAudioPrefsState), replace: true): unknown;
-    persist: {
-        setOptions: (options: Partial<zustand_middleware.PersistOptions<ChatAudioPrefsState, unknown, unknown>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => Promise<void> | void;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: ChatAudioPrefsState) => void) => () => void;
-        onFinishHydration: (fn: (state: ChatAudioPrefsState) => void) => () => void;
-        getOptions: () => Partial<zustand_middleware.PersistOptions<ChatAudioPrefsState, unknown, unknown>>;
-    };
-}>;
+interface UseChatResetReturn {
+    /** Trigger the reset. Safe to call multiple times — re-entrant guard. */
+    reset: () => Promise<boolean>;
+    /** True while the reset is in flight. */
+    isResetting: boolean;
+}
+/**
+ * Generic "clear chat context" hook.
+ *
+ * Stays generic — the backend call lives in the host (it knows the URL,
+ * auth, project slug). Provides the in-flight state and success/error
+ * callbacks every consumer wires up the same way.
+ *
+ * @example
+ * ```tsx
+ * const { reset, isResetting } = useChatReset({
+ *   onReset: async () => {
+ *     const res = await fetch('/api/chat/reset', { method: 'POST', credentials: 'include' });
+ *     return res.ok;
+ *   },
+ *   onSuccess: () => chat.clearMessages(),
+ * });
+ * ```
+ */
+declare function useChatReset(opts: UseChatResetOptions): UseChatResetReturn;
+
+interface UseVisitorFingerprintOptions {
+    /** localStorage key. @default 'chat.visitor.fingerprint' */
+    storageKey?: string;
+}
+/**
+ * Persistent anonymous visitor id, kept in `localStorage`.
+ *
+ * Returns `null` on the first render (SSR-safe) and the stable id from
+ * the second render onwards. Use as `fingerprint` for public chat
+ * transports that need to dedupe sessions per visitor without auth.
+ */
+declare function useVisitorFingerprint(opts?: UseVisitorFingerprintOptions): string | null;
+
+interface ChatDockPrefs {
+    /** Popover (FAB-style) or side-docked panel. */
+    mode: ChatDockMode;
+    /** Which edge the side dock attaches to. */
+    side: ChatDockSide;
+    /** Width in px when side-docked (resizable in the future). */
+    sideWidth: number;
+}
+declare const DEFAULT_DOCK_PREFS: ChatDockPrefs;
+interface UseChatDockPrefsOptions {
+    /** localStorage key. @default 'chat.dock.prefs' */
+    storageKey?: string;
+    /** Override the baseline defaults (per-product branding, etc.). */
+    defaults?: Partial<ChatDockPrefs>;
+}
+interface UseChatDockPrefsReturn extends ChatDockPrefs {
+    /** Merge-update — pass only the fields that changed. */
+    setPrefs: (patch: Partial<ChatDockPrefs>) => void;
+    /** Convenience toggle: popover ⇆ side. */
+    toggleMode: () => void;
+    /** Convenience toggle: right ⇆ left (only affects side mode). */
+    toggleSide: () => void;
+    /** Reset to defaults. */
+    reset: () => void;
+}
+/**
+ * Persistent dock preferences (mode / side / width) via ui-core localStorage.
+ *
+ * SSR-safe: returns defaults on the server, hydrates on mount.
+ * Survives reloads — power users keep their preferred chat layout.
+ */
+declare function useChatDockPrefs(opts?: UseChatDockPrefsOptions): UseChatDockPrefsReturn;
+
+interface UseFocusOnEmptyClickOptions {
+    /**
+     * Custom focus target. Defaults to the composer registered in the chat
+     * context.
+     */
+    targetRef?: RefObject<Focusable | HTMLElement | null>;
+    /** Opt-out without unmounting the hook. @default true */
+    enabled?: boolean;
+    /**
+     * Don't focus if currently streaming (user is reading the reply).
+     * @default true
+     */
+    skipWhileStreaming?: boolean;
+}
+/**
+ * "Click anywhere in the chat → focus the composer" — Slack / Linear /
+ * ChatGPT behaviour.
+ *
+ * Returns a single `onMouseUp` handler to attach to the scrollable
+ * messages container. Heuristics that mirror the popular chat apps:
+ *
+ *   1. Ignore clicks on interactive elements (`button`, `a`, `input`,
+ *      `textarea`, `[role="button"]`, `[contenteditable]`, …) — they
+ *      have their own behaviour.
+ *   2. Ignore clicks that produced a text selection (drag-to-select).
+ *      Stealing focus would break copy-paste flow.
+ *   3. Ignore touch input — on mobile the system focuses the textarea
+ *      via tap on the composer itself; touching messages should never
+ *      open the keyboard.
+ *   4. Optionally skip while the assistant is streaming so the user
+ *      can keep reading without the keyboard popping up.
+ *
+ * @example
+ * ```tsx
+ * const onMouseUp = useFocusOnEmptyClick();
+ * <div ref={scrollRef} onMouseUp={onMouseUp}>{messages}</div>
+ * ```
+ */
+declare function useFocusOnEmptyClick(options?: UseFocusOnEmptyClickOptions): (event: MouseEvent<HTMLElement>) => void;
+
+declare const useChatAudioPrefs: zustand.UseBoundStore<zustand.StoreApi<AudioPrefsState<ChatAudioEvent>>>;
+
+/**
+ * Built-in chat notification sounds.
+ *
+ * Bundled into the JS at build time as base64 data URLs (`tsup.config.ts`
+ * loader: `.mp3 → dataurl`). Total ≈ 136KB, gzipped ≈ 130KB — added to
+ * the lazy Chat tool so hosts get notification sounds with zero setup.
+ *
+ * Source files live in `./sounds/`. Re-encode via ffmpeg if you tweak:
+ *
+ *   ffmpeg -i in.mp3 -ac 2 -ar 44100 -b:a 128k -af 'atrim=0:1.4,afade=t=out:st=1.22:d=0.18' out.mp3
+ */
+
+/**
+ * Default chat notification sounds. Pass to `useChatAudio` (or spread
+ * into a custom map) so hosts don't have to ship assets themselves.
+ *
+ * @example
+ * ```tsx
+ * const audio = useChatAudio({ sounds: DEFAULT_CHAT_SOUNDS });
+ *
+ * // Override one event:
+ * const audio = useChatAudio({
+ *   sounds: { ...DEFAULT_CHAT_SOUNDS, mention: '/custom-mention.mp3' },
+ * });
+ * ```
+ */
+declare const DEFAULT_CHAT_SOUNDS: ChatAudioSounds;
 
 interface ToolPayloadMatcher {
     /** Cheap predicate. First match wins. */
@@ -2449,6 +3347,120 @@ declare function isGeoJSONFeatureCollection(v: unknown): v is {
 };
 declare function isStringValue(v: unknown): v is string;
 
+/**
+ * Chat color tokens — single source of truth.
+ *
+ * Every role-conditional class for chat surfaces lives here.
+ * Components consume via `useChatBubbleStyles` / `useChatRoleStyles`,
+ * never via raw Tailwind literals.
+ *
+ * Why centralize:
+ *   1. One file to edit when the design system changes (e.g. light-theme
+ *      contrast tweaks, palette swap).
+ *   2. Eliminates the "first-token-on-bg-primary-was-text-white" class
+ *      of bugs where each call site picks its own foreground.
+ *   3. Lets us snapshot-test color decisions later.
+ */
+/** Bubble surface classes (background + text), keyed by message state. */
+declare const BUBBLE_SURFACE: {
+    /** User-authored bubble — solid brand color. */
+    readonly user: "bg-primary text-primary-foreground rounded-tr-md";
+    /** Assistant bubble in normal state — neutral muted surface. */
+    readonly assistant: "bg-muted text-foreground rounded-tl-md";
+    /** Assistant bubble when the turn failed — destructive tint. */
+    readonly error: "bg-destructive/10 text-destructive rounded-tl-md border border-destructive/30";
+};
+/**
+ * Anchor (link) classes for markdown content rendered inside a bubble.
+ *
+ * On `bg-primary` the link MUST stay legible against the cyan/brand fill —
+ * `text-primary-foreground` matches the bubble's foreground token, so
+ * contrast tracks the design system automatically.
+ *
+ * On the neutral assistant bubble we keep the brand-primary color so links
+ * still pop without competing with the body text.
+ */
+declare const ANCHOR: {
+    readonly user: string;
+    readonly assistant: "text-primary underline hover:text-primary/80 transition-colors break-all";
+};
+/** Inline secondary action (e.g. "Show more / less"). Same logic as anchors. */
+declare const TOGGLE: {
+    readonly user: "text-primary-foreground/80 hover:text-primary-foreground";
+    readonly assistant: "text-primary hover:text-primary/80";
+};
+/** Destructive surface — used by ErrorBanner and the delete action. */
+declare const DESTRUCTIVE_SURFACE: {
+    /** Banner / card variant: border + tint + text. */
+    readonly banner: "border border-destructive/40 bg-destructive/10 text-destructive";
+    /** Subtle hover for destructive buttons inside the banner / menu. */
+    readonly hover: "hover:bg-destructive/15";
+    /** Strong-hover variant (e.g. trash overlay on attachments). */
+    readonly hoverStrong: "hover:bg-destructive hover:text-destructive-foreground";
+    /** Inline destructive text utility. */
+    readonly text: "text-destructive";
+    /** Hover style for menu items that delete data. */
+    readonly menuItem: "text-destructive focus:text-destructive hover:bg-destructive/15 hover:text-destructive";
+};
+/** Tool-call result text. */
+declare const TOOL_CALL: {
+    readonly errorText: "text-destructive";
+};
+type ChatBubbleSurface = keyof typeof BUBBLE_SURFACE;
+
+/**
+ * Role-aware style hooks for chat surfaces.
+ *
+ * Pure utility hooks — no React state, no side effects, just memoized
+ * className strings derived from `bubbleTokens`. They exist so:
+ *   - components don't import token constants directly (single facade)
+ *   - "the user-bubble link color" can be changed in one file
+ *   - tests can mock the hook to assert intent without parsing classNames
+ */
+interface ChatBubbleStyles {
+    /** className for the bubble container (background + text + border). */
+    surface: string;
+    /** className for an inline anchor inside markdown. */
+    anchor: string;
+    /** className for a secondary inline action (e.g. show more). */
+    toggle: string;
+}
+/**
+ * Resolve bubble + content styles for a single message.
+ *
+ * @param role        'user' | 'assistant' | 'system' (system defaults to assistant styling)
+ * @param isError     marks the bubble as a failed turn (overrides surface)
+ *
+ * @example
+ * ```tsx
+ * const { surface, anchor } = useChatBubbleStyles(message.role, !!message.isError);
+ * <div className={cn('rounded-2xl px-3.5 py-2', surface)}>…</div>
+ * ```
+ */
+declare function useChatBubbleStyles(role: 'user' | 'assistant' | 'system', isError: boolean): ChatBubbleStyles;
+interface ChatRoleStyles {
+    anchor: string;
+    toggle: string;
+}
+/**
+ * Lightweight variant when only role matters (no error state, no surface).
+ * Use in shared markdown renderers that don't know about bubble background.
+ */
+declare function useChatRoleStyles(isUser: boolean): ChatRoleStyles;
+interface ChatDestructiveStyles {
+    banner: string;
+    hover: string;
+    hoverStrong: string;
+    text: string;
+    menuItem: string;
+    toolErrorText: string;
+}
+/**
+ * Destructive (delete / error) class facade. Hook form keeps the API
+ * symmetric with the others; under the hood it returns a frozen object.
+ */
+declare function useChatDestructiveStyles(): ChatDestructiveStyles;
+
 /** Walk the conversation and collect image attachments in chronological order. */
 declare function collectImageAttachments(messages: ChatMessage[]): ChatAttachment[];
 
@@ -2595,6 +3607,20 @@ interface MessageListProps {
      * `!isAtBottom`. Plan64.
      */
     onAtBottomChange?: (isAtBottom: boolean) => void;
+    /**
+     * Pixel distance from the bottom that still counts as "at bottom".
+     * Default 120 — generous enough that mid-message users keep getting
+     * sticky-followed (matches ChatGPT / Slack feel) while still letting
+     * a deliberate scroll-up break the lock. Plan11.
+     */
+    atBottomThreshold?: number;
+    /**
+     * Force-scroll to the bottom when this id changes. Wire to the id of
+     * the most-recently-sent user message: every send re-anchors the
+     * viewport so users always see their own bubble + the incoming
+     * reply, even if they were scrolled up. Plan11.
+     */
+    scrollAnchorId?: string | number | null;
 }
 interface MessageListHandle {
     scrollToBottom: (smooth?: boolean) => void;
@@ -3567,7 +4593,22 @@ interface MarkdownEditorProps {
      */
     onSubmit?: () => boolean | void;
 }
-declare function MarkdownEditor({ value, onChange, placeholder, minHeight, className, disabled, showToolbar, mentions, onMentionIdsChange, onSubmit, }: MarkdownEditorProps): react_jsx_runtime.JSX.Element;
+/**
+ * Imperative handle exposed via `ref`. Matches `ComposerHandle` from
+ * `@djangocfg/ui-tools/chat` so consumers can forward it straight into
+ * `useRegisterComposer({ focus, moveCursorToEnd })` — that's what makes
+ * voice dictation (`VoiceComposerSlot`) push live text into a TipTap
+ * composer.
+ */
+interface MarkdownEditorHandle {
+    /** Move keyboard focus into the editor. */
+    focus: () => void;
+    /** Place the caret at the end of the document (and focus). */
+    moveCursorToEnd: () => void;
+    /** Escape hatch — the underlying TipTap `Editor` instance. */
+    getEditor: () => Editor$1 | null;
+}
+declare const MarkdownEditor: react.ForwardRefExoticComponent<MarkdownEditorProps & react.RefAttributes<MarkdownEditorHandle>>;
 
 /**
  * Built-in serializers for the `MentionConfig.renderMarkdown` callback.
@@ -3776,4 +4817,4 @@ declare function useBlobUrlCleanup(key: string | null): void;
  */
 declare function generateContentKey(content: ArrayBuffer): string;
 
-export { type ApiKey, ArrayFieldItemTemplate, ArrayFieldTemplate, type AspectRatioValue, type AttachmentRenderer, type AttachmentRendererArgs, type AttachmentRendererMap, Attachments, AttachmentsGrid, type AttachmentsGridProps, AttachmentsList, type AttachmentsListProps, type AttachmentsProps, Player as AudioPlayer, type PlayerProps as AudioPlayerProps, AudioToggle, type AudioToggleProps, BaseInputTemplate, type BlobSource, CHAT_EVENT_NAME, CSS_VARS, CardLoadingFallback, type ChatAction, type ChatAssistantContext, type ChatAttachment, type ChatAudioConfig, type ChatAudioEvent, type ChatAudioSounds, type ChatConfig, type ChatContextValue, type ChatDisplayMode, type ChatEventDetail, type ChatLabels, type ChatLightboxState, type ChatLogScope, type ChatLogger, type ChatMessage, type ChatPersona, type ChatPrefs, ChatProvider, type ChatProviderProps, type ChatRole, ChatRoot, type ChatRootProps, type ChatSource, type ChatState, type ChatStreamEvent, type ChatToolCall, type ChatTransport, type ChatUserContext, CheckboxWidget, ColorWidget, Composer, type ComposerProps, type CreateLazyComponentOptions, type CreateSessionOptions, type CreateVideoErrorFallbackOptions, CronScheduler, type CronSchedulerContextValue, type CronSchedulerProps, CronSchedulerProvider, type CronSchedulerState, CustomInput, type DASHSource, DEFAULT_LABELS, DEFAULT_SIDEBAR, DEFAULT_Z_INDEX, type DataUrlSource, DayChips, DiffEditor, type DiffEditorProps, type DisabledWhenRule, Editor, type EditorContextValue, type EditorFile, type EditorOptions, type EditorProps, EditorProvider, type EditorRef, EmptyState, type EmptyStateProps, ErrorBanner, type ErrorBannerProps, type ErrorFallbackProps, ErrorListTemplate, FieldTemplate, type Focusable, type HLSSource, HOTKEYS, type HistoryPage, type HttpTransportConfig, type ImageFile, ImageViewer, type ImageViewerProps, type JsonFormContext, type JsonFormDensity, JsonSchemaForm, type JsonSchemaFormProps, JsonTreeComponent as JsonTree, type JsonTreeConfig, type JsonTreeProps, JumpToLatest, type JumpToLatestProps, LIMITS, LazyPlayer as LazyAudioPlayer, LazyChat, type ChatRootProps as LazyChatProps, LazyCronScheduler, LazyImageViewer, LazyJsonSchemaForm, LazyJsonTree, LazyLottiePlayer, LazyMapContainer, LazyMapView, LazyMermaid, LazyOpenapiViewer, LazyPrettyCode, LazyTree, TreeRootProps as LazyTreeProps, LazyVideoPlayer, LazyWrapper, type LazyWrapperProps, type LinkRule, LoadingFallback, type LoadingFallbackProps, type LottieDirection, LottiePlayer, type LottiePlayerProps, type LottieSize, type LottieSpeed, type MapContainerProps, MapLoadingFallback, type MapStyleKey, type MapViewport, MarkdownEditor, type MarkdownEditorProps, MarkdownMessage, type MarkdownMessageProps, type MarkerData, type MentionAttrs, type MentionConfig, type MentionItem, type MentionMarkdownRenderer, Mermaid, type MermaidProps, MessageActions, type MessageActionsProps, MessageBubble, type MessageBubbleProps, MessageList, type MessageListHandle, type MessageListProps, type MockTransportOptions, type MonthDay, MonthDayGrid, NativeProvider, NumberWidget, ObjectFieldTemplate, Playground as OpenapiViewer, type ParseSSEOptions, type PlayerMode, type PlaygroundConfig, type PlaygroundProps$1 as PlaygroundProps, PrettyCode, type PrettyCodeProps$1 as PrettyCodeProps, type ResolveFileSourceOptions, STORAGE_KEYS, SchedulePreview, type ScheduleType, ScheduleTypeSelector, type SchemaSource, SelectWidget, type SendOptions, type SessionInfo, type SimpleStreamSource, SliderWidget, Sources, type SourcesProps, Spinner, type StreamOptions, StreamProvider, type StreamSource, StreamingIndicator, type StreamingIndicatorProps, SwitchWidget, TextWidget, TimeSelector, type TokenBuffer, ToolCalls, type ToolCallsProps, type ToolPayloadFallback, type ToolPayloadKind, type ToolPayloadMatcher, TransportError, TreeRootProps, type UiGroup, type UrlSource, type UseAutoFocusOnStreamEndOptions, type UseChatAudioReturn, type UseChatComposerOptions, type UseChatComposerReturn, type UseChatConfig, type UseChatHistoryOptions, type UseChatLayoutConfig, type UseChatLayoutReturn, type UseChatLightboxReturn, type UseChatReturn, type UseChatScrollOptions, type UseChatScrollReturn, type UseCollapsibleContentOptions, type UseCollapsibleContentResult, type UseEditorReturn, type UseLottieOptions, type UseLottieReturn, type UseMonacoReturn, VideoControls, VideoErrorFallback, type VideoErrorFallbackProps, VideoPlayer, type VideoPlayerContextValue, type VideoPlayerProps, VideoPlayerProvider, type VideoPlayerProviderProps, type VideoPlayerRef, type VideoSourceUnion, VidstackProvider, type VimeoSource, type WeekDay, type YouTubeSource, buildCron, collectImageAttachments, createHttpTransport, createId, createLazyComponent, createMockTransport, createTokenBuffer, createVideoErrorFallback, deriveInitials, dispatchToolPayload, evaluateDisabledWhen, extractTextFromChildren, generateContentKey, getChatLogger, getRequiredFields, hasRequiredFields, humanizeCron, initialState, isGeoJSONFeatureCollection, isLatLng, isPlainObject, isSimpleStreamSource, isStringValue, isSubmittableDraft, isValidCron, mentionPresets, mergeDefaults, normalizeFormData, parseCron, parseSSE, reducer, resolveFileSource, resolvePersona, resolvePlayerMode, resolveStreamSource, safeJsonParse, safeJsonStringify, sanitizeDraft, useAudioCache, useAutoFocusOnStreamEnd, useBlobUrlCleanup, useChat, useChatAudio, useChatAudioPrefs, useChatComposer, useChatContext, useChatContextOptional, useChatHistory, useChatLayout, useChatLightbox, useChatScroll, useCollapsibleContent, useCronCustom, useCronMonthDays, useCronPreview, useCronScheduler, useCronSchedulerContext, useCronTime, useCronType, useCronWeekDays, useEditor, useEditorContext, useImageCache, useLanguage, useLottie, useMediaCacheStore, useMonaco, useRegisterComposer, useVideoCache, useVideoPlayerContext, useVideoPlayerSettings, validateRequiredFields, validateSchema };
+export { ANCHOR, type ApiKey, ArrayFieldItemTemplate, ArrayFieldTemplate, type AspectRatioValue, type AttachmentRenderer, type AttachmentRendererArgs, type AttachmentRendererMap, Attachments, AttachmentsGrid, type AttachmentsGridProps, AttachmentsList, type AttachmentsListProps, type AttachmentsProps, Player as AudioPlayer, type PlayerProps as AudioPlayerProps, AudioToggle, type AudioToggleProps, BUBBLE_SURFACE, BaseInputTemplate, type BlobSource, CHAT_EVENT_NAME, CSS_VARS, CardLoadingFallback, type ChatAction, type ChatAssistantContext, type ChatAttachment, type ChatAudioConfig, type ChatAudioEvent, type ChatAudioSounds, type ChatBubbleStyles, type ChatBubbleSurface, type ChatConfig, type ChatContextValue, type ChatDestructiveStyles, type ChatDisplayMode, ChatDock, type ChatDockMode, type ChatDockPrefs, type ChatDockProps, type ChatDockSide, type ChatEventDetail, ChatFAB, type ChatFABPosition, type ChatFABProps, type ChatFABSize, type ChatFABVariant, ChatGreeting, type ChatGreetingProps, ChatHeader, ChatHeaderActionButton, type ChatHeaderActionButtonProps, ChatHeaderAudioToggle, type ChatHeaderAudioToggleProps, ChatHeaderModeToggle, type ChatHeaderModeToggleProps, type ChatHeaderProps, ChatHeaderResetButton, type ChatHeaderResetButtonProps, type ChatLabels, ChatLauncher, type ChatLauncherGreeting, type ChatLauncherHotkey, type ChatLauncherProps, type ChatLightboxState, type ChatLogScope, type ChatLogger, type ChatMessage, type ChatPersona, type ChatPrefs, type ChatPresencePhase, ChatProvider, type ChatProviderProps, type ChatRole, type ChatRoleStyles, ChatRoot, type ChatRootProps, type ChatSource, type ChatState, type ChatStreamEvent, type ChatToolCall, type ChatTransport, ChatUnreadPreview, type ChatUnreadPreviewProps, type ChatUserContext, CheckboxWidget, ColorWidget, Composer, type ComposerProps, type CreateLazyComponentOptions, type CreateSessionOptions, type CreateVideoErrorFallbackOptions, CronScheduler, type CronSchedulerContextValue, type CronSchedulerProps, CronSchedulerProvider, type CronSchedulerState, CustomInput, type DASHSource, DEFAULT_CHAT_SOUNDS, DEFAULT_DOCK_PREFS, DEFAULT_LABELS, DEFAULT_SIDEBAR, DEFAULT_Z_INDEX, DESTRUCTIVE_SURFACE, type DataUrlSource, DayChips, DiffEditor, type DiffEditorProps, type DisabledWhenRule, Editor, type EditorContextValue, type EditorFile, type EditorOptions, type EditorProps, EditorProvider, type EditorRef, EmptyState, type EmptyStateProps, ErrorBanner, type ErrorBannerProps, type ErrorFallbackProps, ErrorListTemplate, FieldTemplate, type Focusable, type HLSSource, HOTKEYS, type HistoryPage, type HttpTransportConfig, type ImageFile, ImageViewer, type ImageViewerProps, type JsonFormContext, type JsonFormDensity, JsonSchemaForm, type JsonSchemaFormProps, JsonTreeComponent as JsonTree, type JsonTreeConfig, type JsonTreeProps, JumpToLatest, type JumpToLatestProps, LIMITS, LazyPlayer as LazyAudioPlayer, LazyChat, type ChatRootProps as LazyChatProps, LazyCronScheduler, LazyImageViewer, LazyJsonSchemaForm, LazyJsonTree, LazyLottiePlayer, LazyMapContainer, LazyMapView, LazyMermaid, LazyOpenapiViewer, LazyPrettyCode, LazyTree, TreeRootProps as LazyTreeProps, LazyVideoPlayer, LazyWrapper, type LazyWrapperProps, type LinkRule, LoadingFallback, type LoadingFallbackProps, type LottieDirection, LottiePlayer, type LottiePlayerProps, type LottieSize, type LottieSpeed, type MapContainerProps, MapLoadingFallback, type MapStyleKey, type MapViewport, MarkdownEditor, type MarkdownEditorProps, MarkdownMessage, type MarkdownMessageProps, type MarkerData, type MentionAttrs, type MentionConfig, type MentionItem, type MentionMarkdownRenderer, Mermaid, type MermaidProps, MessageActions, type MessageActionsProps, MessageBubble, type MessageBubbleProps, MessageList, type MessageListHandle, type MessageListProps, type MockTransportOptions, type MonthDay, MonthDayGrid, NativeProvider, NumberWidget, ObjectFieldTemplate, Playground as OpenapiViewer, type ParseSSEOptions, type PlayerMode, type PlaygroundConfig, type PlaygroundProps$1 as PlaygroundProps, PrettyCode, type PrettyCodeProps$1 as PrettyCodeProps, type PydanticAIChatTransportOpts, type PydanticAIEvent, type ResolveFileSourceOptions, STORAGE_KEYS, SchedulePreview, type ScheduleType, ScheduleTypeSelector, type SchemaSource, SelectWidget, type SendOptions, type SessionInfo, type SimpleStreamSource, SliderWidget, Sources, type SourcesProps, Spinner, type StreamOptions, StreamProvider, type StreamSource, StreamingIndicator, type StreamingIndicatorProps, SwitchWidget, TOGGLE, TOOL_CALL, TextWidget, TimeSelector, type TokenBuffer, ToolCalls, type ToolCallsProps, type ToolIdQueue, type ToolPayloadFallback, type ToolPayloadKind, type ToolPayloadMatcher, TransportError, TreeRootProps, type UiGroup, type UrlSource, type UseAutoFocusOnStreamEndOptions, type UseChatAudioReturn, type UseChatComposerOptions, type UseChatComposerReturn, type UseChatConfig, type UseChatDockPrefsOptions, type UseChatDockPrefsReturn, type UseChatHistoryOptions, type UseChatLayoutConfig, type UseChatLayoutReturn, type UseChatLightboxReturn, type UseChatResetOptions, type UseChatResetReturn, type UseChatReturn, type UseChatScrollOptions, type UseChatScrollReturn, type UseCollapsibleContentOptions, type UseCollapsibleContentResult, type UseEditorReturn, type UseFocusOnEmptyClickOptions, type UseLottieOptions, type UseLottieReturn, type UseMonacoReturn, type UseVisitorFingerprintOptions, VideoControls, VideoErrorFallback, type VideoErrorFallbackProps, VideoPlayer, type VideoPlayerContextValue, type VideoPlayerProps, VideoPlayerProvider, type VideoPlayerProviderProps, type VideoPlayerRef, type VideoSourceUnion, VidstackProvider, type VimeoSource, type WeekDay, type YouTubeSource, buildCron, collectImageAttachments, createHttpTransport, createId, createLazyComponent, createMockTransport, createPydanticAIChatTransport, createPydanticAISSEMap, createTokenBuffer, createToolIdQueue, createVideoErrorFallback, deriveInitials, dispatchToolPayload, evaluateDisabledWhen, extractTextFromChildren, generateContentKey, getChatLogger, getRequiredFields, hasRequiredFields, humanizeCron, initialState, isGeoJSONFeatureCollection, isLatLng, isPlainObject, isSimpleStreamSource, isStringValue, isSubmittableDraft, isValidCron, mapPydanticAIEvent, mentionPresets, mergeDefaults, normalizeFormData, parseCron, parseSSE, reducer, resolveFileSource, resolvePersona, resolvePlayerMode, resolveStreamSource, safeJsonParse, safeJsonStringify, sanitizeDraft, useAudioCache, useAutoFocusOnStreamEnd, useBlobUrlCleanup, useChat, useChatAudio, useChatAudioPrefs, useChatBubbleStyles, useChatComposer, useChatContext, useChatContextOptional, useChatDestructiveStyles, useChatDockPrefs, useChatHistory, useChatLayout, useChatLightbox, useChatPresence, useChatReset, useChatRoleStyles, useChatScroll, useCollapsibleContent, useCronCustom, useCronMonthDays, useCronPreview, useCronScheduler, useCronSchedulerContext, useCronTime, useCronType, useCronWeekDays, useEditor, useEditorContext, useFocusOnEmptyClick, useImageCache, useLanguage, useLottie, useMediaCacheStore, useMonaco, useRegisterComposer, useVideoCache, useVideoPlayerContext, useVideoPlayerSettings, useVisitorFingerprint, validateRequiredFields, validateSchema };