@smartspace/chat-ui 1.13.1-pr.243.6b4d4ce

package/dist/index.d.ts

@@ -0,0 +1,1286 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import React__default from 'react';
+import * as _jsonforms_core from '@jsonforms/core';
+import { z } from 'zod';
+import { SignalR } from '@smartspace/api-client';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { QueryClient } from '@tanstack/react-query';
+
+declare global {
+    interface Window {
+        __ssDownloadFile?: (id: string) => Promise<string>;
+    }
+}
+type MessageComposerProps = {
+    /** Mirrors `MessageList`'s `expandedLayout`. See its docs. */
+    expandedLayout?: boolean;
+};
+declare function MessageComposer({ expandedLayout, }?: MessageComposerProps): react_jsx_runtime.JSX.Element;
+
+type MessageListProps = {
+    /**
+     * Apply a solid-base + tag-driven gradient to the message body. Set this
+     * when embedding inside a host whose default page background can show
+     * through and skew the perceived chat color (e.g. Microsoft Teams web
+     * client). Defaults to false — the standard browser app doesn't need it.
+     */
+    applyHostBackgroundOverride?: boolean;
+    /**
+     * Use the wider desktop max-width (90% instead of 70%). Set this when the
+     * chat is rendered in a layout where horizontal room is constrained by
+     * other panels (e.g. a sidebar is open beside it). Standalone fork passes
+     * `leftOpen || rightOpen` from `useSidebar()`; the sandbox doesn't have
+     * sidebars, so it omits the prop and gets the natural 70% width.
+     */
+    expandedLayout?: boolean;
+};
+declare function MessageList({ applyHostBackgroundOverride, expandedLayout, }?: MessageListProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Skeleton for the message list loading state.
+ * Three message-shaped rows; use theme tokens only (no px, no Tailwind).
+ */
+declare function MessageListSkeleton(): react_jsx_runtime.JSX.Element;
+
+type AccessLevel = 'Read' | 'Write';
+interface VariableConfig {
+    access: AccessLevel;
+    schema: _jsonforms_core.JsonSchema7;
+}
+interface WorkspaceLike {
+    variables?: Record<string, VariableConfig>;
+}
+interface ChatVariablesFormProps {
+    workspace: WorkspaceLike;
+    threadId: string;
+}
+interface ChatVariablesFormRef {
+    hasChanges: () => boolean;
+    getChangedVariables: () => Record<string, unknown>;
+    getCurrentVariables: () => Record<string, unknown>;
+    saveChangedVariables: () => Promise<void>;
+}
+
+declare const ChatVariablesForm: React.ForwardRefExoticComponent<ChatVariablesFormProps & {
+    setVariables: (variables: Record<string, unknown>) => void;
+} & React.RefAttributes<ChatVariablesFormRef>>;
+
+type MentionUserLike = {
+    id: string;
+    displayName: string;
+};
+type FetchMentionUsers = (workspaceId: string) => Promise<MentionUserLike[]>;
+type MarkdownEditorHandle = {
+    addFiles: (files: File[]) => void;
+    focus: () => void;
+    /** Clears the editor content (useful when host clears `value`, since Milkdown isn't fully controlled here). */
+    clear: () => void;
+    /**
+     * Serializes the current editor doc to markdown synchronously.
+     * Needed because the `markdownUpdated` listener is debounced by 200ms inside
+     * `@milkdown/plugin-listener`, so React state can lag behind what's in the editor.
+     * Callers that need the freshest text (e.g. sending on Enter) should read from here.
+     */
+    getMarkdown: () => string;
+    /**
+     * Returns mention users currently present in the editor document.
+     * Useful for building API payloads (e.g. comments.mentionedUsers).
+     */
+    getMentionedUsers?: () => Array<{
+        id: string;
+        displayName: string;
+    }>;
+    /**
+     * Returns plain text for the current editor content, with mention nodes rendered as "@Display Name".
+     * Useful when the host renders content as plain text (not markdown).
+     */
+    getPlainText?: () => string;
+};
+type MarkdownEditorProps = {
+    value?: string;
+    onChange?: (md: string) => void;
+    onKeyDown?: (e: React__default.KeyboardEvent) => void;
+    onImagesPasted?: (files: File[]) => void;
+    onFilesAdded?: (files: File[]) => void;
+    onUploadFiles?: (files: File[]) => Promise<{
+        id: string;
+        name: string;
+    }[]>;
+    /**
+     * Controls what happens when the user drops files onto the editor surface.
+     * - 'inline' (default): upload + insert `ssImage`/`fileTag` nodes into the editor when possible.
+     * - 'attachments': do NOT insert into the editor; instead call `onFilesAdded` so the host can manage attachments UI.
+     */
+    fileHandlingMode?: 'inline' | 'attachments';
+    disabled?: boolean;
+    editable?: boolean;
+    className?: string;
+    minHeight?: number | string;
+    maxHeight?: number | string;
+    ghostMessage?: string;
+    placeholder?: string;
+    workspaceId?: string;
+    threadId?: string;
+    enableMentions?: boolean;
+    /**
+     * Optional mention users fetcher. Kept as a prop so this shared component does not
+     * depend on any domain/service modules.
+     */
+    fetchMentionUsers?: FetchMentionUsers;
+};
+declare const MarkdownEditor: React__default.ForwardRefExoticComponent<MarkdownEditorProps & React__default.RefAttributes<MarkdownEditorHandle>>;
+
+type MessageMarkdownProps = {
+    value: string;
+    className?: string;
+};
+/** Read-only markdown renderer for chat messages. Uses react-markdown +
+ *  rehype-raw so mixed markdown/HTML rebalances via parse5, which fixes
+ *  cases like `<details>` wrapping a fenced code block. Shares the
+ *  `ss-code-block` CSS scope with the Milkdown editor via the
+ *  `ss-markdown` wrapper class (see `styles.css`). */
+declare function MessageMarkdown({ value, className }: MessageMarkdownProps): react_jsx_runtime.JSX.Element;
+
+type FileInfo$1 = {
+    id: string;
+    name: string;
+};
+type FileScope = {
+    workspaceId?: string;
+    threadId?: string;
+};
+
+type FlowRunVariables = Record<string, unknown>;
+
+declare enum MessageValueType {
+    OUTPUT = "Output",
+    INPUT = "Input"
+}
+
+type FileInfo = {
+    id: string;
+    name: string;
+};
+type MessageContentItem = {
+    text?: string | null;
+    image?: FileInfo | null;
+};
+type MessageValue = {
+    id: string;
+    name: string;
+    type: MessageValueType;
+    value: unknown;
+    channels: Record<string, number>;
+    createdAt: Date;
+    createdBy: string;
+    createdByUserId?: string | null;
+};
+type Message = {
+    id?: string | null;
+    createdAt: Date;
+    createdBy?: string | null;
+    hasComments?: boolean;
+    createdByUserId?: string | null;
+    messageThreadId?: string | null;
+    errors?: {
+        code: number;
+        message?: string | null;
+        data?: string | null;
+        blockId?: string | null;
+    }[] | null;
+    values?: MessageValue[] | null;
+    optimistic?: boolean;
+};
+
+type ModelProperty = {
+    name: string;
+    type: string;
+    defaultValue: number;
+    minValue: number;
+    maxValue: number;
+    step: number;
+};
+type Model = {
+    id: string;
+    name: string;
+    displayName: string;
+    deploymentStatus: string;
+    modelDeploymentProviderType: string;
+    modelPublisher: string | null;
+    createdByUserId: string;
+    createdAt: Date;
+    properties: ModelProperty[];
+    virtualMachineUrl: string | null;
+};
+
+type MessageThread = {
+    id: string;
+    createdAt: Date;
+    createdBy: string;
+    createdByUserId: string;
+    isFlowRunning: boolean;
+    lastUpdatedAt: Date;
+    lastUpdatedByUserId: string;
+    name: string;
+    totalMessages: number;
+    pinned: boolean;
+    workSpaceId: string;
+};
+type ThreadsResponse = {
+    data: MessageThread[];
+    total: number;
+};
+
+type VariableAccess = 'Read' | 'Write';
+type Variables = Record<string, {
+    schema: Record<string, unknown>;
+    access: VariableAccess;
+}>;
+type MentionUser = {
+    id: string;
+    displayName: string;
+    initials: string;
+};
+type Workspace = {
+    id: string;
+    name: string;
+    tags?: string[];
+    showSources?: boolean;
+    dataSpaces?: unknown[];
+    createdByUserId?: string;
+    createdAt?: Date;
+    modifiedByUserId?: string;
+    modifiedAt?: Date;
+    favorited: boolean;
+    summary?: string;
+    firstPrompt?: string;
+    outputSchema?: unknown;
+    isPromptAndResponseLoggingEnabled?: boolean;
+    inputs?: unknown;
+    variables: Variables;
+    sandBoxThreadId?: string;
+    supportsFiles?: boolean;
+    avatarName: string;
+};
+
+/**
+ * Port / adapter interface for everything the chat UI needs from a backend.
+ *
+ * The production app provides `createDefaultChatService()` which delegates to
+ * the `ChatApi`-backed implementations in `src/domains/*\/service.ts`. A
+ * separate consumer repo (the sandbox debug harness) will provide its own
+ * implementation backed by `ConfigApi.sandBox*` endpoints.
+ *
+ * This interface MUST remain the single contract between the chat UI and its
+ * backend — no component in `src/ui/messages/` or hook in `src/domains/messages/`
+ * should reach outside of this boundary.
+ */
+interface ChatService {
+    /** Fetch messages for a thread (paginated via take/skip). */
+    fetchMessages(threadId: string, opts?: {
+        take?: number;
+        skip?: number;
+    }): Promise<Message[]>;
+    /**
+     * Post a new user message. Returns the server-authoritative initial Message
+     * (id, inputs populated). Output deltas arrive via the thread SSE keyed by
+     * the returned id — callers should reconcile their optimistic temp-id entry
+     * with this response.
+     */
+    sendMessage(args: {
+        workspaceId: string;
+        threadId: string;
+        contentList?: MessageContentItem[];
+        files?: FileInfo$1[];
+        variables?: Record<string, unknown>;
+    }): Promise<Message>;
+    /**
+     * Submit a structured input (e.g. form values) to an existing message. The
+     * server streams `IAsyncEnumerable<Message>`; the last successfully parsed
+     * frame is returned.
+     */
+    addInputToMessage(args: {
+        messageId: string;
+        name: string;
+        value: unknown;
+        channels: Record<string, number> | null;
+    }): Promise<Message>;
+    uploadFiles(files: File[], scope: FileScope, onFileUploaded?: (file: File, fileInfo: FileInfo$1) => void, onChunkUploaded?: (chunkIndex: number, totalChunks: number, file: File) => void): Promise<FileInfo$1[]>;
+    downloadFile(id: string, scope?: FileScope): Promise<Blob>;
+    getFileInfo(id: string, scope: FileScope): Promise<FileInfo$1>;
+    getFileDownloadUrl(sourceUri: string): Promise<string>;
+    fetchThread(workspaceId: string, threadId: string): Promise<MessageThread>;
+    fetchWorkspace(workspaceId: string): Promise<Workspace>;
+    fetchTaggableUsers(workspaceId: string): Promise<MentionUser[]>;
+    /**
+     * Read the current flow-run variable set for a thread. Used by the chat
+     * variables form to seed initial values.
+     */
+    fetchFlowRunVariables(flowRunId: string): Promise<FlowRunVariables>;
+    /**
+     * Patch a single flow-run variable. The chat variables form calls this on
+     * each change to keep the running flow's variable state in sync.
+     */
+    updateFlowRunVariable(args: {
+        flowRunId: string;
+        name: string;
+        value: unknown;
+    }): Promise<void>;
+    /**
+     * List models the user has access to. Drives the model-id renderer in the
+     * variables form (a dropdown of selectable models).
+     */
+    fetchModels(opts?: {
+        search?: string;
+        take?: number;
+        skip?: number;
+    }): Promise<{
+        data: Model[];
+        total: number;
+    }>;
+}
+
+type ChatIdentity = {
+    userId: string;
+    displayName: string;
+};
+type ChatContextIds = {
+    workspaceId: string;
+    /** Empty string when no thread is currently selected (e.g. draft state). */
+    threadId: string;
+};
+type ChatProviderProps = {
+    service: ChatService;
+    workspaceId: string;
+    threadId: string;
+    identity: ChatIdentity;
+    children: React__default.ReactNode;
+};
+/**
+ * Single point of injection for the chat UI subtree. Provides:
+ *   - a `ChatService` implementation (backend port)
+ *   - the current `{ workspaceId, threadId }` context
+ *   - user identity used for optimistic message stamping
+ *
+ * All message UI components and message/file/thread/workspace hooks read
+ * from this provider instead of reaching into platform auth or TanStack
+ * Router directly — that is what makes the chat UI portable to a package.
+ */
+declare function ChatProvider({ service, workspaceId, threadId, identity, children, }: ChatProviderProps): react_jsx_runtime.JSX.Element;
+declare function useChatService(): ChatService;
+declare function useChatContext(): ChatContextIds;
+declare function useChatIdentity(): ChatIdentity;
+
+declare function getModelIcon(model: Model | null | undefined): string | null;
+
+declare const messagesResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        createdAt: z.ZodISODateTime;
+        createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        createdByUserId: z.ZodString;
+        errors: z.ZodArray<z.ZodObject<{
+            blockId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            code: z.ZodNumber;
+            data: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+            message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        hasComments: z.ZodBoolean;
+        id: z.ZodString;
+        messageThreadId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        values: z.ZodArray<z.ZodObject<{
+            channels: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            createdAt: z.ZodISODateTime;
+            createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            createdByUserId: z.ZodString;
+            id: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                Input: "Input";
+                Output: "Output";
+            }>;
+            value: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+type MessagesResponseDto = z.infer<typeof messagesResponseSchema>;
+type MessageDto = MessagesResponseDto['data'][number];
+type MessageValueDto = NonNullable<MessageDto['values']>[number];
+type MessageErrorDto = NonNullable<MessageDto['errors']>[number];
+type MessageError = NonNullable<Message['errors']>[number];
+declare function mapMessageValueDtoToModel(dto: MessageValueDto): MessageValue;
+declare function mapMessageErrorDtoToModel(dto: MessageErrorDto): MessageError;
+declare function mapMessageDtoToModel(dto: MessageDto): Message;
+declare function mapMessagesDtoToModels(dto: MessageDto[]): Message[];
+/**
+ * Merge a streaming delta into a message. `outputs` is a cumulative snapshot
+ * keyed by `(name, type)` per the SSE protocol — when an output streams from
+ * "He" → "Hel" → "Hello" we receive three deltas each carrying the full
+ * text-so-far, so we replace by key rather than appending. Errors aren't
+ * documented as cumulative, so we append them.
+ */
+declare function applyDeltaToMessage(target: Message, delta: {
+    outputs: MessageValue[];
+    errors: MessageError[];
+}): Message;
+
+declare const fileInfoResponseSchema: z.ZodObject<{
+    createdAt: z.ZodISODateTime;
+    createdByUserId: z.ZodString;
+    id: z.ZodString;
+    modifiedAt: z.ZodISODateTime;
+    modifiedByUserId: z.ZodString;
+    name: z.ZodString;
+    size: z.ZodNumber;
+    threadId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    workspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+declare const fileInfoItemSchema: z.ZodObject<{
+    createdAt: z.ZodISODateTime;
+    createdByUserId: z.ZodString;
+    id: z.ZodString;
+    modifiedAt: z.ZodISODateTime;
+    modifiedByUserId: z.ZodString;
+    name: z.ZodString;
+    size: z.ZodNumber;
+    threadId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    workspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type FileInfoDto = z.infer<typeof fileInfoResponseSchema>;
+type FileInfoItemDto = z.infer<typeof fileInfoItemSchema>;
+declare function mapFileInfoDtoToModel(dto: FileInfoDto | FileInfoItemDto): FileInfo$1;
+
+declare const threadsListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        createdAt: z.ZodISODateTime;
+        createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        createdByUserId: z.ZodString;
+        favorited: z.ZodBoolean;
+        id: z.ZodString;
+        isFlowRunning: z.ZodBoolean;
+        lastUpdated: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        lastUpdatedAt: z.ZodISODateTime;
+        lastUpdatedByUserId: z.ZodString;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        totalMessages: z.ZodNumber;
+        workSpaceId: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+declare const threadResponseSchema: z.ZodObject<{
+    createdAt: z.ZodISODateTime;
+    createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdByUserId: z.ZodString;
+    favorited: z.ZodBoolean;
+    id: z.ZodString;
+    isFlowRunning: z.ZodBoolean;
+    lastUpdated: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastUpdatedAt: z.ZodISODateTime;
+    lastUpdatedByUserId: z.ZodString;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    totalMessages: z.ZodNumber;
+    workSpaceId: z.ZodString;
+}, z.core.$strip>;
+type ThreadsResponseDto = z.infer<typeof threadsListResponseSchema>;
+type ThreadDto = z.infer<typeof threadResponseSchema>;
+declare function mapThreadDtoToModel(dto: ThreadDto): MessageThread;
+declare function mapThreadsResponseDtoToModel(dto: ThreadsResponseDto): ThreadsResponse;
+/**
+ * Map the SignalR `receiveThreadUpdate` payload to our thread model so we
+ * can write it straight into the query cache without invalidating + refetching.
+ */
+declare function mapSignalRThreadSummaryToModel(summary: SignalR.MessageThreadSummary): MessageThread;
+
+declare const workspaceResponseSchema: z.ZodObject<{
+    createdAt: z.ZodISODateTime;
+    createdByUserId: z.ZodString;
+    dataSpaces: z.ZodArray<z.ZodObject<{
+        createdAt: z.ZodISODateTime;
+        createdByUserId: z.ZodString;
+        dataSets: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            createdAt: z.ZodISODateTime;
+            createdByUserId: z.ZodString;
+            dataSpaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            flow: z.ZodOptional<z.ZodObject<{
+                activeFlowDefinition: z.ZodOptional<z.ZodObject<{
+                    blocks: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        constants: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                            target: z.ZodObject<{
+                                pin: z.ZodString;
+                                port: z.ZodString;
+                            }, z.core.$strip>;
+                            value: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+                        }, z.core.$strip>>>>;
+                        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        dynamicInputPins: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                            pin: z.ZodString;
+                            port: z.ZodString;
+                        }, z.core.$strip>>>>;
+                        dynamicOutputPins: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                            pin: z.ZodString;
+                            port: z.ZodString;
+                        }, z.core.$strip>>>>;
+                        dynamicPorts: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+                        name: z.ZodString;
+                        version: z.ZodString;
+                    }, z.core.$strip>>>>;
+                    connections: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                        source: z.ZodObject<{
+                            node: z.ZodString;
+                            pin: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                            port: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        }, z.core.$strip>;
+                        target: z.ZodObject<{
+                            node: z.ZodString;
+                            pin: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                            port: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>>;
+                    constants: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        value: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+                    }, z.core.$strip>>>>;
+                    inputs: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        schema: z.ZodRecord<z.ZodString, z.ZodAny>;
+                    }, z.core.$strip>>>>;
+                    layout: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+                    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    outputs: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        schema: z.ZodRecord<z.ZodString, z.ZodAny>;
+                    }, z.core.$strip>>>>;
+                    variables: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        access: z.ZodEnum<{
+                            None: "None";
+                            Read: "Read";
+                            Write: "Write";
+                        }>;
+                        schema: z.ZodRecord<z.ZodString, z.ZodAny>;
+                    }, z.core.$strip>>>>;
+                }, z.core.$strip>>;
+                activeFlowDefinitionId: z.ZodString;
+                id: z.ZodString;
+                triggers: z.ZodArray<z.ZodObject<{
+                    dataSourceContainer: z.ZodObject<{
+                        dataSourceId: z.ZodString;
+                        id: z.ZodString;
+                        name: z.ZodString;
+                        path: z.ZodString;
+                    }, z.core.$strip>;
+                    flowId: z.ZodString;
+                    id: z.ZodString;
+                    inputName: z.ZodString;
+                    type: z.ZodEnum<{
+                        Periodic: "Periodic";
+                        Container: "Container";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            id: z.ZodString;
+            modifiedAt: z.ZodISODateTime;
+            modifiedByUserId: z.ZodString;
+            name: z.ZodString;
+            properties: z.ZodArray<z.ZodObject<{
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                isVector: z.ZodBoolean;
+                name: z.ZodString;
+            }, z.core.$strip>>;
+            version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>>;
+        id: z.ZodString;
+        modifiedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+        modifiedByUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        name: z.ZodString;
+        parentWorkspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        workspacesInfo: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>;
+    favorited: z.ZodBoolean;
+    firstPrompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    inputs: z.ZodRecord<z.ZodString, z.ZodObject<{
+        schema: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, z.core.$strip>>;
+    isPromptAndResponseLoggingEnabled: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    modelConfigurations: z.ZodArray<z.ZodObject<{
+        frequencyPenalty: z.ZodNumber;
+        model: z.ZodObject<{
+            createdAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+            createdByUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            deployment: z.ZodOptional<z.ZodObject<{
+                createdAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+                createdByUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                detailedMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                dockerFile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                id: z.ZodString;
+                modelName: z.ZodString;
+                providerDeploymentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                providerId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                region: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                status: z.ZodEnum<{
+                    Deploying: "Deploying";
+                    Ready: "Ready";
+                    Failed: "Failed";
+                    Deleting: "Deleting";
+                    Deleted: "Deleted";
+                }>;
+                statusMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                statusUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+                steps: z.ZodArray<z.ZodObject<{
+                    finishedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+                    id: z.ZodString;
+                    index: z.ZodNumber;
+                    message: z.ZodString;
+                    name: z.ZodEnum<{
+                        DeployVNet: "DeployVNet";
+                        DeployVM: "DeployVM";
+                        InstallDependencies: "InstallDependencies";
+                        DownloadModel: "DownloadModel";
+                        TestModel: "TestModel";
+                    }>;
+                    progress: z.ZodNumber;
+                    startedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+                }, z.core.$strip>>;
+                url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                virtualMachineServerType: z.ZodOptional<z.ZodEnum<{
+                    TextGenerationInference: "TextGenerationInference";
+                    VLlm: "VLlm";
+                }>>;
+                virtualMachineUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                vmSize: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+            displayName: z.ZodString;
+            id: z.ZodString;
+            modelDeploymentProviderType: z.ZodOptional<z.ZodEnum<{
+                OpenAi: "OpenAi";
+                AzureOpenAi: "AzureOpenAi";
+                HuggingFace: "HuggingFace";
+                Cohere: "Cohere";
+                Anthropic: "Anthropic";
+                Gemini: "Gemini";
+                VertexAi: "VertexAi";
+                AzureFoundry: "AzureFoundry";
+            }>>;
+            modelPublisher: z.ZodOptional<z.ZodEnum<{
+                OpenAi: "OpenAi";
+                HuggingFace: "HuggingFace";
+                Cohere: "Cohere";
+                Anthropic: "Anthropic";
+                Google: "Google";
+                Meta: "Meta";
+                Mistral: "Mistral";
+                Microsoft: "Microsoft";
+                DeepSeek: "DeepSeek";
+                XAi: "XAi";
+                Amazon: "Amazon";
+                Qwen: "Qwen";
+                Other: "Other";
+            }>>;
+            name: z.ZodString;
+            properties: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    Boolean: "Boolean";
+                    Number: "Number";
+                    String: "String";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        prePrompt: z.ZodString;
+        presencePenalty: z.ZodNumber;
+        role: z.ZodEnum<{
+            Document: "Document";
+            Agent: "Agent";
+            Analyzer: "Analyzer";
+        }>;
+        temperature: z.ZodNumber;
+        topP: z.ZodNumber;
+    }, z.core.$strip>>;
+    modifiedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+    modifiedByUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodString;
+    outputSchema: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sandBoxThreadId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    showSources: z.ZodBoolean;
+    summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    supportsFiles: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    tags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    variables: z.ZodRecord<z.ZodString, z.ZodObject<{
+        access: z.ZodEnum<{
+            None: "None";
+            Read: "Read";
+            Write: "Write";
+        }>;
+        schema: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const workspaceUsersResponseSchema: z.ZodArray<z.ZodObject<{
+    displayName: z.ZodString;
+    emailAddress: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    id: z.ZodString;
+    userId: z.ZodString;
+}, z.core.$strip>>;
+declare const workspacesListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        createdAt: z.ZodISODateTime;
+        createdByUserId: z.ZodString;
+        dataSpaces: z.ZodArray<z.ZodObject<{
+            createdAt: z.ZodISODateTime;
+            createdByUserId: z.ZodString;
+            dataSets: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                createdAt: z.ZodISODateTime;
+                createdByUserId: z.ZodString;
+                dataSpaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                flow: z.ZodOptional<z.ZodObject<{
+                    activeFlowDefinition: z.ZodOptional<z.ZodObject<{
+                        blocks: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            constants: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                                target: z.ZodObject<{
+                                    pin: z.ZodString;
+                                    port: z.ZodString;
+                                }, z.core.$strip>;
+                                value: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+                            }, z.core.$strip>>>>;
+                            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                            dynamicInputPins: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                                pin: z.ZodString;
+                                port: z.ZodString;
+                            }, z.core.$strip>>>>;
+                            dynamicOutputPins: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                                pin: z.ZodString;
+                                port: z.ZodString;
+                            }, z.core.$strip>>>>;
+                            dynamicPorts: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+                            name: z.ZodString;
+                            version: z.ZodString;
+                        }, z.core.$strip>>>>;
+                        connections: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                            source: z.ZodObject<{
+                                node: z.ZodString;
+                                pin: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                                port: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                            }, z.core.$strip>;
+                            target: z.ZodObject<{
+                                node: z.ZodString;
+                                pin: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                                port: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>>>>;
+                        constants: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            value: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+                        }, z.core.$strip>>>>;
+                        inputs: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            schema: z.ZodRecord<z.ZodString, z.ZodAny>;
+                        }, z.core.$strip>>>>;
+                        layout: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+                        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        outputs: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            schema: z.ZodRecord<z.ZodString, z.ZodAny>;
+                        }, z.core.$strip>>>>;
+                        variables: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            access: z.ZodEnum<{
+                                None: "None";
+                                Read: "Read";
+                                Write: "Write";
+                            }>;
+                            schema: z.ZodRecord<z.ZodString, z.ZodAny>;
+                        }, z.core.$strip>>>>;
+                    }, z.core.$strip>>;
+                    activeFlowDefinitionId: z.ZodString;
+                    id: z.ZodString;
+                    triggers: z.ZodArray<z.ZodObject<{
+                        dataSourceContainer: z.ZodObject<{
+                            dataSourceId: z.ZodString;
+                            id: z.ZodString;
+                            name: z.ZodString;
+                            path: z.ZodString;
+                        }, z.core.$strip>;
+                        flowId: z.ZodString;
+                        id: z.ZodString;
+                        inputName: z.ZodString;
+                        type: z.ZodEnum<{
+                            Periodic: "Periodic";
+                            Container: "Container";
+                        }>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                id: z.ZodString;
+                modifiedAt: z.ZodISODateTime;
+                modifiedByUserId: z.ZodString;
+                name: z.ZodString;
+                properties: z.ZodArray<z.ZodObject<{
+                    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    isVector: z.ZodBoolean;
+                    name: z.ZodString;
+                }, z.core.$strip>>;
+                version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>>;
+            id: z.ZodString;
+            modifiedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+            modifiedByUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            name: z.ZodString;
+            parentWorkspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            workspacesInfo: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>>;
+        favorited: z.ZodBoolean;
+        firstPrompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        inputs: z.ZodRecord<z.ZodString, z.ZodObject<{
+            schema: z.ZodRecord<z.ZodString, z.ZodAny>;
+        }, z.core.$strip>>;
+        isPromptAndResponseLoggingEnabled: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        modelConfigurations: z.ZodArray<z.ZodObject<{
+            frequencyPenalty: z.ZodNumber;
+            model: z.ZodObject<{
+                createdAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+                createdByUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                deployment: z.ZodOptional<z.ZodObject<{
+                    createdAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+                    createdByUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    detailedMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    dockerFile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    id: z.ZodString;
+                    modelName: z.ZodString;
+                    providerDeploymentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    providerId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    region: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    status: z.ZodEnum<{
+                        Deploying: "Deploying";
+                        Ready: "Ready";
+                        Failed: "Failed";
+                        Deleting: "Deleting";
+                        Deleted: "Deleted";
+                    }>;
+                    statusMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    statusUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+                    steps: z.ZodArray<z.ZodObject<{
+                        finishedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+                        id: z.ZodString;
+                        index: z.ZodNumber;
+                        message: z.ZodString;
+                        name: z.ZodEnum<{
+                            DeployVNet: "DeployVNet";
+                            DeployVM: "DeployVM";
+                            InstallDependencies: "InstallDependencies";
+                            DownloadModel: "DownloadModel";
+                            TestModel: "TestModel";
+                        }>;
+                        progress: z.ZodNumber;
+                        startedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+                    }, z.core.$strip>>;
+                    url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    virtualMachineServerType: z.ZodOptional<z.ZodEnum<{
+                        TextGenerationInference: "TextGenerationInference";
+                        VLlm: "VLlm";
+                    }>>;
+                    virtualMachineUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    vmSize: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strip>>;
+                displayName: z.ZodString;
+                id: z.ZodString;
+                modelDeploymentProviderType: z.ZodOptional<z.ZodEnum<{
+                    OpenAi: "OpenAi";
+                    AzureOpenAi: "AzureOpenAi";
+                    HuggingFace: "HuggingFace";
+                    Cohere: "Cohere";
+                    Anthropic: "Anthropic";
+                    Gemini: "Gemini";
+                    VertexAi: "VertexAi";
+                    AzureFoundry: "AzureFoundry";
+                }>>;
+                modelPublisher: z.ZodOptional<z.ZodEnum<{
+                    OpenAi: "OpenAi";
+                    HuggingFace: "HuggingFace";
+                    Cohere: "Cohere";
+                    Anthropic: "Anthropic";
+                    Google: "Google";
+                    Meta: "Meta";
+                    Mistral: "Mistral";
+                    Microsoft: "Microsoft";
+                    DeepSeek: "DeepSeek";
+                    XAi: "XAi";
+                    Amazon: "Amazon";
+                    Qwen: "Qwen";
+                    Other: "Other";
+                }>>;
+                name: z.ZodString;
+                properties: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodEnum<{
+                        Boolean: "Boolean";
+                        Number: "Number";
+                        String: "String";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            prePrompt: z.ZodString;
+            presencePenalty: z.ZodNumber;
+            role: z.ZodEnum<{
+                Document: "Document";
+                Agent: "Agent";
+                Analyzer: "Analyzer";
+            }>;
+            temperature: z.ZodNumber;
+            topP: z.ZodNumber;
+        }, z.core.$strip>>;
+        modifiedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+        modifiedByUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        name: z.ZodString;
+        outputSchema: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        sandBoxThreadId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        showSources: z.ZodBoolean;
+        summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        supportsFiles: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        tags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        variables: z.ZodRecord<z.ZodString, z.ZodObject<{
+            access: z.ZodEnum<{
+                None: "None";
+                Read: "Read";
+                Write: "Write";
+            }>;
+            schema: z.ZodRecord<z.ZodString, z.ZodAny>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+type WorkspaceDto = z.infer<typeof workspaceResponseSchema>;
+type WorkspacesListResponseDto = z.infer<typeof workspacesListResponseSchema>;
+type WorkspacesListItemDto = WorkspacesListResponseDto['data'][number];
+type MentionUserDto = z.infer<typeof workspaceUsersResponseSchema>[number];
+declare function mapMentionUserDtoToModel(dto: MentionUserDto): MentionUser;
+declare function mapWorkspaceDtoToModel(dto: WorkspaceDto): Workspace;
+declare const mapWorkspacesDtoToModels: (arr: WorkspacesListItemDto[]) => Workspace[];
+
+/**
+ * Write a freshly-observed thread (from SignalR or an SSE thread frame)
+ * directly into the relevant query caches so subscribers paint without a
+ * refetch roundtrip.
+ *
+ * - Merges into `threadsKeys.detail(workspaceId, thread.id)`.
+ * - Splices into every threads-list cache for the workspace, handling both
+ *   finite `ThreadsResponse` and infinite `{ pages, pageParams }` shapes.
+ *
+ * Returns `true` when the thread was found in at least one list cache.
+ * Callers that need to surface brand-new threads (e.g. another user just
+ * created one) can fall back to invalidating the list queries when this
+ * returns `false`.
+ */
+declare function applyThreadToCache(qc: QueryClient, thread: MessageThread): boolean;
+/**
+ * Invalidate every threads-list cache for a workspace. Use as a fallback when
+ * `applyThreadToCache` didn't find the thread in any list (i.e. brand-new
+ * thread) so the sidebar refetches and picks it up.
+ */
+declare function invalidateWorkspaceThreadLists(qc: QueryClient, workspaceId: string): void;
+/**
+ * Client-only flag for "we just hit send for this thread, server hasn't
+ * confirmed yet". Stored in its own cache cell (not on `MessageThread`)
+ * so the SSE gate — which reads server-confirmed `isFlowRunning` from the
+ * detail cache — stays unaffected. The unified UI selector
+ * `useThreadIsRunning` ORs this with `thread.isFlowRunning` so the composer,
+ * message list typing dots, and sidebar dot all light up at the same instant
+ * on send and turn off together when the flow's terminal frame arrives.
+ */
+declare function setThreadOptimisticRunning(qc: QueryClient, threadId: string, running: boolean): void;
+/**
+ * Optimistically flip a single thread's `isFlowRunning` flag in every list
+ * cache for the workspace (finite + infinite shapes). Used by `useSendMessage`
+ * so the sidebar dot lights up instantly without waiting for SignalR — the
+ * detail cache is intentionally NOT touched here, since that value gates the
+ * thread SSE and must stay server-confirmed.
+ */
+declare function setThreadRunningInLists(qc: QueryClient, workspaceId: string, threadId: string, running: boolean): void;
+
+declare const messagesKeys: {
+    all: readonly ["messages"];
+    lists: () => readonly ["messages", "list"];
+    list: (threadId: string) => readonly ["messages", "list", {
+        readonly threadId: string;
+    }];
+    details: () => readonly ["messages", "detail"];
+    detail: (messageId: string) => readonly ["messages", "detail", {
+        readonly messageId: string;
+    }];
+    infinite: (threadId: string) => readonly ["messages", "list", "infinite", {
+        readonly threadId: string;
+    }];
+};
+declare const messagesMutationsKeys: {
+    all: readonly ["messages", "mutations"];
+    send: () => readonly ["messages", "mutations", "send"];
+    addInput: () => readonly ["messages", "mutations", "addInput"];
+};
+
+declare const filesKeys: {
+    all: readonly ["files"];
+    queries: () => readonly ["files", "query"];
+    downloadBlob: (fileId: string) => readonly ["files", "query", "downloadBlob", {
+        readonly fileId: string;
+    }];
+    mutations: () => readonly ["files", "mutation"];
+    mutation: {
+        upload: (scope?: {
+            workspaceId?: string;
+            threadId?: string;
+        }) => readonly ["files", "mutation", "upload", {
+            readonly scope: {
+                workspaceId?: string;
+                threadId?: string;
+            } | undefined;
+        }];
+        download: (fileId: string) => readonly ["files", "mutation", "download", {
+            readonly fileId: string;
+        }];
+        downloadBlob: (fileId: string) => readonly ["files", "mutation", "downloadBlob", {
+            readonly fileId: string;
+        }];
+        downloadByUri: (uri: string) => readonly ["files", "mutation", "downloadByUri", {
+            readonly uri: string;
+        }];
+    };
+};
+
+/** Page size used by the sidebar thread list; must match ThreadsList.vm so list cache key is consistent. */
+declare const THREAD_LIST_PAGE_SIZE = 30;
+declare const threadsKeys: {
+    all: readonly ["threads"];
+    lists: () => readonly ["threads", "list"];
+    list: (workspaceId: string, opts?: {
+        take?: number;
+        skip?: number;
+    }) => readonly ["threads", "list", {
+        readonly take?: number;
+        readonly skip?: number;
+        readonly workspaceId: string;
+    }];
+    details: () => readonly ["threads", "detail"];
+    detail: (workspaceId: string, threadId: string) => readonly ["threads", "detail", {
+        readonly workspaceId: string;
+        readonly threadId: string;
+    }];
+    optimisticRunning: (threadId: string) => readonly ["threads", "optimisticRunning", string];
+    mutations: () => readonly ["threads", "mutations"];
+    setPin: (threadId: string) => readonly ["threads", "mutations", "setPin", {
+        readonly threadId: string;
+    }];
+    renameThread: (threadId: string) => readonly ["threads", "mutations", "renameThread", {
+        readonly threadId: string;
+    }];
+    deleteThread: (threadId: string) => readonly ["threads", "mutations", "deleteThread", {
+        readonly threadId: string;
+    }];
+};
+
+declare const workspaceKeys: {
+    all: readonly ["workspaces"];
+    list: (searchTerm?: string) => readonly ["workspaces", "list", string];
+    byId: (workspaceId: string) => readonly ["workspaces", "byId", string];
+    taggableUsers: (workspaceId: string) => readonly ["workspaces", "taggableUsers", string];
+};
+
+declare const flowRunsKeys: {
+    all: readonly ["flowruns"];
+    variables: (flowRunId: string) => readonly ["flowruns", "variables", {
+        readonly flowRunId: string;
+    }];
+    mutations: () => readonly ["flowruns", "mutations"];
+    updateVariable: (flowRunId: string, variableName: string) => readonly ["flowruns", "mutations", "updateVariable", {
+        readonly flowRunId: string;
+        readonly variableName: string;
+    }];
+};
+
+declare const modelsKeys: {
+    all: readonly ["models"];
+    lists: () => readonly ["models", "list"];
+    list: (opts?: {
+        search?: string;
+        take?: number;
+        skip?: number;
+    }) => readonly ["models", "list", {
+        readonly search: string | undefined;
+        readonly take: number | undefined;
+        readonly skip: number | undefined;
+    }];
+    details: () => readonly ["models", "detail"];
+    detail: (modelId: string) => readonly ["models", "detail", {
+        readonly modelId: string;
+    }];
+};
+
+declare const messagesListOptions: (service: ChatService, threadId: string, opts?: {
+    take?: number;
+    skip?: number;
+}) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<Message[], Error, Message[], readonly unknown[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<Message[], readonly unknown[], never> | undefined;
+} & {
+    queryKey: readonly unknown[] & {
+        [dataTagSymbol]: Message[];
+        [dataTagErrorSymbol]: Error;
+    };
+};
+declare function useMessages(threadId: string, opts?: {
+    take?: number;
+    skip?: number;
+    skipWhenNewThread?: boolean;
+}): _tanstack_react_query.UseQueryResult<Message[], Error>;
+
+declare const useFileMutations: (scope: FileScope) => {
+    uploadFilesMutation: _tanstack_react_query.UseMutationResult<FileInfo$1[], Error, File[], unknown>;
+    downloadFileMutation: _tanstack_react_query.UseMutationResult<void, Error, FileInfo$1, unknown>;
+    downloadFileByUriMutation: _tanstack_react_query.UseMutationResult<Blob, Error, {
+        name: string;
+        sourceUri: string;
+    }, unknown>;
+    getFileBlobUrl: (id: string) => Promise<string>;
+    fileProgress: Record<string, number>;
+    uploadedFiles: FileInfo$1[];
+    clearUploadState: () => void;
+    fileStates: (files: File[]) => {
+        name: string;
+        progress: number;
+        status: "done" | "uploading";
+    }[];
+};
+
+declare const downloadFileBlobOptions: (service: ChatService, fileId: string, scope: FileScope) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<Blob, Error, Blob, readonly ["files", "query", "downloadBlob", {
+    readonly fileId: string;
+}]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<Blob, readonly ["files", "query", "downloadBlob", {
+        readonly fileId: string;
+    }], never> | undefined;
+} & {
+    queryKey: readonly ["files", "query", "downloadBlob", {
+        readonly fileId: string;
+    }] & {
+        [dataTagSymbol]: Blob;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+declare const useDownloadFileBlobQuery: (fileId: string, scope: FileScope) => _tanstack_react_query.UseQueryResult<Blob, Error>;
+
+type SendArgs = {
+    workspaceId: string;
+    threadId: string;
+    contentList?: MessageContentItem[];
+    files?: FileInfo$1[];
+    variables?: Record<string, unknown>;
+};
+declare function useSendMessage(): _tanstack_react_query.UseMutationResult<void, Error, SendArgs, unknown>;
+type AddInputArgs = {
+    workspaceId?: string;
+    threadId: string;
+    messageId: string;
+    name: string;
+    value: unknown;
+    channels: Record<string, number> | null;
+};
+declare function useAddInputToMessage(): {
+    addInputToMessageMutation: _tanstack_react_query.UseMutationResult<Message, Error, AddInputArgs, unknown>;
+};
+
+declare const threadDetailOptions: ({ service, workspaceId, threadId, }: {
+    service: ChatService;
+    workspaceId: string;
+    threadId: string;
+}) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<MessageThread, Error, MessageThread, readonly ["threads", "detail", {
+    readonly workspaceId: string;
+    readonly threadId: string;
+}]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<MessageThread, readonly ["threads", "detail", {
+        readonly workspaceId: string;
+        readonly threadId: string;
+    }], never> | undefined;
+} & {
+    queryKey: readonly ["threads", "detail", {
+        readonly workspaceId: string;
+        readonly threadId: string;
+    }] & {
+        [dataTagSymbol]: MessageThread;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+/**
+ * Derive placeholder thread from list cache for instant detail display (e.g. drafts).
+ * Searches all list caches for this workspace (infinite and non-infinite).
+ */
+declare function getThreadPlaceholderFromListCache(queryClient: QueryClient, workspaceId: string, threadId: string): MessageThread | undefined;
+declare const useThread: ({ workspaceId, threadId, enabled, }: {
+    workspaceId: string;
+    threadId: string;
+    enabled?: boolean;
+}) => _tanstack_react_query.UseQueryResult<MessageThread, Error>;
+/**
+ * Unified "is this thread running?" signal for UI consumers (composer,
+ * message list typing dots, sidebar dot). ORs the client-only optimistic
+ * flag (set the instant the user hits send) with server-confirmed
+ * `isFlowRunning` from the detail cache, so all three indicators start
+ * and stop on the same render. The optimistic cell is cleared by
+ * `useSendMessage` once POST returns and the detail cache holds the
+ * authoritative value.
+ */
+declare const useThreadIsRunning: (workspaceId: string | undefined, threadId: string | undefined) => boolean;
+
+declare const workspaceDetailOptions: ({ service, workspaceId, }: {
+    service: ChatService;
+    workspaceId: string;
+}) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<Workspace, Error, Workspace, readonly unknown[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<Workspace, readonly unknown[], never> | undefined;
+} & {
+    queryKey: readonly unknown[] & {
+        [dataTagSymbol]: Workspace;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+declare function useWorkspace(workspaceId: string): _tanstack_react_query.UseQueryResult<Workspace, Error>;
+declare const taggableUsersOptions: ({ service, workspaceId, }: {
+    service: ChatService;
+    workspaceId: string;
+}) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<MentionUser[], Error, MentionUser[], readonly unknown[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<MentionUser[], readonly unknown[], never> | undefined;
+} & {
+    queryKey: readonly unknown[] & {
+        [dataTagSymbol]: MentionUser[];
+        [dataTagErrorSymbol]: Error;
+    };
+};
+declare function useTaggableWorkspaceUsers(workspaceId: string): _tanstack_react_query.UseQueryResult<MentionUser[], Error>;
+
+/**
+ * Read the current flow-run variable values for a thread. The chat
+ * variables form seeds initial UI state from this and rerenders when
+ * the cache invalidates.
+ */
+declare function useFlowRunVariables(flowRunId?: string): _tanstack_react_query.UseQueryResult<FlowRunVariables, Error>;
+
+/**
+ * Patch a single flow-run variable. Called per-change by the chat
+ * variables form. Skips writes for draft threads (no flow-run yet)
+ * and invalidates the matching variables cache on success.
+ */
+declare function useUpdateFlowRunVariable(): _tanstack_react_query.UseMutationResult<void, Error, {
+    flowRunId: string;
+    variableName: string;
+    value: unknown;
+}, unknown>;
+
+/**
+ * List models the user has access to. Drives the model-id renderer in
+ * the chat variables form (a searchable dropdown of models).
+ */
+declare function useModels({ search, take, skip, }?: {
+    search?: string;
+    take?: number;
+    skip?: number;
+}): _tanstack_react_query.UseQueryResult<{
+    data: Model[];
+    total: number;
+}, Error>;
+
+export { type ChatContextIds, type ChatIdentity, ChatProvider, type ChatProviderProps, type ChatService, ChatVariablesForm, type FileInfo$1 as FileInfo, type FileScope, type FlowRunVariables, MarkdownEditor, type MarkdownEditorHandle, type MentionUser, type Message, MessageComposer, type MessageComposerProps, type MessageContentItem, type MessageError, MessageList, type MessageListProps, MessageListSkeleton, MessageMarkdown, type MessageThread, type MessageValue, MessageValueType, type Model, type ModelProperty, THREAD_LIST_PAGE_SIZE, type ThreadsResponse, type Variables, type Workspace, applyDeltaToMessage, applyThreadToCache, downloadFileBlobOptions, filesKeys, flowRunsKeys, getModelIcon, getThreadPlaceholderFromListCache, invalidateWorkspaceThreadLists, mapFileInfoDtoToModel, mapMentionUserDtoToModel, mapMessageDtoToModel, mapMessageErrorDtoToModel, mapMessageValueDtoToModel, mapMessagesDtoToModels, mapSignalRThreadSummaryToModel, mapThreadDtoToModel, mapThreadsResponseDtoToModel, mapWorkspaceDtoToModel, mapWorkspacesDtoToModels, messagesKeys, messagesListOptions, messagesMutationsKeys, modelsKeys, setThreadOptimisticRunning, setThreadRunningInLists, taggableUsersOptions, threadDetailOptions, threadsKeys, useAddInputToMessage, useChatContext, useChatIdentity, useChatService, useDownloadFileBlobQuery, useFileMutations, useFlowRunVariables, useMessages, useModels, useSendMessage, useTaggableWorkspaceUsers, useThread, useThreadIsRunning, useUpdateFlowRunVariable, useWorkspace, workspaceDetailOptions, workspaceKeys };