@iota-uz/sdk 0.1.0

package/dist/bichat/index.d.cts

@@ -0,0 +1,1081 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+/**
+ * Type definitions for BI-Chat UI components
+ */
+interface Session {
+    id: string;
+    title: string;
+    status: 'active' | 'archived';
+    pinned: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+declare enum MessageRole {
+    User = "user",
+    Assistant = "assistant",
+    System = "system",
+    Tool = "tool"
+}
+interface Message {
+    id: string;
+    sessionId: string;
+    role: MessageRole;
+    content: string;
+    createdAt: string;
+    toolCalls?: ToolCall[];
+    citations?: Citation[];
+    chartData?: ChartData;
+    artifacts?: Artifact[];
+    explanation?: string;
+}
+interface ToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+}
+interface Citation {
+    id: string;
+    source: string;
+    url?: string;
+    excerpt?: string;
+}
+interface Attachment {
+    id: string;
+    filename: string;
+    mimeType: string;
+    sizeBytes: number;
+    base64Data?: string;
+}
+interface ImageAttachment {
+    filename: string;
+    mimeType: string;
+    sizeBytes: number;
+    base64Data: string;
+    preview: string;
+}
+interface CodeOutput {
+    type: 'image' | 'text' | 'error';
+    content: string | ImageAttachment;
+}
+interface QueuedMessage {
+    content: string;
+    attachments: ImageAttachment[];
+}
+interface ChartData {
+    type: 'bar' | 'line' | 'pie' | 'area';
+    title?: string;
+    data: any[];
+    xAxisKey?: string;
+    yAxisKey?: string;
+}
+interface Artifact {
+    type: 'excel' | 'pdf';
+    filename: string;
+    url: string;
+    sizeReadable?: string;
+    rowCount?: number;
+    description?: string;
+}
+interface PendingQuestion {
+    id: string;
+    turnId: string;
+    question: string;
+    type: 'MULTIPLE_CHOICE' | 'FREE_TEXT';
+    options?: string[];
+    status: 'PENDING' | 'ANSWERED' | 'CANCELLED';
+}
+type QuestionAnswers = Record<string, string>;
+interface StreamChunk {
+    type: 'chunk' | 'error' | 'done' | 'user_message';
+    content?: string;
+    error?: string;
+    sessionId?: string;
+}
+interface ChatDataSource {
+    createSession(): Promise<Session>;
+    fetchSession(id: string): Promise<{
+        session: Session;
+        messages: Message[];
+        pendingQuestion?: PendingQuestion | null;
+    } | null>;
+    sendMessage(sessionId: string, content: string, attachments?: Attachment[], signal?: AbortSignal): AsyncGenerator<StreamChunk>;
+    submitQuestionAnswers(sessionId: string, questionId: string, answers: QuestionAnswers): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    cancelPendingQuestion(questionId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    navigateToSession?(sessionId: string): void;
+}
+interface ChatSessionContextValue {
+    message: string;
+    messages: Message[];
+    loading: boolean;
+    error: string | null;
+    currentSessionId?: string;
+    pendingQuestion: PendingQuestion | null;
+    session: Session | null;
+    fetching: boolean;
+    streamingContent: string;
+    isStreaming: boolean;
+    messageQueue: QueuedMessage[];
+    codeOutputs: CodeOutput[];
+    setMessage: (message: string) => void;
+    setError: (error: string | null) => void;
+    setCodeOutputs: (outputs: CodeOutput[]) => void;
+    handleSubmit: (e: React.FormEvent, attachments?: ImageAttachment[]) => void;
+    handleRegenerate?: (messageId: string) => Promise<void>;
+    handleEdit?: (messageId: string, newContent: string) => Promise<void>;
+    handleCopy: (text: string) => Promise<void>;
+    handleSubmitQuestionAnswers: (answers: QuestionAnswers) => void;
+    handleCancelPendingQuestion: () => Promise<void>;
+    handleUnqueue: () => {
+        content: string;
+        attachments: ImageAttachment[];
+    } | null;
+    sendMessage: (content: string, attachments?: Attachment[]) => Promise<void>;
+    cancel: () => void;
+}
+
+interface ChatSessionProps {
+    dataSource: ChatDataSource;
+    sessionId?: string;
+    isReadOnly?: boolean;
+    renderUserMessage?: (message: Message) => ReactNode;
+    renderAssistantMessage?: (message: Message) => ReactNode;
+    className?: string;
+    /** Custom content to display as header */
+    headerSlot?: ReactNode;
+    /** Custom welcome screen component (replaces default WelcomeContent) */
+    welcomeSlot?: ReactNode;
+    /** Custom logo for the header */
+    logoSlot?: ReactNode;
+    /** Custom action buttons for the header */
+    actionsSlot?: ReactNode;
+    /** Callback when user navigates back */
+    onBack?: () => void;
+}
+declare function ChatSession(props: ChatSessionProps): react_jsx_runtime.JSX.Element;
+
+interface ChatHeaderProps {
+    session: Session | null;
+    onBack?: () => void;
+    /** Custom logo component to display */
+    logoSlot?: ReactNode;
+    /** Custom action buttons */
+    actionsSlot?: ReactNode;
+}
+declare function ChatHeader({ session, onBack, logoSlot, actionsSlot }: ChatHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface MessageListProps {
+    renderUserMessage?: (message: Message) => ReactNode;
+    renderAssistantMessage?: (message: Message) => ReactNode;
+}
+declare function MessageList({ renderUserMessage, renderAssistantMessage }: MessageListProps): react_jsx_runtime.JSX.Element;
+
+interface TurnBubbleProps {
+    message: Message;
+    renderUserMessage?: (message: Message) => ReactNode;
+    renderAssistantMessage?: (message: Message) => ReactNode;
+}
+declare function TurnBubble({ message, renderUserMessage, renderAssistantMessage, }: TurnBubbleProps): react_jsx_runtime.JSX.Element | null;
+
+interface UserTurnViewProps {
+    message: Message & {
+        attachments?: ImageAttachment[];
+    };
+}
+declare function UserTurnView({ message }: UserTurnViewProps): react_jsx_runtime.JSX.Element;
+
+interface AssistantTurnViewProps {
+    message: Message & {
+        codeOutputs?: CodeOutput[];
+        isStreaming?: boolean;
+    };
+}
+declare function AssistantTurnView({ message }: AssistantTurnViewProps): react_jsx_runtime.JSX.Element;
+
+interface MarkdownRendererProps {
+    content: string;
+    citations?: Citation[] | null;
+}
+declare function MarkdownRenderer({ content }: MarkdownRendererProps): react_jsx_runtime.JSX.Element;
+
+interface ChartCardProps {
+    chartData: ChartData;
+}
+declare function ChartCard({ chartData }: ChartCardProps): react_jsx_runtime.JSX.Element;
+
+interface SourcesPanelProps {
+    citations: Citation[];
+}
+declare function SourcesPanel({ citations }: SourcesPanelProps): react_jsx_runtime.JSX.Element | null;
+
+interface DownloadCardProps {
+    artifact: Artifact;
+}
+declare function DownloadCard({ artifact }: DownloadCardProps): react_jsx_runtime.JSX.Element;
+
+interface InlineQuestionFormProps {
+    pendingQuestion: PendingQuestion;
+}
+declare function InlineQuestionForm({ pendingQuestion }: InlineQuestionFormProps): react_jsx_runtime.JSX.Element;
+
+interface MessageInputRef {
+    focus: () => void;
+    clear: () => void;
+}
+interface MessageInputProps {
+    message: string;
+    loading: boolean;
+    fetching?: boolean;
+    disabled?: boolean;
+    messageQueue?: QueuedMessage[];
+    onMessageChange: (value: string) => void;
+    onSubmit: (e: React.FormEvent, attachments: ImageAttachment[]) => void;
+    onUnqueue?: () => {
+        content: string;
+        attachments: ImageAttachment[];
+    } | null;
+    placeholder?: string;
+    maxFiles?: number;
+    maxFileSize?: number;
+    containerClassName?: string;
+}
+declare const MessageInput: react.ForwardRefExoticComponent<MessageInputProps & react.RefAttributes<MessageInputRef>>;
+
+interface AttachmentGridProps {
+    attachments: ImageAttachment[];
+    onRemove?: (index: number) => void;
+    onView?: (index: number) => void;
+    className?: string;
+}
+declare function AttachmentGrid({ attachments, onRemove, onView, className }: AttachmentGridProps): react_jsx_runtime.JSX.Element | null;
+
+interface ImageModalProps {
+    images: ImageAttachment[];
+    initialIndex: number;
+    onClose: () => void;
+}
+declare function ImageModal({ images, initialIndex, onClose }: ImageModalProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * WelcomeContent Component
+ * Landing page shown when starting a new chat session
+ * Clean, professional design for enterprise BI applications
+ */
+interface WelcomeContentProps {
+    onPromptSelect?: (prompt: string) => void;
+    title?: string;
+    description?: string;
+    disabled?: boolean;
+}
+declare function WelcomeContent({ onPromptSelect, title, description, disabled }: WelcomeContentProps): react_jsx_runtime.JSX.Element;
+
+interface CodeOutputsPanelProps {
+    outputs: CodeOutput[];
+}
+declare function CodeOutputsPanel({ outputs }: CodeOutputsPanelProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * StreamingCursor Component
+ * Animated cursor shown during AI response streaming
+ */
+declare function StreamingCursor(): react_jsx_runtime.JSX.Element;
+
+/**
+ * ScrollToBottomButton Component
+ * Floating button to scroll chat to bottom, shown when user scrolls up
+ */
+interface ScrollToBottomButtonProps {
+    show: boolean;
+    onClick: () => void;
+    unreadCount?: number;
+}
+declare function ScrollToBottomButton({ show, onClick, unreadCount }: ScrollToBottomButtonProps): react_jsx_runtime.JSX.Element;
+
+interface EmptyStateProps {
+    /** Optional icon to display */
+    icon?: ReactNode;
+    /** Main title text */
+    title: string;
+    /** Optional description text */
+    description?: string;
+    /** Optional action element (button, link, etc.) */
+    action?: ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+}
+declare function EmptyState({ icon, title, description, action, className, size, }: EmptyStateProps): react_jsx_runtime.JSX.Element;
+declare const _default$3: react.MemoExoticComponent<typeof EmptyState>;
+
+/**
+ * EditableText Component
+ * Inline editable text with double-click to edit
+ * Features: auto-focus, auto-select, Enter to save, Escape to cancel
+ * Can be triggered programmatically via ref.startEditing()
+ */
+interface EditableTextProps {
+    /** Current text value */
+    value: string;
+    /** Callback when text is saved */
+    onSave: (newValue: string) => void;
+    /** Maximum character length */
+    maxLength?: number;
+    /** Whether the component is in loading state */
+    isLoading?: boolean;
+    /** Placeholder text when empty */
+    placeholder?: string;
+    /** Additional CSS classes for the text display */
+    className?: string;
+    /** Additional CSS classes for the input */
+    inputClassName?: string;
+    /** Font size variant */
+    size?: 'sm' | 'md' | 'lg';
+}
+interface EditableTextRef {
+    /** Programmatically start editing mode */
+    startEditing: () => void;
+    /** Programmatically cancel editing */
+    cancelEditing: () => void;
+}
+declare const _default$2: react.MemoExoticComponent<react.ForwardRefExoticComponent<EditableTextProps & react.RefAttributes<EditableTextRef>>>;
+
+/**
+ * SearchInput Component
+ * Reusable search input with icon, clear button, and keyboard shortcuts
+ */
+interface SearchInputProps {
+    /** Current search value */
+    value: string;
+    /** Callback when value changes */
+    onChange: (value: string) => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Auto-focus on mount */
+    autoFocus?: boolean;
+    /** Callback when Enter is pressed */
+    onSubmit?: (value: string) => void;
+    /** Callback when Escape is pressed */
+    onEscape?: () => void;
+    /** Additional CSS classes for the container */
+    className?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Disable the input */
+    disabled?: boolean;
+    /** ARIA label for accessibility */
+    ariaLabel?: string;
+}
+declare function SearchInput({ value, onChange, placeholder, autoFocus, onSubmit, onEscape, className, size, disabled, ariaLabel, }: SearchInputProps): react_jsx_runtime.JSX.Element;
+declare const _default$1: react.MemoExoticComponent<typeof SearchInput>;
+
+/**
+ * Skeleton Component
+ * Reusable loading skeleton with multiple variants
+ */
+interface SkeletonProps {
+    /** Skeleton variant */
+    variant?: 'text' | 'circular' | 'rectangular' | 'rounded';
+    /** Width (CSS value or number for pixels) */
+    width?: string | number;
+    /** Height (CSS value or number for pixels) */
+    height?: string | number;
+    /** Additional CSS classes */
+    className?: string;
+    /** Enable animation */
+    animate?: boolean;
+}
+interface SkeletonGroupProps {
+    /** Number of skeleton items to render */
+    count?: number;
+    /** Gap between items */
+    gap?: 'sm' | 'md' | 'lg';
+    /** Additional CSS classes for the container */
+    className?: string;
+    /** Render function for each skeleton item */
+    children?: (index: number) => React.ReactNode;
+}
+declare function Skeleton({ variant, width, height, className, animate, }: SkeletonProps): react_jsx_runtime.JSX.Element;
+/**
+ * SkeletonGroup - Renders multiple skeleton items
+ */
+declare function SkeletonGroup({ count, gap, className, children, }: SkeletonGroupProps): react_jsx_runtime.JSX.Element;
+/**
+ * SkeletonText - Text line skeleton with configurable width
+ */
+declare function SkeletonText({ lines, className, }: {
+    lines?: number;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * SkeletonAvatar - Circular avatar skeleton
+ */
+declare function SkeletonAvatar({ size, className, }: {
+    size?: number;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * SkeletonCard - Card-shaped skeleton
+ */
+declare function SkeletonCard({ width, height, className, }: {
+    width?: string | number;
+    height?: string | number;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * ListItemSkeleton - Common list item skeleton with icon and text
+ */
+declare function ListItemSkeleton({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare const _default: react.MemoExoticComponent<typeof Skeleton>;
+
+/**
+ * Framer Motion animation variants for BiChat UI
+ * Subtle, professional animations for enterprise applications
+ * Respects prefers-reduced-motion for accessibility
+ */
+/**
+ * Fade in animation
+ */
+declare const fadeInVariants: {
+    initial: {
+        opacity: number;
+    };
+    animate: {
+        opacity: number;
+        transition: {
+            duration: number;
+        };
+    };
+    exit: {
+        opacity: number;
+        transition: {
+            duration: number;
+        };
+    };
+};
+/**
+ * Fade in with subtle slide up
+ */
+declare const fadeInUpVariants: {
+    initial: {
+        opacity: number;
+        y: number;
+    };
+    animate: {
+        opacity: number;
+        y: number;
+        transition: {
+            duration: number;
+            ease: number[];
+        };
+    };
+    exit: {
+        opacity: number;
+        y: number;
+        transition: {
+            duration: number;
+        };
+    };
+};
+/**
+ * Scale fade for modals and popups
+ */
+declare const scaleFadeVariants: {
+    initial: {
+        opacity: number;
+        scale: number;
+    };
+    animate: {
+        opacity: number;
+        scale: number;
+        transition: {
+            duration: number;
+        };
+    };
+    exit: {
+        opacity: number;
+        scale: number;
+        transition: {
+            duration: number;
+        };
+    };
+};
+/**
+ * Modal backdrop
+ */
+declare const backdropVariants: {
+    initial: {
+        opacity: number;
+    };
+    animate: {
+        opacity: number;
+        transition: {
+            duration: number;
+        };
+    };
+    exit: {
+        opacity: number;
+        transition: {
+            duration: number;
+        };
+    };
+};
+/**
+ * Button press feedback
+ */
+declare const buttonVariants: {
+    tap: {
+        scale: number;
+    };
+};
+/**
+ * Stagger container for lists
+ */
+declare const staggerContainerVariants: {
+    hidden: {
+        opacity: number;
+    };
+    visible: {
+        opacity: number;
+        transition: {
+            staggerChildren: number;
+            delayChildren: number;
+        };
+    };
+};
+/**
+ * List item animation
+ */
+declare const listItemVariants: {
+    initial: {
+        opacity: number;
+        x: number;
+    };
+    animate: {
+        opacity: number;
+        x: number;
+        transition: {
+            duration: number;
+        };
+    };
+    exit: {
+        opacity: number;
+        x: number;
+        transition: {
+            duration: number;
+        };
+    };
+};
+/**
+ * Message entrance animation
+ */
+declare const messageVariants: {
+    initial: {
+        opacity: number;
+        y: number;
+    };
+    animate: {
+        opacity: number;
+        y: number;
+        transition: {
+            duration: number;
+            ease: number[];
+        };
+    };
+    exit: {
+        opacity: number;
+        transition: {
+            duration: number;
+        };
+    };
+};
+/**
+ * Container for staggered messages
+ */
+declare const messageContainerVariants: {
+    initial: {
+        opacity: number;
+    };
+    animate: {
+        opacity: number;
+        transition: {
+            staggerChildren: number;
+            delayChildren: number;
+        };
+    };
+};
+/**
+ * Typing indicator dots
+ */
+declare const typingDotVariants: {
+    initial: {
+        opacity: number;
+    };
+    animate: {
+        opacity: number[];
+        transition: {
+            duration: number;
+            repeat: number;
+            ease: string;
+        };
+    };
+};
+/**
+ * Floating button (scroll to bottom, etc.)
+ */
+declare const floatingButtonVariants: {
+    initial: {
+        opacity: number;
+        scale: number;
+    };
+    animate: {
+        opacity: number;
+        scale: number;
+        transition: {
+            duration: number;
+        };
+    };
+    exit: {
+        opacity: number;
+        scale: number;
+        transition: {
+            duration: number;
+        };
+    };
+};
+/**
+ * Dropdown menu
+ */
+declare const dropdownVariants: {
+    initial: {
+        opacity: number;
+        y: number;
+    };
+    animate: {
+        opacity: number;
+        y: number;
+        transition: {
+            duration: number;
+        };
+    };
+    exit: {
+        opacity: number;
+        y: number;
+        transition: {
+            duration: number;
+        };
+    };
+};
+/**
+ * Toast notification
+ */
+declare const toastVariants: {
+    initial: {
+        opacity: number;
+        y: number;
+    };
+    animate: {
+        opacity: number;
+        y: number;
+        transition: {
+            duration: number;
+        };
+    };
+    exit: {
+        opacity: number;
+        y: number;
+        transition: {
+            duration: number;
+        };
+    };
+};
+
+/**
+ * Per-session rate limiter
+ * Prevents excessive requests within a time window
+ */
+interface RateLimiterConfig {
+    maxRequests: number;
+    windowMs: number;
+}
+declare class RateLimiter {
+    private timestamps;
+    private maxRequests;
+    private windowMs;
+    constructor(config: RateLimiterConfig);
+    /**
+     * Check if a request can be made
+     * Updates internal state if request is allowed
+     */
+    canMakeRequest(): boolean;
+    /**
+     * Get milliseconds until next request is allowed
+     * Returns 0 if request can be made immediately
+     */
+    getTimeUntilNextRequest(): number;
+    /**
+     * Reset the rate limiter state
+     */
+    reset(): void;
+}
+
+interface ChatSessionProviderProps {
+    dataSource: ChatDataSource;
+    sessionId?: string;
+    rateLimiter?: RateLimiter;
+    children: ReactNode;
+}
+declare function ChatSessionProvider({ dataSource, sessionId, rateLimiter: externalRateLimiter, children }: ChatSessionProviderProps): react_jsx_runtime.JSX.Element;
+declare function useChat(): ChatSessionContextValue;
+
+/**
+ * Type definitions matching Go structs for server-side context
+ */
+interface UserContext {
+    id: number;
+    email: string;
+    firstName: string;
+    lastName: string;
+    permissions: string[];
+}
+interface TenantContext {
+    id: string;
+    name: string;
+}
+interface LocaleContext {
+    language: string;
+    translations: Record<string, string>;
+}
+interface AppConfig {
+    graphQLEndpoint: string;
+    streamEndpoint: string;
+}
+interface Extensions {
+    branding?: {
+        appName?: string;
+        logoUrl?: string;
+        theme?: {
+            primary?: string;
+            secondary?: string;
+            accent?: string;
+        };
+        welcome?: {
+            title?: string;
+            description?: string;
+            examplePrompts?: Array<{
+                category: string;
+                text: string;
+                icon: string;
+            }>;
+        };
+        colors?: {
+            primary?: string;
+            secondary?: string;
+            accent?: string;
+        };
+        logo?: {
+            src?: string;
+            alt?: string;
+        };
+    };
+    features?: {
+        vision?: boolean;
+        webSearch?: boolean;
+        codeInterpreter?: boolean;
+        multiAgent?: boolean;
+    };
+}
+interface IotaContext {
+    user: UserContext;
+    tenant: TenantContext;
+    locale: LocaleContext;
+    config: AppConfig;
+    extensions?: Extensions;
+}
+declare global {
+    interface Window {
+        __BICHAT_CONTEXT__: IotaContext;
+        __CSRF_TOKEN__: string;
+    }
+}
+
+interface IotaContextProviderProps {
+    children: ReactNode;
+}
+declare function IotaContextProvider({ children }: IotaContextProviderProps): react_jsx_runtime.JSX.Element;
+declare function useIotaContext(): IotaContext;
+/**
+ * Check if user has a specific permission
+ */
+declare function hasPermission$1(permission: string): boolean;
+
+interface BiChatConfig {
+    user: {
+        id: string;
+        email: string;
+        firstName: string;
+        lastName: string;
+        permissions: string[];
+    };
+    tenant: {
+        id: string;
+        name: string;
+    };
+    locale: {
+        language: string;
+        translations: Record<string, string>;
+    };
+    endpoints: {
+        graphQL: string;
+        stream: string;
+    };
+    csrfToken?: string;
+}
+interface ConfigProviderProps {
+    config?: BiChatConfig;
+    useGlobalConfig?: boolean;
+    children: ReactNode;
+}
+/**
+ * ConfigProvider component
+ * Provides configuration to the BiChat library
+ *
+ * @param config - Configuration object (preferred method)
+ * @param useGlobalConfig - If true, falls back to window.__BICHAT_CONTEXT__ when config is not provided
+ * @param children - React children
+ */
+declare function ConfigProvider({ config, useGlobalConfig, children }: ConfigProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access BiChat configuration
+ * Returns null if no configuration is available
+ */
+declare function useConfig(): BiChatConfig | null;
+/**
+ * Hook to access BiChat configuration (required)
+ * Throws an error if configuration is not available
+ */
+declare function useRequiredConfig(): BiChatConfig;
+/**
+ * Check if user has a specific permission
+ */
+declare function hasPermission(config: BiChatConfig | null, permission: string): boolean;
+
+/**
+ * useStreaming hook
+ * Handles AsyncGenerator streaming responses with cancellation support
+ */
+
+interface UseStreamingOptions {
+    onChunk?: (content: string) => void;
+    onError?: (error: string) => void;
+    onDone?: () => void;
+}
+declare function useStreaming(options?: UseStreamingOptions): {
+    content: string;
+    isStreaming: boolean;
+    error: Error | null;
+    processStream: (stream: AsyncGenerator<StreamChunk>, signal?: AbortSignal) => Promise<void>;
+    cancel: () => void;
+    reset: () => void;
+};
+
+/**
+ * Translation hook using locale from IotaContext
+ */
+declare function useTranslation(): {
+    t: (key: string, params?: Record<string, any>) => string;
+    locale: string;
+};
+
+/**
+ * Theme system type definitions
+ */
+interface Theme {
+    name: string;
+    colors: ThemeColors;
+    spacing: ThemeSpacing;
+    borderRadius: ThemeBorderRadius;
+}
+interface ThemeColors {
+    background: string;
+    surface: string;
+    primary: string;
+    secondary: string;
+    text: string;
+    textMuted: string;
+    border: string;
+    error: string;
+    success: string;
+    warning: string;
+    userBubble: string;
+    assistantBubble: string;
+    userText: string;
+    assistantText: string;
+}
+interface ThemeSpacing {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+}
+interface ThemeBorderRadius {
+    sm: string;
+    md: string;
+    lg: string;
+    full: string;
+}
+
+interface ThemeProviderProps {
+    theme?: Theme | 'light' | 'dark' | 'system';
+    children: ReactNode;
+}
+/**
+ * Theme provider component
+ * Wraps the application and provides theme context
+ */
+declare function ThemeProvider({ theme, children }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access current theme
+ */
+declare function useTheme(): Theme;
+
+/**
+ * Predefined theme configurations
+ */
+
+declare const lightTheme: Theme;
+declare const darkTheme: Theme;
+
+/**
+ * CSRF token management for API requests
+ */
+/**
+ * Get CSRF token from window object
+ * @returns CSRF token string
+ */
+declare function getCSRFToken(): string;
+/**
+ * Add CSRF token to request headers
+ * @param headers - Headers object to modify
+ * @returns Modified headers object
+ */
+declare function addCSRFHeader(headers: Headers): Headers;
+/**
+ * Create headers with CSRF token
+ * @param init - Optional initial headers
+ * @returns Headers object with CSRF token
+ */
+declare function createHeadersWithCSRF(init?: HeadersInit): Headers;
+
+/**
+ * Built-in HTTP data source with SSE streaming and AbortController
+ * Implements ChatDataSource interface with real HTTP/GraphQL calls
+ */
+
+interface HttpDataSourceConfig {
+    baseUrl: string;
+    graphQLEndpoint?: string;
+    streamEndpoint?: string;
+    csrfToken?: string | (() => string);
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+interface SessionState {
+    session: Session;
+    messages: Message[];
+    pendingQuestion?: PendingQuestion | null;
+}
+interface Result<T> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+declare class HttpDataSource implements ChatDataSource {
+    private config;
+    private abortController;
+    constructor(config: HttpDataSourceConfig);
+    /**
+     * Get CSRF token from config
+     */
+    private getCSRFToken;
+    /**
+     * Create headers for HTTP requests
+     */
+    private createHeaders;
+    /**
+     * Execute GraphQL query
+     */
+    private graphql;
+    /**
+     * Create a new chat session
+     */
+    createSession(): Promise<Session>;
+    /**
+     * Fetch an existing session with messages
+     */
+    fetchSession(id: string): Promise<SessionState | null>;
+    /**
+     * Send a message and stream the response using SSE
+     */
+    sendMessage(sessionId: string, content: string, attachments?: Attachment[], signal?: AbortSignal): AsyncGenerator<StreamChunk>;
+    /**
+     * Cancel ongoing stream
+     */
+    cancelStream(): void;
+    /**
+     * Submit answers to a pending question
+     */
+    submitQuestionAnswers(sessionId: string, questionId: string, answers: QuestionAnswers): Promise<Result<void>>;
+    /**
+     * Cancel a pending question
+     */
+    cancelPendingQuestion(questionId: string): Promise<Result<void>>;
+    /**
+     * Navigate to a session (optional, for SPA routing)
+     */
+    navigateToSession?(sessionId: string): void;
+}
+/**
+ * Factory function to create HttpDataSource
+ */
+declare function createHttpDataSource(config: HttpDataSourceConfig): ChatDataSource;
+
+/**
+ * File Utilities
+ * Validation, conversion, and formatting for file attachments
+ */
+/**
+ * Validates an image file against size and type constraints
+ * @throws Error if validation fails
+ */
+declare function validateImageFile(file: File, maxSizeBytes?: number): void;
+/**
+ * Converts a file to base64 string (without data URL prefix)
+ */
+declare function convertToBase64(file: File): Promise<string>;
+/**
+ * Creates a data URL from base64 string and MIME type
+ */
+declare function createDataUrl(base64: string, mimeType: string): string;
+/**
+ * Formats file size in human-readable format
+ */
+declare function formatFileSize(bytes: number): string;
+/**
+ * Validates multiple files don't exceed count limit
+ * @throws Error if count exceeds limit
+ */
+declare function validateFileCount(currentCount: number, newCount: number, maxCount?: number): void;
+
+export { type AppConfig, type Artifact, AssistantTurnView, type Attachment, AttachmentGrid, type BiChatConfig, ChartCard, type ChartData, type ChatDataSource, ChatHeader, ChatSession, type ChatSessionContextValue, ChatSessionProvider, type Citation, type CodeOutput, CodeOutputsPanel, ConfigProvider, DownloadCard, _default$2 as EditableText, type EditableTextProps, type EditableTextRef, _default$3 as EmptyState, type EmptyStateProps, HttpDataSource, type HttpDataSourceConfig, type ImageAttachment, ImageModal, InlineQuestionForm, type IotaContext, IotaContextProvider, ListItemSkeleton, type LocaleContext, MarkdownRenderer, type Message, MessageInput, type MessageInputProps, type MessageInputRef, MessageList, MessageRole, type PendingQuestion, type QuestionAnswers, type QueuedMessage, RateLimiter, type RateLimiterConfig, ScrollToBottomButton, _default$1 as SearchInput, type SearchInputProps, type Session, _default as Skeleton, SkeletonAvatar, SkeletonCard, SkeletonGroup, type SkeletonGroupProps, type SkeletonProps, SkeletonText, SourcesPanel, type StreamChunk, StreamingCursor, type TenantContext, type Theme, type ThemeBorderRadius, type ThemeColors, ThemeProvider, type ThemeSpacing, type ToolCall, TurnBubble, type UserContext, UserTurnView, WelcomeContent, addCSRFHeader, backdropVariants, buttonVariants, convertToBase64, createDataUrl, createHeadersWithCSRF, createHttpDataSource, darkTheme, dropdownVariants, fadeInUpVariants, fadeInVariants, floatingButtonVariants, formatFileSize, getCSRFToken, hasPermission as hasConfigPermission, hasPermission$1 as hasPermission, lightTheme, listItemVariants, messageContainerVariants, messageVariants, scaleFadeVariants, staggerContainerVariants, toastVariants, typingDotVariants, useChat, useConfig, useIotaContext, useRequiredConfig, useStreaming, useTheme, useTranslation, validateFileCount, validateImageFile };