@reverbia/sdk 1.0.0 → 1.1.0-next.20251230221037

package/dist/react/index.d.mts

@@ -0,0 +1,3139 @@
+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 Model$1, { Associations } from '@nozbe/watermelondb/Model';
+import { Class } from '@nozbe/watermelondb/types';
+import { ReactNode, JSX } from 'react';
+
+/**
+ * ExtraFields contains additional metadata such as provider/model information.
+ */
+type LlmapiImageGenerationExtraFields = {
+    /**
+     * ModelRequested is the model identifier that the client asked for.
+     */
+    model_requested?: string;
+    /**
+     * Provider is the gateway that serviced this request.
+     */
+    provider?: string;
+    /**
+     * RequestType is always "image_generation".
+     */
+    request_type?: string;
+};
+type LlmapiImageGenerationImage = {
+    /**
+     * B64JSON is the base64 payload for models that can only return binary.
+     */
+    b64_json?: string;
+    /**
+     * URL is the signed URL to download the image.
+     */
+    url?: string;
+};
+type LlmapiImageGenerationRequest = {
+    /**
+     * Model is the model identifier to use for generation (e.g., "gpt-image-1").
+     */
+    model: string;
+    /**
+     * Prompt is the text description of the desired image.
+     */
+    prompt: string;
+    /**
+     * Quality targets a quality preset (e.g., "auto", "high").
+     */
+    quality?: string;
+    /**
+     * ResponseFormat controls how the generated image is returned (e.g., "url" or "b64_json").
+     */
+    response_format?: string;
+    /**
+     * Size controls the dimensions of the generated image (e.g., "1024x1024").
+     */
+    size?: string;
+};
+type LlmapiImageGenerationResponse = {
+    /**
+     * Created is the Unix timestamp when the image was generated.
+     */
+    created?: number;
+    extra_fields?: LlmapiImageGenerationExtraFields;
+    /**
+     * Images contains the generated images.
+     */
+    images?: Array<LlmapiImageGenerationImage>;
+    /**
+     * Model is the model identifier that generated the image.
+     */
+    model?: string;
+    /**
+     * Provider is the gateway that produced the image.
+     */
+    provider?: string;
+    usage?: LlmapiImageGenerationUsage;
+};
+/**
+ * Usage documents token usage (when available).
+ */
+type LlmapiImageGenerationUsage = {
+    /**
+     * CostMicroUSD is the inference cost for this image generation request
+     */
+    cost_micro_usd?: number;
+    /**
+     * InputTokens is the number of tokens sent in the prompt.
+     */
+    input_tokens?: number;
+    /**
+     * OutputTokens is the number of tokens returned by the model.
+     */
+    output_tokens?: number;
+    /**
+     * TotalTokens is the total number of tokens consumed.
+     */
+    total_tokens?: number;
+};
+/**
+ * Message is the generated message
+ */
+type LlmapiMessage = {
+    /**
+     * Content is the message content
+     */
+    content?: Array<LlmapiMessageContentPart>;
+    role?: LlmapiRole;
+    /**
+     * ToolCalls contains tool/function calls made by the assistant (only for assistant role)
+     */
+    tool_calls?: Array<LlmapiToolCall>;
+};
+/**
+ * ImageURL is used when Type=image_url
+ */
+type LlmapiMessageContentImage = {
+    /**
+     * Detail is the OpenAI detail hint (auto|low|high)
+     */
+    detail?: string;
+    /**
+     * URL is the image URL or data URI
+     */
+    url?: string;
+};
+type LlmapiMessageContentPart = {
+    image_url?: LlmapiMessageContentImage;
+    /**
+     * Text holds the text content when Type=text
+     */
+    text?: string;
+    /**
+     * Type is the block type (`text` or `image_url`)
+     */
+    type?: string;
+};
+type LlmapiModel = {
+    architecture?: LlmapiModelArchitecture;
+    /**
+     * CanonicalSlug is the canonical slug for the model
+     */
+    canonical_slug?: string;
+    /**
+     * ContextLength is the maximum context length in tokens
+     */
+    context_length?: number;
+    /**
+     * Created is the Unix timestamp of when the model was created
+     */
+    created?: number;
+    /**
+     * DefaultParameters contains default parameter values
+     */
+    default_parameters?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Description describes the model and its capabilities
+     */
+    description?: string;
+    /**
+     * HuggingFaceID is the Hugging Face model identifier
+     */
+    hugging_face_id?: string;
+    /**
+     * ID is the model identifier (e.g., "openai/gpt-4")
+     */
+    id?: string;
+    /**
+     * MaxInputTokens is the maximum input tokens
+     */
+    max_input_tokens?: number;
+    /**
+     * 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)
+     */
+    name?: string;
+    /**
+     * OwnedBy is the organization that owns the model
+     */
+    owned_by?: string;
+    per_request_limits?: LlmapiModelPerRequestLimits;
+    pricing?: LlmapiModelPricing;
+    /**
+     * SupportedMethods is a list of supported API methods
+     */
+    supported_methods?: Array<string>;
+    /**
+     * SupportedParameters is a list of supported parameter names
+     */
+    supported_parameters?: Array<string>;
+    top_provider?: LlmapiModelTopProvider;
+};
+/**
+ * Architecture describes the model's technical capabilities
+ */
+type LlmapiModelArchitecture = {
+    instruct_type?: string;
+    modality?: string;
+    prompt_formatting?: string;
+    tokenizer?: string;
+};
+/**
+ * PerRequestLimits contains rate limiting information
+ */
+type LlmapiModelPerRequestLimits = {
+    completion_tokens?: number;
+    prompt_tokens?: number;
+};
+/**
+ * Pricing contains the pricing structure for using this model
+ */
+type LlmapiModelPricing = {
+    completion?: string;
+    image?: string;
+    prompt?: string;
+    request?: string;
+};
+/**
+ * TopProvider contains configuration details for the primary provider
+ */
+type LlmapiModelTopProvider = {
+    context_length?: number;
+    is_moderated?: boolean;
+    max_completion_tokens?: number;
+};
+/**
+ * ExtraFields contains additional metadata
+ */
+type LlmapiResponseExtraFields = {
+    /**
+     * Latency is the request latency in milliseconds
+     */
+    latency?: number;
+    /**
+     * ModelRequested is the model that was requested
+     */
+    model_requested?: string;
+    /**
+     * Provider is the LLM provider used (e.g., "openai", "anthropic")
+     */
+    provider?: string;
+    /**
+     * RequestType is always "responses"
+     */
+    request_type?: string;
+};
+type LlmapiResponseOutputContent = {
+    /**
+     * Text is the text content
+     */
+    text?: string;
+    /**
+     * Type is the content type (e.g., "output_text")
+     */
+    type?: string;
+};
+type LlmapiResponseOutputItem = {
+    /**
+     * Arguments is the function arguments for function_call types
+     */
+    arguments?: string;
+    /**
+     * CallID is the call ID for function_call types
+     */
+    call_id?: string;
+    /**
+     * Content is the content array for message and reasoning types
+     */
+    content?: Array<LlmapiResponseOutputContent>;
+    /**
+     * ID is the unique identifier for this output item
+     */
+    id?: string;
+    /**
+     * Name is the function name for function_call types
+     */
+    name?: string;
+    /**
+     * Role is the role for message types (e.g., "assistant")
+     */
+    role?: string;
+    /**
+     * Status is the status of this output item (e.g., "completed")
+     */
+    status?: string;
+    /**
+     * Summary is the reasoning summary for reasoning types
+     */
+    summary?: Array<LlmapiResponseOutputContent>;
+    /**
+     * Type is the output item type (e.g., "message", "function_call", "reasoning")
+     */
+    type?: string;
+};
+/**
+ * Reasoning configures reasoning for o-series and other reasoning models
+ */
+type LlmapiResponseReasoning = {
+    /**
+     * Effort controls reasoning effort: "low", "medium", or "high"
+     */
+    effort?: string;
+    /**
+     * Summary controls reasoning summary: "auto", "concise", or "detailed"
+     */
+    summary?: string;
+};
+type LlmapiResponseResponse = {
+    /**
+     * Created is the Unix timestamp of creation (created_at in OpenAI format)
+     */
+    created_at?: number;
+    extra_fields?: LlmapiResponseExtraFields;
+    /**
+     * ID is the unique response identifier
+     */
+    id?: string;
+    /**
+     * Model is the model used for generation
+     */
+    model?: string;
+    /**
+     * Object is the response type (e.g., "response")
+     */
+    object?: string;
+    /**
+     * Output is the array of output items (OpenAI Responses API format)
+     */
+    output?: Array<LlmapiResponseOutputItem>;
+    usage?: LlmapiResponseUsage;
+};
+/**
+ * Usage contains token usage information
+ */
+type LlmapiResponseUsage = {
+    /**
+     * CompletionTokens is the number of tokens in the completion
+     */
+    completion_tokens?: number;
+    /**
+     * CostMicroUSD is the cost of this response in micro-dollars (USD × 1,000,000)
+     */
+    cost_micro_usd?: number;
+    /**
+     * PromptTokens is the number of tokens in the prompt
+     */
+    prompt_tokens?: number;
+    /**
+     * TotalTokens is the total number of tokens used
+     */
+    total_tokens?: number;
+};
+/**
+ * Role is the message role (system, user, assistant)
+ */
+type LlmapiRole = string;
+/**
+ * ExtraFields contains additional metadata.
+ */
+type LlmapiSearchExtraFields = {
+    /**
+     * RequestType is always "search".
+     */
+    request_type?: string;
+    /**
+     * SearchProvider is the search provider used (e.g., "perplexity", "google-pse").
+     */
+    search_provider?: string;
+};
+type LlmapiSearchResponse = {
+    extra_fields?: LlmapiSearchExtraFields;
+    /**
+     * List of search results.
+     */
+    results?: Array<LlmapiSearchResult>;
+    usage?: LlmapiSearchUsage;
+};
+type LlmapiSearchResult = {
+    /**
+     * Optional publication or last updated date.
+     */
+    date?: string;
+    /**
+     * Text snippet from the result.
+     */
+    snippet?: string;
+    /**
+     * Title of the search result.
+     */
+    title?: string;
+    /**
+     * URL of the search result.
+     */
+    url?: string;
+};
+/**
+ * Usage contains usage information.
+ */
+type LlmapiSearchUsage = {
+    /**
+     * CostMicroUSD is the cost of this search in micro-dollars (USD × 1,000,000).
+     */
+    cost_micro_usd?: number;
+};
+/**
+ * Thinking configures extended thinking for Anthropic models
+ */
+type LlmapiThinkingOptions = {
+    /**
+     * BudgetTokens is the token budget for thinking
+     */
+    budget_tokens?: number;
+    /**
+     * Type indicates if thinking is enabled: "enabled" or "disabled"
+     */
+    type?: string;
+};
+type LlmapiTool = {
+    function?: LlmapiToolFunction;
+    /**
+     * Type is the tool type (function, code_interpreter, file_search, web_search)
+     */
+    type?: string;
+};
+type LlmapiToolCall = {
+    function?: LlmapiToolCallFunction;
+    /**
+     * ID is the unique identifier for this tool call
+     */
+    id?: string;
+    /**
+     * Type is the type of tool call (always "function" for now)
+     */
+    type?: string;
+};
+/**
+ * Function contains the function call details
+ */
+type LlmapiToolCallFunction = {
+    /**
+     * Arguments is the JSON string of arguments to pass to the function
+     */
+    arguments?: string;
+    /**
+     * Name is the name of the function to call
+     */
+    name?: string;
+};
+/**
+ * Function is the function definition (when Type is "function")
+ */
+type LlmapiToolFunction = {
+    /**
+     * Arguments is the function arguments schema (JSON object)
+     */
+    arguments?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Name is the function name
+     */
+    name?: string;
+};
+
+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'>);
+
+/**
+ * Responses API options that can be passed to sendMessage
+ */
+type ResponsesApiOptions = {
+    /**
+     * Whether to store the response server-side.
+     * When true, the response can be retrieved later using the response ID.
+     */
+    store?: boolean;
+    /**
+     * ID of a previous response to continue from.
+     * Enables multi-turn conversations without resending full history.
+     */
+    previousResponseId?: string;
+    /**
+     * Conversation ID for grouping related responses.
+     */
+    conversation?: string;
+    /**
+     * Controls randomness in the response (0.0 to 2.0).
+     * Lower values make output more deterministic.
+     */
+    temperature?: number;
+    /**
+     * Maximum number of tokens to generate in the response.
+     */
+    maxOutputTokens?: number;
+    /**
+     * Array of tool definitions available to the model.
+     */
+    tools?: LlmapiTool[];
+    /**
+     * Controls which tool to use: "auto", "any", "none", "required", or a specific tool name.
+     */
+    toolChoice?: string;
+    /**
+     * Reasoning configuration for o-series and other reasoning models.
+     * Controls reasoning effort and summary output.
+     */
+    reasoning?: LlmapiResponseReasoning;
+    /**
+     * Extended thinking configuration for Anthropic models (Claude).
+     * Enables the model to think through complex problems step by step.
+     */
+    thinking?: LlmapiThinkingOptions;
+};
+/**
+ * Base arguments for sending a message
+ */
+type BaseSendMessageArgs = ResponsesApiOptions & {
+    messages: LlmapiMessage[];
+    model?: string;
+    /**
+     * Per-request callback for data chunks. Called in addition to the global
+     * `onData` callback if provided in `useChat` options.
+     *
+     * @param chunk - The content delta from the current chunk
+     */
+    onData?: (chunk: string) => void;
+};
+/**
+ * Base options for useChat hook
+ */
+type BaseUseChatOptions = {
+    getToken?: () => Promise<string | null>;
+    baseUrl?: string;
+    /**
+     * Callback function to be called when a new data chunk is received.
+     */
+    onData?: (chunk: string) => void;
+    /**
+     * Callback function to be called when thinking/reasoning content is received.
+     * This is called with delta chunks as the model "thinks" through a problem.
+     */
+    onThinking?: (chunk: string) => void;
+    /**
+     * Callback function to be called when the chat completion finishes successfully.
+     */
+    onFinish?: (response: LlmapiResponseResponse) => void;
+    /**
+     * Callback function to be called when an unexpected error is encountered.
+     *
+     * **Note:** This callback is NOT called for aborted requests (via `stop()` or
+     * component unmount). Aborts are intentional actions and are not considered
+     * errors. To detect aborts, check the `error` field in the `sendMessage` result:
+     * `result.error === "Request aborted"`.
+     *
+     * @param error - The error that occurred (never an AbortError)
+     */
+    onError?: (error: Error) => void;
+};
+/**
+ * Base result type for useChat hook
+ */
+type BaseUseChatResult = {
+    isLoading: boolean;
+    /**
+     * Aborts the current streaming request if one is in progress.
+     *
+     * When a request is aborted, `sendMessage` will return with
+     * `{ data: null, error: "Request aborted" }`. The `onError` callback
+     * will NOT be called, as aborts are intentional actions, not errors.
+     */
+    stop: () => void;
+};
+
+type SendMessageArgs = BaseSendMessageArgs & {
+    /**
+     * Optional custom headers to include with the request.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Memory context to inject as a system message.
+     * This is typically formatted memories from useMemoryStorage.
+     */
+    memoryContext?: string;
+    /**
+     * Search context to inject as a system message.
+     * This is typically formatted search results from useSearch.
+     */
+    searchContext?: string;
+    /**
+     * Per-request callback for thinking/reasoning chunks. Called in addition to the global
+     * `onThinking` callback if provided in `useChat` options.
+     *
+     * @param chunk - The thinking delta from the current chunk
+     */
+    onThinking?: (chunk: string) => void;
+};
+type SendMessageResult = {
+    data: LlmapiResponseResponse;
+    error: null;
+} | {
+    data: LlmapiResponseResponse | null;
+    error: string;
+};
+type UseChatOptions = BaseUseChatOptions;
+type UseChatResult = BaseUseChatResult & {
+    sendMessage: (args: SendMessageArgs) => Promise<SendMessageResult>;
+};
+/**
+ * A React hook for managing chat completions with authentication.
+ *
+ * This hook provides a convenient way to send chat messages to the LLM API
+ * with automatic token management and loading state handling.
+ * Streaming is enabled by default for better user experience.
+ *
+ * @param options - Optional configuration object
+ * @param options.getToken - An async function that returns an authentication token.
+ *   This token will be used as a Bearer token in the Authorization header.
+ *   If not provided, `sendMessage` will return an error.
+ * @param options.baseUrl - Optional base URL for the API requests.
+ * @param options.onData - Callback function to be called when a new data chunk is received.
+ * @param options.onThinking - Callback function to be called when thinking/reasoning content is received.
+ * @param options.onFinish - Callback function to be called when the chat completion finishes successfully.
+ * @param options.onError - Callback function to be called when an unexpected error
+ *   is encountered. Note: This is NOT called for aborted requests (see `stop()`).
+ *
+ * @category Hooks
+ *
+ * @returns An object containing:
+ *   - `isLoading`: A boolean indicating whether a request is currently in progress
+ *   - `sendMessage`: An async function to send chat messages
+ *   - `stop`: A function to abort the current request
+ *
+ * @example
+ * ```tsx
+ * // Basic usage with API
+ * const { isLoading, sendMessage, stop } = useChat({
+ *   getToken: async () => await getAuthToken(),
+ *   onFinish: (response) => console.log("Chat finished:", response),
+ *   onError: (error) => console.error("Chat error:", error)
+ * });
+ *
+ * const handleSend = async () => {
+ *   const result = await sendMessage({
+ *     messages: [{ role: 'user', content: [{ type: 'text', text: 'Hello!' }] }],
+ *     model: 'gpt-4o-mini'
+ *   });
+ * };
+ *
+ * // Using extended thinking (Anthropic Claude)
+ * const result = await sendMessage({
+ *   messages: [{ role: 'user', content: [{ type: 'text', text: 'Solve this complex problem...' }] }],
+ *   model: 'anthropic/claude-3-7-sonnet-20250219',
+ *   thinking: { type: 'enabled', budget_tokens: 10000 },
+ *   onThinking: (chunk) => console.log('Thinking:', chunk)
+ * });
+ *
+ * // Using reasoning (OpenAI o-series)
+ * const result = await sendMessage({
+ *   messages: [{ role: 'user', content: [{ type: 'text', text: 'Reason through this...' }] }],
+ *   model: 'openai/o1',
+ *   reasoning: { effort: 'high', summary: 'detailed' }
+ * });
+ * ```
+ */
+declare function useChat(options?: UseChatOptions): UseChatResult;
+
+/**
+ * Clears the encryption key for a wallet address from memory
+ * @param address - The wallet address
+ */
+declare function clearEncryptionKey(address: string): void;
+/**
+ * Clears all encryption keys from memory
+ */
+declare function clearAllEncryptionKeys(): void;
+/**
+ * Encrypts data using AES-GCM with the stored encryption key
+ * @param plaintext - The data to encrypt (string or Uint8Array)
+ * @param address - The wallet address for encryption
+ * @returns Encrypted data as hex string (IV + ciphertext + auth tag)
+ */
+declare function encryptData(plaintext: string | Uint8Array, address: string): Promise<string>;
+/**
+ * Decrypts data using AES-GCM with the stored encryption key
+ * @param encryptedHex - Encrypted data as hex string (IV + ciphertext + auth tag)
+ * @param address - The wallet address for decryption
+ * @returns Decrypted data as string
+ */
+declare function decryptData(encryptedHex: string, address: string): Promise<string>;
+/**
+ * Decrypts data and returns as Uint8Array (for binary data)
+ * @param encryptedHex - Encrypted data as hex string (IV + ciphertext + auth tag)
+ * @returns Decrypted data as Uint8Array
+ */
+declare function decryptDataBytes(encryptedHex: string, address: string): Promise<Uint8Array>;
+/**
+ * Checks if an encryption key exists in memory for the given wallet address
+ */
+declare function hasEncryptionKey(address: string): boolean;
+/**
+ * Type for the signMessage function that client must provide
+ */
+type SignMessageFn = (message: string) => Promise<string>;
+/**
+ * Requests the user to sign a message to generate an encryption key.
+ * If a key already exists in memory for the given wallet, resolves immediately.
+ *
+ * Note: Keys are stored in memory only and do not persist across page reloads.
+ * This is a security feature - users must sign once per session to derive their key.
+ *
+ * Handles Privy rate limits (429 errors) with automatic retry and exponential backoff.
+ *
+ * @param walletAddress - The wallet address to generate the key for
+ * @param signMessage - Function to sign a message (returns signature hex string)
+ * @returns Promise that resolves when the key is available
+ */
+declare function requestEncryptionKey(walletAddress: string, signMessage: SignMessageFn): Promise<void>;
+/**
+ * Requests the user to sign a message to generate an ECDH key pair.
+ * If a key pair already exists in memory for the given wallet, resolves immediately.
+ *
+ * Note: Key pairs are stored in memory only and do not persist across page reloads.
+ * This is a security feature - users must sign once per session to derive their key pair.
+ *
+ * Handles Privy rate limits (429 errors) with automatic retry and exponential backoff.
+ *
+ * @param walletAddress - The wallet address to generate the key pair for
+ * @param signMessage - Function to sign a message (returns signature hex string)
+ * @returns Promise that resolves when the key pair is available
+ */
+declare function requestKeyPair(walletAddress: string, signMessage: SignMessageFn): Promise<void>;
+/**
+ * Exports the public key for a wallet address as SPKI format (base64)
+ * @param address - The wallet address
+ * @param signMessage - Function to sign a message (returns signature hex string)
+ * @returns The public key as base64-encoded SPKI string
+ */
+declare function exportPublicKey(address: string, signMessage: SignMessageFn): Promise<string>;
+/**
+ * Checks if a key pair exists in memory for the given wallet address
+ * @param address - The wallet address
+ * @returns True if key pair exists, false otherwise
+ */
+declare function hasKeyPair(address: string): boolean;
+/**
+ * Clears the key pair for a wallet address from memory
+ * @param address - The wallet address
+ */
+declare function clearKeyPair(address: string): void;
+/**
+ * Clears all key pairs from memory
+ */
+declare function clearAllKeyPairs(): void;
+/**
+ * Hook that provides on-demand encryption key management.
+ * @param signMessage - Function to sign a message (from Privy's useSignMessage)
+ * @returns Functions to request encryption keys and manage key pairs
+ * @category Hooks
+ */
+declare function useEncryption(signMessage: SignMessageFn): {
+    requestEncryptionKey: (walletAddress: string) => Promise<void>;
+    requestKeyPair: (walletAddress: string) => Promise<void>;
+    exportPublicKey: (walletAddress: string) => Promise<string>;
+    hasKeyPair: (walletAddress: string) => boolean;
+    clearKeyPair: (walletAddress: string) => void;
+};
+
+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[];
+}>;
+
+interface MemoryItem$1 {
+    type: "identity" | "preference" | "project" | "skill" | "constraint";
+    namespace: string;
+    key: string;
+    value: string;
+    rawEvidence: string;
+    confidence: number;
+    pii: boolean;
+}
+interface MemoryExtractionResult {
+    items: MemoryItem$1[];
+}
+
+type MemoryType = "identity" | "preference" | "project" | "skill" | "constraint";
+interface MemoryItem {
+    type: MemoryType;
+    namespace: string;
+    key: string;
+    value: string;
+    rawEvidence: string;
+    confidence: number;
+    pii: boolean;
+}
+interface CreateMemoryOptions extends MemoryItem {
+    embedding?: number[];
+    embeddingModel?: string;
+}
+type UpdateMemoryOptions = Partial<CreateMemoryOptions>;
+interface StoredMemory extends MemoryItem {
+    uniqueId: string;
+    compositeKey: string;
+    uniqueKey: string;
+    createdAt: Date;
+    updatedAt: Date;
+    embedding?: number[];
+    embeddingModel?: string;
+    isDeleted: boolean;
+}
+interface StoredMemoryWithSimilarity extends StoredMemory {
+    similarity: number;
+}
+interface BaseUseMemoryStorageOptions {
+    database: Database;
+    completionsModel?: string;
+    embeddingModel?: string | null;
+    generateEmbeddings?: boolean;
+    onFactsExtracted?: (facts: MemoryExtractionResult) => void;
+    getToken?: () => Promise<string | null>;
+    baseUrl?: string;
+    /** Wallet address for encryption (optional - encryption disabled if not provided) */
+    walletAddress?: string | null;
+    /** Function to request encryption key (optional - encryption disabled if not provided) */
+    requestEncryptionKey?: (address: string) => Promise<void>;
+    /** Function to sign message for migration (optional - migration disabled if not provided) */
+    signMessage?: (message: string) => Promise<string>;
+}
+interface BaseUseMemoryStorageResult {
+    memories: StoredMemory[];
+    refreshMemories: () => Promise<void>;
+    extractMemoriesFromMessage: (options: {
+        messages: Array<{
+            role: string;
+            content: string;
+        }>;
+        model?: string;
+    }) => Promise<MemoryExtractionResult | null>;
+    searchMemories: (query: string, limit?: number, minSimilarity?: number) => Promise<StoredMemoryWithSimilarity[]>;
+    fetchAllMemories: () => Promise<StoredMemory[]>;
+    fetchMemoriesByNamespace: (namespace: string) => Promise<StoredMemory[]>;
+    fetchMemoriesByKey: (namespace: string, key: string) => Promise<StoredMemory[]>;
+    getMemoryById: (id: string) => Promise<StoredMemory | null>;
+    saveMemory: (memory: CreateMemoryOptions) => Promise<StoredMemory>;
+    saveMemories: (memories: CreateMemoryOptions[]) => Promise<StoredMemory[]>;
+    updateMemory: (id: string, updates: UpdateMemoryOptions) => Promise<StoredMemory | null>;
+    removeMemory: (namespace: string, key: string, value: string) => Promise<void>;
+    removeMemoryById: (id: string) => Promise<void>;
+    removeMemories: (namespace: string, key: string) => Promise<void>;
+    clearMemories: () => Promise<void>;
+}
+declare function generateCompositeKey(namespace: string, key: string): string;
+declare function generateUniqueKey(namespace: string, key: string, value: string): string;
+
+type ChatRole = "user" | "assistant" | "system";
+interface FileMetadata {
+    id: string;
+    name: string;
+    type: string;
+    size: number;
+    url?: string;
+}
+interface ChatCompletionUsage {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    costMicroUsd?: number;
+}
+interface SearchSource {
+    title?: string;
+    url?: string;
+    snippet?: string;
+    date?: string;
+}
+interface StoredMessage {
+    uniqueId: string;
+    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;
+    /** If set, indicates the message failed with this error */
+    error?: string;
+    thoughtProcess?: ActivityPhase[];
+    /** Reasoning/thinking content from models that support extended thinking */
+    thinking?: string;
+}
+interface ActivityPhase {
+    id: string;
+    label: string;
+    timestamp: number;
+    status: "pending" | "active" | "completed";
+    data?: StoredMemory[];
+}
+interface StoredConversation {
+    uniqueId: string;
+    conversationId: string;
+    title: string;
+    createdAt: Date;
+    updatedAt: Date;
+    isDeleted: boolean;
+}
+interface StoredMessageWithSimilarity extends StoredMessage {
+    similarity: number;
+}
+interface CreateMessageOptions {
+    conversationId: string;
+    role: ChatRole;
+    content: string;
+    model?: string;
+    files?: FileMetadata[];
+    usage?: ChatCompletionUsage;
+    sources?: SearchSource[];
+    responseDuration?: number;
+    vector?: number[];
+    embeddingModel?: string;
+    wasStopped?: boolean;
+    /** If set, indicates the message failed with this error */
+    error?: string;
+    thoughtProcess?: ActivityPhase[];
+    /** Reasoning/thinking content from models that support extended thinking */
+    thinking?: string;
+}
+interface CreateConversationOptions {
+    conversationId?: string;
+    title?: string;
+}
+interface UpdateMessageOptions {
+    content?: string;
+    model?: string;
+    files?: FileMetadata[];
+    usage?: ChatCompletionUsage;
+    sources?: SearchSource[];
+    responseDuration?: number;
+    vector?: number[];
+    embeddingModel?: string;
+    wasStopped?: boolean;
+    error?: string | null;
+    thoughtProcess?: ActivityPhase[];
+    /** Reasoning/thinking content from models that support extended thinking */
+    thinking?: string | null;
+}
+interface BaseUseChatStorageOptions {
+    database: Database;
+    conversationId?: string;
+    autoCreateConversation?: boolean;
+    defaultConversationTitle?: string;
+    getToken?: () => Promise<string | null>;
+    baseUrl?: string;
+    onData?: (chunk: string) => void;
+    onFinish?: (response: LlmapiResponseResponse) => void;
+    onError?: (error: Error) => void;
+    /** Wallet address for encryption (optional - encryption disabled if not provided) */
+    walletAddress?: string | null;
+    /** Function to request encryption key (optional - encryption disabled if not provided) */
+    requestEncryptionKey?: (address: string) => Promise<void>;
+    /** Function to sign message for migration (optional - required for migrating old encrypted data) */
+    signMessage?: (message: string) => Promise<string>;
+}
+interface BaseSendMessageWithStorageArgs {
+    content: string;
+    model?: string;
+    messages?: LlmapiMessage[];
+    includeHistory?: boolean;
+    maxHistoryMessages?: number;
+    files?: FileMetadata[];
+    onData?: (chunk: string) => void;
+    memoryContext?: string;
+    searchContext?: string;
+    sources?: SearchSource[];
+    thoughtProcess?: ActivityPhase[];
+    /**
+     * Whether to store the response server-side.
+     * When true, the response can be retrieved later using the response ID.
+     */
+    store?: boolean;
+    /**
+     * ID of a previous response to continue from.
+     * Enables multi-turn conversations without resending full history.
+     */
+    previousResponseId?: string;
+    /**
+     * Conversation ID for grouping related responses on the server.
+     */
+    serverConversation?: string;
+    /**
+     * Controls randomness in the response (0.0 to 2.0).
+     */
+    temperature?: number;
+    /**
+     * Maximum number of tokens to generate in the response.
+     */
+    maxOutputTokens?: number;
+    /**
+     * Array of tool definitions available to the model.
+     */
+    tools?: LlmapiTool[];
+    /**
+     * Controls which tool to use: "auto", "any", "none", "required", or a specific tool name.
+     */
+    toolChoice?: string;
+    /**
+     * Reasoning configuration for o-series and other reasoning models.
+     * Controls reasoning effort and summary output.
+     */
+    reasoning?: LlmapiResponseReasoning;
+    /**
+     * Extended thinking configuration for Anthropic models (Claude).
+     * Enables the model to think through complex problems step by step.
+     */
+    thinking?: LlmapiThinkingOptions;
+    /**
+     * Per-request callback for thinking/reasoning chunks.
+     * Called with delta chunks as the model "thinks" through a problem.
+     */
+    onThinking?: (chunk: string) => void;
+}
+interface BaseUseChatStorageResult {
+    isLoading: boolean;
+    stop: () => void;
+    conversationId: string | null;
+    setConversationId: (id: string | null) => void;
+    createConversation: (options?: CreateConversationOptions) => Promise<StoredConversation>;
+    getConversation: (id: string) => Promise<StoredConversation | null>;
+    getConversations: () => Promise<StoredConversation[]>;
+    updateConversationTitle: (id: string, title: string) => Promise<boolean>;
+    deleteConversation: (id: string) => Promise<boolean>;
+    getMessages: (conversationId: string) => Promise<StoredMessage[]>;
+    getMessageCount: (conversationId: string) => Promise<number>;
+    clearMessages: (conversationId: string) => Promise<void>;
+}
+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;
+    error?: string;
+    thoughtProcess?: ActivityPhase[];
+    thinking?: string;
+}
+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)
+ *
+ * Uses base options.
+ */
+type UseChatStorageOptions = BaseUseChatStorageOptions;
+/**
+ * Arguments for sendMessage with storage (React version)
+ *
+ * Extends base arguments with headers support.
+ */
+interface SendMessageWithStorageArgs extends BaseSendMessageWithStorageArgs {
+    /** Custom headers */
+    headers?: Record<string, string>;
+}
+/**
+ * Result from sendMessage with storage (React version)
+ */
+type SendMessageWithStorageResult = {
+    data: LlmapiResponseResponse;
+    error: null;
+    userMessage: StoredMessage;
+    assistantMessage: StoredMessage;
+} | {
+    data: null;
+    error: string;
+    userMessage?: StoredMessage;
+    assistantMessage?: undefined;
+};
+/**
+ * Options for searching messages
+ */
+interface SearchMessagesOptions {
+    /** Limit the number of results (default: 10) */
+    limit?: number;
+    /** Minimum similarity threshold (default: 0.5) */
+    minSimilarity?: number;
+    /** Filter by conversation ID */
+    conversationId?: string;
+}
+/**
+ * Result returned by useChatStorage hook (React version)
+ *
+ * Extends base result with React-specific sendMessage signature.
+ */
+interface UseChatStorageResult extends BaseUseChatStorageResult {
+    /** Send a message and automatically store it */
+    sendMessage: (args: SendMessageWithStorageArgs) => Promise<SendMessageWithStorageResult>;
+    /** Search messages by vector similarity */
+    searchMessages: (queryVector: number[], options?: SearchMessagesOptions) => Promise<StoredMessageWithSimilarity[]>;
+    /** Update a message's embedding vector. Returns updated message or null if not found. */
+    updateMessageEmbedding: (uniqueId: string, vector: number[], embeddingModel: string) => Promise<StoredMessage | null>;
+    /** Extract all links from assistant message content as SearchSource objects */
+    extractSourcesFromAssistantMessage: (assistantMessage: {
+        content: string;
+        sources?: SearchSource[];
+    }) => SearchSource[];
+    /** Update a message's fields (content, embedding, files, etc). Returns updated message or null if not found. */
+    updateMessage: (uniqueId: string, options: UpdateMessageOptions) => Promise<StoredMessage | null>;
+}
+/**
+ * A React hook that wraps useChat with automatic message persistence using WatermelonDB.
+ *
+ * This hook provides all the functionality of useChat plus automatic storage of
+ * messages and conversations to a WatermelonDB database. Messages are automatically
+ * saved when sent and when responses are received.
+ *
+ * @param options - Configuration options
+ * @returns An object containing chat state, methods, and storage operations
+ *
+ * @example
+ * ```tsx
+ * import { Database } from '@nozbe/watermelondb';
+ * import { useChatStorage } from '@reverbia/sdk/react';
+ *
+ * function ChatComponent({ database }: { database: Database }) {
+ *   const {
+ *     isLoading,
+ *     sendMessage,
+ *     conversationId,
+ *     getMessages,
+ *     createConversation,
+ *   } = useChatStorage({
+ *     database,
+ *     getToken: async () => getAuthToken(),
+ *     onData: (chunk) => setResponse((prev) => prev + chunk),
+ *   });
+ *
+ *   const handleSend = async () => {
+ *     const result = await sendMessage({
+ *       content: 'Hello, how are you?',
+ *       model: 'gpt-4o-mini',
+ *       includeHistory: true, // Include previous messages from this conversation
+ *     });
+ *
+ *     if (result.error) {
+ *       console.error('Error:', result.error);
+ *     } else {
+ *       console.log('User message stored:', result.userMessage);
+ *       console.log('Assistant message stored:', result.assistantMessage);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleSend} disabled={isLoading}>Send</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useChatStorage(options: UseChatStorageOptions): UseChatStorageResult;
+
+/**
+ * Combined WatermelonDB schema for all SDK storage modules.
+ *
+ * This unified schema includes all tables needed by the SDK:
+ * - `history`: Chat message storage with embeddings and metadata
+ * - `conversations`: Conversation metadata and organization
+ * - `memories`: Persistent memory storage with semantic search
+ * - `modelPreferences`: User model preferences and settings
+ *
+ * @example
+ * ```typescript
+ * import { Database } from '@nozbe/watermelondb';
+ * import LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs';
+ * import { sdkSchema, sdkMigrations, sdkModelClasses } from '@reverbia/sdk/react';
+ *
+ * const adapter = new LokiJSAdapter({
+ *   schema: sdkSchema,
+ *   migrations: sdkMigrations,
+ *   dbName: 'my-app-db',
+ *   useWebWorker: false,
+ *   useIncrementalIndexedDB: true,
+ * });
+ *
+ * const database = new Database({
+ *   adapter,
+ *   modelClasses: sdkModelClasses,
+ * });
+ * ```
+ */
+declare const sdkSchema: Readonly<{
+    version: _nozbe_watermelondb_Schema.SchemaVersion;
+    tables: _nozbe_watermelondb_Schema.TableMap;
+    unsafeSql?: (_: string, __: _nozbe_watermelondb_Schema.AppSchemaUnsafeSqlKind) => string;
+}>;
+/**
+ * Combined migrations for all SDK storage modules.
+ *
+ * These migrations handle database schema upgrades from any previous version
+ * to the current version. The SDK manages all migration logic internally,
+ * so consumer apps don't need to handle version arithmetic or migration merging.
+ *
+ * **Minimum supported version: v2**
+ * Migrations from v1 are not supported. Databases at v1 require a fresh install.
+ *
+ * Migration history:
+ * - v2 → v3: Added `was_stopped` column to history table
+ * - v3 → v4: Added `modelPreferences` table for settings storage
+ * - v4 → v5: Added `error` column to history table for error persistence
+ * - v5 → v6: Added `thought_process` column to history table for activity tracking
+ */
+declare const sdkMigrations: Readonly<{
+    validated: true;
+    minVersion: _nozbe_watermelondb_Schema.SchemaVersion;
+    maxVersion: _nozbe_watermelondb_Schema.SchemaVersion;
+    sortedMigrations: _nozbe_watermelondb_Schema_migrations.Migration[];
+}>;
+/**
+ * Model classes to register with the WatermelonDB database.
+ *
+ * Pass this array directly to the `modelClasses` option when creating
+ * your Database instance.
+ *
+ * @example
+ * ```typescript
+ * import { Database } from '@nozbe/watermelondb';
+ * import { sdkSchema, sdkMigrations, sdkModelClasses } from '@reverbia/sdk/react';
+ *
+ * const database = new Database({
+ *   adapter,
+ *   modelClasses: sdkModelClasses,
+ * });
+ * ```
+ */
+declare const sdkModelClasses: Class<Model$1>[];
+
+declare const memoryStorageSchema: Readonly<{
+    version: _nozbe_watermelondb_Schema.SchemaVersion;
+    tables: _nozbe_watermelondb_Schema.TableMap;
+    unsafeSql?: (_: string, __: _nozbe_watermelondb_Schema.AppSchemaUnsafeSqlKind) => 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)
+ *
+ * Uses the base options. React-specific features can be added here if needed.
+ */
+type UseMemoryStorageOptions = BaseUseMemoryStorageOptions;
+/**
+ * Result returned by useMemoryStorage hook (React version)
+ *
+ * Uses the base result. React-specific features can be added here if needed.
+ */
+type UseMemoryStorageResult = BaseUseMemoryStorageResult;
+/**
+ * A React hook that wraps useMemory with automatic memory persistence using WatermelonDB.
+ *
+ * This hook provides all the functionality of useMemory plus automatic storage of
+ * memories to a WatermelonDB database. Memories are automatically saved when extracted
+ * and can be searched using semantic similarity.
+ *
+ * @param options - Configuration options
+ * @returns An object containing memory state, methods, and storage operations
+ *
+ * @example
+ * ```tsx
+ * import { Database } from '@nozbe/watermelondb';
+ * import { useMemoryStorage } from '@reverbia/sdk/react';
+ *
+ * function MemoryComponent({ database }: { database: Database }) {
+ *   const {
+ *     memories,
+ *     extractMemoriesFromMessage,
+ *     searchMemories,
+ *     fetchAllMemories,
+ *   } = useMemoryStorage({
+ *     database,
+ *     getToken: async () => getAuthToken(),
+ *     onFactsExtracted: (facts) => console.log('Extracted:', facts),
+ *   });
+ *
+ *   const handleExtract = async () => {
+ *     const result = await extractMemoriesFromMessage({
+ *       messages: [{ role: 'user', content: 'My name is John and I live in NYC' }],
+ *       model: 'gpt-4o-mini',
+ *     });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleExtract}>Extract Memories</button>
+ *       <p>Total memories: {memories.length}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useMemoryStorage(options: UseMemoryStorageOptions): UseMemoryStorageResult;
+
+/**
+ * Memory Encryption Utilities
+ *
+ * Encrypts sensitive memory fields at rest while keeping search/index fields unencrypted.
+ * Based on the implementation from ai-memoryless-client.
+ */
+
+/**
+ * Get the encryption version from an encrypted value
+ */
+declare function getEncryptionVersion(value: string): "v1" | "v2" | null;
+/**
+ * Encrypt a single string value using the SDK's encryption.
+ * Returns the encrypted value with a prefix for identification.
+ *
+ * @param value - The plain text value to encrypt
+ * @param address - The user's wallet address (encryption key identifier)
+ * @returns The encrypted value with prefix
+ * @throws {Error} If encryption fails - prevents sensitive data from being stored unencrypted
+ */
+declare function encryptField(value: string, address: string): Promise<string>;
+/**
+ * Placeholder returned when decryption fails.
+ * Allows UI to render a friendly message instead of gibberish.
+ */
+declare const DECRYPTION_FAILED_PLACEHOLDER = "[Decryption Failed]";
+/**
+ * Decrypt a single string value using the SDK's decryption.
+ * Supports both v1 (legacy) and v2 encryption formats.
+ * Automatically migrates old encrypted values to new format.
+ *
+ * @param value - The encrypted value (with prefix)
+ * @param address - The user's wallet address (encryption key identifier)
+ * @param signMessage - Optional function to sign message for migration (required if old encryption detected)
+ * @param onMigrated - Optional callback when a value is migrated
+ * @returns The decrypted plain text, original value if not encrypted, or placeholder on error
+ */
+declare function decryptField(value: string, address: string, signMessage?: SignMessageFn, onMigrated?: (migratedValue: string) => Promise<void>): Promise<string>;
+/**
+ * Memory data structure with fields that may be encrypted
+ */
+interface MemoryData {
+    value?: string;
+    rawEvidence?: string;
+    key?: string;
+    namespace?: string;
+    [key: string]: unknown;
+}
+/**
+ * Encrypt sensitive fields in a memory object.
+ * Only encrypts the fields defined in ENCRYPTED_FIELDS.
+ * Embeddings and other indexed fields are left unencrypted.
+ *
+ * @param memory - The memory object with plain text fields
+ * @param address - The user's wallet address
+ * @returns A new memory object with sensitive fields encrypted
+ */
+declare function encryptMemoryFields<T extends MemoryData>(memory: T, address: string): Promise<T>;
+/**
+ * Decrypt sensitive fields in a memory object.
+ * Only decrypts the fields defined in ENCRYPTED_FIELDS.
+ * Automatically migrates old encrypted values to new format.
+ * Also encrypts unencrypted fields when found (for users migrating to encryption).
+ *
+ * @param memory - The memory object with encrypted fields
+ * @param address - The user's wallet address
+ * @param signMessage - Optional function to sign message for migration (required if old encryption detected)
+ * @param updateMemory - Optional function to update memory in storage after migration/encryption
+ * @returns A new memory object with sensitive fields decrypted
+ */
+declare function decryptMemoryFields<T extends MemoryData>(memory: T, address: string, signMessage?: SignMessageFn, updateMemory?: (id: string, data: Partial<T>) => Promise<void>): Promise<T>;
+/**
+ * Batch encrypt multiple memory objects.
+ * Uses parallel processing for performance.
+ *
+ * @param memories - Array of memory objects
+ * @param address - The user's wallet address
+ * @returns Array of memory objects with encrypted fields
+ */
+declare function encryptMemoriesBatch<T extends MemoryData>(memories: T[], address: string): Promise<T[]>;
+/**
+ * Batch decrypt multiple memory objects.
+ * Uses parallel processing for performance.
+ * Automatically migrates old encrypted values to new format.
+ *
+ * @param memories - Array of memory objects
+ * @param address - The user's wallet address
+ * @param signMessage - Optional function to sign message for migration (required if old encryption detected)
+ * @param updateMemory - Optional function to update memory in storage after migration
+ * @returns Array of memory objects with decrypted fields
+ */
+declare function decryptMemoriesBatch<T extends MemoryData>(memories: T[], address: string, signMessage?: SignMessageFn, updateMemory?: (id: string, data: Partial<T>) => Promise<void>): Promise<T[]>;
+/**
+ * Check if a memory has any encrypted fields.
+ * Useful for determining if migration is needed.
+ */
+declare function hasEncryptedFields(memory: MemoryData): boolean;
+/**
+ * Check if a memory needs encryption (has unencrypted sensitive fields).
+ */
+declare function needsEncryption(memory: MemoryData): boolean;
+/**
+ * Memory fields needed for encryption update
+ */
+interface MemoryEncryptionFields extends MemoryData {
+    type: string;
+    namespace: string;
+    key: string;
+    value: string;
+    rawEvidence: string;
+    confidence: number;
+    pii: boolean;
+}
+/**
+ * Memory object with the required fields for batch encryption
+ */
+interface MemoryForBatchEncryption {
+    uniqueId: string;
+    type: string;
+    namespace: string;
+    key: string;
+    value: string;
+    rawEvidence: string;
+    confidence: number;
+    pii: boolean;
+}
+/**
+ * Encrypt a batch of memories in parallel with rate limiting and retry logic.
+ * Tracks failed memories for error reporting.
+ *
+ * @param memories - Array of memories to encrypt
+ * @param address - User's wallet address
+ * @param updateFn - Function to update a memory in storage
+ * @param batchSize - Number of memories to process in parallel (default: 5)
+ * @returns Object with success count and failed memory IDs
+ */
+declare function encryptMemoriesBatchInPlace(memories: MemoryForBatchEncryption[], address: string, updateFn: (id: string, data: MemoryData) => Promise<unknown>, batchSize?: number): Promise<{
+    success: number;
+    failed: string[];
+    errors: Array<{
+        id: string;
+        error: string;
+    }>;
+}>;
+
+declare const settingsStorageSchema: Readonly<{
+    version: _nozbe_watermelondb_Schema.SchemaVersion;
+    tables: _nozbe_watermelondb_Schema.TableMap;
+    unsafeSql?: (_: string, __: _nozbe_watermelondb_Schema.AppSchemaUnsafeSqlKind) => string;
+}>;
+
+declare class ModelPreference extends Model {
+    static table: string;
+    walletAddress: string;
+    models?: string;
+}
+
+interface StoredModelPreference {
+    uniqueId: string;
+    walletAddress: string;
+    models?: string;
+}
+interface CreateModelPreferenceOptions {
+    walletAddress: string;
+    models?: string;
+}
+interface UpdateModelPreferenceOptions {
+    models?: string;
+}
+interface BaseUseSettingsOptions {
+    database: Database;
+    walletAddress?: string;
+}
+interface BaseUseSettingsResult {
+    modelPreference: StoredModelPreference | null;
+    isLoading: boolean;
+    getModelPreference: (walletAddress: string) => Promise<StoredModelPreference | null>;
+    setModelPreference: (walletAddress: string, models?: string) => Promise<StoredModelPreference | null>;
+    deleteModelPreference: (walletAddress: string) => Promise<boolean>;
+}
+
+/**
+ * Options for useSettings hook (React version)
+ */
+interface UseSettingsOptions extends BaseUseSettingsOptions {
+}
+/**
+ * Result returned by useSettings hook (React version)
+ */
+interface UseSettingsResult extends BaseUseSettingsResult {
+}
+/**
+ * A React hook for managing user settings with automatic persistence using WatermelonDB.
+ *
+ * This hook provides methods to get, set, and delete user model preferences,
+ * with automatic loading of preferences when a wallet address is provided.
+ *
+ * @param options - Configuration options
+ * @returns An object containing settings state and methods
+ *
+ * @example
+ * ```tsx
+ * import { Database } from '@nozbe/watermelondb';
+ * import { useSettings } from '@reverbia/sdk/react';
+ *
+ * function SettingsComponent({ database }: { database: Database }) {
+ *   const {
+ *     modelPreference,
+ *     isLoading,
+ *     setModelPreference,
+ *     getModelPreference,
+ *     deleteModelPreference,
+ *   } = useSettings({
+ *     database,
+ *     walletAddress: '0x123...', // Optional: auto-loads preference for this wallet
+ *   });
+ *
+ *   const handleModelChange = async (model: string) => {
+ *     await setModelPreference('0x123...', model);
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <p>Current model: {modelPreference?.model ?? 'Not set'}</p>
+ *       <button onClick={() => handleModelChange('gpt-4o')}>
+ *         Use GPT-4o
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @category Hooks
+ */
+declare function useSettings(options: UseSettingsOptions): UseSettingsResult;
+
+interface PdfFile {
+    url: string;
+    mediaType?: string;
+    filename?: string;
+}
+/**
+ * React hook for extracting text from PDF files.
+ * @category Hooks
+ */
+declare function usePdf(): {
+    extractPdfContext: (files: PdfFile[]) => Promise<string | null>;
+    isProcessing: boolean;
+    error: Error | null;
+};
+
+interface OCRFile {
+    url: string | File | Blob;
+    filename?: string;
+    language?: string;
+}
+/**
+ * React hook for extracting text from images using OCR.
+ * @category Hooks
+ */
+declare function useOCR(): {
+    extractOCRContext: (files: OCRFile[]) => Promise<string | null>;
+    isProcessing: boolean;
+    error: Error | null;
+};
+
+type UseModelsOptions = {
+    /**
+     * Custom function to get auth token for API calls
+     */
+    getToken?: () => Promise<string | null>;
+    /**
+     * Optional base URL for the API requests.
+     */
+    baseUrl?: string;
+    /**
+     * Optional filter for specific provider (e.g. "openai")
+     */
+    provider?: string;
+    /**
+     * Whether to fetch models automatically on mount (default: true)
+     */
+    autoFetch?: boolean;
+};
+type UseModelsResult = {
+    models: LlmapiModel[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+/**
+ * React hook for fetching available LLM models.
+ * Automatically fetches all available models.
+ * @category Hooks
+ */
+declare function useModels(options?: UseModelsOptions): UseModelsResult;
+
+type UseSearchOptions = {
+    /**
+     * Custom function to get auth token for API calls
+     */
+    getToken?: () => Promise<string | null>;
+    /**
+     * Optional base URL for the API requests.
+     */
+    baseUrl?: string;
+    /**
+     * Callback function to be called when an error is encountered.
+     */
+    onError?: (error: Error) => void;
+};
+type SearchOptions = {
+    /**
+     * Country code for search results (e.g., "us", "gb")
+     */
+    country?: string;
+    /**
+     * Maximum number of results to return
+     */
+    max_results?: number;
+    /**
+     * Maximum tokens per page
+     */
+    max_tokens_per_page?: number;
+    /**
+     * List of domains to filter results (max 20 domains)
+     */
+    search_domain_filter?: string[];
+    /**
+     * The search provider to use
+     */
+    search_tool_name?: string;
+};
+type UseSearchResult = {
+    isLoading: boolean;
+    search: (query: string | string[], options?: SearchOptions) => Promise<LlmapiSearchResponse | null>;
+    results: LlmapiSearchResult[] | null;
+    response: LlmapiSearchResponse | null;
+    error: Error | null;
+};
+/**
+ * React hook for performing search operations using the AI SDK.
+ *
+ * @param options - Configuration options for the search hook
+ * @returns Object containing search function, results, loading state, and error
+ * @category Hooks
+ *
+ * @example
+ * ```tsx
+ * const { search, results, isLoading } = useSearch({
+ *   getToken: async () => "my-token"
+ * });
+ *
+ * const handleSearch = async () => {
+ *   await search("What is ZetaChain?");
+ * };
+ * ```
+ */
+declare function useSearch(options?: UseSearchOptions): UseSearchResult;
+
+type UseImageGenerationOptions = {
+    /**
+     * Custom function to get auth token for API calls
+     */
+    getToken?: () => Promise<string | null>;
+    /**
+     * Optional base URL for the API requests.
+     */
+    baseUrl?: string;
+    /**
+     * Callback function to be called when the generation finishes successfully.
+     */
+    onFinish?: (response: LlmapiImageGenerationResponse) => void;
+    /**
+     * Callback function to be called when an unexpected error is encountered.
+     */
+    onError?: (error: Error) => void;
+};
+type GenerateImageArgs = LlmapiImageGenerationRequest;
+type GenerateImageResult = {
+    data: LlmapiImageGenerationResponse;
+    error: null;
+} | {
+    data: null;
+    error: string;
+};
+type UseImageGenerationResult = {
+    isLoading: boolean;
+    generateImage: (args: GenerateImageArgs) => Promise<GenerateImageResult>;
+    stop: () => void;
+};
+/**
+ * React hook for generating images using the LLM API.
+ * @category Hooks
+ */
+declare function useImageGeneration(options?: UseImageGenerationOptions): UseImageGenerationResult;
+
+/**
+ * Format memories into a context string that can be included in chat messages
+ * @param memories Array of memories with similarity scores
+ * @param format Format style: "compact" (key-value pairs) or "detailed" (includes evidence)
+ * @returns Formatted string ready to include in system/user message
+ */
+declare const formatMemoriesForChat: (memories: Array<StoredMemory & {
+    similarity?: number;
+}>, format?: "compact" | "detailed") => string;
+/**
+ * Create a system message that includes relevant memories
+ * @param memories Array of memories to include
+ * @param baseSystemPrompt Optional base system prompt (memories will be prepended)
+ * @returns System message content with memories
+ */
+declare const createMemoryContextSystemMessage: (memories: Array<StoredMemory & {
+    similarity?: number;
+}>, baseSystemPrompt?: string) => string;
+/**
+ * Extract conversation context from messages for memory search
+ * @param messages Array of chat messages
+ * @param maxMessages Maximum number of recent messages to include (default: 3)
+ * @returns Combined text query for memory search
+ */
+declare const extractConversationContext: (messages: Array<{
+    role: string;
+    content: string;
+}>, maxMessages?: number) => string;
+
+/**
+ * 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$1 = "/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 Authorization Code Flow
+ *
+ * Flow:
+ * 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
+ */
+
+/**
+ * Clear Dropbox token data
+ */
+declare function clearToken(): void;
+/**
+ * Check if we have any stored credentials (including refresh token)
+ * Works with both encrypted and unencrypted credentials
+ */
+declare function hasDropboxCredentials(): boolean;
+
+/**
+ * Props for DropboxAuthProvider
+ */
+interface DropboxAuthProviderProps {
+    /** Dropbox App Key (from Dropbox Developer Console) */
+    appKey: string | undefined;
+    /** 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;
+}
+/**
+ * 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: () => 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 Authorization Code flow with refresh tokens.
+ *
+ * @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, apiClient, 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 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)
+ * Works with both encrypted and unencrypted credentials
+ */
+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
+ *
+ * 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;
+    /** 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 Google Drive is configured */
+    isConfigured: boolean;
+    /** 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,
+ * authentication, and managing the backup/restore process.
+ *
+ * Must be used within a GoogleDriveAuthProvider.
+ *
+ * @example
+ * ```tsx
+ * import { useGoogleDriveBackup } from "@reverbia/sdk/react";
+ *
+ * function BackupButton() {
+ *   const { backup, restore, isConfigured, isAuthenticated } = useGoogleDriveBackup({
+ *     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 useGoogleDriveBackup(options: UseGoogleDriveBackupOptions): UseGoogleDriveBackupResult;
+
+/**
+ * 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 CreateConversationOptions, type CreateMemoryOptions, type CreateMessageOptions, type CreateModelPreferenceOptions, DECRYPTION_FAILED_PLACEHOLDER, 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, 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 MemoryData, type MemoryEncryptionFields, 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 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, clearAllEncryptionKeys, clearAllKeyPairs, clearToken as clearDropboxToken, clearEncryptionKey, clearGoogleDriveToken, clearICloudAuth, clearKeyPair, createMemoryContextSystemMessage, decryptData, decryptDataBytes, decryptField, decryptMemoriesBatch, decryptMemoryFields, encryptData, encryptField, encryptMemoriesBatch, encryptMemoriesBatchInPlace, encryptMemoryFields, exportPublicKey, extractConversationContext, formatMemoriesForChat, generateCompositeKey, generateConversationId, generateUniqueKey, getEncryptionVersion, getGoogleDriveStoredToken, hasDropboxCredentials, hasEncryptedFields, hasEncryptionKey, hasGoogleDriveCredentials, hasICloudCredentials, hasKeyPair, memoryStorageSchema, needsEncryption, requestEncryptionKey, requestKeyPair, sdkMigrations, sdkModelClasses, sdkSchema, settingsStorageSchema, useBackup, useBackupAuth, useChat, useChatStorage, useDropboxAuth, useDropboxBackup, useEncryption, useGoogleDriveAuth, useGoogleDriveBackup, useICloudAuth, useICloudBackup, useImageGeneration, useMemoryStorage, useModels, useOCR, usePdf, useSearch, useSettings };