@reverbia/sdk 1.0.0-next.20251217134403 → 1.0.0-next.20251217144909

package/dist/react/index.d.ts

@@ -2,6 +2,7 @@ import { Database, Model } from '@nozbe/watermelondb';
 import * as _nozbe_watermelondb_Schema_migrations from '@nozbe/watermelondb/Schema/migrations';
 import * as _nozbe_watermelondb_Schema from '@nozbe/watermelondb/Schema';
 import { Associations } from '@nozbe/watermelondb/Model';
+import { ReactNode, JSX } from 'react';
 
 /**
  * ExtraFields contains additional metadata
@@ -236,6 +237,10 @@ type LlmapiModel = {
      * MaxOutputTokens is the maximum output tokens
      */
     max_output_tokens?: number;
+    /**
+     * Modalities is a list of supported modalities (e.g., ["llm", "vision"])
+     */
+    modalities?: Array<string>;
     /**
      * Name is the human-readable model name (optional)
      */
@@ -630,224 +635,148 @@ declare function useEncryption(signMessage: SignMessageFn): {
     requestEncryptionKey: (walletAddress: string) => Promise<void>;
 };
 
-/**
- * Message role type
- */
+declare const chatStorageSchema: Readonly<{
+    version: _nozbe_watermelondb_Schema.SchemaVersion;
+    tables: _nozbe_watermelondb_Schema.TableMap;
+    unsafeSql?: (_: string, __: _nozbe_watermelondb_Schema.AppSchemaUnsafeSqlKind) => string;
+}>;
+declare const chatStorageMigrations: Readonly<{
+    validated: true;
+    minVersion: _nozbe_watermelondb_Schema.SchemaVersion;
+    maxVersion: _nozbe_watermelondb_Schema.SchemaVersion;
+    sortedMigrations: _nozbe_watermelondb_Schema_migrations.Migration[];
+}>;
+
 type ChatRole = "user" | "assistant" | "system";
-/**
- * File metadata for attached files
- */
 interface FileMetadata {
-    /** Unique file identifier */
     id: string;
-    /** Original file name */
     name: string;
-    /** MIME type */
     type: string;
-    /** File size in bytes */
     size: number;
-    /** Optional URL or data URI */
     url?: string;
 }
-/**
- * Token usage and cost information
- */
 interface ChatCompletionUsage {
-    /** Number of tokens in the prompt */
     promptTokens?: number;
-    /** Number of tokens in the completion */
     completionTokens?: number;
-    /** Total tokens used */
     totalTokens?: number;
-    /** Cost in micro-dollars (USD × 1,000,000) */
     costMicroUsd?: number;
 }
-/**
- * Web search source information
- */
 interface SearchSource {
-    /** Source title */
     title?: string;
-    /** Source URL */
     url?: string;
-    /** Text snippet from the source */
     snippet?: string;
-    /** Publication or last updated date */
     date?: string;
 }
-/**
- * Stored message record (what gets persisted to the database)
- */
 interface StoredMessage {
-    /** Primary key, unique message identifier (WatermelonDB auto-generated) */
     uniqueId: string;
-    /** Sequential message ID within conversation */
     messageId: number;
-    /** Links message to its conversation */
     conversationId: string;
-    /** Who sent the message */
     role: ChatRole;
-    /** The message text */
     content: string;
-    /** LLM model used */
     model?: string;
-    /** Optional attached files */
     files?: FileMetadata[];
-    /** When the message was created */
     createdAt: Date;
-    /** When the message was last updated */
     updatedAt: Date;
-    /** Embedding vector for semantic search */
     vector?: number[];
-    /** Model used to generate embedding */
     embeddingModel?: string;
-    /** Token counts and cost */
     usage?: ChatCompletionUsage;
-    /** Web search sources */
     sources?: SearchSource[];
-    /** Response time in seconds */
     responseDuration?: number;
-    /** Whether the message generation was stopped by the user */
     wasStopped?: boolean;
 }
-/**
- * Stored conversation record
- */
 interface StoredConversation {
-    /** Primary key (WatermelonDB auto-generated) */
     uniqueId: string;
-    /** Unique conversation identifier */
     conversationId: string;
-    /** Conversation title */
     title: string;
-    /** When the conversation was created */
     createdAt: Date;
-    /** When the conversation was last updated */
     updatedAt: Date;
-    /** Soft delete flag */
     isDeleted: boolean;
 }
-/**
- * Stored message with similarity score (for search results)
- */
 interface StoredMessageWithSimilarity extends StoredMessage {
-    /** Cosine similarity score (0 to 1) */
     similarity: number;
 }
-/**
- * Options for creating a new message
- */
 interface CreateMessageOptions {
-    /** Conversation ID to add the message to */
     conversationId: string;
-    /** Message role */
     role: ChatRole;
-    /** Message content */
     content: string;
-    /** LLM model used (for assistant messages) */
     model?: string;
-    /** Attached files */
     files?: FileMetadata[];
-    /** Token usage information */
     usage?: ChatCompletionUsage;
-    /** Web search sources */
     sources?: SearchSource[];
-    /** Response duration in seconds */
     responseDuration?: number;
-    /** Embedding vector for semantic search */
     vector?: number[];
-    /** Model used to generate the embedding */
     embeddingModel?: string;
-    /** Whether the message generation was stopped by the user */
     wasStopped?: boolean;
 }
-/**
- * Options for creating a new conversation
- */
 interface CreateConversationOptions {
-    /** Custom conversation ID (auto-generated if not provided) */
     conversationId?: string;
-    /** Conversation title */
     title?: string;
 }
-/**
- * Base options for useChatStorage hook (shared between React and Expo)
- */
 interface BaseUseChatStorageOptions {
-    /** WatermelonDB database instance */
     database: Database;
-    /** Current conversation ID (will create new if not provided) */
     conversationId?: string;
-    /** Auto-create conversation if it doesn't exist (default: true) */
     autoCreateConversation?: boolean;
-    /** Default title for auto-created conversations */
     defaultConversationTitle?: string;
-    /** Authentication token getter */
     getToken?: () => Promise<string | null>;
-    /** Base URL for API requests */
     baseUrl?: string;
-    /** Callback when data chunk is received */
     onData?: (chunk: string) => void;
-    /** Callback when chat completion finishes */
     onFinish?: (response: LlmapiChatCompletionResponse) => void;
-    /** Callback when an error occurs */
     onError?: (error: Error) => void;
 }
-/**
- * Base arguments for sendMessage with storage (shared between React and Expo)
- */
 interface BaseSendMessageWithStorageArgs {
-    /** Message content to send */
     content: string;
-    /** Model to use for the completion */
     model?: string;
-    /** Previous messages to include (if not using stored messages) */
     messages?: LlmapiMessage[];
-    /** Whether to include stored messages from conversation */
     includeHistory?: boolean;
-    /** Maximum number of history messages to include (default: 50) */
     maxHistoryMessages?: number;
-    /** Attached files */
     files?: FileMetadata[];
-    /** Per-request data callback */
     onData?: (chunk: string) => void;
-    /** Memory context to inject as system message (formatted memories from useMemoryStorage) */
     memoryContext?: string;
 }
-/**
- * Base result returned by useChatStorage hook (shared between React and Expo)
- */
 interface BaseUseChatStorageResult {
-    /** Whether a chat request is in progress */
     isLoading: boolean;
-    /** Stop the current request */
     stop: () => void;
-    /** Current conversation ID */
     conversationId: string | null;
-    /** Set the current conversation ID */
     setConversationId: (id: string | null) => void;
-    /** Create a new conversation */
     createConversation: (options?: CreateConversationOptions) => Promise<StoredConversation>;
-    /** Get a conversation by ID */
     getConversation: (id: string) => Promise<StoredConversation | null>;
-    /** Get all conversations (excluding soft-deleted) */
     getConversations: () => Promise<StoredConversation[]>;
-    /** Update conversation title. Returns true if updated, false if not found. */
     updateConversationTitle: (id: string, title: string) => Promise<boolean>;
-    /** Soft delete a conversation. Returns true if deleted, false if not found. */
     deleteConversation: (id: string) => Promise<boolean>;
-    /** Get messages for a conversation */
     getMessages: (conversationId: string) => Promise<StoredMessage[]>;
-    /** Get message count for a conversation */
     getMessageCount: (conversationId: string) => Promise<number>;
-    /** Clear all messages in a conversation */
     clearMessages: (conversationId: string) => Promise<void>;
 }
-/**
- * Generate a unique ID for conversations
- */
 declare function generateConversationId(): string;
 
+declare class Message extends Model {
+    static table: string;
+    static associations: Associations;
+    messageId: number;
+    conversationId: string;
+    role: ChatRole;
+    content: string;
+    model?: string;
+    files?: FileMetadata[];
+    createdAt: Date;
+    updatedAt: Date;
+    vector?: number[];
+    embeddingModel?: string;
+    usage?: ChatCompletionUsage;
+    sources?: SearchSource[];
+    responseDuration?: number;
+    wasStopped?: boolean;
+}
+declare class Conversation extends Model {
+    static table: string;
+    static associations: Associations;
+    conversationId: string;
+    title: string;
+    createdAt: Date;
+    updatedAt: Date;
+    isDeleted: boolean;
+}
+
 /**
  * Options for useChatStorage hook (React version)
  *
@@ -975,83 +904,11 @@ interface UseChatStorageResult extends BaseUseChatStorageResult {
  */
 declare function useChatStorage(options: UseChatStorageOptions): UseChatStorageResult;
 
-/**
- * WatermelonDB schema for chat storage
- *
- * Defines two tables:
- * - history: Chat messages with metadata
- * - conversations: Conversation metadata
- */
-declare const chatStorageSchema: Readonly<{
+declare const memoryStorageSchema: Readonly<{
     version: _nozbe_watermelondb_Schema.SchemaVersion;
     tables: _nozbe_watermelondb_Schema.TableMap;
     unsafeSql?: (_: string, __: _nozbe_watermelondb_Schema.AppSchemaUnsafeSqlKind) => string;
 }>;
-/**
- * Schema migrations
- */
-declare const chatStorageMigrations: Readonly<{
-    validated: true;
-    minVersion: _nozbe_watermelondb_Schema.SchemaVersion;
-    maxVersion: _nozbe_watermelondb_Schema.SchemaVersion;
-    sortedMigrations: _nozbe_watermelondb_Schema_migrations.Migration[];
-}>;
-
-/**
- * Message model representing a single chat message
- *
- * Note: This model uses raw column accessors instead of decorators
- * for better TypeScript compatibility without requiring legacy decorators.
- */
-declare class Message extends Model {
-    static table: string;
-    static associations: Associations;
-    /** Sequential message ID within conversation */
-    get messageId(): number;
-    /** Links message to its conversation */
-    get conversationId(): string;
-    /** Who sent the message: 'user' | 'assistant' | 'system' */
-    get role(): ChatRole;
-    /** The message text content */
-    get content(): string;
-    /** LLM model used (e.g., GPT-4, Claude) */
-    get model(): string | undefined;
-    /** Optional attached files */
-    get files(): FileMetadata[] | undefined;
-    /** Created timestamp */
-    get createdAt(): Date;
-    /** Updated timestamp */
-    get updatedAt(): Date;
-    /** Embedding vector for semantic search */
-    get vector(): number[] | undefined;
-    /** Model used to generate embedding */
-    get embeddingModel(): string | undefined;
-    /** Token counts and cost */
-    get usage(): ChatCompletionUsage | undefined;
-    /** Web search sources */
-    get sources(): SearchSource[] | undefined;
-    /** Response time in seconds */
-    get responseDuration(): number | undefined;
-    /** Whether the message generation was stopped by the user */
-    get wasStopped(): boolean;
-}
-/**
- * Conversation model representing conversation metadata
- */
-declare class Conversation extends Model {
-    static table: string;
-    static associations: Associations;
-    /** Unique conversation identifier */
-    get conversationId(): string;
-    /** Conversation title */
-    get title(): string;
-    /** Created timestamp */
-    get createdAt(): Date;
-    /** Updated timestamp */
-    get updatedAt(): Date;
-    /** Soft delete flag */
-    get isDeleted(): boolean;
-}
 
 interface MemoryItem$1 {
     type: "identity" | "preference" | "project" | "skill" | "constraint";
@@ -1066,13 +923,7 @@ interface MemoryExtractionResult {
     items: MemoryItem$1[];
 }
 
-/**
- * Memory type classification
- */
 type MemoryType = "identity" | "preference" | "project" | "skill" | "constraint";
-/**
- * Base memory item (matches existing MemoryItem from memory/service.ts)
- */
 interface MemoryItem {
     type: MemoryType;
     namespace: string;
@@ -1082,137 +933,37 @@ interface MemoryItem {
     confidence: number;
     pii: boolean;
 }
-/**
- * Stored memory record (what gets persisted to the database)
- */
-interface StoredMemory {
-    /** Primary key, unique memory identifier (WatermelonDB auto-generated) */
+interface CreateMemoryOptions extends MemoryItem {
+    embedding?: number[];
+    embeddingModel?: string;
+}
+type UpdateMemoryOptions = Partial<CreateMemoryOptions>;
+interface StoredMemory extends MemoryItem {
     uniqueId: string;
-    /** Memory type classification */
-    type: MemoryType;
-    /** Namespace for grouping related memories */
-    namespace: string;
-    /** Key within the namespace */
-    key: string;
-    /** The memory value/content */
-    value: string;
-    /** Raw evidence from which this memory was extracted */
-    rawEvidence: string;
-    /** Confidence score (0-1) */
-    confidence: number;
-    /** Whether this memory contains PII */
-    pii: boolean;
-    /** Composite key (namespace:key) for efficient lookups */
     compositeKey: string;
-    /** Unique key (namespace:key:value) for deduplication */
     uniqueKey: string;
-    /** ISO timestamp */
     createdAt: Date;
-    /** ISO timestamp */
     updatedAt: Date;
-    /** Embedding vector for semantic search */
     embedding?: number[];
-    /** Model used to generate embedding */
     embeddingModel?: string;
-    /** Soft delete flag */
     isDeleted: boolean;
 }
-/**
- * Memory with similarity score (returned from semantic search)
- */
 interface StoredMemoryWithSimilarity extends StoredMemory {
-    /** Cosine similarity score (0-1) */
     similarity: number;
 }
-/**
- * Options for creating a new memory
- */
-interface CreateMemoryOptions {
-    /** Memory type */
-    type: MemoryType;
-    /** Namespace for grouping */
-    namespace: string;
-    /** Key within namespace */
-    key: string;
-    /** Memory value/content */
-    value: string;
-    /** Raw evidence text */
-    rawEvidence: string;
-    /** Confidence score (0-1) */
-    confidence: number;
-    /** Whether this contains PII */
-    pii: boolean;
-    /** Optional embedding vector */
-    embedding?: number[];
-    /** Optional embedding model name */
-    embeddingModel?: string;
-}
-/**
- * Options for updating a memory
- */
-interface UpdateMemoryOptions {
-    /** Memory type */
-    type?: MemoryType;
-    /** Namespace for grouping */
-    namespace?: string;
-    /** Key within namespace */
-    key?: string;
-    /** Memory value/content */
-    value?: string;
-    /** Raw evidence text */
-    rawEvidence?: string;
-    /** Confidence score (0-1) */
-    confidence?: number;
-    /** Whether this contains PII */
-    pii?: boolean;
-    /** Optional embedding vector */
-    embedding?: number[];
-    /** Optional embedding model name */
-    embeddingModel?: string;
-}
-/**
- * Base options for useMemoryStorage hook (shared between React and Expo)
- */
 interface BaseUseMemoryStorageOptions {
-    /** WatermelonDB database instance */
     database: Database;
-    /** The model to use for fact extraction (default: "openai/gpt-4o") */
     completionsModel?: string;
-    /**
-     * The model to use for generating embeddings
-     * For local: default is "Snowflake/snowflake-arctic-embed-xs"
-     * For api: default is "openai/text-embedding-3-small"
-     * Set to null to disable embedding generation
-     */
     embeddingModel?: string | null;
-    /**
-     * The provider to use for generating embeddings (default: "local")
-     * "local": Uses a local HuggingFace model (in-browser)
-     * "api": Uses the backend API
-     */
     embeddingProvider?: "local" | "api";
-    /** Whether to automatically generate embeddings for extracted memories (default: true) */
     generateEmbeddings?: boolean;
-    /** Callback when facts are extracted */
     onFactsExtracted?: (facts: MemoryExtractionResult) => void;
-    /** Custom function to get auth token for API calls */
     getToken?: () => Promise<string | null>;
-    /** Optional base URL for the API requests */
     baseUrl?: string;
 }
-/**
- * Base result returned by useMemoryStorage hook (shared between React and Expo)
- */
 interface BaseUseMemoryStorageResult {
-    /** Current memories in state (reactive) */
     memories: StoredMemory[];
-    /** Refresh memories from storage */
     refreshMemories: () => Promise<void>;
-    /**
-     * Extract memories from messages and store them
-     * @param options Messages and model to use for extraction
-     * @returns Extraction result or null if failed
-     */
     extractMemoriesFromMessage: (options: {
         messages: Array<{
             role: string;
@@ -1220,89 +971,40 @@ interface BaseUseMemoryStorageResult {
         }>;
         model?: string;
     }) => Promise<MemoryExtractionResult | null>;
-    /**
-     * Search for similar memories using semantic search
-     * @param query The text query to search for
-     * @param limit Maximum number of results (default: 10)
-     * @param minSimilarity Minimum similarity threshold 0-1 (default: 0.6)
-     * @returns Array of memories with similarity scores, sorted by relevance
-     */
     searchMemories: (query: string, limit?: number, minSimilarity?: number) => Promise<StoredMemoryWithSimilarity[]>;
-    /**
-     * Get all memories stored in the database
-     * @returns Array of all stored memories
-     */
     fetchAllMemories: () => Promise<StoredMemory[]>;
-    /**
-     * Get memories filtered by namespace
-     * @param namespace The namespace to filter by
-     * @returns Array of memories in the specified namespace
-     */
     fetchMemoriesByNamespace: (namespace: string) => Promise<StoredMemory[]>;
-    /**
-     * Get memories by namespace and key
-     * @param namespace The namespace
-     * @param key The key within the namespace
-     * @returns Array of memories matching the namespace and key
-     */
     fetchMemoriesByKey: (namespace: string, key: string) => Promise<StoredMemory[]>;
-    /**
-     * Get a memory by its unique ID
-     * @param id The memory unique ID
-     * @returns The memory or null if not found
-     */
     getMemoryById: (id: string) => Promise<StoredMemory | null>;
-    /**
-     * Save a single memory to storage
-     * @param memory The memory to save
-     * @returns The stored memory
-     */
     saveMemory: (memory: CreateMemoryOptions) => Promise<StoredMemory>;
-    /**
-     * Save multiple memories to storage
-     * @param memories Array of memories to save
-     * @returns Array of stored memories
-     */
     saveMemories: (memories: CreateMemoryOptions[]) => Promise<StoredMemory[]>;
-    /**
-     * Update a memory by its ID
-     * @param id The memory ID
-     * @param updates Partial memory fields to update
-     * @returns The updated memory or null if not found
-     */
     updateMemory: (id: string, updates: UpdateMemoryOptions) => Promise<StoredMemory | null>;
-    /**
-     * Delete a specific memory by namespace, key, and value
-     * @param namespace The namespace
-     * @param key The key
-     * @param value The value
-     */
     removeMemory: (namespace: string, key: string, value: string) => Promise<void>;
-    /**
-     * Delete a memory by its ID (soft delete)
-     * @param id The memory ID
-     */
     removeMemoryById: (id: string) => Promise<void>;
-    /**
-     * Delete all memories by namespace and key
-     * @param namespace The namespace
-     * @param key The key
-     */
     removeMemories: (namespace: string, key: string) => Promise<void>;
-    /**
-     * Clear all memories from storage
-     */
     clearMemories: () => Promise<void>;
 }
-/**
- * Generate composite key from namespace and key
- */
 declare function generateCompositeKey(namespace: string, key: string): string;
-/**
- * Generate unique key from namespace, key, and value
- */
 declare function generateUniqueKey(namespace: string, key: string, value: string): string;
 
+declare class Memory extends Model {
+    static table: string;
+    type: MemoryType;
+    namespace: string;
+    key: string;
+    value: string;
+    rawEvidence: string;
+    confidence: number;
+    pii: boolean;
+    compositeKey: string;
+    uniqueKey: string;
+    createdAt: Date;
+    updatedAt: Date;
+    embedding?: number[];
+    embeddingModel?: string;
+    isDeleted: boolean;
+}
+
 /**
  * Options for useMemoryStorage hook (React version)
  *
@@ -1362,105 +1064,39 @@ type UseMemoryStorageResult = BaseUseMemoryStorageResult;
  */
 declare function useMemoryStorage(options: UseMemoryStorageOptions): UseMemoryStorageResult;
 
-/**
- * WatermelonDB schema for memory storage
- *
- * Defines the memories table for storing extracted user memories
- * with support for vector embeddings for semantic search.
- */
-declare const memoryStorageSchema: Readonly<{
+declare const settingsStorageSchema: Readonly<{
     version: _nozbe_watermelondb_Schema.SchemaVersion;
     tables: _nozbe_watermelondb_Schema.TableMap;
     unsafeSql?: (_: string, __: _nozbe_watermelondb_Schema.AppSchemaUnsafeSqlKind) => string;
 }>;
 
-/**
- * Memory model representing a single extracted memory
- *
- * Note: This model uses raw column accessors instead of decorators
- * for better TypeScript compatibility without requiring legacy decorators.
- */
-declare class Memory extends Model {
+declare class ModelPreference extends Model {
     static table: string;
-    /** Memory type classification */
-    get type(): MemoryType;
-    /** Namespace for grouping related memories */
-    get namespace(): string;
-    /** Key within the namespace */
-    get key(): string;
-    /** The memory value/content */
-    get value(): string;
-    /** Raw evidence from which this memory was extracted */
-    get rawEvidence(): string;
-    /** Confidence score (0-1) */
-    get confidence(): number;
-    /** Whether this memory contains PII */
-    get pii(): boolean;
-    /** Composite key (namespace:key) for efficient lookups */
-    get compositeKey(): string;
-    /** Unique key (namespace:key:value) for deduplication */
-    get uniqueKey(): string;
-    /** Created timestamp */
-    get createdAt(): Date;
-    /** Updated timestamp */
-    get updatedAt(): Date;
-    /** Embedding vector for semantic search */
-    get embedding(): number[] | undefined;
-    /** Model used to generate embedding */
-    get embeddingModel(): string | undefined;
-    /** Soft delete flag */
-    get isDeleted(): boolean;
+    walletAddress: string;
+    models?: string;
 }
 
-/**
- * Stored model preference record (what gets persisted to the database)
- */
 interface StoredModelPreference {
-    /** Primary key (WatermelonDB auto-generated) */
     uniqueId: string;
-    /** User's wallet address */
     walletAddress: string;
-    /** Preferred model identifiers */
     models?: string;
 }
-/**
- * Options for creating a new model preference
- */
 interface CreateModelPreferenceOptions {
-    /** User's wallet address */
     walletAddress: string;
-    /** Preferred model identifiers */
     models?: string;
 }
-/**
- * Options for updating a model preference
- */
 interface UpdateModelPreferenceOptions {
-    /** New preferred model identifiers */
     models?: string;
 }
-/**
- * Base options for useSettings hook
- */
 interface BaseUseSettingsOptions {
-    /** WatermelonDB database instance */
     database: Database;
-    /** User's wallet address */
     walletAddress?: string;
 }
-/**
- * Base result returned by useSettings hook
- */
 interface BaseUseSettingsResult {
-    /** Current model preference */
     modelPreference: StoredModelPreference | null;
-    /** Whether the settings are loading */
     isLoading: boolean;
-    /** Get model preference by wallet address. Throws on error. */
     getModelPreference: (walletAddress: string) => Promise<StoredModelPreference | null>;
-    /** Create or update model preference. Throws on error. */
     setModelPreference: (walletAddress: string, models?: string) => Promise<StoredModelPreference | null>;
-    /** Delete model preference. Throws on error. */
     deleteModelPreference: (walletAddress: string) => Promise<boolean>;
 }
 
@@ -1519,32 +1155,6 @@ interface UseSettingsResult extends BaseUseSettingsResult {
  */
 declare function useSettings(options: UseSettingsOptions): UseSettingsResult;
 
-/**
- * WatermelonDB schema for settings storage
- *
- * * Defines one table::
- * - modelPreferences: Model preferences metadata
- */
-declare const settingsStorageSchema: Readonly<{
-    version: _nozbe_watermelondb_Schema.SchemaVersion;
-    tables: _nozbe_watermelondb_Schema.TableMap;
-    unsafeSql?: (_: string, __: _nozbe_watermelondb_Schema.AppSchemaUnsafeSqlKind) => string;
-}>;
-
-/**
- * ModelPreference model representing user model preferences
- *
- * Note: This model uses raw column accessors instead of decorators
- * for better TypeScript compatibility without requiring legacy decorators.
- */
-declare class ModelPreference extends Model {
-    static table: string;
-    /** User's wallet address */
-    get walletAddress(): string;
-    /** Preferred model identifier */
-    get models(): string | undefined;
-}
-
 interface PdfFile {
     url: string;
     mediaType?: string;
@@ -1757,4 +1367,352 @@ declare function executeTool(tool: ClientTool, params: Record<string, unknown>):
     error?: string;
 }>;
 
-export { Conversation as ChatConversation, Message as ChatMessage, type ChatRole, type ClientTool, type CreateConversationOptions, type CreateMemoryOptions, type CreateMessageOptions, type CreateModelPreferenceOptions, DEFAULT_TOOL_SELECTOR_MODEL, type FileMetadata, type MemoryItem, type MemoryType, type OCRFile, type PdfFile, type SearchMessagesOptions, type SearchSource, type SendMessageWithStorageArgs, type SendMessageWithStorageResult, type SignMessageFn, type ChatCompletionUsage as StoredChatCompletionUsage, type StoredConversation, type StoredMemory, Memory as StoredMemoryModel, type StoredMemoryWithSimilarity, type StoredMessage, type StoredMessageWithSimilarity, type StoredModelPreference, ModelPreference as StoredModelPreferenceModel, type ToolExecutionResult, type ToolParameter, type ToolSelectionResult, type UpdateMemoryOptions, type UpdateModelPreferenceOptions, type UseChatStorageOptions, type UseChatStorageResult, type UseMemoryStorageOptions, type UseMemoryStorageResult, type UseSettingsOptions, type UseSettingsResult, chatStorageMigrations, chatStorageSchema, createMemoryContextSystemMessage, decryptData, decryptDataBytes, encryptData, executeTool, extractConversationContext, formatMemoriesForChat, generateCompositeKey, generateConversationId, generateUniqueKey, hasEncryptionKey, memoryStorageSchema, requestEncryptionKey, selectTool, settingsStorageSchema, useChat, useChatStorage, useEncryption, useImageGeneration, useMemoryStorage, useModels, useOCR, usePdf, useSearch, useSettings };
+/**
+ * Dropbox API utilities
+ *
+ * Uses Dropbox HTTP API for file operations.
+ * Dropbox uses OAuth 2.0 with PKCE for browser apps.
+ */
+/** Default folder path for Dropbox backups */
+declare const DEFAULT_BACKUP_FOLDER = "/ai-chat-app/conversations";
+
+/**
+ * Dropbox Backup Implementation
+ *
+ * Generic backup/restore functionality for Dropbox storage.
+ * Works directly with WatermelonDB database.
+ */
+
+interface DropboxExportResult {
+    success: boolean;
+    uploaded: number;
+    skipped: number;
+    total: number;
+}
+interface DropboxImportResult {
+    success: boolean;
+    restored: number;
+    failed: number;
+    total: number;
+    /** True if no backups were found in Dropbox */
+    noBackupsFound?: boolean;
+}
+
+/**
+ * Options for useDropboxBackup hook
+ */
+interface UseDropboxBackupOptions {
+    /** WatermelonDB database instance */
+    database: Database;
+    /** Current user address (null if not signed in) */
+    userAddress: string | null;
+    /** Request encryption key for the user address */
+    requestEncryptionKey: (address: string) => Promise<void>;
+    /** Export a conversation to an encrypted blob */
+    exportConversation: (conversationId: string, userAddress: string) => Promise<{
+        success: boolean;
+        blob?: Blob;
+    }>;
+    /** Import a conversation from an encrypted blob */
+    importConversation: (blob: Blob, userAddress: string) => Promise<{
+        success: boolean;
+    }>;
+    /** Dropbox folder path for backups (default: '/ai-chat-app/conversations') */
+    backupFolder?: string;
+}
+/**
+ * Result returned by useDropboxBackup hook
+ */
+interface UseDropboxBackupResult {
+    /** Backup all conversations to Dropbox */
+    backup: (options?: {
+        onProgress?: (current: number, total: number) => void;
+    }) => Promise<DropboxExportResult | {
+        error: string;
+    }>;
+    /** Restore conversations from Dropbox */
+    restore: (options?: {
+        onProgress?: (current: number, total: number) => void;
+    }) => Promise<DropboxImportResult | {
+        error: string;
+    }>;
+    /** Whether Dropbox is configured */
+    isConfigured: boolean;
+    /** Whether user has a Dropbox token */
+    isAuthenticated: boolean;
+}
+/**
+ * React hook for Dropbox backup and restore functionality.
+ *
+ * This hook provides methods to backup conversations to Dropbox and restore them.
+ * It handles all the logic for checking timestamps, skipping unchanged files,
+ * authentication, and managing the backup/restore process.
+ *
+ * Must be used within a DropboxAuthProvider.
+ *
+ * @example
+ * ```tsx
+ * import { useDropboxBackup } from "@reverbia/sdk/react";
+ *
+ * function BackupButton() {
+ *   const { backup, restore, isConfigured } = useDropboxBackup({
+ *     database,
+ *     userAddress,
+ *     requestEncryptionKey,
+ *     exportConversation,
+ *     importConversation,
+ *   });
+ *
+ *   const handleBackup = async () => {
+ *     const result = await backup({
+ *       onProgress: (current, total) => {
+ *         console.log(`Progress: ${current}/${total}`);
+ *       },
+ *     });
+ *
+ *     if ("error" in result) {
+ *       console.error(result.error);
+ *     } else {
+ *       console.log(`Uploaded: ${result.uploaded}, Skipped: ${result.skipped}`);
+ *     }
+ *   };
+ *
+ *   return <button onClick={handleBackup} disabled={!isConfigured}>Backup</button>;
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useDropboxBackup(options: UseDropboxBackupOptions): UseDropboxBackupResult;
+
+/**
+ * Dropbox OAuth 2.0 with PKCE
+ *
+ * Flow:
+ * 1. Generate code_verifier and code_challenge
+ * 2. Redirect user to Dropbox authorization URL
+ * 3. User authorizes and is redirected back with authorization code
+ * 4. Exchange code for access token using code_verifier
+ */
+/**
+ * Get the stored access token from session storage
+ */
+declare function getStoredToken(): string | null;
+/**
+ * Store access token in session storage
+ */
+declare function storeToken(token: string): void;
+/**
+ * Clear stored access token
+ */
+declare function clearToken(): void;
+
+/**
+ * Props for DropboxAuthProvider
+ */
+interface DropboxAuthProviderProps {
+    /** Dropbox App Key (from Dropbox Developer Console) */
+    appKey: string | undefined;
+    /** OAuth callback path (e.g., "/auth/dropbox/callback") */
+    callbackPath?: string;
+    /** Children to render */
+    children: ReactNode;
+}
+/**
+ * Context value for Dropbox authentication
+ */
+interface DropboxAuthContextValue {
+    /** Current access token (null if not authenticated) */
+    accessToken: string | null;
+    /** Whether user has authenticated with Dropbox */
+    isAuthenticated: boolean;
+    /** Whether Dropbox is configured (app key exists) */
+    isConfigured: boolean;
+    /** Request Dropbox access - returns token or redirects to OAuth */
+    requestAccess: () => Promise<string>;
+    /** Clear stored token and log out */
+    logout: () => void;
+}
+/**
+ * Provider component for Dropbox OAuth authentication.
+ *
+ * Wrap your app with this provider to enable Dropbox authentication.
+ * It handles the OAuth 2.0 PKCE flow automatically.
+ *
+ * @example
+ * ```tsx
+ * import { DropboxAuthProvider } from "@reverbia/sdk/react";
+ *
+ * function App() {
+ *   return (
+ *     <DropboxAuthProvider
+ *       appKey={process.env.NEXT_PUBLIC_DROPBOX_APP_KEY}
+ *       callbackPath="/auth/dropbox/callback"
+ *     >
+ *       <MyApp />
+ *     </DropboxAuthProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @category Components
+ */
+declare function DropboxAuthProvider({ appKey, callbackPath, children, }: DropboxAuthProviderProps): JSX.Element;
+/**
+ * Hook to access Dropbox authentication state and methods.
+ *
+ * Must be used within a DropboxAuthProvider.
+ *
+ * @example
+ * ```tsx
+ * import { useDropboxAuth } from "@reverbia/sdk/react";
+ *
+ * function DropboxButton() {
+ *   const { isAuthenticated, isConfigured, requestAccess, logout } = useDropboxAuth();
+ *
+ *   if (!isConfigured) {
+ *     return <p>Dropbox not configured</p>;
+ *   }
+ *
+ *   if (isAuthenticated) {
+ *     return <button onClick={logout}>Disconnect Dropbox</button>;
+ *   }
+ *
+ *   return <button onClick={requestAccess}>Connect Dropbox</button>;
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useDropboxAuth(): DropboxAuthContextValue;
+
+/**
+ * Google Drive API utilities
+ *
+ * Uses Google Drive API v3 for file operations.
+ * Requires an OAuth 2.0 access token with drive.file scope.
+ */
+/** Default root folder name for backups */
+declare const DEFAULT_ROOT_FOLDER = "ai-chat-app";
+/** Default subfolder for conversation backups */
+declare const DEFAULT_CONVERSATIONS_FOLDER = "conversations";
+
+/**
+ * Google Drive Backup Implementation
+ *
+ * Generic backup/restore functionality for Google Drive storage.
+ * Works directly with WatermelonDB database.
+ */
+
+interface GoogleDriveExportResult {
+    success: boolean;
+    uploaded: number;
+    skipped: number;
+    total: number;
+}
+interface GoogleDriveImportResult {
+    success: boolean;
+    restored: number;
+    failed: number;
+    total: number;
+    /** True if no backups were found in Google Drive */
+    noBackupsFound?: boolean;
+}
+
+/**
+ * Options for useGoogleDriveBackup hook
+ */
+interface UseGoogleDriveBackupOptions {
+    /** WatermelonDB database instance */
+    database: Database;
+    /** Current user address (null if not signed in) */
+    userAddress: string | null;
+    /** Current Google Drive access token (null if not authenticated) */
+    accessToken: string | null;
+    /** Request Google Drive access - returns access token */
+    requestDriveAccess: () => Promise<string>;
+    /** Request encryption key for the user address */
+    requestEncryptionKey: (address: string) => Promise<void>;
+    /** Export a conversation to an encrypted blob */
+    exportConversation: (conversationId: string, userAddress: string) => Promise<{
+        success: boolean;
+        blob?: Blob;
+    }>;
+    /** Import a conversation from an encrypted blob */
+    importConversation: (blob: Blob, userAddress: string) => Promise<{
+        success: boolean;
+    }>;
+    /** Root folder name in Google Drive (default: 'ai-chat-app') */
+    rootFolder?: string;
+    /** Subfolder for conversations (default: 'conversations') */
+    conversationsFolder?: string;
+}
+/**
+ * Result returned by useGoogleDriveBackup hook
+ */
+interface UseGoogleDriveBackupResult {
+    /** Backup all conversations to Google Drive */
+    backup: (options?: {
+        onProgress?: (current: number, total: number) => void;
+    }) => Promise<GoogleDriveExportResult | {
+        error: string;
+    }>;
+    /** Restore conversations from Google Drive */
+    restore: (options?: {
+        onProgress?: (current: number, total: number) => void;
+    }) => Promise<GoogleDriveImportResult | {
+        error: string;
+    }>;
+    /** Whether user has a Google Drive token */
+    isAuthenticated: boolean;
+}
+/**
+ * React hook for Google Drive backup and restore functionality.
+ *
+ * This hook provides methods to backup conversations to Google Drive and restore them.
+ * It handles all the logic for checking timestamps, skipping unchanged files,
+ * and managing the backup/restore process.
+ *
+ * Unlike Dropbox, Google Drive auth requires browser-specific setup (Google Identity Services),
+ * so the auth provider must be implemented in the app. This hook accepts the auth
+ * callbacks as options.
+ *
+ * @example
+ * ```tsx
+ * import { useGoogleDriveBackup } from "@reverbia/sdk/react";
+ *
+ * function BackupButton() {
+ *   const { accessToken, requestDriveAccess } = useGoogleAccessToken();
+ *   const { backup, restore, isAuthenticated } = useGoogleDriveBackup({
+ *     database,
+ *     userAddress,
+ *     accessToken,
+ *     requestDriveAccess,
+ *     requestEncryptionKey,
+ *     exportConversation,
+ *     importConversation,
+ *   });
+ *
+ *   const handleBackup = async () => {
+ *     const result = await backup({
+ *       onProgress: (current, total) => {
+ *         console.log(`Progress: ${current}/${total}`);
+ *       },
+ *     });
+ *
+ *     if ("error" in result) {
+ *       console.error(result.error);
+ *     } else {
+ *       console.log(`Uploaded: ${result.uploaded}, Skipped: ${result.skipped}`);
+ *     }
+ *   };
+ *
+ *   return <button onClick={handleBackup}>Backup</button>;
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useGoogleDriveBackup(options: UseGoogleDriveBackupOptions): UseGoogleDriveBackupResult;
+
+export { Conversation as ChatConversation, Message as ChatMessage, type ChatRole, type ClientTool, type CreateConversationOptions, type CreateMemoryOptions, type CreateMessageOptions, type CreateModelPreferenceOptions, DEFAULT_BACKUP_FOLDER, DEFAULT_CONVERSATIONS_FOLDER as DEFAULT_DRIVE_CONVERSATIONS_FOLDER, DEFAULT_ROOT_FOLDER as DEFAULT_DRIVE_ROOT_FOLDER, DEFAULT_TOOL_SELECTOR_MODEL, type DropboxAuthContextValue, DropboxAuthProvider, type DropboxAuthProviderProps, type DropboxExportResult, type DropboxImportResult, type FileMetadata, type GoogleDriveExportResult, type GoogleDriveImportResult, type MemoryItem, type MemoryType, type OCRFile, type PdfFile, type SearchMessagesOptions, type SearchSource, type SendMessageWithStorageArgs, type SendMessageWithStorageResult, type SignMessageFn, type ChatCompletionUsage as StoredChatCompletionUsage, type StoredConversation, type StoredMemory, Memory as StoredMemoryModel, type StoredMemoryWithSimilarity, type StoredMessage, type StoredMessageWithSimilarity, type StoredModelPreference, ModelPreference as StoredModelPreferenceModel, type ToolExecutionResult, type ToolParameter, type ToolSelectionResult, type UpdateMemoryOptions, type UpdateModelPreferenceOptions, type UseChatStorageOptions, type UseChatStorageResult, type UseDropboxBackupOptions, type UseDropboxBackupResult, type UseGoogleDriveBackupOptions, type UseGoogleDriveBackupResult, type UseMemoryStorageOptions, type UseMemoryStorageResult, type UseSettingsOptions, type UseSettingsResult, chatStorageMigrations, chatStorageSchema, clearToken as clearDropboxToken, createMemoryContextSystemMessage, decryptData, decryptDataBytes, encryptData, executeTool, extractConversationContext, formatMemoriesForChat, generateCompositeKey, generateConversationId, generateUniqueKey, getStoredToken as getDropboxToken, hasEncryptionKey, memoryStorageSchema, requestEncryptionKey, selectTool, settingsStorageSchema, storeToken as storeDropboxToken, useChat, useChatStorage, useDropboxAuth, useDropboxBackup, useEncryption, useGoogleDriveBackup, useImageGeneration, useMemoryStorage, useModels, useOCR, usePdf, useSearch, useSettings };