@llmnative/react 0.1.1 → 1.0.0

package/dist/types/src/providers/ai/gemini.d.ts

@@ -0,0 +1,2 @@
+import type { AIProviderDefinition } from './shared';
+export declare const GEMINI_PROVIDER_DEFINITION: AIProviderDefinition;

package/dist/types/src/providers/ai/glm.d.ts

@@ -0,0 +1 @@
+export declare const GLM_PROVIDER_DEFINITION: import("./shared").AIProviderDefinition;

package/dist/types/src/providers/ai/index.d.ts

@@ -1,134 +1,9 @@
-import { Prompt, PROMPTS } from "../../conf/Prompt";
-import { type ProviderConfigurationState } from "../ProviderConfiguration";
-import { PromptVariables } from "../../conf/Prompt";
-export default function fetchAI(provider?: string): (prompt: string, options?: {
-    model?: string;
-    temperature?: number;
-}, strategy?: keyof typeof PROMPTS | undefined) => Promise<any>;
-interface AIProvider {
-    name: string;
-    url: string;
-    model: string;
-    models: string[];
-    framework?: string;
-    frameworks?: string[];
-    temperature: number;
-    parseHeaders: () => Record<string, string>;
-    parseBody: (prompt: string, role: string, options: AIOptions) => Record<string, any>;
-    parseResponse: (response: any) => any;
-}
-interface AIOptions {
-    language?: string;
-    voice?: string;
-    style?: string;
-    role?: string;
-    model?: string;
-    temperature?: number;
-}
-export interface AIFetchConfig extends AIOptions {
-    provider?: keyof typeof PROVIDERS;
-}
-export declare const getAIProviderConfigurationState: (provider?: keyof typeof PROVIDERS) => ProviderConfigurationState;
-declare const PROVIDERS: {
-    openai: {
-        name: string;
-        url: string;
-        model: string;
-        models: string[];
-        framework: string;
-        frameworks: string[];
-        temperature: number;
-        parseHeaders: () => {
-            'Content-Type': string;
-            Authorization: string;
-        };
-        parseBody: (prompt: string, role: string, options: AIOptions) => {
-            model: string;
-            messages: {
-                role: string;
-                content: string;
-            }[];
-            temperature: number;
-        };
-        parseResponse: (response: any) => any;
-    };
-    gemini: {
-        name: string;
-        url: string;
-        model: string;
-        models: string[];
-        temperature: number;
-        parseHeaders: () => {
-            'Content-Type': string;
-            Authorization: string;
-        };
-        parseBody: (prompt: string, role: string, options: AIOptions) => {
-            model: string;
-            instances: {
-                content: string;
-            }[];
-            temperature: number;
-        };
-        parseResponse: (response: any) => any;
-    };
-    anthropic: {
-        name: string;
-        url: string;
-        model: string;
-        models: string[];
-        temperature: number;
-        parseHeaders: () => {
-            'Content-Type': string;
-            Authorization: string;
-        };
-        parseBody: (prompt: string, role: string, options: AIOptions) => {
-            model: string;
-            messages: {
-                role: string;
-                content: string;
-            }[];
-            temperature: number;
-        };
-        parseResponse: (response: any) => any;
-    };
-    mistral: {
-        name: string;
-        url: string;
-        model: string;
-        models: string[];
-        temperature: number;
-        parseHeaders: () => {
-            'Content-Type': string;
-            Authorization: string;
-        };
-        parseBody: (prompt: string, role: string, options: AIOptions) => {
-            model: string;
-            messages: {
-                role: string;
-                content: string;
-            }[];
-            temperature: number;
-        };
-        parseResponse: (response: any) => any;
-    };
-};
-export declare class AI extends Prompt {
-    config: AIProvider;
-    options: AIOptions;
-    data?: PromptVariables;
-    static fetch(prompt: string, config: AIFetchConfig, data?: PromptVariables): Promise<any>;
-    static getModels(provider?: keyof typeof PROVIDERS): string[];
-    constructor(provider?: keyof typeof PROVIDERS);
-    setOptions(options: AIOptions): this;
-    setData(data?: PromptVariables): this;
-    static defaults(): {
-        model: string;
-        role: string;
-        language: string;
-        country: string;
-        voice: string;
-        style: string;
-    };
-    fetchAPI(prompt: string): Promise<any>;
-}
-export {};
+import type { AIConfig } from '../../Config';
+import type { AIProviderAdapter } from './AIProvider';
+import { type AIProviderDefinition } from './shared';
+export type { AIProviderAdapter, AIKeyValidationResult, AIModelDescriptor, AIProviderCapabilities, AIRequestOptions, AIAttachment } from './AIProvider';
+export { formatAIModelRef, parseAIModelRef } from './AIProvider';
+export type { AIModelCatalog } from './shared';
+export { getAIModelCatalog } from './shared';
+export declare const AI_PROVIDER_DEFINITIONS: AIProviderDefinition[];
+export declare const createAIProviderRegistry: (aiConfig?: AIConfig) => Record<string, AIProviderAdapter>;

package/dist/types/src/providers/ai/mistral.d.ts

@@ -0,0 +1 @@
+export declare const MISTRAL_PROVIDER_DEFINITION: import("./shared").AIProviderDefinition;

package/dist/types/src/providers/ai/openai.d.ts

@@ -0,0 +1 @@
+export declare const OPENAI_PROVIDER_DEFINITION: import("./shared").AIProviderDefinition;

package/dist/types/src/providers/ai/openaiCompatible.d.ts

@@ -0,0 +1,17 @@
+import type { AIProviderDefinition, BuiltInAIProviderId } from './shared';
+type OpenAICompatibleDefinitionOptions = {
+    id: BuiltInAIProviderId;
+    label: string;
+    configKey: string;
+    requiredConfigKeys?: string[];
+    defaultModel: string;
+    fallbackModels: string[];
+    baseUrl: string;
+    modelsUrl?: string;
+    chatCompletionsUrl?: string;
+    dashboardUrl?: string;
+    /** Override the default validateApiKey when the models endpoint is public or uses a non-standard error format. */
+    validateApiKey?: AIProviderDefinition['validateApiKey'];
+};
+export declare const createOpenAICompatibleProviderDefinition: ({ id, label, configKey, requiredConfigKeys, defaultModel, fallbackModels, baseUrl, modelsUrl, chatCompletionsUrl, dashboardUrl, validateApiKey: validateApiKeyOverride, }: OpenAICompatibleDefinitionOptions) => AIProviderDefinition;
+export {};

package/dist/types/src/providers/ai/opencode.d.ts

@@ -0,0 +1,2 @@
+import type { AIProviderDefinition } from './shared';
+export declare const OPENCODE_PROVIDER_DEFINITION: AIProviderDefinition;

package/dist/types/src/providers/ai/openrouter.d.ts

@@ -0,0 +1 @@
+export declare const OPENROUTER_PROVIDER_DEFINITION: import("./shared").AIProviderDefinition;

package/dist/types/src/providers/ai/shared.d.ts

@@ -0,0 +1,46 @@
+import { type ProviderConfigurationState } from '../ProviderConfiguration';
+import type { AICompleteRequest, AIKeyValidationResult, AIModelDescriptor, AIProviderAdapter, AIProviderCapabilities, AIRequestOptions } from './AIProvider';
+export type BuiltInAIProviderId = 'openai' | 'openrouter' | 'opencode' | 'openai-compatible' | 'deepseek' | 'gemini' | 'anthropic' | 'mistral' | 'glm';
+export type AIProviderDefinition = {
+    id: BuiltInAIProviderId;
+    label: string;
+    configKey?: string;
+    requiredConfigKeys?: string[];
+    defaultModel: string;
+    fallbackModels: string[];
+    /** URL to the provider's API key management page (shown in UI on validation error). */
+    dashboardUrl?: string;
+    capabilities?: Omit<AIProviderCapabilities, 'models'>;
+    discoverModels: (apiKey: string) => Promise<string[]>;
+    complete: (apiKey: string, request: Required<Pick<AICompleteRequest, 'prompt' | 'model'>> & AIRequestOptions) => Promise<string | null>;
+    /**
+     * Per-provider auth check. When omitted, the default implementation in
+     * RuntimeAIProvider calls discoverModels() live (no cache) and treats any
+     * thrown error as invalid. Providers whose error format is non-standard or
+     * whose models endpoint is public MUST provide their own implementation.
+     */
+    validateApiKey?: (apiKey: string) => Promise<Omit<AIKeyValidationResult, 'dashboardUrl'>>;
+};
+export type AIModelCatalog = {
+    models: AIModelDescriptor[];
+    modelsByProvider: Record<string, AIModelDescriptor[]>;
+    capabilitiesByProvider: Record<string, AIProviderCapabilities>;
+};
+export declare const extractProviderError: (err: unknown) => string;
+export declare const createBrowserTransportError: (label: string) => Error;
+export declare const parseTextResponse: (value: unknown) => string | null;
+export declare const getAIModelCatalog: (registry: Record<string, AIProviderAdapter>, forceRefresh?: boolean) => Promise<AIModelCatalog>;
+export declare class RuntimeAIProvider implements AIProviderAdapter {
+    id: BuiltInAIProviderId;
+    label: string;
+    defaultModel: string;
+    dashboardUrl?: string;
+    private readonly definition;
+    private readonly apiKey;
+    constructor(definition: AIProviderDefinition, apiKey: string);
+    isConfigured(): boolean;
+    getConfigurationState(): ProviderConfigurationState;
+    getCapabilities(forceRefresh?: boolean): Promise<AIProviderCapabilities>;
+    complete(request: AICompleteRequest): Promise<string | null>;
+    validateApiKey(): Promise<AIKeyValidationResult>;
+}

package/dist/types/src/providers/api/ApiProvider.d.ts

@@ -0,0 +1,43 @@
+import type { ProviderConfigurable } from '../ProviderConfiguration';
+/**
+ * "api" — a real provider category (docs/24-tenant-platform.md, Service Gateway), same
+ * registry/lifecycle as data/storage/etc. Registers a third-party REST integration (Brevo,
+ * a payments API, a non-streaming AI provider, ...) once — base URL, fixed header/query/body
+ * fields (where a secret usually lives) — and exposes one generic call:
+ *
+ *   setProvider('api', 'payments', new DirectApiProviderAdapter({
+ *       baseUrl: 'https://payments.acme.com/api',
+ *       header: { Authorization: 'Bearer <secret>' },
+ *   }));
+ *
+ *   useApiProvider('payments').fetch({ path: '/charges', method: 'post', body: { amount: 1000 } });
+ *
+ * Registered/fixed fields always win over a matching key the caller passes — same
+ * authoritative-merge rule as the tenant-session handshake.
+ *
+ * Other category adapters (an EmailProviderAdapter for Brevo, an AIProviderAdapter for a
+ * REST-only model) call an ApiProviderAdapter internally instead of fetch()/proxyFetch()
+ * directly — a vendor adapter is just a few lines of normal code, no framework-provided bridge.
+ *
+ * Adapters (same interface, different execution context — mirrors DataProviderAdapter's
+ * Firebase/Supabase/Mock split), one file each like data/storage:
+ * - direct.ts   — DirectApiProviderAdapter, client-resident, via proxyFetch (CORS-safe). The
+ *   secret IS visible to the browser here — a dev/personal key, or a no-backend deploy, never
+ *   a real shared tenant secret.
+ * - firebase.ts — FirebaseApiProviderAdapter, routes through a Firebase Callable Function;
+ *   the secret lives server-side, resolved there from the real tenant/user registration.
+ * - supabase.ts — SupabaseApiProviderAdapter, same idea via a Supabase Edge Function.
+ * - mock.ts     — MockApiProviderAdapter, resolves via a local function, no network. Dev/tests.
+ */
+export type ApiProviderRequest = {
+    path: string;
+    /** Default: 'POST'. */
+    method?: string;
+    query?: Record<string, string>;
+    body?: unknown;
+};
+export interface ApiProviderAdapter extends ProviderConfigurable {
+    fetch(request: ApiProviderRequest): Promise<unknown>;
+}
+/** Convenience wrapper over useProvider('api', name) — same registry, just the ergonomic one-arg form. */
+export declare const useApiProvider: (name: string) => ApiProviderAdapter;

package/dist/types/src/providers/api/direct.d.ts

@@ -0,0 +1,14 @@
+import type { ApiProviderAdapter, ApiProviderRequest } from './ApiProvider';
+export type DirectApiProviderConfig = {
+    baseUrl: string;
+    /** Fixed fields merged into every call — this is where a secret normally lives. Always wins over a matching key in the request. */
+    header?: Record<string, string>;
+    query?: Record<string, string>;
+    body?: Record<string, unknown>;
+};
+/** Client-resident: calls the target directly via proxyFetch (CORS-safe). Secret visible to the browser — dev/personal key or no-backend deploy only. */
+export declare class DirectApiProviderAdapter implements ApiProviderAdapter {
+    private config;
+    constructor(config: DirectApiProviderConfig);
+    fetch(request: ApiProviderRequest): Promise<unknown>;
+}

package/dist/types/src/providers/api/firebase.d.ts

@@ -0,0 +1,14 @@
+import type { ApiProviderAdapter, ApiProviderRequest } from './ApiProvider';
+export type FirebaseApiProviderConfig = {
+    /** Name of the Callable Function that receives { provider, request } and does the real, secret-bearing call server-side. */
+    functionName: string;
+    /** The registered provider's own name — sent alongside the request so the function knows which registration to resolve. */
+    providerName: string;
+    region?: string;
+};
+/** Routes through a Firebase Callable Function — the secret lives server-side, resolved there from the real tenant/user registration. */
+export declare class FirebaseApiProviderAdapter implements ApiProviderAdapter {
+    private config;
+    constructor(config: FirebaseApiProviderConfig);
+    fetch(request: ApiProviderRequest): Promise<unknown>;
+}

package/dist/types/src/providers/api/mock.d.ts

@@ -0,0 +1,7 @@
+import type { ApiProviderAdapter, ApiProviderRequest } from './ApiProvider';
+/** Resolves via a local function, no network. Dev/tests. */
+export declare class MockApiProviderAdapter implements ApiProviderAdapter {
+    private resolver;
+    constructor(resolver: (request: ApiProviderRequest) => unknown | Promise<unknown>);
+    fetch(request: ApiProviderRequest): Promise<unknown>;
+}

package/dist/types/src/providers/api/supabase.d.ts

@@ -0,0 +1,14 @@
+import type { ApiProviderAdapter, ApiProviderRequest } from './ApiProvider';
+export type SupabaseApiProviderConfig = {
+    url: string;
+    anonKey: string;
+    /** Name of the Edge Function that receives { provider, request } and does the real, secret-bearing call server-side. */
+    functionName: string;
+    providerName: string;
+};
+/** Routes through a Supabase Edge Function — the secret lives server-side, resolved there from the real tenant/user registration. */
+export declare class SupabaseApiProviderAdapter implements ApiProviderAdapter {
+    private config;
+    constructor(config: SupabaseApiProviderConfig);
+    fetch(request: ApiProviderRequest): Promise<unknown>;
+}

package/dist/types/src/providers/auth/AuthProvider.d.ts

@@ -4,13 +4,13 @@ export interface UserProfile {
     email?: string;
     displayName?: string;
     photoURL?: string;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export type AuthIntent = 'signIn' | 'connect' | 'signOut' | 'disconnect' | 'reauthorize';
 export interface AuthSignInOptions {
     scopes?: string[];
     intent?: AuthIntent;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export interface AuthProviderAdapter extends ProviderConfigurable {
     getUser(): UserProfile | null;

package/dist/types/src/providers/auth/firebase/FirebaseAuthProvider.d.ts

@@ -0,0 +1,26 @@
+import type { AuthProviderAdapter, AuthSignInOptions, UserProfile } from '../AuthProvider';
+import type { ProviderConfigurationState } from '../../ProviderConfiguration';
+/**
+ * Firebase-specific sign-in options.
+ *
+ * method: 'password' (default) | 'anonymous' | 'oauth'
+ * email + password: required when method = 'password'
+ * provider: required when method = 'oauth' - e.g. 'github', 'apple', 'microsoft'
+ *           Note: for Google OAuth use GoogleAuthProvider, not FirebaseAuthProvider.
+ */
+export interface FirebaseSignInOptions extends AuthSignInOptions {
+    method?: 'password' | 'anonymous' | 'oauth';
+    email?: string;
+    password?: string;
+    provider?: string;
+}
+export declare class FirebaseAuthProvider implements AuthProviderAdapter {
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    getUser(): UserProfile | null;
+    isAuthenticated(): boolean;
+    signIn(options?: FirebaseSignInOptions): Promise<UserProfile | null>;
+    signOut(): Promise<void>;
+    onAuthChange(callback: (user: UserProfile | null) => void): () => void;
+    getAccessToken(): Promise<string>;
+}

package/dist/types/src/providers/auth/google/GoogleAuth.d.ts

@@ -4,9 +4,9 @@ declare global {
         google: {
             accounts: {
                 id: {
-                    initialize: (options: any) => void;
+                    initialize: (options: Record<string, unknown>) => void;
                     prompt: (callback?: () => void) => void;
-                    renderButton: (element: HTMLElement, options: any) => void;
+                    renderButton: (element: HTMLElement, options: Record<string, unknown>) => void;
                     disableAutoSelect: () => void;
                     revoke: (hint: string, callback?: () => void) => void;
                 };

package/dist/types/src/providers/auth/supabase/SupabaseAuthProvider.d.ts

@@ -0,0 +1,48 @@
+import type { AuthProviderAdapter, AuthSignInOptions, UserProfile } from '../AuthProvider';
+import type { ProviderConfigurationState } from '../../ProviderConfiguration';
+export interface SupabaseAuthConfig {
+    url: string;
+    anonKey: string;
+}
+/**
+ * Supabase-specific sign-in options.
+ * Passed as part of `AuthSignInOptions` (open `[key: string]: any` index signature).
+ *
+ * method:   'password' (default) | 'magic_link' | 'oauth' | 'anonymous'
+ * email:    required for 'password' and 'magic_link'
+ * password: required for 'password'
+ * provider: required for 'oauth' - e.g. 'github', 'google', 'apple', 'twitter'
+ * redirectTo: optional - overrides the redirect URL after OAuth / magic link
+ */
+export interface SupabaseSignInOptions extends AuthSignInOptions {
+    method?: 'password' | 'magic_link' | 'oauth' | 'anonymous';
+    email?: string;
+    password?: string;
+    provider?: string;
+    redirectTo?: string;
+}
+export declare class SupabaseAuthProvider implements AuthProviderAdapter {
+    private config;
+    private get client();
+    constructor(config: SupabaseAuthConfig);
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    /**
+     * Returns the currently cached session user (synchronous, no network call).
+     * Returns null if no active session.
+     */
+    getUser(): UserProfile | null;
+    isAuthenticated(): boolean;
+    /**
+     * Authenticate with Supabase.
+     *
+     * options.method = 'password'   (default): email + password sign-in
+     * options.method = 'magic_link': OTP email - returns null (email sent, no user yet)
+     * options.method = 'oauth':      redirect flow - returns null (user arrives after redirect)
+     * options.method = 'anonymous':  anonymous session
+     */
+    signIn(options?: SupabaseSignInOptions): Promise<UserProfile | null>;
+    signOut(): Promise<void>;
+    onAuthChange(callback: (user: UserProfile | null) => void): () => void;
+    getAccessToken(): Promise<string>;
+}

package/dist/types/src/providers/credentials/CredentialsProvider.d.ts

@@ -0,0 +1,3 @@
+export interface CredentialsAdapter {
+    getToken(scope?: string): Promise<string>;
+}

package/dist/types/src/providers/credentials/CredentialsProviderContext.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { CredentialsAdapter } from './CredentialsProvider';
+type CredentialsProviderContextValue = {
+    registry: Record<string, CredentialsAdapter>;
+    defaultKey: string;
+};
+declare const CredentialsProviderContext: React.Context<CredentialsProviderContextValue | null>;
+export declare const CredentialsProvider: ({ registry, defaultKey, children, }: CredentialsProviderContextValue & {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+export declare const useCredentialsProvider: (name?: string) => CredentialsAdapter;
+export default CredentialsProviderContext;

package/dist/types/src/providers/credentials/google/GoogleServiceAccountProvider.d.ts

@@ -0,0 +1,8 @@
+import type { CredentialsAdapter } from '../CredentialsProvider';
+import type { GoogleServiceAccount } from '../../../Config';
+export declare class GoogleServiceAccountProvider implements CredentialsAdapter {
+    private config;
+    private cache;
+    constructor(config: GoogleServiceAccount);
+    getToken(scope?: string): Promise<string>;
+}

package/dist/types/src/providers/data/DataProvider.d.ts

@@ -1,10 +1,20 @@
 import type { ProviderConfigurable } from '../ProviderConfiguration';
-type FieldMap = Record<string, any>;
+/** Canonical primary-key field name used by all data providers and the Form widget. */
+export declare const RECORD_KEY: "_key";
+/** A single field value in a record - scalar, nested object, or array of scalars. */
+export type FieldValue = string | number | boolean | null | undefined | Record<string, unknown> | unknown[];
+type FieldMap = Record<string, FieldValue>;
 type RecordObject = Record<string, FieldMap>;
+/**
+ * A data record as used by Form, Grid, and all data providers.
+ * `_key` is the primary key injected by the provider (matches `RECORD_KEY`).
+ * `_index` is the 0-based position in the parent collection (read-only, injected by providers).
+ */
 export type RecordProps = FieldMap & {
     _key?: string;
     _index?: number;
 };
+/** Ordered list of records returned by a provider `subscribe` or `read` call. */
 export type RecordArray = Array<RecordProps>;
 type ScalarValue = string | number | boolean | null;
 type RangeValue = string | number | boolean;
@@ -45,14 +55,30 @@ export interface SetChunksOptions {
     purge?: boolean;
     onProgress?: (done: number, total: number, message: string) => void;
 }
+/**
+ * Port contract for all data back-ends (Firebase RTDB, Firestore, Supabase, Mock, …).
+ * Implement this interface to register a custom provider via `<App providers={...}>`.
+ */
 export interface DataProviderAdapter extends ProviderConfigurable {
+    /** Read a single record or collection at `path`. Returns `null` when not found. */
     read(path: string, options?: ReadOptions): Promise<any>;
+    /** Write (overwrite) the node at `path` with `data`. */
     set(path: string, data: object, exception?: boolean): Promise<void>;
+    /** Merge `data` into the existing node at `path` (partial update). */
     update(path: string, data: object, exception?: boolean): Promise<void>;
+    /** Delete the node at `path`. */
     remove(path: string, exception?: boolean): Promise<void>;
+    /**
+     * Subscribe to real-time updates at `path`.
+     * `setRecords` is called immediately with the current data, then on every change.
+     * Returns a cleanup function that cancels the subscription.
+     */
     subscribe(path: string | undefined, setRecords: (records: RecordArray) => void, options?: DatabaseOptions): () => void;
+    /** Return the number of records in the collection at `path`. */
     count?(path: string): Promise<number>;
+    /** Return only the direct child keys of `path` without fetching full records. */
     readShallow?(path: string, exception?: boolean): Promise<string[]>;
+    /** Write `data` to `path` in batches (useful for large imports). */
     setChunks?(path: string, data: object, options?: SetChunksOptions): Promise<void>;
 }
 export {};

package/dist/types/src/providers/data/firebase.d.ts

@@ -1,4 +1,3 @@
-import 'firebase/compat/database';
 import { DataProviderAdapter, DatabaseOptions, ReadOptions, SetChunksOptions, RecordProps } from "./DataProvider";
 import type { ProviderConfigurationState } from "../ProviderConfiguration";
 export declare const SYSTEM_FIELDS: {
@@ -6,13 +5,15 @@ export declare const SYSTEM_FIELDS: {
     value: string;
 };
 export declare class FirebaseDataProvider implements DataProviderAdapter {
+    private static listenerRegistered;
+    constructor();
     getConfigurationState(): ProviderConfigurationState;
     isConfigured(): boolean;
     readShallow: (path: string, exception?: boolean) => Promise<string[]>;
     read: (path: string, { where, order, toArray, exception }?: ReadOptions) => Promise<any>;
-    update: (path: string, data: any, exception?: boolean) => Promise<void>;
-    set: (path: string, data: any, exception?: boolean) => Promise<void>;
-    setChunks: (path: string, data: any, { chunkSize, purge, onProgress }?: SetChunksOptions) => Promise<void>;
+    update: (path: string, data: object, exception?: boolean) => Promise<void>;
+    set: (path: string, data: object, exception?: boolean) => Promise<void>;
+    setChunks: (path: string, data: object, { chunkSize, purge, onProgress }?: SetChunksOptions) => Promise<void>;
     remove: (path: string, exception?: boolean) => Promise<void>;
     count: (path: string) => Promise<number>;
     subscribe: <T extends RecordProps = RecordProps>(path: string | undefined, setRecords: (records: T[]) => void, { where, order, fieldMap, onLoad }?: DatabaseOptions) => (() => void);

package/dist/types/src/providers/data/firestore.d.ts

@@ -0,0 +1,38 @@
+import { DataProviderAdapter, DatabaseOptions, ReadOptions, SetChunksOptions, RecordProps } from './DataProvider';
+import type { ProviderConfigurationState } from '../ProviderConfiguration';
+export declare class FirestoreDataProvider implements DataProviderAdapter {
+    private static listenerRegistered;
+    constructor();
+    getConfigurationState(): ProviderConfigurationState;
+    isConfigured(): boolean;
+    read: (path: string, { where, order, toArray, exception }?: ReadOptions) => Promise<any>;
+    set: (path: string, data: object, exception?: boolean) => Promise<void>;
+    update: (path: string, data: object, exception?: boolean) => Promise<void>;
+    remove: (path: string, exception?: boolean) => Promise<void>;
+    count: (path: string) => Promise<number>;
+    /**
+     * Real-time listener via Firestore onSnapshot.
+     *
+     * - Collection path (/users): subscribes to all matching documents.
+     * - Document path (/users/uid): subscribes to a single document.
+     *
+     * Returns an unsubscribe function - always call it on component unmount.
+     *
+     * Firestore inequality filters on a field require the first orderBy() to be
+     * on that same field. Pass `order` accordingly to avoid SDK errors.
+     */
+    subscribe: <T extends RecordProps = RecordProps>(path: string | undefined, setRecords: (records: T[]) => void, { where, order, fieldMap, onLoad }?: DatabaseOptions) => (() => void);
+    /**
+     * Returns the list of document IDs in a collection without loading document
+     * data - the Firestore equivalent of RTDB's ?shallow=true REST endpoint.
+     * On a document path, returns the document's field names.
+     */
+    readShallow: (path: string, exception?: boolean) => Promise<string[]>;
+    /**
+     * Bulk-writes `data` to a collection using Firestore writeBatch.
+     * Each batch holds at most min(chunkSize, 500) documents (Firestore limit).
+     * If `purge` is true, all existing documents in the collection are deleted
+     * first (also in batches of 500).
+     */
+    setChunks: (path: string, data: object, { chunkSize, purge, onProgress }?: SetChunksOptions) => Promise<void>;
+}

package/dist/types/src/providers/data/mock.d.ts

@@ -1,9 +1,16 @@
 import { DataProviderAdapter, DatabaseOptions, ReadOptions, RecordArray } from './DataProvider';
 type CollectionStore = Record<string, Record<string, any>>;
+export type MockDataProviderOptions = {
+    persist?: boolean;
+    storageKey?: string;
+};
 export declare class MockDataProvider implements DataProviderAdapter {
     private store;
     private listeners;
-    constructor(initialData?: CollectionStore);
+    private persistKey;
+    constructor(initialData?: CollectionStore, options?: MockDataProviderOptions);
+    private loadStore;
+    private saveStore;
     isConfigured(): boolean;
     getConfigurationState(): {
         configured: boolean;