@hsafa/ui-sdk 0.3.3 → 0.4.1

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import * as React from 'react';
+import * as React$1 from 'react';
 import React__default, { ComponentType } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
@@ -74,11 +74,12 @@ interface FloatingChatButtonProps {
 }
 declare function FloatingChatButton({ show, onClick, resolvedColors, floatingButtonPosition }: FloatingChatButtonProps): react_jsx_runtime.JSX.Element | null;
 
-declare function useAutoScroll<T extends HTMLElement>(shouldScroll?: boolean): React.MutableRefObject<T | null>;
+declare function useAutoScroll<T extends HTMLElement>(shouldScroll?: boolean): React$1.MutableRefObject<T | null>;
 
 /**
  * Type definitions for the Hsafa SDK - minimal exports used across the SDK
  */
+
 type Attachment = {
     id: string;
     name?: string;
@@ -86,10 +87,60 @@ type Attachment = {
     mimeType?: string;
     size?: number;
 };
+type UserContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    image: URL;
+    mediaType: string;
+} | {
+    type: 'file';
+    data: string;
+    mediaType: string;
+    name?: string;
+};
+type AssistantContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'reasoning';
+    text: string;
+} | {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName?: string;
+    input?: any;
+};
+type ChatMessage = {
+    id: string;
+    role: 'user';
+    content: string | UserContentPart[];
+    createdAt?: number;
+    text?: string;
+    attachments?: Attachment[];
+} | {
+    id: string;
+    role: 'assistant';
+    content?: string | AssistantContentPart[];
+    items: any[];
+    reasoning?: string;
+    reasoningOpen?: boolean;
+    mainAgentActions?: any[];
+    createdAt?: number;
+};
 type HsafaTool = ((input: any) => any | Promise<any>) | {
     tool: (input: any) => any | Promise<any>;
     executeEachToken?: boolean;
 };
+type CustomToolUIRenderProps = {
+    toolName: string;
+    toolCallId: string;
+    input: any;
+    output: any;
+    status?: string;
+    addToolResult: (result: any) => void;
+};
 interface HsafaChatProps {
     agentId: string;
     theme?: 'dark' | 'light';
@@ -121,20 +172,475 @@ interface HsafaChatProps {
     defaultReasoningOpen?: boolean;
     hideReasoningContent?: boolean;
     HsafaTools?: Record<string, HsafaTool>;
+    dynamicPageTypes?: any[];
+    componentAboveInput?: React__default.ComponentType<any>;
+    editProcessContent?: EditProcessContent;
 }
+type EditProcessContent = {
+    title?: string;
+    content?: string | React__default.ComponentType<any>;
+    submit_button_label?: string;
+    cancel_button_label?: string;
+    icon?: React__default.ComponentType<any>;
+    message_icon?: React__default.ComponentType<any>;
+};
 
-declare function useFileUpload(baseUrl: string): {
+declare function useFileUpload(baseUrl?: string): {
     attachments: Attachment[];
     uploading: boolean;
-    fileInputRef: React.MutableRefObject<HTMLInputElement | null>;
+    fileInputRef: React$1.MutableRefObject<HTMLInputElement | null>;
     formatBytes: (bytes: number) => string;
     handleRemoveAttachment: (id: string) => void;
     handleFileSelection: (fileList: FileList | File[] | null, setError: (error: string | null) => void) => Promise<void>;
     buildUserContent: (text: string, attachments: Attachment[]) => any[];
     clearAttachments: () => void;
+    setAttachments: React$1.Dispatch<React$1.SetStateAction<Attachment[]>>;
     MAX_UPLOAD_SIZE: number;
 };
 
+/**
+ * Dynamic Page Types
+ * Defines all types for the Dynamic Page system
+ */
+interface DynamicPageGrid {
+    gridTemplateColumns: string;
+    gridTemplateRows: string;
+    gap?: string;
+    gridTemplateAreas?: string;
+}
+interface DynamicPageObjectMeta {
+    title?: string;
+    description?: string;
+    tags?: string[];
+}
+interface DynamicPageObject {
+    object_name: string;
+    area?: string;
+    data: any;
+    type?: string;
+    meta?: DynamicPageObjectMeta;
+    version: number;
+    updatedAt: string;
+}
+interface ComponentError {
+    object_name: string;
+    area: string;
+    error: string;
+    errorStack?: string | null;
+    timestamp: string;
+    type?: string;
+}
+interface DynamicPageState {
+    grid: DynamicPageGrid | null;
+    objects: Record<string, DynamicPageObject>;
+    componentErrors?: ComponentError[];
+}
+interface DynamicPageTypeConfig {
+    type: string;
+    component: React.ComponentType<any>;
+    description: string;
+    variants?: string[];
+    /** Optional Zod schema or JSON schema describing the expected data structure */
+    schema?: any;
+    /** Optional examples showing valid data for this type */
+    examples?: any[];
+}
+interface ToolResult {
+    success: boolean;
+    message?: string;
+    [key: string]: any;
+}
+
+/**
+ * Dynamic Page Operations
+ * All tool logic for managing dynamic pages
+ */
+
+declare class DynamicPageOperations {
+    private chatId;
+    private state;
+    private availableTypes;
+    private onStateChange;
+    constructor(chatId: string, state: DynamicPageState, availableTypes: DynamicPageTypeConfig[], onStateChange: (state: DynamicPageState) => void);
+    private updateState;
+    setGrid(params: {
+        gridTemplateColumns: string;
+        gridTemplateRows: string;
+        gap?: string;
+        gridTemplateAreas?: string;
+    }): ToolResult;
+    readGrid(): ToolResult;
+    readAvailableTypes(): ToolResult;
+    setObject(params: {
+        object_name: string;
+        area?: string;
+        data: any;
+        type?: string;
+        meta?: {
+            title?: string;
+            description?: string;
+            tags?: string[];
+        };
+    }): ToolResult;
+    editObject(params: {
+        object_name: string;
+        json_patch?: any[];
+        merge_patch?: any;
+        replace_entire_data?: boolean;
+        new_data?: any;
+        options?: any;
+    }): ToolResult;
+    deleteObject(params: {
+        object_name: string;
+    }): ToolResult;
+    readAllObjects(): ToolResult;
+    readObject(params: {
+        object_name: string;
+    }): ToolResult;
+    readAtPointer(params: {
+        object_name: string;
+        pointer?: string;
+    }): ToolResult;
+    renameObject(params: {
+        current_name: string;
+        new_name: string;
+        new_area?: string;
+    }): ToolResult;
+    moveObject(params: {
+        object_name: string;
+        target_area: string;
+    }): ToolResult;
+    validateGrid(): ToolResult;
+    readComponentErrors(params?: {
+        limit?: number;
+    }): ToolResult;
+    clearComponentErrors(): ToolResult;
+    private getRecentErrorsSummary;
+}
+
+/**
+ * useDynamicPage Hook
+ * Manages dynamic page state and operations
+ */
+
+declare function useDynamicPage(chatIdParam: string, availableTypes: DynamicPageTypeConfig[]): {
+    state: DynamicPageState;
+    isDynamicPageOpen: boolean;
+    getOperations: () => DynamicPageOperations | null;
+    closeDynamicPage: () => void;
+    openDynamicPage: () => void;
+    handleError: (error: ComponentError) => void;
+};
+
+/**
+ * useHsafaAgent - The main headless hook for Hsafa Agent
+ *
+ * This hook provides all the logic needed to integrate an AI agent into your custom UI.
+ * It handles chat state, tool execution, message streaming, and more.
+ *
+ * @example
+ * ```tsx
+ * function MyCustomChat() {
+ *   const agent = useHsafaAgent({
+ *     agentId: 'my-agent',
+ *     baseUrl: 'http://localhost:3000',
+ *     tools: {
+ *       customTool: async (input) => {
+ *         return { result: 'Custom tool executed!' };
+ *       }
+ *     }
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       {agent.messages.map(msg => (
+ *         <div key={msg.id}>{msg.content}</div>
+ *       ))}
+ *       <input
+ *         value={agent.input}
+ *         onChange={(e) => agent.setInput(e.target.value)}
+ *         onKeyPress={(e) => e.key === 'Enter' && agent.sendMessage()}
+ *       />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+
+interface UseHsafaAgentConfig {
+    /** The agent ID to connect to */
+    agentId: string;
+    /** Base URL of your backend server */
+    baseUrl?: string;
+    /** Custom tools that the agent can use */
+    tools?: Record<string, any>;
+    /** Custom UI components for rendering tool results */
+    uiComponents?: Record<string, React.ComponentType<any>>;
+    /** Dynamic page type configurations */
+    dynamicPageTypes?: any[];
+    /** Callback when a message finishes */
+    onFinish?: (message: any) => void;
+    /** Callback when an error occurs */
+    onError?: (error: Error) => void;
+    /** Initial messages to load */
+    initialMessages?: any[];
+    /** Callback when messages change */
+    onMessagesChange?: (messages: any[]) => void;
+}
+interface HsafaAgentAPI {
+    /** Current input text */
+    input: string;
+    /** Set the input text */
+    setInput: (value: string) => void;
+    /** All chat messages */
+    messages: any[];
+    /** Whether the agent is currently processing */
+    isLoading: boolean;
+    /** Current chat status */
+    status: 'idle' | 'submitted' | 'streaming' | 'error' | 'ready';
+    /** Any error that occurred */
+    error: Error | undefined;
+    /** Send the current input as a message */
+    sendMessage: (options?: {
+        text?: string;
+        files?: any[];
+    }) => Promise<void>;
+    /** Stop the current generation */
+    stop: () => void;
+    /** Clear all messages and start a new chat */
+    newChat: () => void;
+    /** Set messages directly (for loading history) */
+    setMessages: (messages: any[]) => void;
+    /** Direct access to the underlying chat API */
+    chatApi: any;
+    /** Current chat ID */
+    chatId: string;
+    /** Set the chat ID (for switching chats) */
+    setChatId: (chatId: string) => void;
+    /** All available tools (built-in + custom + dynamic page) */
+    tools: Record<string, any>;
+    /** All available UI components */
+    uiComponents: Record<string, any>;
+    /** Dynamic page operations (if enabled) */
+    dynamicPage: ReturnType<typeof useDynamicPage> | null;
+    /** Ref to form host elements (for requestInput tool) */
+    formHostRef: React.MutableRefObject<Map<string, HTMLDivElement>>;
+    /** Ref to form state (for requestInput tool) */
+    formStateRef: React.MutableRefObject<Map<string, {
+        submitted?: boolean;
+        skipped?: boolean;
+        values?: Record<string, any>;
+    }>>;
+    /** Cleanup all active forms */
+    cleanupForms: () => void;
+    /** Callback when a UI component renders successfully */
+    onUISuccess: (toolCallId: string, toolName: string) => void;
+    /** Callback when a UI component encounters an error */
+    onUIError: (toolCallId: string, toolName: string, error: Error) => void;
+}
+declare function useHsafaAgent(config: UseHsafaAgentConfig): HsafaAgentAPI;
+
+interface ChatMeta {
+    id: string;
+    title: string;
+    createdAt: number;
+    updatedAt: number;
+}
+interface ChatData {
+    id: string;
+    messages: ChatMessage[];
+    agentId?: string;
+}
+declare function createChatStorage(agentId: string): {
+    loadChatsIndex: () => ChatMeta[];
+    saveChatsIndex: (list: ChatMeta[]) => void;
+    loadChat: (id: string) => ChatData | null;
+    saveChat: (data: ChatData) => void;
+    upsertChatMeta: (meta: ChatMeta) => void;
+    deleteChatMeta: (id: string) => void;
+    deleteChatData: (id: string) => void;
+    deleteChat: (id: string) => void;
+    loadShowChatPreference: (defaultValue: boolean) => boolean;
+    saveShowChatPreference: (value: boolean) => void;
+    loadCurrentChatId: () => string | null;
+    saveCurrentChatId: (chatId: string) => void;
+    removeCurrentChatId: () => void;
+};
+
+/**
+ * useChatStorage - Hook for managing chat history persistence
+ *
+ * This hook provides utilities for saving and loading chat conversations
+ * to/from localStorage. It handles chat metadata, message persistence,
+ * and chat history management.
+ *
+ * @example
+ * ```tsx
+ * function MyChat() {
+ *   const agent = useHsafaAgent({ agentId: 'my-agent' });
+ *   const storage = useChatStorage({
+ *     agentId: 'my-agent',
+ *     chatId: agent.chatId,
+ *     messages: agent.messages,
+ *     isLoading: agent.isLoading,
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => {
+ *         const chat = storage.loadChat(chatId);
+ *         if (chat) agent.setMessages(chat.messages);
+ *       }}>
+ *         Load Chat
+ *       </button>
+ *       <select onChange={(e) => storage.switchToChat(e.target.value, agent.setMessages)}>
+ *         {storage.chatList.map(chat => (
+ *           <option key={chat.id} value={chat.id}>{chat.title}</option>
+ *         ))}
+ *       </select>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+
+interface UseChatStorageConfig {
+    /** The agent ID (used as storage namespace) */
+    agentId: string;
+    /** Current chat ID */
+    chatId: string;
+    /** Current messages to auto-save */
+    messages: any[];
+    /** Whether chat is currently loading (skip saving during load) */
+    isLoading?: boolean;
+    /** Whether to auto-save messages (default: true) */
+    autoSave?: boolean;
+    /** Whether to auto-restore last chat on mount (default: true) */
+    autoRestore?: boolean;
+}
+interface ChatMetadata {
+    id: string;
+    title: string;
+    createdAt: number;
+    updatedAt: number;
+}
+interface SavedChat {
+    id: string;
+    messages: any[];
+    agentId: string;
+}
+interface ChatStorageAPI {
+    /** List of all saved chats */
+    chatList: ChatMetadata[];
+    /** Current chat metadata */
+    currentChatMeta: ChatMetadata | null;
+    /** Refresh the chat list */
+    refreshChatList: () => void;
+    /** Load a specific chat */
+    loadChat: (chatId: string) => SavedChat | null;
+    /** Save the current chat */
+    saveCurrentChat: () => void;
+    /** Delete a chat */
+    deleteChat: (chatId: string) => void;
+    /** Switch to a different chat */
+    switchToChat: (chatId: string, setMessages: (messages: any[]) => void) => void;
+    /** Create a new chat */
+    createNewChat: (onNewChat: () => void) => void;
+    /** Search chats by title */
+    searchChats: (query: string) => ChatMetadata[];
+    /** The underlying storage utility */
+    storage: ReturnType<typeof createChatStorage>;
+}
+declare function useChatStorage(config: UseChatStorageConfig): ChatStorageAPI;
+
+/**
+ * useMessageEditor - Hook for editing and regenerating messages
+ *
+ * This hook provides functionality to edit user messages and regenerate
+ * responses from a specific point in the conversation.
+ *
+ * @example
+ * ```tsx
+ * function MyChat() {
+ *   const agent = useHsafaAgent({ agentId: 'my-agent' });
+ *   const editor = useMessageEditor({
+ *     messages: agent.messages,
+ *     isLoading: agent.isLoading,
+ *     sendMessage: agent.sendMessage,
+ *     setMessages: agent.setMessages,
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       {agent.messages.map(msg => (
+ *         <div key={msg.id}>
+ *           {editor.isEditing(msg.id) ? (
+ *             <div>
+ *               <textarea
+ *                 value={editor.editingText}
+ *                 onChange={(e) => editor.setEditingText(e.target.value)}
+ *               />
+ *               <button onClick={() => editor.saveEdit(msg.id)}>Save</button>
+ *               <button onClick={editor.cancelEdit}>Cancel</button>
+ *             </div>
+ *           ) : (
+ *             <div>
+ *               {msg.content}
+ *               <button onClick={() => editor.startEdit(msg.id, msg.content)}>
+ *                 Edit
+ *               </button>
+ *             </div>
+ *           )}
+ *         </div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+interface UseMessageEditorConfig {
+    /** Current messages array */
+    messages: any[];
+    /** Whether chat is currently loading */
+    isLoading: boolean;
+    /** Function to send a message */
+    sendMessage: (options: {
+        text: string;
+        files?: any[];
+    }) => Promise<void>;
+    /** Function to update messages array */
+    setMessages: (messages: any[]) => void;
+    /** Base URL for file uploads (if editing messages with attachments) */
+    baseUrl?: string;
+}
+interface MessageEditorAPI {
+    /** ID of the message currently being edited */
+    editingMessageId: string | null;
+    /** Current edit text */
+    editingText: string;
+    /** Set the edit text */
+    setEditingText: (text: string) => void;
+    /** Attachments for the edited message */
+    editAttachments: any[];
+    /** Set edit attachments */
+    setEditAttachments: (attachments: any[]) => void;
+    /** Whether files are currently uploading */
+    editUploading: boolean;
+    /** Start editing a message */
+    startEdit: (messageId: string, text: string, attachments?: any[]) => void;
+    /** Cancel editing */
+    cancelEdit: () => void;
+    /** Save the edit and regenerate from that point */
+    saveEdit: (messageId: string) => Promise<void>;
+    /** Check if a message is being edited */
+    isEditing: (messageId: string) => boolean;
+    /** Add attachments to the edit */
+    addEditAttachments: (files: FileList) => Promise<void>;
+    /** Remove an attachment from the edit */
+    removeEditAttachment: (id: string) => void;
+}
+declare function useMessageEditor(config: UseMessageEditorConfig): MessageEditorAPI;
+
 /**
  * Handler function for custom actions that can be triggered by the AI agent
  */
@@ -185,6 +691,16 @@ interface HsafaContextValue extends HsafaConfig {
     isAnyChatOpen: boolean;
     /** Set chat open state for a specific chat instance */
     setChatOpenState: (chatId: string, isOpen: boolean) => void;
+    /** Currently active chat id (set by HsafaChat) */
+    currentChatId?: string;
+    /** Setter for current chat id */
+    setCurrentChatId: (chatId: string) => void;
+    /** Dynamic page types registered by active chat */
+    dynamicPageTypes: any[];
+    /** Register dynamic page types from a chat */
+    registerDynamicPageTypes: (chatId: string, types: any[]) => void;
+    /** Unregister dynamic page types when chat unmounts */
+    unregisterDynamicPageTypes: (chatId: string) => void;
 }
 /**
  * Props for the HsafaProvider component
@@ -215,23 +731,13 @@ declare function HsafaProvider({ baseUrl, dir, theme, children }: HsafaProviderP
  * ```tsx
  * function MyComponent() {
  *   const { registerAction, baseUrl } = useHsafa();
- *
- *   useEffect(() => {
- *     const unregister = registerAction('myAction', async (params) => {
- *       console.log('Action called with:', params);
- *       return { success: true };
- *     });
- *
- *     return unregister;
- *   }, [registerAction]);
- *
  *   return <div>My Component</div>;
  * }
  * ```
  */
 declare function useHsafa(): HsafaContextValue;
 
-declare function HsafaChat({ agentId, theme, primaryColor, primaryColorDark, primaryColorLight, backgroundColor, borderColor, textColor, accentColor, baseUrl, initialMessages, onMessagesChange, defaultOpen, floatingButtonPosition, HsafaTools, HsafaUI, }: HsafaChatProps & {
+declare function HsafaChat({ agentId, theme, primaryColor, primaryColorDark, primaryColorLight, backgroundColor, borderColor, textColor, accentColor, baseUrl, initialMessages, onMessagesChange, defaultOpen, floatingButtonPosition, HsafaTools, HsafaUI, dynamicPageTypes, componentAboveInput, editProcessContent, }: HsafaChatProps & {
     baseUrl?: string;
     initialMessages?: any[];
     onMessagesChange?: (messages: any[]) => void;
@@ -253,6 +759,7 @@ interface ContentContainerProps {
     enableMargin?: boolean;
     chatWidth?: number | string;
     dir?: "ltr" | "rtl";
+    onDynamicPageError?: (error: ComponentError) => void;
 }
 /**
  * ContentContainer component that wraps your content and applies animations
@@ -270,7 +777,7 @@ interface ContentContainerProps {
  *   <ContentContainer theme="dark" enableBorderAnimation>
  *     <YourApp />
  *   </ContentContainer>
- *   <HsafaChat agentId="agent-1" width={450} />
+ *   <HsafaChat agentId="agent-1" width={450} dynamicPageTypes={types} />
  * </HsafaProvider>
  *
  * // With custom chat width and RTL support
@@ -283,7 +790,7 @@ interface ContentContainerProps {
  *   >
  *     <YourApp />
  *   </ContentContainer>
- *   <HsafaChat agentId="agent-1" width={450} dir="rtl" />
+ *   <HsafaChat agentId="agent-1" width={450} dir="rtl" dynamicPageTypes={types} />
  * </HsafaProvider>
  *
  * // Disable margin (content stays full width)
@@ -291,11 +798,11 @@ interface ContentContainerProps {
  *   <ContentContainer enableMargin={false}>
  *     <YourApp />
  *   </ContentContainer>
- *   <HsafaChat agentId="agent-1" />
+ *   <HsafaChat agentId="agent-1" dynamicPageTypes={types} />
  * </HsafaProvider>
  * ```
  */
-declare function ContentContainer({ children, theme, primaryColor, backgroundColor, borderColor, textColor, mutedTextColor, enableBorderAnimation, borderRadius, enableContentBorder, className, enableMargin, chatWidth, dir, }: ContentContainerProps): react_jsx_runtime.JSX.Element;
+declare function ContentContainer({ children, theme, primaryColor, backgroundColor, borderColor, textColor, mutedTextColor, enableBorderAnimation, borderRadius, enableContentBorder, className, enableMargin, chatWidth, dir, onDynamicPageError, }: ContentContainerProps): react_jsx_runtime.JSX.Element;
 
 /**
  * Component Registry for custom UI components
@@ -557,4 +1064,49 @@ type FillResult = {
 };
 declare function FillActiveInput(value: any, options?: FillInputOptions): Promise<FillResult>;
 
-export { type Anchor, Button, type ButtonProps, ContentContainer, type ContentContainerProps, CursorController, type DomComponent, FillActiveInput, type FillInputOptions, type FillResult, FloatingChatButton, type GetDomComponentsOptions, type GetDomComponentsResult, type GuideAction, type GuideCursorOptions, type GuideOptions, type GuideRunResult, type GuideStep, type GuideStepResult, type GuideTarget, HsafaChat, type HsafaChatProps, HsafaProvider, type UIComponentProps, registry as componentRegistry, guideCursor as controlCursor, getDomComponents, guideCursor, useAutoScroll, useFileUpload, useHsafa };
+interface DynamicPageProps {
+    state: DynamicPageState;
+    typeConfigs: DynamicPageTypeConfig[];
+    theme?: 'dark' | 'light';
+    primaryColor?: string;
+    backgroundColor?: string;
+    borderColor?: string;
+    textColor?: string;
+    onError?: (error: ComponentError) => void;
+}
+declare function DynamicPage({ state, typeConfigs, theme, primaryColor, backgroundColor, borderColor, textColor, onError, }: DynamicPageProps): react_jsx_runtime.JSX.Element;
+
+declare function createDynamicPageTools(getOperations: () => DynamicPageOperations | null, _addToolResult?: (payload: any) => void): {
+    setGrid: (toolCall: any) => Promise<ToolResult>;
+    readGrid: (toolCall: any) => Promise<ToolResult>;
+    readAvailableTypes: () => Promise<ToolResult>;
+    setObject: {
+        executeEachToken: boolean;
+        tool: (toolCall: any) => Promise<ToolResult>;
+    };
+    editObject: {
+        executeEachToken: boolean;
+        tool: (toolCall: any) => Promise<ToolResult>;
+    };
+    deleteObject: (toolCall: any) => Promise<ToolResult>;
+    readAllObjects: () => Promise<ToolResult>;
+    readObject: (toolCall: any) => Promise<ToolResult>;
+    readAtPointer: (toolCall: any) => Promise<ToolResult>;
+    renameObject: (toolCall: any) => Promise<ToolResult>;
+    moveObject: (toolCall: any) => Promise<ToolResult>;
+    validateGrid: () => Promise<ToolResult>;
+    readComponentErrors: (toolCall: any) => Promise<ToolResult>;
+    clearComponentErrors: () => Promise<ToolResult>;
+};
+
+/**
+ * Dynamic Page Storage
+ * Manages localStorage persistence for dynamic page data linked to chat ID
+ */
+
+declare function saveDynamicPageState(chatId: string, state: DynamicPageState): void;
+declare function loadDynamicPageState(chatId: string): DynamicPageState | null;
+declare function deleteDynamicPageState(chatId: string): void;
+declare function dynamicPageExists(chatId: string): boolean;
+
+export { type Anchor, type Attachment, Button, type ButtonProps, type ChatMessage, type ChatMetadata, type ChatStorageAPI, type ComponentError, ContentContainer, type ContentContainerProps, CursorController, type CustomToolUIRenderProps, type DomComponent, DynamicPage, type DynamicPageGrid, type DynamicPageObject, type DynamicPageObjectMeta, DynamicPageOperations, type DynamicPageState, type DynamicPageTypeConfig, type EditProcessContent, FillActiveInput, type FillInputOptions, type FillResult, FloatingChatButton, type GetDomComponentsOptions, type GetDomComponentsResult, type GuideAction, type GuideCursorOptions, type GuideOptions, type GuideRunResult, type GuideStep, type GuideStepResult, type GuideTarget, type HsafaAgentAPI, HsafaChat, type HsafaChatProps, HsafaProvider, type HsafaTool, type MessageEditorAPI, type SavedChat, type ToolResult, type UIComponentProps, type UseChatStorageConfig, type UseHsafaAgentConfig, type UseMessageEditorConfig, registry as componentRegistry, guideCursor as controlCursor, createDynamicPageTools, deleteDynamicPageState, dynamicPageExists, getDomComponents, guideCursor, loadDynamicPageState, saveDynamicPageState, useAutoScroll, useChatStorage, useDynamicPage, useFileUpload, useHsafa, useHsafaAgent, useMessageEditor };