@djangocfg/ui-tools 2.1.335 → 2.1.337

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import * as React$1 from 'react';
-import React__default, { ReactNode, ComponentType } from 'react';
+import * as react from 'react';
+import react__default, { ReactNode, ComponentType, RefObject, ChangeEvent, KeyboardEvent, ClipboardEvent } from 'react';
 import { Components } from 'react-markdown';
 import { ViewState } from 'react-map-gl/maplibre';
 import { Language } from 'prism-react-renderer';
@@ -13,11 +13,12 @@ export { CustomJsonSchema7, CustomJsonSchema7Type, CustomJsonUiDisabledWhenRule,
 import { CommonExternalProps } from 'react-json-tree';
 import { b as TreeRootProps } from './types-CevSbyfD.js';
 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.js';
+import * as zustand_middleware from 'zustand/middleware';
+import * as zustand from 'zustand';
+import { ConsolaInstance } from 'consola';
 import { MediaPlayerInstance } from '@vidstack/react';
 import * as monaco from 'monaco-editor';
 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.js';
-import * as zustand_middleware from 'zustand/middleware';
-import * as zustand from 'zustand';
 
 interface LoadingFallbackProps {
     /** Minimum height of the loading container */
@@ -146,9 +147,9 @@ interface LinkRule {
      *  (markdown-rendered React content). */
     render: (props: {
         href: string;
-        children: React__default.ReactNode;
+        children: react__default.ReactNode;
         isUser: boolean;
-    }) => React__default.ReactNode;
+    }) => react__default.ReactNode;
     /** URL scheme(s) to whitelist on the sanitize side, e.g. `['cmdop']`.
      *  Bare schemes only — no `://`. Optional; omit for `http(s)` rules. */
     protocols?: readonly string[];
@@ -259,12 +260,12 @@ interface MarkdownMessageProps {
  * />
  * ```
  */
-declare const MarkdownMessage: React__default.FC<MarkdownMessageProps>;
+declare const MarkdownMessage: react__default.FC<MarkdownMessageProps>;
 
 /** Recursively concatenate the text content of a React.ReactNode tree.
  *  Used by the markdown renderers (e.g. `<pre>` extracting code) and
  *  by consumers that need a plain-string label out of link children. */
-declare function extractTextFromChildren(children: React__default.ReactNode): string;
+declare function extractTextFromChildren(children: react__default.ReactNode): string;
 
 interface UseCollapsibleContentOptions {
     /**
@@ -363,11 +364,11 @@ interface MapContainerProps {
  *
  * Automatically shows loading state while MapLibre GL loads (~800KB)
  */
-declare const LazyMapContainer: React$1.ComponentType<MapContainerProps>;
+declare const LazyMapContainer: react.ComponentType<MapContainerProps>;
 /**
  * LazyMapView - Lazy-loaded map view (alias for MapContainer)
  */
-declare const LazyMapView: React$1.ComponentType<Omit<MapContainerProps, "initialViewport">>;
+declare const LazyMapView: react.ComponentType<Omit<MapContainerProps, "initialViewport">>;
 
 /**
  * Mermaid Component - Dynamic Import Wrapper
@@ -390,14 +391,14 @@ interface MermaidProps {
      */
     scrollIsolation?: boolean;
 }
-declare const Mermaid: React__default.FC<MermaidProps>;
+declare const Mermaid: react__default.FC<MermaidProps>;
 
 /**
  * LazyMermaid - Lazy-loaded Mermaid diagram renderer
  *
  * Automatically shows loading state while Mermaid loads (~800KB)
  */
-declare const LazyMermaid: React$1.ComponentType<MermaidProps>;
+declare const LazyMermaid: react.ComponentType<MermaidProps>;
 
 interface PrettyCodeProps$1 {
     data: string | object;
@@ -419,7 +420,7 @@ interface PrettyCodeProps$1 {
  *
  * Automatically shows loading state while Prism loads (~500KB)
  */
-declare const LazyPrettyCode: React$1.ComponentType<PrettyCodeProps$1>;
+declare const LazyPrettyCode: react.ComponentType<PrettyCodeProps$1>;
 
 interface ApiKey {
     id: string;
@@ -487,7 +488,7 @@ interface PlaygroundProps$1 {
     config: PlaygroundConfig;
 }
 
-declare const LazyOpenapiViewer: React$1.FC<PlaygroundProps$1>;
+declare const LazyOpenapiViewer: react.FC<PlaygroundProps$1>;
 
 /** Visual density for form controls. */
 type JsonFormDensity = 'comfortable' | 'compact';
@@ -547,7 +548,7 @@ interface JsonSchemaFormProps<T = any> extends Omit<Partial<FormProps<T>>, 'sche
  *
  * Automatically shows loading state while RJSF loads (~300KB)
  */
-declare const LazyJsonSchemaForm: React$1.ComponentType<JsonSchemaFormProps<any>>;
+declare const LazyJsonSchemaForm: react.ComponentType<JsonSchemaFormProps<any>>;
 
 /**
  * JSON Schema Form Component
@@ -842,7 +843,7 @@ interface LottiePlayerProps {
  *
  * Automatically shows loading state while Lottie loads (~200KB)
  */
-declare const LazyLottiePlayer: React$1.ComponentType<LottiePlayerProps>;
+declare const LazyLottiePlayer: react.ComponentType<LottiePlayerProps>;
 
 type WaveformMode = 'peaks' | 'live' | 'bars' | 'progress' | 'none';
 type WaveformConfig = {
@@ -895,7 +896,7 @@ type PlayerHandle = {
     getDuration: () => number;
 };
 
-declare const LazyPlayer: React$1.ComponentType<PlayerProps>;
+declare const LazyPlayer: react.ComponentType<PlayerProps>;
 
 /**
  * Video source type definitions
@@ -1042,7 +1043,7 @@ interface VideoPlayerProps extends CommonPlayerSettings, CommonPlayerEvents {
     /** Preloader timeout in ms */
     preloaderTimeout?: number;
     /** Custom error fallback UI */
-    errorFallback?: React__default.ReactNode | ((props: ErrorFallbackProps) => React__default.ReactNode);
+    errorFallback?: react__default.ReactNode | ((props: ErrorFallbackProps) => react__default.ReactNode);
 }
 /** VideoPlayer ref methods */
 interface VideoPlayerRef {
@@ -1080,7 +1081,7 @@ interface VidstackProviderProps extends CommonPlayerSettings, CommonPlayerEvents
     theme?: 'default' | 'minimal' | 'modern';
     showInfo?: boolean;
     className?: string;
-    errorFallback?: React__default.ReactNode | ((props: ErrorFallbackProps) => React__default.ReactNode);
+    errorFallback?: react__default.ReactNode | ((props: ErrorFallbackProps) => react__default.ReactNode);
 }
 /** Props passed to Native provider */
 interface NativeProviderProps extends CommonPlayerSettings, CommonPlayerEvents {
@@ -1099,7 +1100,7 @@ interface StreamProviderProps extends CommonPlayerSettings, CommonPlayerEvents {
     disableContextMenu?: boolean;
     showPreloader?: boolean;
     preloaderTimeout?: number;
-    errorFallback?: React__default.ReactNode | ((props: ErrorFallbackProps) => React__default.ReactNode);
+    errorFallback?: react__default.ReactNode | ((props: ErrorFallbackProps) => react__default.ReactNode);
 }
 /** Options for resolving file source */
 interface ResolveFileSourceOptions {
@@ -1127,7 +1128,7 @@ interface VideoPlayerContextValue {
     sessionId?: string | null;
 }
 interface VideoPlayerProviderProps extends VideoPlayerContextValue {
-    children: React__default.ReactNode;
+    children: react__default.ReactNode;
 }
 /** Simplified stream source (uses context for getStreamUrl) */
 interface SimpleStreamSource {
@@ -1147,7 +1148,7 @@ interface SimpleStreamSource {
  *
  * Automatically shows loading state while Vidstack loads (~150KB)
  */
-declare const LazyVideoPlayer: React$1.ComponentType<VideoPlayerProps>;
+declare const LazyVideoPlayer: react.ComponentType<VideoPlayerProps>;
 
 type JsonTreeMode = 'full' | 'compact' | 'inline';
 interface JsonTreeConfig {
@@ -1226,7 +1227,7 @@ interface JsonTreeProps {
  * // Inline mode (minimal, for embedding)
  * <LazyJsonTree data={obj} mode="inline" />
  */
-declare const LazyJsonTree: React$1.ComponentType<JsonTreeProps>;
+declare const LazyJsonTree: react.ComponentType<JsonTreeProps>;
 
 /**
  * ImageViewer type definitions
@@ -1269,7 +1270,7 @@ interface ImageViewerProps {
  *
  * Automatically shows loading state while ImageViewer loads (~50KB)
  */
-declare const LazyImageViewer: React$1.ComponentType<ImageViewerProps>;
+declare const LazyImageViewer: react.ComponentType<ImageViewerProps>;
 
 /**
  * CronScheduler Types
@@ -1377,9 +1378,994 @@ interface CronSchedulerProviderProps {
  *   timeFormat="24h"
  * />
  */
-declare const LazyCronScheduler: React$1.ComponentType<CronSchedulerProps>;
+declare const LazyCronScheduler: react.ComponentType<CronSchedulerProps>;
+
+declare const LazyTree: react.ComponentType<TreeRootProps<unknown>>;
+
+/**
+ * Public types for the Chat tool.
+ *
+ * Shapes here are the contract between transport adapters, the reducer,
+ * the hooks layer and the components. Keep serializable (no Date, no Map).
+ */
+type ChatRole = 'user' | 'assistant' | 'system';
+interface ChatToolCall {
+    id: string;
+    name: string;
+    input: unknown;
+    output?: unknown;
+    /** Live buffer accumulated during streaming. Replaced by `output` on completion. */
+    streamingText?: string;
+    status: 'running' | 'success' | 'error' | 'cancelled';
+    startedAt: number;
+    endedAt?: number;
+    /** Optional grouping label for parallel/fan-out execution. */
+    sourceHostname?: string;
+}
+interface ChatAttachment {
+    id: string;
+    type: 'image' | 'file' | 'audio' | 'video';
+    url: string;
+    thumbnailUrl?: string;
+    name?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+    status?: 'uploading' | 'ready' | 'error';
+    /** 0..1 while uploading. */
+    progress?: number;
+    /** Extracted text from images (OCR). */
+    ocrText?: string;
+}
+interface ChatSource {
+    title: string;
+    url: string;
+    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;
+}
+interface ChatMessage {
+    id: string;
+    role: ChatRole;
+    content: string;
+    /** epoch ms — serializable. */
+    createdAt: number;
+    isStreaming?: boolean;
+    isError?: boolean;
+    /** Bumps on edit so memo keys invalidate. */
+    version?: number;
+    /** Per-message persona override (multi-user / multi-bot). Falls back to
+     *  `ChatConfig.user` / `ChatConfig.assistant` when absent. */
+    sender?: ChatPersona;
+    /** Simple status indicator above message ("Searching knowledge base..."). */
+    toolActivity?: string;
+    toolCalls?: ChatToolCall[];
+    attachments?: ChatAttachment[];
+    sources?: ChatSource[];
+    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;
+}
+interface ChatPrefs {
+    /** Submit hotkey for the composer. */
+    submitOn?: 'enter' | 'cmd+enter';
+    /** UI density. */
+    density?: 'comfortable' | 'compact';
+    /** Locale forwarded to transport metadata. */
+    locale?: string;
+    /** Show timestamps on each bubble. */
+    showTimestamps?: boolean;
+}
+interface ChatConfig {
+    /** Window title / aria-label. */
+    title?: string;
+    /** Composer placeholder. */
+    placeholder?: string;
+    /** Empty-state greeting. */
+    greeting?: string;
+    /** Empty-state description. */
+    description?: string;
+    /** Suggested prompts shown on empty conversation. */
+    suggestions?: Array<{
+        label: string;
+        prompt: string;
+    }>;
+    /** Locale forwarded to the transport via stream metadata. */
+    locale?: string;
+    /** Project / chat slug forwarded to the transport. */
+    slug?: string;
+    /** UI density. Use `prefs.density` for the same effect; this stays for
+     *  backwards compatibility. */
+    density?: 'comfortable' | 'compact';
+    /** Identity of the human author. Renders avatar / name on user bubbles
+     *  and gets stamped on outgoing messages as `message.sender`. */
+    user?: ChatUserContext;
+    /** Identity of the assistant. Renders avatar / name on assistant bubbles. */
+    assistant?: ChatAssistantContext;
+    /** UI preferences. */
+    prefs?: ChatPrefs;
+    /** 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;
+}
+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>;
+}
+type ChatStreamEvent = {
+    type: 'message_start';
+    messageId: string;
+    sessionId: string;
+} | {
+    type: 'chunk';
+    delta: string;
+} | {
+    type: 'tool_activity';
+    tool: string;
+    status: string;
+} | {
+    type: 'tool_call_start';
+    toolId: string;
+    name: string;
+    input: unknown;
+    sourceHostname?: string;
+} | {
+    type: 'tool_call_delta';
+    toolId: string;
+    delta: string;
+} | {
+    type: 'tool_call_end';
+    toolId: string;
+    output: unknown;
+    status: 'success' | 'error';
+} | {
+    type: 'message_end';
+    tokensIn?: number;
+    tokensOut?: number;
+    sources?: ChatSource[];
+} | {
+    type: 'error';
+    code: string;
+    message: string;
+};
+interface ChatTransport {
+    createSession(opts?: CreateSessionOptions): Promise<SessionInfo>;
+    loadHistory(sessionId: string, cursor?: string | null, limit?: number): Promise<HistoryPage>;
+    stream(sessionId: string, content: string, options: StreamOptions): AsyncGenerator<ChatStreamEvent, void, void>;
+    send(sessionId: string, content: string, options?: SendOptions): Promise<ChatMessage>;
+    closeSession(sessionId: string): Promise<void>;
+}
+
+type ChatAudioEvent = 'messageSent' | 'messageReceived' | 'streamStart' | 'error' | 'mention' | 'notification';
+/** Map an event to a sound URL. `false` silences the event explicitly. */
+type ChatAudioSounds = Partial<Record<ChatAudioEvent, string | false>>;
+interface ChatAudioConfig {
+    /** Map event → asset URL. Omit (or set `false`) to silence one event. */
+    sounds?: ChatAudioSounds;
+    /** Master volume 0..1. Persisted via the global prefs store. */
+    volume?: number;
+    /** Master mute. */
+    muted?: boolean;
+    /** Custom predicate — return `false` to suppress a play call. */
+    shouldPlay?: (event: ChatAudioEvent) => boolean;
+    /** Default-suppress when user prefers reduced motion. Default: true. */
+    respectReducedMotion?: boolean;
+    /** Default-suppress when user prefers reduced data. Default: true. */
+    respectReducedData?: boolean;
+    /** Mute when host page is hidden (`visibilityState === 'hidden'`). Default: true. */
+    muteWhenHidden?: boolean;
+}
+interface UseChatAudioReturn {
+    /** Play a sound for an event. No-ops if the event has no URL or is muted. */
+    play: (event: ChatAudioEvent) => void;
+    /** Eagerly load an event's audio (called automatically on mount). */
+    preload: (event: ChatAudioEvent) => void;
+    /** Manually unlock — useful in stories/tests. */
+    unlock: () => void;
+    /** True after the first user gesture inside the chat root. */
+    isUnlocked: boolean;
+    /** Master mute (persistent). */
+    muted: boolean;
+    setMuted: (m: boolean) => 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;
+}
+
+/**
+ * Pure chat state machine. Zero React. Zero I/O.
+ *
+ * Invariants:
+ *  - At most one message has `isStreaming === true` at any time. It is always
+ *    the last message in the array.
+ *  - Messages are immutable; updates produce new objects.
+ *  - `version` bumps on edit so memo keys invalidate.
+ */
 
-declare const LazyTree: React$1.ComponentType<TreeRootProps<unknown>>;
+interface ChatState {
+    sessionId: string | null;
+    messages: ChatMessage[];
+    /** Initial history load in flight. */
+    isLoading: boolean;
+    /** Assistant is generating a reply. */
+    isStreaming: boolean;
+    /** Older history page in flight. */
+    isLoadingMore: boolean;
+    hasMore: boolean;
+    oldestCursor: string | null;
+    error: string | null;
+}
+declare const initialState: ChatState;
+type ChatAction = {
+    type: 'SESSION_SET';
+    sessionId: string;
+    messages?: ChatMessage[];
+    hasMore?: boolean;
+    cursor?: string | null;
+} | {
+    type: 'HISTORY_LOAD_START';
+} | {
+    type: 'HISTORY_LOAD_DONE';
+    messages: ChatMessage[];
+    hasMore: boolean;
+    cursor: string | null;
+} | {
+    type: 'HISTORY_MORE_START';
+} | {
+    type: 'HISTORY_MORE_DONE';
+    messages: ChatMessage[];
+    hasMore: boolean;
+    cursor: string | null;
+} | {
+    type: 'MESSAGE_USER_ADD';
+    message: ChatMessage;
+} | {
+    type: 'STREAM_START';
+    id: string;
+    createdAt?: number;
+} | {
+    type: 'STREAM_CHUNK';
+    delta: string;
+} | {
+    type: 'STREAM_TOOL_ACTIVITY';
+    tool: string;
+} | {
+    type: 'TOOL_CALL_START';
+    messageId: string;
+    toolCall: ChatToolCall;
+} | {
+    type: 'TOOL_CALL_DELTA';
+    messageId: string;
+    toolId: string;
+    delta: string;
+} | {
+    type: 'TOOL_CALL_END';
+    messageId: string;
+    toolId: string;
+    output: unknown;
+    status: 'success' | 'error';
+} | {
+    type: 'STREAM_DONE';
+    id: string;
+    tokensIn?: number;
+    tokensOut?: number;
+    sources?: ChatSource[];
+} | {
+    type: 'STREAM_CANCELLED';
+    id: string;
+    partialText: string;
+    label?: string;
+} | {
+    type: 'STREAM_ERROR';
+    id?: string;
+    message: string;
+} | {
+    type: 'MESSAGE_EDIT';
+    id: string;
+    content: string;
+} | {
+    type: 'MESSAGE_DELETE';
+    id: string;
+} | {
+    type: 'MESSAGES_CLEAR';
+} | {
+    type: 'ERROR_SET';
+    error: string | null;
+} | {
+    type: 'ATTACHMENT_PROGRESS';
+    messageId: string;
+    attachmentId: string;
+    progress?: number;
+    status?: ChatAttachment['status'];
+};
+declare function reducer(state: ChatState, action: ChatAction): ChatState;
+
+interface UseChatConfig {
+    transport: ChatTransport;
+    initialSessionId?: string;
+    autoCreateSession?: boolean;
+    streaming?: boolean;
+    pageSize?: number;
+    onError?: (err: Error) => void;
+    /** Fires once an assistant message finishes streaming (or buffered send returns). */
+    onMessageEnd?: (msg: ChatMessage) => void;
+    /** Fires after a user message is added to the state (right before streaming starts). */
+    onMessageSent?: (msg: ChatMessage) => void;
+    /** Fires when the assistant placeholder is created (first byte / pre-stream). */
+    onStreamStart?: (assistantMessageId: string) => void;
+    metadata?: Record<string, unknown>;
+    /** Stamped on outgoing user messages as `message.sender`. */
+    userPersona?: ChatPersona;
+    /**
+     * Enable verbose dev-mode logging (consola, namespace `chat:*`).
+     * Defaults to `isDev` from `@djangocfg/ui-core/lib`. Pass `false` to silence
+     * even in development; `true` to force on in production.
+     */
+    debug?: boolean;
+}
+interface UseChatReturn extends ChatState {
+    sendMessage: (content: string, attachments?: ChatAttachment[]) => Promise<void>;
+    cancelStream: () => void;
+    regenerate: (messageId?: string) => Promise<void>;
+    editMessage: (id: string, content: string) => Promise<void>;
+    deleteMessage: (id: string) => void;
+    clearMessages: () => void;
+    loadMore: () => Promise<void>;
+    newSession: () => Promise<void>;
+    lastError: Error | null;
+}
+declare function useChat(config: UseChatConfig): UseChatReturn;
+
+interface UseChatLayoutConfig {
+    defaultMode?: ChatDisplayMode;
+    storageKey?: string;
+    sidebarStorageKey?: string;
+    reserveCssVar?: string;
+    defaultSidebarWidth?: number;
+    minSidebarWidth?: number;
+    maxSidebarWidth?: number;
+    /** Mobile breakpoint, e.g. '(max-width: 640px)'. */
+    mobileQuery?: string;
+}
+interface UseChatLayoutReturn {
+    mode: ChatDisplayMode;
+    setMode: (m: ChatDisplayMode) => void;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    sidebarWidth: number;
+    setSidebarWidth: (w: number) => void;
+    isMobile: boolean;
+    /** Mode after mobile collapse rules — sidebar/floating become fullscreen on mobile. */
+    effectiveMode: ChatDisplayMode;
+}
+declare function useChatLayout(config?: UseChatLayoutConfig): UseChatLayoutReturn;
+
+interface ChatContextValue extends UseChatReturn {
+    layout: UseChatLayoutReturn;
+    config: ChatConfig;
+    labels: ChatLabels;
+    audio: UseChatAudioReturn;
+}
+interface ChatProviderProps {
+    transport: ChatTransport;
+    config?: ChatConfig;
+    initialSessionId?: string;
+    autoCreateSession?: boolean;
+    streaming?: boolean;
+    /** Audio-trigger configuration. Off by default (no `sounds` map). */
+    audio?: ChatAudioConfig;
+    /** Enable verbose dev logging via consola. Defaults to `isDev`. */
+    debug?: boolean;
+    children?: ReactNode;
+}
+declare function ChatProvider({ transport, config, initialSessionId, autoCreateSession, streaming, audio, debug, children, }: ChatProviderProps): react_jsx_runtime.JSX.Element;
+declare function useChatContext(): ChatContextValue;
+declare function useChatContextOptional(): ChatContextValue | null;
+
+interface UseChatComposerOptions {
+    onSubmit: (content: string, attachments: ChatAttachment[]) => void | Promise<void>;
+    initialValue?: string;
+    maxLength?: number;
+    maxAttachments?: number;
+    disabled?: boolean;
+    /** 'enter' = Enter sends, Shift+Enter newline. 'cmd+enter' = Enter inserts newline, Cmd/Ctrl+Enter sends. */
+    submitOn?: 'enter' | 'cmd+enter';
+    history?: {
+        enabled?: boolean;
+        size?: number;
+    };
+    onPasteFiles?: (files: File[]) => void;
+}
+interface UseChatComposerReturn {
+    value: string;
+    setValue: (next: string) => void;
+    attachments: ChatAttachment[];
+    addAttachment: (a: ChatAttachment) => void;
+    removeAttachment: (id: string) => void;
+    isSubmitting: boolean;
+    canSubmit: boolean;
+    submit: () => Promise<void>;
+    reset: () => void;
+    focus: () => void;
+    textareaRef: RefObject<HTMLTextAreaElement | null>;
+    textareaProps: {
+        ref: RefObject<HTMLTextAreaElement | null>;
+        value: string;
+        disabled: boolean;
+        onChange: (e: ChangeEvent<HTMLTextAreaElement>) => void;
+        onKeyDown: (e: KeyboardEvent<HTMLTextAreaElement>) => void;
+        onPaste: (e: ClipboardEvent<HTMLTextAreaElement>) => void;
+    };
+    recallPrevious: () => void;
+    recallNext: () => void;
+}
+declare function useChatComposer(options: UseChatComposerOptions): UseChatComposerReturn;
+
+interface AttachmentRendererArgs {
+    attachment: ChatAttachment;
+    /** True when shown inside the composer's staging tray (denser layout). */
+    isInComposer: boolean;
+    onClick?: () => void;
+    onRemove?: () => void;
+}
+type AttachmentRenderer = (args: AttachmentRendererArgs) => ReactNode;
+interface AttachmentRendererMap {
+    image?: AttachmentRenderer;
+    audio?: AttachmentRenderer;
+    video?: AttachmentRenderer;
+    file?: AttachmentRenderer;
+    /** Fallback renderer when no per-type entry matched. */
+    default?: AttachmentRenderer;
+}
+interface CommonProps {
+    attachments: ChatAttachment[];
+    maxVisible?: number;
+    onClick?: (a: ChatAttachment) => void;
+    onRemove?: (a: ChatAttachment) => void;
+    isInComposer?: boolean;
+    className?: string;
+}
+interface AttachmentsGridProps extends CommonProps {
+    layout?: 'wrap' | 'grid';
+}
+declare function AttachmentsGrid({ attachments, maxVisible, onClick, onRemove, isInComposer, layout, className, }: AttachmentsGridProps): react_jsx_runtime.JSX.Element;
+interface AttachmentsListProps extends CommonProps {
+    /** Per-type renderer overrides. Falls back to the default tile. */
+    renderers?: AttachmentRendererMap;
+}
+declare function AttachmentsList({ attachments, maxVisible, onClick, onRemove, renderers, isInComposer, className, }: AttachmentsListProps): react_jsx_runtime.JSX.Element;
+interface AttachmentsProps extends CommonProps {
+    layout?: 'grid' | 'row';
+    renderers?: AttachmentRendererMap;
+}
+declare function Attachments(props: AttachmentsProps): react_jsx_runtime.JSX.Element;
+
+type ToolPayloadKind = 'input' | 'output' | 'streaming';
+interface ToolCallsProps {
+    calls: ChatToolCall[];
+    /** Open every panel up-front. Default: false (panels are closed). */
+    defaultExpanded?: boolean;
+    /** Auto-open while a tool is running, then auto-close on completion.
+     *  User toggles after that are remembered. Default: true. */
+    expandWhileStreaming?: boolean;
+    /** Override how the tool input payload is rendered. Receives the raw value. */
+    renderInput?: (input: unknown, call: ChatToolCall) => ReactNode;
+    /** Override how the tool output payload is rendered. */
+    renderOutput?: (output: unknown, call: ChatToolCall) => ReactNode;
+    /** Override how the live `streamingText` is rendered. */
+    renderStreaming?: (text: string, call: ChatToolCall) => ReactNode;
+    /** Single override for all three; specific renderers above take precedence. */
+    renderPayload?: (value: unknown, kind: ToolPayloadKind, call: ChatToolCall) => ReactNode;
+    className?: string;
+}
+declare function ToolCalls({ calls, defaultExpanded, expandWhileStreaming, renderInput, renderOutput, renderStreaming, renderPayload, className, }: ToolCallsProps): react_jsx_runtime.JSX.Element;
+
+interface ChatRootProps {
+    transport: ChatTransport;
+    config?: ChatConfig;
+    initialSessionId?: string;
+    autoCreateSession?: boolean;
+    streaming?: boolean;
+    /** Audio-trigger configuration. Off by default (no `sounds` map). */
+    audio?: ChatAudioConfig;
+    /**
+     * Verbose dev-mode logging via `consola` (namespace `chat:*`).
+     * Defaults to `isDev` from `@djangocfg/ui-core/lib`. Pass `false` to silence
+     * even in development, or `true` to force on in production for debugging.
+     */
+    debug?: boolean;
+    className?: string;
+    /** Sticky banner above the message list (e.g. quota warning). */
+    banner?: ReactNode;
+    /** Header row below the banner — title / actions / session switcher. */
+    header?: ReactNode;
+    /** Footer slot below the composer (disclaimers, model picker). */
+    footer?: ReactNode;
+    /** Replaces the default `<EmptyState>` rendered when the conversation is empty. */
+    empty?: ReactNode;
+    /** Slot left of the textarea inside `<Composer>`. */
+    composerToolbarStart?: ReactNode;
+    /** Slot right of the textarea inside `<Composer>`. */
+    composerToolbarEnd?: ReactNode;
+    /** Replaces the default attachment tray inside `<Composer>`. */
+    composerAttachmentTray?: ReactNode;
+    /** Replaces the default `<JumpToLatest>` floating pill. */
+    jumpToLatest?: ReactNode;
+    /** Replace `<MessageBubble>` per message. */
+    renderMessage?: (m: ChatMessage, i: number) => ReactNode;
+    /** Render the header lazily — receives the chat context. */
+    renderHeader?: (ctx: ChatContextValue) => ReactNode;
+    /** Render the empty-state lazily — receives a `setValue` to seed the composer. */
+    renderEmpty?: (api: {
+        setValue: (v: string) => void;
+        focus: () => void;
+    }) => ReactNode;
+    /** Forwarded into `<MessageBubble toolCallsProps>` so hosts can swap payload renderers. */
+    toolCallsProps?: Omit<ToolCallsProps, 'calls'>;
+    /** Per-type attachment renderers — `{ image, audio, video, file, default }`. */
+    attachmentRenderers?: AttachmentRendererMap;
+    /** Called when an attachment tile is clicked (e.g. open lightbox). */
+    onAttachmentOpen?: (attachment: ChatAttachment) => void;
+    /** Show the paperclip "attach" button in the composer. */
+    showAttachmentButton?: boolean;
+    /** Called when the user clicks the attach button (host opens its file picker). */
+    onPickFiles?: () => void;
+}
+declare function ChatRoot(props: ChatRootProps): react_jsx_runtime.JSX.Element;
+
+declare const LazyChat: react.ComponentType<ChatRootProps>;
+
+/**
+ * Chat defaults and constants.
+ */
+declare const STORAGE_KEYS: {
+    readonly mode: "djc-chat-mode";
+    readonly sidebarWidth: "djc-chat-sidebar-width";
+    readonly composerHistory: "djc-chat-composer-history";
+};
+declare const CSS_VARS: {
+    readonly reserve: "--djc-chat-reserve";
+};
+declare const DEFAULT_Z_INDEX = 9000;
+declare const LIMITS: {
+    /** Max characters per single message. */
+    readonly messageMaxLength: 8000;
+    /** Max attachments per message. */
+    readonly attachmentsMax: 10;
+    /** Composer history slots. */
+    readonly composerHistorySize: 50;
+    /** Coalesce stream tokens within this window before dispatching. */
+    readonly streamCoalesceMs: 16;
+    /** Default history page size. */
+    readonly pageSize: 50;
+    /** Virtualize list when >= this many messages (host-controlled threshold). */
+    readonly virtualizeThreshold: 50;
+    /** SSE idle timeout. */
+    readonly sseIdleMs: 45000;
+};
+declare const DEFAULT_SIDEBAR: {
+    readonly width: 420;
+    readonly min: 320;
+    readonly max: 720;
+};
+declare const HOTKEYS: {
+    readonly send: "mod+enter";
+    readonly cancel: "esc";
+    readonly newChat: "mod+shift+n";
+    readonly toggleOpen: "mod+/";
+    readonly focusComposer: "mod+l";
+};
+declare const CHAT_EVENT_NAME = "djc:chat:send";
+interface ChatEventDetail {
+    content: string;
+    sessionId?: string;
+    attachments?: unknown[];
+    metadata?: Record<string, unknown>;
+}
+
+/**
+ * ID generation. Uses crypto.randomUUID when available with a fallback
+ * for older environments (and SSR bundles that may not have crypto).
+ */
+declare function createId(prefix?: string): string;
+
+/**
+ * Token coalescer. Buffers stream tokens within a small time window before
+ * dispatching a single aggregated chunk. Prevents 60+ re-renders per second
+ * on fast streams.
+ */
+interface TokenBuffer {
+    /** Append a delta. Returns immediately. */
+    push(delta: string): void;
+    /** Force flush and resolve any pending timer. */
+    flush(): void;
+    /** Stop accepting tokens; flush whatever is buffered. */
+    close(): void;
+}
+declare function createTokenBuffer(onFlush: (delta: string) => void, windowMs?: 16): TokenBuffer;
+
+declare function resolvePersona(message: Pick<ChatMessage, 'role' | 'sender'>, user?: ChatUserContext, assistant?: ChatAssistantContext): ChatPersona;
+/** Compute initials for an avatar fallback. */
+declare function deriveInitials(persona: ChatPersona, role?: string): string;
+
+/**
+ * HTTP + SSE transport. Default implementation for web hosts.
+ *
+ * Backend contract (see @dev/@refactoring7-chat/06-integration.md):
+ *   POST   /sessions                     → SessionInfo (JSON)
+ *   GET    /sessions/:id/history?cursor= → HistoryPage (JSON)
+ *   POST   /sessions/:id/messages        → SSE stream of ChatStreamEvent
+ *   POST   /sessions/:id/messages/buffered → ChatMessage (JSON, fallback)
+ *   DELETE /sessions/:id                 → 204
+ */
+
+interface HttpTransportConfig {
+    /** Base URL without trailing slash, e.g. '/api/chat' or 'https://api.example.com/v1/chat'. */
+    baseUrl: string;
+    /** Optional slug appended/forwarded as project identifier. */
+    slug?: string;
+    /** Returns headers applied to every request — e.g. Authorization. */
+    getAuthHeader?: () => Record<string, string> | Promise<Record<string, string>>;
+    /** Default fetch timeout (per non-streaming request). */
+    timeoutMs?: number;
+    /** Override fetch implementation (useful for tests or custom retry layers). */
+    fetchImpl?: typeof fetch;
+}
+declare function createHttpTransport(config: HttpTransportConfig): ChatTransport;
+
+/**
+ * In-memory chat transport for stories and tests. Replays scripted replies.
+ */
+
+interface MockTransportOptions {
+    /** Each entry is the assistant's reply for one user turn. Strings are split
+     *  into chunks; arrays are taken as the exact event sequence (after a
+     *  prepended `message_start` and before a synthetic `message_end`). */
+    replies?: Array<string | ChatStreamEvent[]>;
+    latencyMs?: number;
+    /** Initial history returned by `createSession`. */
+    initialMessages?: ChatMessage[];
+    shouldFail?: (attempt: number) => boolean;
+}
+declare function createMockTransport(opts?: MockTransportOptions): ChatTransport;
+
+/**
+ * Server-Sent Events parser as an AsyncGenerator.
+ *
+ * Yields parsed events from a `Response` body. Handles the split-read case
+ * where `event:` and `data:` arrive in separate TCP packets. Skips malformed
+ * JSON gracefully. Honors AbortSignal (caller passes one to fetch).
+ */
+
+interface RawEvent {
+    event?: string;
+    data?: string;
+}
+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;
+    idleTimeoutMs?: number;
+}
+declare function parseSSE(response: Response, options?: ParseSSEOptions): AsyncGenerator<ChatStreamEvent, void, void>;
+
+/**
+ * Transport surface re-export. Lives in core so transport implementations
+ * never need to reach into the public types module.
+ */
+
+declare class TransportError extends Error {
+    code: string;
+    constructor(message: string, code?: string);
+}
+
+interface UseChatScrollOptions {
+    containerRef: RefObject<HTMLElement | null>;
+    bottomRef: RefObject<HTMLElement | null>;
+    isStreaming?: boolean;
+    /** Distance from bottom (px) considered "at bottom". */
+    bottomThresholdPx?: number;
+    /** Bump key — increment when a new message arrives so the hook re-evaluates auto-scroll. */
+    messagesCount?: number;
+}
+interface UseChatScrollReturn {
+    isAtBottom: boolean;
+    unreadCount: number;
+    scrollToBottom: (smooth?: boolean) => void;
+    resetUnread: () => void;
+}
+declare function useChatScroll(options: UseChatScrollOptions): UseChatScrollReturn;
+
+interface UseChatHistoryOptions {
+    enabled?: boolean;
+    containerRef: RefObject<HTMLElement | null>;
+    topSentinelRef: RefObject<HTMLElement | null>;
+    hasMore: boolean;
+    isLoadingMore: boolean;
+    loadMore: () => Promise<void>;
+}
+/** Triggers `loadMore` when the top sentinel enters the container's viewport.
+ *  Preserves scroll anchor: if the container's height grows after load, we
+ *  bump scrollTop by the delta so the previously-visible message stays put. */
+declare function useChatHistory(options: UseChatHistoryOptions): void;
+
+declare function useChatAudio(config?: ChatAudioConfig): UseChatAudioReturn;
+
+interface ChatLightboxState {
+    gallery: ChatAttachment[];
+    index: number;
+}
+interface UseChatLightboxReturn {
+    state: ChatLightboxState | null;
+    open: (att: ChatAttachment, gallery?: ChatAttachment[]) => void;
+    close: () => void;
+}
+/** Tiny state container for an image lightbox. The host owns the modal +
+ *  `<LazyImageViewer>` mount; we just track which gallery to show. */
+declare function useChatLightbox(): UseChatLightboxReturn;
+
+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;
+}
+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 ToolPayloadMatcher {
+    /** Cheap predicate. First match wins. */
+    match: (value: unknown, kind: ToolPayloadKind, call: ChatToolCall) => boolean;
+    render: (value: unknown, kind: ToolPayloadKind, call: ChatToolCall) => ReactNode;
+}
+type ToolPayloadFallback = (value: unknown, kind: ToolPayloadKind, call: ChatToolCall) => ReactNode;
+declare function dispatchToolPayload(matchers: ToolPayloadMatcher[], fallback: ToolPayloadFallback): ToolPayloadFallback;
+declare function isPlainObject(v: unknown): v is Record<string, unknown>;
+declare function isLatLng(v: unknown): v is {
+    lat: number;
+    lng: number;
+};
+declare function isGeoJSONFeatureCollection(v: unknown): v is {
+    type: 'FeatureCollection';
+    features: unknown[];
+};
+declare function isStringValue(v: unknown): v is string;
+
+/** Walk the conversation and collect image attachments in chronological order. */
+declare function collectImageAttachments(messages: ChatMessage[]): ChatAttachment[];
+
+/**
+ * Chat dev logger.
+ *
+ * A thin namespaced wrapper over `consola` that no-ops in production unless
+ * the host app explicitly opts in via `<ChatRoot debug />`. The default
+ * detection uses `isDev` from `@djangocfg/ui-core/lib/env` (NODE_ENV).
+ *
+ * Why a dedicated module: chat is async and event-heavy (bootstrap, transport,
+ * SSE chunks, tool calls, regenerate, …). Inline `console.log`s rot fast and
+ * leak into prod. A single `getChatLogger()` call gives every layer the same
+ * namespaced sub-logger and keeps zero-cost gating in one place.
+ *
+ * Sub-loggers:
+ *   bootstrap  — initial session bootstrap (createSession / loadHistory)
+ *   transport  — outbound transport calls + responses
+ *   stream     — SSE chunk / tool / message_end events
+ *   lifecycle  — sendMessage, regenerate, newSession, edits
+ *   tools      — tool_call_start / _delta / _end specifics
+ *   error      — caught errors (always emitted as `error` level)
+ */
+
+type ChatLogScope = 'bootstrap' | 'transport' | 'stream' | 'lifecycle' | 'tools' | 'error';
+interface ChatLogger {
+    bootstrap: ConsolaInstance;
+    transport: ConsolaInstance;
+    stream: ConsolaInstance;
+    lifecycle: ConsolaInstance;
+    tools: ConsolaInstance;
+    error: ConsolaInstance;
+    /** True when this logger is actually emitting (host opted in or NODE_ENV=development). */
+    enabled: boolean;
+}
+/**
+ * Get the chat logger.
+ * @param debug Explicit override from the host. `undefined` falls back to `isDev`.
+ */
+declare function getChatLogger(debug?: boolean): ChatLogger;
+
+interface MessageListProps {
+    messages?: ChatMessage[];
+    renderItem?: (m: ChatMessage, i: number) => ReactNode;
+    renderEmpty?: () => ReactNode;
+    isLoadingMore?: boolean;
+    topSentinelRef?: RefObject<HTMLDivElement | null>;
+    bottomRef?: RefObject<HTMLDivElement | null>;
+    className?: string;
+    itemClassName?: string;
+}
+declare const MessageList: react.ForwardRefExoticComponent<MessageListProps & react.RefAttributes<HTMLDivElement>>;
+
+interface MessageBubbleProps {
+    message: ChatMessage;
+    isUser?: boolean;
+    showAvatar?: boolean;
+    /** Override avatar URL (skips persona resolution). */
+    avatarSrc?: string;
+    /** Override avatar fallback (skips persona resolution). */
+    avatarFallback?: ReactNode;
+    /** Personas — when provided, take precedence over context. */
+    user?: ChatUserContext;
+    assistant?: ChatAssistantContext;
+    showTimestamp?: boolean;
+    showActions?: boolean;
+    isCompact?: boolean;
+    className?: string;
+    beforeContent?: ReactNode;
+    afterContent?: ReactNode;
+    toolCallsRenderer?: (calls: ChatToolCall[]) => ReactNode;
+    /** Forwarded to the default `<ToolCalls>` when `toolCallsRenderer` is not set. */
+    toolCallsProps?: Omit<ToolCallsProps, 'calls'>;
+    sourcesRenderer?: (sources: ChatSource[]) => ReactNode;
+    attachmentsRenderer?: (atts: ChatAttachment[]) => ReactNode;
+    /** Per-type attachment renderers forwarded to default `<Attachments>`. */
+    attachmentRenderers?: AttachmentRendererMap;
+    /** Click handler for attachment tiles (e.g. open lightbox). */
+    onAttachmentOpen?: (a: ChatAttachment) => void;
+    onCopy?: () => void;
+    onRegenerate?: () => void;
+    onEdit?: () => void;
+    onDelete?: () => void;
+}
+declare const MessageBubble: react.MemoExoticComponent<({ message, isUser: isUserProp, showAvatar, avatarSrc, avatarFallback, user, assistant, showTimestamp, showActions, isCompact, className, beforeContent, afterContent, toolCallsRenderer, toolCallsProps, sourcesRenderer, attachmentsRenderer, attachmentRenderers, onAttachmentOpen, onCopy, onRegenerate, onEdit, onDelete, }: MessageBubbleProps) => react_jsx_runtime.JSX.Element>;
+
+interface MessageActionsProps {
+    role: ChatRole;
+    onCopy?: () => void;
+    onRegenerate?: () => void;
+    onEdit?: () => void;
+    onDelete?: () => void;
+    hideOn?: Array<ChatRole>;
+    className?: string;
+}
+declare function MessageActions({ role, onCopy, onRegenerate, onEdit, onDelete, hideOn, className, }: MessageActionsProps): react_jsx_runtime.JSX.Element;
+
+interface ComposerProps {
+    composer: UseChatComposerReturn;
+    placeholder?: string;
+    disabled?: boolean;
+    showAttachmentButton?: boolean;
+    onPickFiles?: () => void;
+    toolbarStart?: ReactNode;
+    toolbarEnd?: ReactNode;
+    attachmentTray?: ReactNode;
+    className?: string;
+    textareaClassName?: string;
+    /** Show "Stop" button instead of "Send" while streaming. */
+    isStreaming?: boolean;
+    onCancel?: () => void;
+}
+declare const Composer: react.ForwardRefExoticComponent<ComposerProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SourcesProps {
+    sources: ChatSource[];
+    layout?: 'inline' | 'grid';
+    maxVisible?: number;
+    onClick?: (source: ChatSource) => void;
+    className?: string;
+}
+declare function Sources({ sources, layout, maxVisible, onClick, className }: SourcesProps): react_jsx_runtime.JSX.Element;
+
+interface EmptyStateProps {
+    greeting?: string;
+    description?: string;
+    suggestions?: Array<{
+        label: string;
+        prompt: string;
+    }>;
+    onPickSuggestion?: (prompt: string) => void;
+    className?: string;
+}
+declare function EmptyState({ greeting, description, suggestions, onPickSuggestion, className, }: EmptyStateProps): react_jsx_runtime.JSX.Element;
+
+interface ErrorBannerProps {
+    error: string | null;
+    onDismiss?: () => void;
+    onRetry?: () => void;
+    className?: string;
+}
+declare function ErrorBanner({ error, onDismiss, onRetry, className }: ErrorBannerProps): react_jsx_runtime.JSX.Element;
+
+interface JumpToLatestProps {
+    visible?: boolean;
+    unreadCount?: number;
+    onClick?: () => void;
+    className?: string;
+}
+declare function JumpToLatest({ visible, unreadCount, onClick, className }: JumpToLatestProps): react_jsx_runtime.JSX.Element;
+
+interface StreamingIndicatorProps {
+    variant?: 'dots' | 'pulse';
+    label?: string;
+    className?: string;
+}
+declare function StreamingIndicator({ variant, label, className }: StreamingIndicatorProps): react_jsx_runtime.JSX.Element;
 
 /**
  * PrettyCode Component - Dynamic Import Wrapper
@@ -1418,7 +2404,7 @@ interface PrettyCodeProps {
      */
     variant?: 'card' | 'plain';
 }
-declare const PrettyCode: React__default.FC<PrettyCodeProps>;
+declare const PrettyCode: react__default.FC<PrettyCodeProps>;
 
 /**
  * useLottie Hook
@@ -1501,7 +2487,7 @@ declare function LottiePlayer(props: LottiePlayerProps): react_jsx_runtime.JSX.E
 interface PlaygroundProps {
     config: PlaygroundConfig;
 }
-declare const Playground: React__default.FC<PlaygroundProps>;
+declare const Playground: react__default.FC<PlaygroundProps>;
 
 /**
  * VideoPlayer - Unified Video Player Component
@@ -1541,12 +2527,12 @@ declare const Playground: React__default.FC<PlaygroundProps>;
  * <VideoPlayer source={{ type: 'blob', data: arrayBuffer, mimeType: 'video/mp4' }} />
  */
 
-declare const VideoPlayer: React__default.ForwardRefExoticComponent<VideoPlayerProps & {
+declare const VideoPlayer: react__default.ForwardRefExoticComponent<VideoPlayerProps & {
     source: VideoSourceUnion | SimpleStreamSource;
-} & React__default.RefAttributes<VideoPlayerRef>>;
+} & react__default.RefAttributes<VideoPlayerRef>>;
 
 interface VideoControlsProps {
-    player: React__default.RefObject<MediaPlayerInstance | null>;
+    player: react__default.RefObject<MediaPlayerInstance | null>;
     className?: string;
 }
 declare function VideoControls({ player, className }: VideoControlsProps): react_jsx_runtime.JSX.Element;
@@ -1563,7 +2549,7 @@ interface VideoErrorFallbackProps extends ErrorFallbackProps {
     /** Custom className */
     className?: string;
     /** Custom icon */
-    icon?: React__default.ReactNode;
+    icon?: react__default.ReactNode;
     /** Custom title (defaults to error message) */
     title?: string;
     /** Custom description */
@@ -1618,21 +2604,21 @@ interface CreateVideoErrorFallbackOptions {
  *
  * <VideoPlayer source={source} errorFallback={errorFallback} />
  */
-declare function createVideoErrorFallback(options: CreateVideoErrorFallbackOptions): (props: ErrorFallbackProps, source?: unknown) => React__default.ReactNode;
+declare function createVideoErrorFallback(options: CreateVideoErrorFallbackOptions): (props: ErrorFallbackProps, source?: unknown) => react__default.ReactNode;
 
 /**
  * VidstackProvider - Full-featured video player using Vidstack
  * Supports YouTube, Vimeo, HLS, DASH, and direct URLs
  */
 
-declare const VidstackProvider: React__default.ForwardRefExoticComponent<VidstackProviderProps & React__default.RefAttributes<VideoPlayerRef>>;
+declare const VidstackProvider: react__default.ForwardRefExoticComponent<VidstackProviderProps & react__default.RefAttributes<VideoPlayerRef>>;
 
 /**
  * NativeProvider - Lightweight native HTML5 video player
  * For demo videos, background videos, autoplay loop muted scenarios
  */
 
-declare const NativeProvider: React__default.ForwardRefExoticComponent<NativeProviderProps & React__default.RefAttributes<VideoPlayerRef>>;
+declare const NativeProvider: react__default.ForwardRefExoticComponent<NativeProviderProps & react__default.RefAttributes<VideoPlayerRef>>;
 
 /**
  * StreamProvider - HTTP Range streaming and Blob video player
@@ -1644,7 +2630,7 @@ declare const NativeProvider: React__default.ForwardRefExoticComponent<NativePro
  * - Custom error fallback
  */
 
-declare const StreamProvider: React__default.ForwardRefExoticComponent<StreamProviderProps & React__default.RefAttributes<VideoPlayerRef>>;
+declare const StreamProvider: react__default.ForwardRefExoticComponent<StreamProviderProps & react__default.RefAttributes<VideoPlayerRef>>;
 
 /**
  * Provider for VideoPlayer streaming configuration
@@ -1703,7 +2689,7 @@ declare function resolveStreamSource(source: SimpleStreamSource, context: VideoP
  */
 declare function resolveFileSource(options: ResolveFileSourceOptions): VideoSourceUnion | null;
 
-declare const Player: React$1.ForwardRefExoticComponent<PlayerProps & React$1.RefAttributes<PlayerHandle>>;
+declare const Player: react.ForwardRefExoticComponent<PlayerProps & react.RefAttributes<PlayerHandle>>;
 
 declare function ImageViewer({ images, initialIndex, inDialog, }: ImageViewerProps): react_jsx_runtime.JSX.Element;
 
@@ -2015,7 +3001,7 @@ interface EditorRef {
  * />
  * ```
  */
-declare const Editor: React$1.ForwardRefExoticComponent<EditorProps & React$1.RefAttributes<EditorRef>>;
+declare const Editor: react.ForwardRefExoticComponent<EditorProps & react.RefAttributes<EditorRef>>;
 
 /**
  * Monaco Diff Editor Component
@@ -2400,4 +3386,4 @@ declare function useBlobUrlCleanup(key: string | null): void;
  */
 declare function generateContentKey(content: ArrayBuffer): string;
 
-export { type ApiKey, ArrayFieldItemTemplate, ArrayFieldTemplate, type AspectRatioValue, Player as AudioPlayer, type PlayerProps as AudioPlayerProps, BaseInputTemplate, type BlobSource, CardLoadingFallback, CheckboxWidget, ColorWidget, type CreateLazyComponentOptions, type CreateVideoErrorFallbackOptions, CronScheduler, type CronSchedulerContextValue, type CronSchedulerProps, CronSchedulerProvider, type CronSchedulerState, CustomInput, type DASHSource, type DataUrlSource, DayChips, DiffEditor, type DiffEditorProps, type DisabledWhenRule, Editor, type EditorContextValue, type EditorFile, type EditorOptions, type EditorProps, EditorProvider, type EditorRef, type ErrorFallbackProps, ErrorListTemplate, FieldTemplate, type HLSSource, type ImageFile, ImageViewer, type ImageViewerProps, type JsonFormContext, type JsonFormDensity, JsonSchemaForm, type JsonSchemaFormProps, JsonTreeComponent as JsonTree, type JsonTreeConfig, type JsonTreeProps, LazyPlayer as LazyAudioPlayer, 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, type MonthDay, MonthDayGrid, NativeProvider, NumberWidget, ObjectFieldTemplate, Playground as OpenapiViewer, type PlayerMode, type PlaygroundConfig, type PlaygroundProps$1 as PlaygroundProps, PrettyCode, type PrettyCodeProps$1 as PrettyCodeProps, type ResolveFileSourceOptions, SchedulePreview, type ScheduleType, ScheduleTypeSelector, type SchemaSource, SelectWidget, type SimpleStreamSource, SliderWidget, Spinner, StreamProvider, type StreamSource, SwitchWidget, TextWidget, TimeSelector, TreeRootProps, type UiGroup, type UrlSource, 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, createLazyComponent, createVideoErrorFallback, evaluateDisabledWhen, extractTextFromChildren, generateContentKey, getRequiredFields, hasRequiredFields, humanizeCron, isSimpleStreamSource, isValidCron, mentionPresets, mergeDefaults, normalizeFormData, parseCron, resolveFileSource, resolvePlayerMode, resolveStreamSource, safeJsonParse, safeJsonStringify, useAudioCache, useBlobUrlCleanup, useCollapsibleContent, useCronCustom, useCronMonthDays, useCronPreview, useCronScheduler, useCronSchedulerContext, useCronTime, useCronType, useCronWeekDays, useEditor, useEditorContext, useImageCache, useLanguage, useLottie, useMediaCacheStore, useMonaco, useVideoCache, useVideoPlayerContext, useVideoPlayerSettings, validateRequiredFields, validateSchema };
+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, 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 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 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 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, isValidCron, mentionPresets, mergeDefaults, normalizeFormData, parseCron, parseSSE, reducer, resolveFileSource, resolvePersona, resolvePlayerMode, resolveStreamSource, safeJsonParse, safeJsonStringify, useAudioCache, 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, useVideoCache, useVideoPlayerContext, useVideoPlayerSettings, validateRequiredFields, validateSchema };