@llamaindex/ui/dist/index.d.mts

A comprehensive UI component library built with React, TypeScript, and Tailwind CSS for LlamaIndex applications

export { c as FILE_TYPE_GROUPS, b as FileType, m as FileUploadData, a as FileUploader, F as FileUploaderProps, I as InputField, U as UploadResult, n as UseFileUploadOptions, o as UseFileUploadReturn, h as createFileTypeValidator, j as formatFileSize, d as getFileExtensions, e as getFileMimeTypes, g as getFileTypeDefinition, f as getFileTypesByCategory, l as isCryptoSupported, k as isFileApiSupported, i as isFileTypeMatch, u as useFileUpload, v as validateFile } from './file-uploader-DZW0tk1P.mjs';
export { FileUploadProgress, UploadProgress, UploadProgressProps, UseUploadProgressReturn, useUploadProgress } from './file-uploader/index.mjs';
export { AcceptReject, ConfidenceThresholdSettings, EditableField, ExtractedDataDisplay, ExtractedDataDisplayProps, ItemHookData, JsonObject, JsonShape, JsonValue, ListRenderer, PrimitiveValue, PropertyRenderer, RendererMetadata, TableRenderer, UseItemDataOptions, getConfidenceBackgroundClass, useItemData } from './extracted-data/index.mjs';
export { BoundingBox, FileData, FilePreview, FilePreviewProps, Highlight, PageData, PdfNavigator, PdfPreview, useFileData } from './file-preview/index.mjs';
export { BuiltInColumnConfig, BusinessConfig, Column, ColumnHeader, EXTRACTED_DATA_COLUMN_NAMES, ExtractedDataItemGrid, FormattedDate, ItemGrid, PaginationControls, PaginationState, ReviewStatusBadge, STATUS_OPTIONS, SortDirection, SortState, SyncedIcon, createExtractedDataColumn, getItemsToReviewCount, useItemGridData } from './item-grid/index.mjs';
import { WorkflowEvent } from './workflows/index.mjs';
export { AgentStreamDisplay, RunStatus, WorkflowHandlerSummary, WorkflowProgressBar, WorkflowProgressState, WorkflowTrigger, createHandlerStore, useHandlerStore, useWorkflowHandler, useWorkflowHandlerList, useWorkflowProgress, useWorkflowRun } from './workflows/index.mjs';
export { IndexPipeline, useIndex, useIndexList, useIndexStore } from './indexes/index.mjs';
export { ItemCount, ItemCountProps } from './item-count/index.mjs';
export { ApiClients, ApiProvider, ApiProviderProps, CloudApiClient, createMockClients, useAgentDataClient, useApiClients, useCloudApiClient, useWorkflowsClient } from './lib/index.mjs';
export { Accordion, AccordionContent, AccordionItem, AccordionTrigger } from './base/accordion.mjs';
export { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger } from './base/alert-dialog.mjs';
export { Avatar, AvatarFallback, AvatarImage } from './base/avatar.mjs';
export { Badge, badgeVariants } from './base/badge.mjs';
export { Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator } from './base/breadcrumb.mjs';
export { Button, buttonVariants } from './base/button.mjs';
export { Calendar, CalendarDayButton } from './base/calendar.mjs';
export { Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from './base/card.mjs';
export { Checkbox } from './base/checkbox.mjs';
export { Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut } from './base/command.mjs';
export { ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger } from './base/context-menu.mjs';
export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger } from './base/dialog.mjs';
export { Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger } from './base/drawer.mjs';
export { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger } from './base/dropdown-menu.mjs';
export { Form, FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage, useFormField } from './base/form.mjs';
export { HoverCard, HoverCardContent, HoverCardTrigger } from './base/hover-card.mjs';
export { Input } from './base/input.mjs';
export { Label } from './base/label.mjs';
export { Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, MenubarPortal, MenubarRadioGroup, MenubarRadioItem, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger } from './base/menubar.mjs';
export { NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, NavigationMenuViewport, navigationMenuTriggerStyle } from './base/navigation-menu.mjs';
export { Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious } from './base/pagination.mjs';
export { Popover, PopoverAnchor, PopoverContent, PopoverTrigger } from './base/popover.mjs';
export { Progress } from './base/progress.mjs';
export { RadioGroup, RadioGroupItem } from './base/radio-group.mjs';
export { ResizableHandle, ResizablePanel, ResizablePanelGroup } from './base/resizable.mjs';
export { ScrollArea, ScrollBar } from './base/scroll-area.mjs';
export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue } from './base/select.mjs';
export { Separator } from './base/separator.mjs';
export { Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle, SheetTrigger } from './base/sheet.mjs';
export { Skeleton } from './base/skeleton.mjs';
export { Slider } from './base/slider.mjs';
export { Toaster } from './base/sonner.mjs';
export { Switch } from './base/switch.mjs';
export { Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow } from './base/table.mjs';
export { Tabs, TabsContent, TabsList, TabsTrigger } from './base/tabs.mjs';
export { Textarea } from './base/textarea.mjs';
export { Toggle, toggleVariants } from './base/toggle.mjs';
export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from './base/tooltip.mjs';
export { c as cn } from './utils-Cbsgs0XP.mjs';
export { AgentClient as CloudAgentClient, createAgentDataClient as createCloudAgentClient } from 'llama-cloud-services/beta/agent';
export { Client as WorkflowsClient, createClient as createWorkflowsClient, createConfig as createWorkflowsConfig, client as workflowsClient } from '@llamaindex/workflows-client';
export { client as cloudApiClient } from 'llama-cloud-services/api';
import 'react/jsx-runtime';
import 'react';
import 'zod/v4/core';
import 'zustand';
import '@radix-ui/react-accordion';
import '@radix-ui/react-alert-dialog';
import '@radix-ui/react-avatar';
import 'class-variance-authority/types';
import 'class-variance-authority';
import 'react-day-picker';
import '@radix-ui/react-checkbox';
import 'cmdk';
import '@radix-ui/react-dialog';
import '@radix-ui/react-context-menu';
import 'vaul';
import '@radix-ui/react-dropdown-menu';
import 'react-hook-form';
import '@radix-ui/react-label';
import '@radix-ui/react-slot';
import '@radix-ui/react-hover-card';
import '@radix-ui/react-menubar';
import '@radix-ui/react-navigation-menu';
import '@radix-ui/react-popover';
import '@radix-ui/react-progress';
import '@radix-ui/react-radio-group';
import 'react-resizable-panels';
import '@radix-ui/react-scroll-area';
import '@radix-ui/react-select';
import '@radix-ui/react-separator';
import '@radix-ui/react-slider';
import 'sonner';
import '@radix-ui/react-switch';
import '@radix-ui/react-tabs';
import '@radix-ui/react-toggle';
import '@radix-ui/react-tooltip';
import 'clsx';

type FileData = {
    filename: string;
    mediaType: string;
    url: string;
};

type MessagePart = TextPart | DataPart | FilePart | AnyPart;
declare const TextPartType: "text";
declare const FilePartType: "data-file";
type TextPart = {
    type: typeof TextPartType;
    text: string;
};
type DataPart<T extends `data-${string}` = `data-${string}`, D = any> = {
    id?: string;
    type: T;
    data: D;
};
type FilePart = DataPart<typeof FilePartType, FileData>;
type AnyPart<T extends string = any> = {
    id?: string;
    type: T;
    data?: any;
};

declare const MessageRole: {
    readonly System: "system";
    readonly User: "user";
    readonly Assistant: "assistant";
};
type MessageRoleType = (typeof MessageRole)[keyof typeof MessageRole];
interface Message {
    id: string;
    role: MessageRoleType;
    parts: MessagePart[];
}
type ChatRequestOptions = {
    headers?: Record<string, string> | Headers;
    body?: object;
};
type ChatHandler = {
    messages: Message[];
    status: "idle" | "submitted" | "streaming" | "ready" | "error";
    sendMessage: (msg: Message, opts?: ChatRequestOptions) => Promise<void>;
    stop?: () => Promise<void>;
    regenerate?: (opts?: {
        messageId?: string;
    } & ChatRequestOptions) => void;
    setMessages?: (messages: Message[]) => void;
};

/**
 * StreamingMessage Class
 * Manages event accumulation and parsing for streaming messages
 *
 * Problem:
 * - During streaming, delta events contain partial text (e.g., "```py", "thon\n", "def ")
 * - Parsing each event individually breaks markdown/XML syntax detection
 * - Different event types (delta, tool call, etc.) should not be merged together
 *
 * Solution:
 * - Only merge **adjacent** delta events
 * - When a non-delta event arrives, flush the current text buffer
 * - Maintain two lists: finalized parts + current text parts
 * - Incrementally update for O(1) getParts()
 *
 * Example flow:
 * 1. delta1 + delta2 + delta3 → merged in buffer, parsed as TextPart(s)
 * 2. tool_call_event → flush buffer to finalized, append ToolCallPart to finalized
 * 3. delta4 + delta5 → merged in new buffer, parsed as TextPart(s)
 * 4. InputRequiredEvent → flush buffer to finalized, append InputRequiredPart to finalized
 *
 * Usage in chat-store:
 * - Create instance when streaming starts (with messageId)
 * - Call addEvent() for each incoming event (triggers incremental parse)
 * - Call getParts() to get current MessagePart[] (returns finalized + current)
 * - Call complete() when streaming ends (flushes remaining buffer)
 */

declare class StreamingMessage {
    private events;
    private currentTextBuffer;
    private currentTextParts;
    private finalizedParts;
    private _status;
    readonly messageId: string;
    constructor(messageId: string);
    /**
     * Get current status
     */
    get status(): "streaming" | "completed";
    /**
     * Add a new event and incrementally update the parsed result
     * Only adjacent delta events are merged together
     */
    addEvent(event: WorkflowEvent): void;
    /**
     * Mark the streaming as completed and flush any remaining text
     */
    complete(): void;
    /**
     * Get current MessagePart[] (returns finalized + current, O(1))
     */
    getParts(): MessagePart[];
    /**
     * Get accumulated events (mainly for debugging)
     */
    getEvents(): WorkflowEvent[];
    /**
     * Get current text buffer (mainly for debugging)
     */
    getTextBuffer(): string;
    /**
     * Clear all accumulated state
     */
    clear(): void;
    /**
     * Flush the current text buffer (finalize adjacent delta events)
     * This is called when a non-delta event arrives or streaming completes
     */
    private flushTextBuffer;
}

/**
 * Chat Store Types
 * Based on contracts/chat-store.contract.ts
 */

/**
 * Chat session state
 *
 * NOTE: sessionId conceptually equals handlerId
 * One chat session = one handler
 * (run_id exists in telemetry but not tracked in state)
 */
interface ChatSession {
    handlerId: string;
    workflowName: string;
    messages: Message[];
    status: "idle" | "submitted" | "streaming" | "ready" | "error";
    error: Error | null;
    streamingMessage: StreamingMessage | null;
}
/**
 * Options for creating a chat session
 */
interface CreateSessionOptions {
    workflowName: string;
    handlerId?: string;
    initialMessages?: Message[];
}
/**
 * Chat store state and actions
 */
interface ChatStoreState {
    sessions: Record<string, ChatSession>;
    createSession(options: CreateSessionOptions): Promise<string>;
    deleteSession(handlerId: string): void;
    getSession(handlerId: string): ChatSession | undefined;
    sendMessage(handlerId: string, message: Message, opts?: ChatRequestOptions): Promise<void>;
    setMessages(handlerId: string, messages: Message[]): void;
    _appendMessage(handlerId: string, message: Message): void;
    _updateAssistantMessage(handlerId: string, messageId: string, parts: MessagePart[]): void;
    setStatus(handlerId: string, status: ChatSession["status"]): void;
    setError(handlerId: string, error: Error | null): void;
    stop(handlerId: string): Promise<void>;
    regenerate(handlerId: string, messageId?: string): Promise<void>;
    _setStreamingMessage(handlerId: string, streamingMessage: StreamingMessage | null): void;
}

/**
 * Chat Store Hook with Auto-Singleton Pattern
 * Provides both selector API and direct store access
 * Pattern: Similar to workflows/hooks/use-handler-store.ts
 */

declare function useChatStore(): ChatStoreState;
declare function useChatStore<T>(selector: (state: ChatStoreState) => T): T;

/**
 * useChat Hook - Bridge Chat UI to Workflow
 * Implements ChatHandler interface backed by Zustand store
 */

interface UseChatOptions {
    /**
     * Workflow name to use for this chat session
     */
    workflowName: string;
    /**
     * Optional handler ID to reuse existing session
     * If not provided, a new session will be created
     */
    handlerId?: string;
    /**
     * Optional initial messages to populate the chat
     */
    initialMessages?: Message[];
    /**
     * Callback when chat session is initialized and handlerId is available
     * - If handlerId is provided: fires on mount
     * - If no handlerId: fires when first message is sent (lazy initialization)
     */
    onReady?: (handlerId: string) => void;
    /**
     * Callback on error
     */
    onError?: (error: Error) => void;
}
/**
 * Hook to manage a chat session as a workflow
 *
 * Session initialization is lazy by default - the session is created when the first message is sent.
 * If you provide a handlerId, the session is initialized immediately on mount.
 *
 * @example
 * ```tsx
 * // Lazy initialization - session created on first message
 * function MyChat() {
 *   const chat = useChat({
 *     workflowName: "my-chat-workflow",
 *     onReady: (handlerId) => {
 *       // Called when first message is sent
 *       console.log("Chat ready:", handlerId);
 *     },
 *   });
 *
 *   return <ChatSection handler={chat} />;
 * }
 *
 * // Eager initialization - session created on mount
 * function MyResumableChat() {
 *   const chat = useChat({
 *     workflowName: "my-chat-workflow",
 *     handlerId: "existing-session-123",
 *     onReady: (handlerId) => {
 *       // Called immediately on mount
 *       console.log("Chat ready:", handlerId);
 *     },
 *   });
 *
 *   return <ChatSection handler={chat} />;
 * }
 * ```
 */
declare function useChat(options: UseChatOptions): ChatHandler & {
    handlerId: string | null;
};

export { type UseChatOptions, WorkflowEvent, useChat, useChatStore };