@reverbia/sdk 1.0.0-next.20251218225706 → 1.0.0-next.20251219154503

package/dist/react/index.d.mts

@@ -348,6 +348,295 @@ type LlmapiSearchUsage = {
     cost_micro_usd?: number;
 };
 
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * Header or query parameter name.
+     *
+     * @default 'Authorization'
+     */
+    name?: string;
+    scheme?: 'basic' | 'bearer';
+    type: 'apiKey' | 'http';
+}
+
+interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
+}
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
+
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: any) => any;
+type QuerySerializerOptionsObject = {
+    allowReserved?: boolean;
+    array?: Partial<SerializerOptions<ArrayStyle>>;
+    object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
+    /**
+     * Per-parameter serialization overrides. When provided, these settings
+     * override the global array/object settings for specific parameter names.
+     */
+    parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    getConfig: () => Config;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+} & {
+    [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? {
+    sse?: never;
+} : {
+    sse: {
+        [K in HttpMethod]: SseFn;
+    };
+});
+interface Config$1 {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: Uppercase<HttpMethod>;
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g. converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+    /**
+     * Callback invoked when a network or parsing error occurs during streaming.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param error The error that occurred.
+     */
+    onSseError?: (error: unknown) => void;
+    /**
+     * Callback invoked when an event is streamed from the server.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param event Event streamed from the server.
+     * @returns Nothing (void).
+     */
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
+    /**
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
+     */
+    sseDefaultRetryDelay?: number;
+    /**
+     * Maximum number of retry attempts before giving up.
+     */
+    sseMaxRetryAttempts?: number;
+    /**
+     * Maximum retry delay in milliseconds.
+     *
+     * Applies only when exponential backoff is used.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 30000
+     */
+    sseMaxRetryDelay?: number;
+    /**
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
+     */
+    sseSleepFn?: (ms: number) => Promise<void>;
+    url: string;
+};
+interface StreamEvent<TData = unknown> {
+    data: TData;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+
+type ErrInterceptor<Err, Res, Options> = (error: Err, response: Res, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Options> = (options: Options) => void | Promise<void>;
+type ResInterceptor<Res, Options> = (response: Res, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    fns: Array<Interceptor | null>;
+    clear(): void;
+    eject(id: number | Interceptor): void;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+    use(fn: Interceptor): number;
+}
+interface Middleware<Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Options>>;
+    request: Interceptors<ReqInterceptor<Options>>;
+    response: Interceptors<ResInterceptor<Res, Options>>;
+}
+
+interface Config<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+interface RequestOptions<TData = unknown, ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+interface ResolvedRequestOptions<ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, ThrowOnError, Url> {
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean> = ThrowOnError extends true ? Promise<{
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    response: Response;
+}> : Promise<({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    response: Response;
+}>;
+interface ClientOptions {
+    baseUrl?: string;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions<TData, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError>;
+type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions<TData, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions<TData, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: TData & Options<TData>) => string;
+type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Response, unknown, ResolvedRequestOptions>;
+};
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = OmitKeys<RequestOptions<TResponse, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+
 /**
  * Parameter definition for a client-side tool
  */
@@ -1455,7 +1744,7 @@ declare function executeTool(tool: ClientTool, params: Record<string, unknown>):
  * 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";
+declare const DEFAULT_BACKUP_FOLDER$1 = "/ai-chat-app/conversations";
 
 /**
  * Dropbox Backup Implementation
@@ -1567,26 +1856,23 @@ interface UseDropboxBackupResult {
 declare function useDropboxBackup(options: UseDropboxBackupOptions): UseDropboxBackupResult;
 
 /**
- * Dropbox OAuth 2.0 with PKCE
+ * Dropbox OAuth 2.0 Authorization Code Flow
  *
  * 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
+ * 1. Redirect user to Dropbox authorization URL
+ * 2. User authorizes and is redirected back with authorization code
+ * 3. Exchange code on backend for access + refresh tokens
+ * 4. Use refresh token to get new access tokens silently
  */
+
 /**
- * Get the stored access token from session storage
- */
-declare function getStoredToken(): string | null;
-/**
- * Store access token in session storage
+ * Clear Dropbox token data
  */
-declare function storeToken(token: string): void;
+declare function clearToken(): void;
 /**
- * Clear stored access token
+ * Check if we have any stored credentials (including refresh token)
  */
-declare function clearToken(): void;
+declare function hasDropboxCredentials(): boolean;
 
 /**
  * Props for DropboxAuthProvider
@@ -1594,8 +1880,13 @@ declare function clearToken(): void;
 interface DropboxAuthProviderProps {
     /** Dropbox App Key (from Dropbox Developer Console) */
     appKey: string | undefined;
-    /** OAuth callback path (e.g., "/auth/dropbox/callback") */
+    /** OAuth callback path (default: "/auth/dropbox/callback") */
     callbackPath?: string;
+    /**
+     * API client for backend OAuth requests. Optional - uses the default SDK client if not provided.
+     * Only needed if you have a custom client configuration (e.g., different baseUrl).
+     */
+    apiClient?: Client;
     /** Children to render */
     children: ReactNode;
 }
@@ -1612,13 +1903,15 @@ interface DropboxAuthContextValue {
     /** Request Dropbox access - returns token or redirects to OAuth */
     requestAccess: () => Promise<string>;
     /** Clear stored token and log out */
-    logout: () => void;
+    logout: () => Promise<void>;
+    /** Refresh the access token using the refresh token */
+    refreshToken: () => Promise<string | null>;
 }
 /**
  * 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.
+ * It handles the OAuth 2.0 Authorization Code flow with refresh tokens.
  *
  * @example
  * ```tsx
@@ -1638,7 +1931,7 @@ interface DropboxAuthContextValue {
  *
  * @category Components
  */
-declare function DropboxAuthProvider({ appKey, callbackPath, children, }: DropboxAuthProviderProps): JSX.Element;
+declare function DropboxAuthProvider({ appKey, callbackPath, apiClient, children, }: DropboxAuthProviderProps): JSX.Element;
 /**
  * Hook to access Dropbox authentication state and methods.
  *
@@ -1667,6 +1960,115 @@ declare function DropboxAuthProvider({ appKey, callbackPath, children, }: Dropbo
  */
 declare function useDropboxAuth(): DropboxAuthContextValue;
 
+/**
+ * Google Drive OAuth 2.0 Authorization Code Flow
+ *
+ * Flow:
+ * 1. Redirect user to Google authorization URL
+ * 2. User authorizes and is redirected back with authorization code
+ * 3. Exchange code on backend for access + refresh tokens
+ * 4. Use refresh token to get new access tokens silently
+ */
+
+/**
+ * Get stored token data for Google Drive
+ */
+declare function getGoogleDriveStoredToken(): string | null;
+/**
+ * Clear Google Drive token data
+ */
+declare function clearGoogleDriveToken(): void;
+/**
+ * Check if we have any stored credentials (including refresh token)
+ */
+declare function hasGoogleDriveCredentials(): boolean;
+
+/**
+ * Props for GoogleDriveAuthProvider
+ */
+interface GoogleDriveAuthProviderProps {
+    /** Google OAuth Client ID (from Google Cloud Console) */
+    clientId: string | undefined;
+    /** OAuth callback path (default: "/auth/google/callback") */
+    callbackPath?: string;
+    /**
+     * API client for backend OAuth requests. Optional - uses the default SDK client if not provided.
+     * Only needed if you have a custom client configuration (e.g., different baseUrl).
+     */
+    apiClient?: Client;
+    /** Children to render */
+    children: ReactNode;
+}
+/**
+ * Context value for Google Drive authentication
+ */
+interface GoogleDriveAuthContextValue {
+    /** Current access token (null if not authenticated) */
+    accessToken: string | null;
+    /** Whether user has authenticated with Google Drive */
+    isAuthenticated: boolean;
+    /** Whether Google Drive is configured (client ID exists) */
+    isConfigured: boolean;
+    /** Request Google Drive access - returns token or redirects to OAuth */
+    requestAccess: () => Promise<string>;
+    /** Clear stored token and log out */
+    logout: () => Promise<void>;
+    /** Refresh the access token using the refresh token */
+    refreshToken: () => Promise<string | null>;
+}
+/**
+ * Provider component for Google Drive OAuth authentication.
+ *
+ * Wrap your app with this provider to enable Google Drive authentication.
+ * It handles the OAuth 2.0 Authorization Code flow with refresh tokens.
+ *
+ * @example
+ * ```tsx
+ * import { GoogleDriveAuthProvider } from "@reverbia/sdk/react";
+ *
+ * function App() {
+ *   return (
+ *     <GoogleDriveAuthProvider
+ *       clientId={process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID}
+ *       callbackPath="/auth/google/callback"
+ *     >
+ *       <MyApp />
+ *     </GoogleDriveAuthProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @category Components
+ */
+declare function GoogleDriveAuthProvider({ clientId, callbackPath, apiClient, children, }: GoogleDriveAuthProviderProps): JSX.Element;
+/**
+ * Hook to access Google Drive authentication state and methods.
+ *
+ * Must be used within a GoogleDriveAuthProvider.
+ *
+ * @example
+ * ```tsx
+ * import { useGoogleDriveAuth } from "@reverbia/sdk/react";
+ *
+ * function GoogleDriveButton() {
+ *   const { isAuthenticated, isConfigured, requestAccess, logout } = useGoogleDriveAuth();
+ *
+ *   if (!isConfigured) {
+ *     return <p>Google Drive not configured</p>;
+ *   }
+ *
+ *   if (isAuthenticated) {
+ *     return <button onClick={logout}>Disconnect Google Drive</button>;
+ *   }
+ *
+ *   return <button onClick={requestAccess}>Connect Google Drive</button>;
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useGoogleDriveAuth(): GoogleDriveAuthContextValue;
+
 /**
  * Google Drive API utilities
  *
@@ -1708,10 +2110,6 @@ interface UseGoogleDriveBackupOptions {
     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 */
@@ -1744,6 +2142,8 @@ interface UseGoogleDriveBackupResult {
     }) => Promise<GoogleDriveImportResult | {
         error: string;
     }>;
+    /** Whether Google Drive is configured */
+    isConfigured: boolean;
     /** Whether user has a Google Drive token */
     isAuthenticated: boolean;
 }
@@ -1752,23 +2152,18 @@ interface UseGoogleDriveBackupResult {
  *
  * 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.
+ * authentication, 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.
+ * Must be used within a GoogleDriveAuthProvider.
  *
  * @example
  * ```tsx
  * import { useGoogleDriveBackup } from "@reverbia/sdk/react";
  *
  * function BackupButton() {
- *   const { accessToken, requestDriveAccess } = useGoogleAccessToken();
- *   const { backup, restore, isAuthenticated } = useGoogleDriveBackup({
+ *   const { backup, restore, isConfigured, isAuthenticated } = useGoogleDriveBackup({
  *     database,
  *     userAddress,
- *     accessToken,
- *     requestDriveAccess,
  *     requestEncryptionKey,
  *     exportConversation,
  *     importConversation,
@@ -1788,7 +2183,7 @@ interface UseGoogleDriveBackupResult {
  *     }
  *   };
  *
- *   return <button onClick={handleBackup}>Backup</button>;
+ *   return <button onClick={handleBackup} disabled={!isConfigured}>Backup</button>;
  * }
  * ```
  *
@@ -1796,4 +2191,614 @@ interface UseGoogleDriveBackupResult {
  */
 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, sdkMigrations, sdkModelClasses, sdkSchema, selectTool, settingsStorageSchema, storeToken as storeDropboxToken, useChat, useChatStorage, useDropboxAuth, useDropboxBackup, useEncryption, useGoogleDriveBackup, useImageGeneration, useMemoryStorage, useModels, useOCR, usePdf, useSearch, useSettings };
+/**
+ * Props for ICloudAuthProvider
+ */
+interface ICloudAuthProviderProps {
+    /** CloudKit API token (from Apple Developer Console) */
+    apiToken: string;
+    /** CloudKit container identifier (default: "iCloud.Memoryless") */
+    containerIdentifier?: string;
+    /** CloudKit environment (default: "production") */
+    environment?: "development" | "production";
+    /** Children to render */
+    children: ReactNode;
+}
+/**
+ * Context value for iCloud authentication
+ */
+interface ICloudAuthContextValue {
+    /** Whether user is authenticated with iCloud */
+    isAuthenticated: boolean;
+    /** Whether iCloud is configured and available */
+    isConfigured: boolean;
+    /** Whether CloudKit JS is loaded */
+    isAvailable: boolean;
+    /** User record name (unique identifier) */
+    userRecordName: string | null;
+    /** Request access - triggers iCloud sign-in if needed */
+    requestAccess: () => Promise<void>;
+    /** Sign out from iCloud */
+    logout: () => void;
+}
+/**
+ * Provider component for iCloud authentication.
+ *
+ * Wrap your app with this provider to enable iCloud authentication.
+ * CloudKit JS is loaded automatically when needed.
+ *
+ * @example
+ * ```tsx
+ * import { ICloudAuthProvider } from "@reverbia/sdk/react";
+ *
+ * function App() {
+ *   return (
+ *     <ICloudAuthProvider
+ *       apiToken={process.env.NEXT_PUBLIC_CLOUDKIT_API_TOKEN!}
+ *       containerIdentifier="iCloud.Memoryless"
+ *       environment="production"
+ *     >
+ *       <MyApp />
+ *     </ICloudAuthProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @category Components
+ */
+declare function ICloudAuthProvider({ apiToken, containerIdentifier, environment, children, }: ICloudAuthProviderProps): JSX.Element;
+/**
+ * Hook to access iCloud authentication state and methods.
+ *
+ * Must be used within an ICloudAuthProvider.
+ *
+ * @example
+ * ```tsx
+ * import { useICloudAuth } from "@reverbia/sdk/react";
+ *
+ * function ICloudStatus() {
+ *   const { isAuthenticated, isAvailable, requestAccess, logout } = useICloudAuth();
+ *
+ *   if (!isAvailable) {
+ *     return <p>iCloud is not available. Please load CloudKit JS.</p>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       {isAuthenticated ? (
+ *         <>
+ *           <span>Connected to iCloud</span>
+ *           <button onClick={logout}>Disconnect</button>
+ *         </>
+ *       ) : (
+ *         <button onClick={requestAccess}>Connect to iCloud</button>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useICloudAuth(): ICloudAuthContextValue;
+/**
+ * Check if iCloud is configured (has API token)
+ */
+declare function hasICloudCredentials(): boolean;
+/**
+ * Clear iCloud authentication state
+ * Note: This only clears local state; user remains signed in to iCloud
+ */
+declare function clearICloudAuth(): void;
+
+/**
+ * iCloud CloudKit API utilities
+ *
+ * Uses Apple CloudKit JS for file operations in iCloud Drive.
+ * Requires CloudKit container configuration and user authentication.
+ *
+ * CloudKit JS is loaded dynamically when needed.
+ */
+/** Default folder path for iCloud backups */
+declare const DEFAULT_BACKUP_FOLDER = "conversations";
+/** CloudKit record structure */
+interface CloudKitRecord {
+    recordName: string;
+    recordType: string;
+    fields: {
+        filename?: {
+            value: string;
+        };
+        data?: {
+            value: {
+                downloadURL: string;
+                size: number;
+            };
+        };
+    };
+    modified?: {
+        timestamp: number;
+    };
+    created?: {
+        timestamp: number;
+    };
+}
+/** CloudKit response structure */
+interface CloudKitResponse {
+    records?: CloudKitRecord[];
+    continuationMarker?: string;
+}
+declare global {
+    interface Window {
+        CloudKit?: {
+            configure: (config: {
+                containers: Array<{
+                    containerIdentifier: string;
+                    apiTokenAuth: {
+                        apiToken: string;
+                        persist: boolean;
+                        signInButton?: {
+                            id: string;
+                            theme?: string;
+                        };
+                        signOutButton?: {
+                            id: string;
+                            theme?: string;
+                        };
+                    };
+                    environment: string;
+                }>;
+            }) => void;
+            getDefaultContainer: () => CloudKitContainer;
+        };
+    }
+}
+interface CloudKitContainer {
+    containerIdentifier: string;
+    setUpAuth: (options?: {
+        buttonContainer?: HTMLElement;
+        signInButtonId?: string;
+        signOutButtonId?: string;
+    }) => Promise<CloudKitUserIdentity | null>;
+    whenUserSignsIn: () => Promise<CloudKitUserIdentity>;
+    whenUserSignsOut: () => Promise<void>;
+    privateCloudDatabase: CloudKitDatabase;
+}
+interface CloudKitUserIdentity {
+    userRecordName: string;
+    isDiscoverable?: boolean;
+}
+interface CloudKitDatabase {
+    saveRecords: (records: CloudKitRecordToSave | CloudKitRecordToSave[], options?: {
+        zoneName?: string;
+    }) => Promise<CloudKitResponse>;
+    deleteRecords: (recordNames: {
+        recordName: string;
+    }[], options?: {
+        zoneName?: string;
+    }) => Promise<CloudKitResponse>;
+    performQuery: (query: CloudKitQuery) => Promise<CloudKitResponse>;
+    fetchRecords: (recordNames: Array<{
+        recordName: string;
+    }>, options?: {
+        desiredKeys?: string[];
+    }) => Promise<CloudKitResponse>;
+}
+interface CloudKitRecordToSave {
+    recordType: string;
+    recordName?: string;
+    fields: Record<string, {
+        value: unknown;
+    }>;
+}
+interface CloudKitQuery {
+    recordType: string;
+    filterBy?: Array<{
+        fieldName: string;
+        comparator: string;
+        fieldValue: {
+            value: unknown;
+        };
+    }>;
+    sortBy?: Array<{
+        fieldName: string;
+        ascending: boolean;
+    }>;
+}
+
+/**
+ * iCloud Backup Implementation
+ *
+ * Generic backup/restore functionality for iCloud storage.
+ * Works directly with WatermelonDB database.
+ */
+
+interface ICloudExportResult {
+    success: boolean;
+    uploaded: number;
+    skipped: number;
+    total: number;
+}
+interface ICloudImportResult {
+    success: boolean;
+    restored: number;
+    failed: number;
+    total: number;
+    /** True if no backups were found in iCloud */
+    noBackupsFound?: boolean;
+}
+
+/**
+ * Options for useICloudBackup hook
+ */
+interface UseICloudBackupOptions {
+    /** 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;
+    }>;
+}
+/**
+ * Result returned by useICloudBackup hook
+ */
+interface UseICloudBackupResult {
+    /** Backup all conversations to iCloud */
+    backup: (options?: {
+        onProgress?: (current: number, total: number) => void;
+    }) => Promise<ICloudExportResult | {
+        error: string;
+    }>;
+    /** Restore conversations from iCloud */
+    restore: (options?: {
+        onProgress?: (current: number, total: number) => void;
+    }) => Promise<ICloudImportResult | {
+        error: string;
+    }>;
+    /** Whether iCloud is configured */
+    isConfigured: boolean;
+    /** Whether user has signed in to iCloud */
+    isAuthenticated: boolean;
+    /** Whether CloudKit JS is available */
+    isAvailable: boolean;
+}
+/**
+ * React hook for iCloud backup and restore functionality.
+ *
+ * This hook provides methods to backup conversations to iCloud 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 an ICloudAuthProvider.
+ *
+ * @example
+ * ```tsx
+ * import { useICloudBackup } from "@reverbia/sdk/react";
+ *
+ * function BackupButton() {
+ *   const { backup, restore, isConfigured, isAuthenticated, isAvailable } = useICloudBackup({
+ *     database,
+ *     userAddress,
+ *     requestEncryptionKey,
+ *     exportConversation,
+ *     importConversation,
+ *   });
+ *
+ *   if (!isAvailable) {
+ *     return <p>CloudKit JS not loaded</p>;
+ *   }
+ *
+ *   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 to iCloud</button>;
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useICloudBackup(options: UseICloudBackupOptions): UseICloudBackupResult;
+
+/**
+ * Props for BackupAuthProvider
+ *
+ * At least one of `dropboxAppKey`, `googleClientId`, or `icloudApiToken` should be provided
+ * for the provider to be useful. All are optional to allow using just one backup provider.
+ */
+interface BackupAuthProviderProps {
+    /** Dropbox App Key (from Dropbox Developer Console). Optional - omit to disable Dropbox. */
+    dropboxAppKey?: string;
+    /** Dropbox OAuth callback path (default: "/auth/dropbox/callback") */
+    dropboxCallbackPath?: string;
+    /** Google OAuth Client ID (from Google Cloud Console). Optional - omit to disable Google Drive. */
+    googleClientId?: string;
+    /** Google OAuth callback path (default: "/auth/google/callback") */
+    googleCallbackPath?: string;
+    /** CloudKit API token (from Apple Developer Console). Optional - omit to disable iCloud. */
+    icloudApiToken?: string;
+    /** CloudKit container identifier (default: "iCloud.Memoryless") */
+    icloudContainerIdentifier?: string;
+    /** CloudKit environment (default: "production") */
+    icloudEnvironment?: "development" | "production";
+    /**
+     * API client for backend OAuth requests. Optional - uses the default SDK client if not provided.
+     * Only needed if you have a custom client configuration (e.g., different baseUrl).
+     */
+    apiClient?: Client;
+    /** Children to render */
+    children: ReactNode;
+}
+/**
+ * Auth state for a single provider
+ */
+interface ProviderAuthState {
+    /** Current access token (null if not authenticated) */
+    accessToken: string | null;
+    /** Whether user has authenticated with this provider */
+    isAuthenticated: boolean;
+    /** Whether this provider is configured */
+    isConfigured: boolean;
+    /** Request access - returns token or redirects to OAuth */
+    requestAccess: () => Promise<string>;
+    /** Clear stored token and log out */
+    logout: () => Promise<void>;
+    /** Refresh the access token using the refresh token */
+    refreshToken: () => Promise<string | null>;
+}
+/**
+ * Context value for unified backup authentication
+ */
+interface BackupAuthContextValue {
+    /** Dropbox authentication state and methods */
+    dropbox: ProviderAuthState;
+    /** Google Drive authentication state and methods */
+    googleDrive: ProviderAuthState;
+    /** iCloud authentication state and methods */
+    icloud: ProviderAuthState;
+    /** Check if any provider is configured */
+    hasAnyProvider: boolean;
+    /** Check if any provider is authenticated */
+    hasAnyAuthentication: boolean;
+    /** Logout from all providers */
+    logoutAll: () => Promise<void>;
+}
+/**
+ * Unified provider component for backup OAuth authentication.
+ *
+ * Wrap your app with this provider to enable both Dropbox and Google Drive
+ * authentication. It handles the OAuth 2.0 Authorization Code flow with
+ * refresh tokens for both providers.
+ *
+ * @example
+ * ```tsx
+ * import { BackupAuthProvider } from "@reverbia/sdk/react";
+ *
+ * function App() {
+ *   return (
+ *     <BackupAuthProvider
+ *       dropboxAppKey={process.env.NEXT_PUBLIC_DROPBOX_APP_KEY}
+ *       dropboxCallbackPath="/auth/dropbox/callback"
+ *       googleClientId={process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID}
+ *       googleCallbackPath="/auth/google/callback"
+ *       icloudApiToken={process.env.NEXT_PUBLIC_CLOUDKIT_API_TOKEN}
+ *       icloudContainerIdentifier="iCloud.Memoryless"
+ *       apiClient={apiClient}
+ *     >
+ *       <MyApp />
+ *     </BackupAuthProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @category Components
+ */
+declare function BackupAuthProvider({ dropboxAppKey, dropboxCallbackPath, googleClientId, googleCallbackPath, icloudApiToken, icloudContainerIdentifier, icloudEnvironment, apiClient, children, }: BackupAuthProviderProps): JSX.Element;
+/**
+ * Hook to access unified backup authentication state and methods.
+ *
+ * Must be used within a BackupAuthProvider.
+ *
+ * @example
+ * ```tsx
+ * import { useBackupAuth } from "@reverbia/sdk/react";
+ *
+ * function BackupSettings() {
+ *   const { dropbox, googleDrive, logoutAll } = useBackupAuth();
+ *
+ *   return (
+ *     <div>
+ *       <h3>Backup Providers</h3>
+ *
+ *       {dropbox.isConfigured && (
+ *         <div>
+ *           <span>Dropbox: {dropbox.isAuthenticated ? 'Connected' : 'Not connected'}</span>
+ *           {dropbox.isAuthenticated ? (
+ *             <button onClick={dropbox.logout}>Disconnect</button>
+ *           ) : (
+ *             <button onClick={dropbox.requestAccess}>Connect</button>
+ *           )}
+ *         </div>
+ *       )}
+ *
+ *       {googleDrive.isConfigured && (
+ *         <div>
+ *           <span>Google Drive: {googleDrive.isAuthenticated ? 'Connected' : 'Not connected'}</span>
+ *           {googleDrive.isAuthenticated ? (
+ *             <button onClick={googleDrive.logout}>Disconnect</button>
+ *           ) : (
+ *             <button onClick={googleDrive.requestAccess}>Connect</button>
+ *           )}
+ *         </div>
+ *       )}
+ *
+ *       <button onClick={logoutAll}>Disconnect All</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useBackupAuth(): BackupAuthContextValue;
+
+/**
+ * Options for useBackup hook
+ */
+interface UseBackupOptions {
+    /** 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') */
+    dropboxFolder?: string;
+    /** Google Drive root folder name (default: 'ai-chat-app') */
+    googleRootFolder?: string;
+    /** Google Drive conversations subfolder (default: 'conversations') */
+    googleConversationsFolder?: string;
+}
+/**
+ * Progress callback type
+ */
+type ProgressCallback = (current: number, total: number) => void;
+/**
+ * Backup options for individual operations
+ */
+interface BackupOperationOptions {
+    onProgress?: ProgressCallback;
+}
+/**
+ * Provider-specific backup state
+ */
+interface ProviderBackupState {
+    /** Whether the provider is configured */
+    isConfigured: boolean;
+    /** Whether user has authenticated with this provider */
+    isAuthenticated: boolean;
+    /** Backup all conversations to this provider */
+    backup: (options?: BackupOperationOptions) => Promise<DropboxExportResult | GoogleDriveExportResult | ICloudExportResult | {
+        error: string;
+    }>;
+    /** Restore conversations from this provider */
+    restore: (options?: BackupOperationOptions) => Promise<DropboxImportResult | GoogleDriveImportResult | ICloudImportResult | {
+        error: string;
+    }>;
+    /** Request access to this provider (triggers OAuth if needed) */
+    connect: () => Promise<string>;
+    /** Disconnect from this provider */
+    disconnect: () => Promise<void>;
+}
+/**
+ * Result returned by useBackup hook
+ */
+interface UseBackupResult {
+    /** Dropbox backup state and methods */
+    dropbox: ProviderBackupState;
+    /** Google Drive backup state and methods */
+    googleDrive: ProviderBackupState;
+    /** iCloud backup state and methods */
+    icloud: ProviderBackupState;
+    /** Whether any backup provider is configured */
+    hasAnyProvider: boolean;
+    /** Whether any backup provider is authenticated */
+    hasAnyAuthentication: boolean;
+    /** Disconnect from all providers */
+    disconnectAll: () => Promise<void>;
+}
+/**
+ * Unified React hook for backup and restore functionality.
+ *
+ * This hook provides methods to backup conversations to both Dropbox and Google Drive,
+ * 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 BackupAuthProvider.
+ *
+ * @example
+ * ```tsx
+ * import { useBackup } from "@reverbia/sdk/react";
+ *
+ * function BackupManager() {
+ *   const { dropbox, googleDrive, hasAnyProvider } = useBackup({
+ *     database,
+ *     userAddress,
+ *     requestEncryptionKey,
+ *     exportConversation,
+ *     importConversation,
+ *   });
+ *
+ *   if (!hasAnyProvider) {
+ *     return <p>No backup providers configured</p>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       {dropbox.isConfigured && (
+ *         <div>
+ *           <h3>Dropbox</h3>
+ *           {dropbox.isAuthenticated ? (
+ *             <>
+ *               <button onClick={() => dropbox.backup()}>Backup</button>
+ *               <button onClick={() => dropbox.restore()}>Restore</button>
+ *               <button onClick={dropbox.disconnect}>Disconnect</button>
+ *             </>
+ *           ) : (
+ *             <button onClick={dropbox.connect}>Connect Dropbox</button>
+ *           )}
+ *         </div>
+ *       )}
+ *
+ *       {googleDrive.isConfigured && (
+ *         <div>
+ *           <h3>Google Drive</h3>
+ *           {googleDrive.isAuthenticated ? (
+ *             <>
+ *               <button onClick={() => googleDrive.backup()}>Backup</button>
+ *               <button onClick={() => googleDrive.restore()}>Restore</button>
+ *               <button onClick={googleDrive.disconnect}>Disconnect</button>
+ *             </>
+ *           ) : (
+ *             <button onClick={googleDrive.connect}>Connect Google Drive</button>
+ *           )}
+ *         </div>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useBackup(options: UseBackupOptions): UseBackupResult;
+
+export { DEFAULT_CONVERSATIONS_FOLDER as BACKUP_DRIVE_CONVERSATIONS_FOLDER, DEFAULT_ROOT_FOLDER as BACKUP_DRIVE_ROOT_FOLDER, DEFAULT_BACKUP_FOLDER as BACKUP_ICLOUD_FOLDER, type BackupAuthContextValue, BackupAuthProvider, type BackupAuthProviderProps, type BackupOperationOptions, Conversation as ChatConversation, Message as ChatMessage, type ChatRole, type ClientTool, type CreateConversationOptions, type CreateMemoryOptions, type CreateMessageOptions, type CreateModelPreferenceOptions, DEFAULT_BACKUP_FOLDER$1 as DEFAULT_BACKUP_FOLDER, DEFAULT_CONVERSATIONS_FOLDER as DEFAULT_DRIVE_CONVERSATIONS_FOLDER, DEFAULT_ROOT_FOLDER as DEFAULT_DRIVE_ROOT_FOLDER, DEFAULT_BACKUP_FOLDER$1 as DEFAULT_DROPBOX_FOLDER, DEFAULT_BACKUP_FOLDER as DEFAULT_ICLOUD_BACKUP_FOLDER, DEFAULT_TOOL_SELECTOR_MODEL, type DropboxAuthContextValue, DropboxAuthProvider, type DropboxAuthProviderProps, type DropboxExportResult, type DropboxImportResult, type FileMetadata, type GoogleDriveAuthContextValue, GoogleDriveAuthProvider, type GoogleDriveAuthProviderProps, type GoogleDriveExportResult, type GoogleDriveImportResult, type ICloudAuthContextValue, ICloudAuthProvider, type ICloudAuthProviderProps, type ICloudExportResult, type ICloudImportResult, type MemoryItem, type MemoryType, type OCRFile, type PdfFile, type ProgressCallback, type ProviderAuthState, type ProviderBackupState, 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 UseBackupOptions, type UseBackupResult, type UseChatStorageOptions, type UseChatStorageResult, type UseDropboxBackupOptions, type UseDropboxBackupResult, type UseGoogleDriveBackupOptions, type UseGoogleDriveBackupResult, type UseICloudBackupOptions, type UseICloudBackupResult, type UseMemoryStorageOptions, type UseMemoryStorageResult, type UseSettingsOptions, type UseSettingsResult, chatStorageMigrations, chatStorageSchema, clearToken as clearDropboxToken, clearGoogleDriveToken, clearICloudAuth, createMemoryContextSystemMessage, decryptData, decryptDataBytes, encryptData, executeTool, extractConversationContext, formatMemoriesForChat, generateCompositeKey, generateConversationId, generateUniqueKey, getGoogleDriveStoredToken, hasDropboxCredentials, hasEncryptionKey, hasGoogleDriveCredentials, hasICloudCredentials, memoryStorageSchema, requestEncryptionKey, sdkMigrations, sdkModelClasses, sdkSchema, selectTool, settingsStorageSchema, useBackup, useBackupAuth, useChat, useChatStorage, useDropboxAuth, useDropboxBackup, useEncryption, useGoogleDriveAuth, useGoogleDriveBackup, useICloudAuth, useICloudBackup, useImageGeneration, useMemoryStorage, useModels, useOCR, usePdf, useSearch, useSettings };