@llmnative/react 0.1.1 → 1.0.0

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

@@ -1,36 +1,62 @@
 import './globals.css';
-export { default as App } from './App';
+export { default as App, AppProvider } from './App';
 export { useMenu } from './App';
-export type { AppProps, AppProvidersConfig } from './App';
-export type { ServicesConfig, SupabaseProviderConfig, GoogleProviderConfig, MockProviderConfig, DataDriverName, StorageDriverName, AuthDriverName, EmailDriverName, } from './providers/manifest';
+export type { AppProps, AppProviderProps, AppProvidersConfig, MenuConfig } from './App';
+export type { AIConfig } from './Config';
+export type { ServicesConfig, SupabaseProviderConfig, GoogleProviderConfig, MockProviderConfig, DataDriverName, StorageDriverName, AuthDriverName, EmailDriverName, AIDriverName, } from './providers/manifest';
+export type { ProxyConfig } from './Config';
 export { Head, HeadProvider, DEFAULT_DOCUMENT_HEAD, DEFAULT_HEAD_APP_NAME, DEFAULT_LANGUAGE_HEAD, useAssetsHead, useDocumentHead, useHead, useHeadLinks, useLanguageHead, usePaginationHead, usePwaHead, useSchemaOrgHead, useSocialHead, } from './Head';
 export type { HeadController, AssetsHeadState, DocumentBaseHead, DocumentHeadState, DocumentHttpEquivMeta, HeadFontAsset, HeadLinkDescriptor, HeadLinksState, HeadMetaAttributes, HeadProviderProps, HeadScriptAsset, HeadStyleAsset, LanguageAlternateLink, LanguageHeadState, OpenGraphHeadState, PageMetadataState, PaginationHeadState, PwaIconLink, PwaHeadState, SchemaOrgHeadState, SchemaOrgJson, SocialHeadState, TwitterHeadState, } from './Head';
 export { useTheme, useThemeController, BUILT_IN_THEMES, BUILT_IN_THEME_IDS } from './Theme';
-export type { AppThemeProviderConfig, BuiltInThemeId, CardTheme, ColorScale, GalleryTheme, MenuTheme, ModalTheme, TableTheme, Theme, ThemeConfig, ThemeController, ThemeMode, ThemeDefinition, ThemePresetConfig, } from './Theme';
+export { I18nProvider, useI18n, interpolate, defineLocaleMessages, createTranslations, } from './I18n';
+export type { I18nDict, I18nConfig, I18nController, I18nTranslations, I18nLocale } from './I18n';
+export * as locales from './conf/i18n';
+export type { AppThemeProviderConfig, BuiltInThemeId, CardTheme, ColorScale, GalleryTheme, ListCardTheme, MenuTheme, ModalTheme, ProviderSwitcherTheme, ToolbarTheme, TableTheme, Theme, ThemeConfig, ThemeController, ThemeMode, ThemeDefinition, ThemePresetConfig, } from './Theme';
 export { AuthButton, useAccessToken, getAccessToken } from './auth';
 export { useGlobalVars, getGlobalVars, setGlobalVars, removeGlobalVars } from './Global';
-export type { DataProviderAdapter, RecordProps, RecordArray, DatabaseOptions, DBConfig, ReadOptions, WhereClause, OrderClause, Condition } from './providers/data/DataProvider';
+export type { DataProviderAdapter, FieldValue, RecordProps, RecordArray, DatabaseOptions, DBConfig, ReadOptions, WhereClause, OrderClause, Condition } from './providers/data/DataProvider';
 export type { OrderConfig, OrderDirection } from './libs/order';
 export { Order } from './libs/order';
+export { PromptUtils } from './libs/promptUtils';
+export type { PromptCommand, PromptAction, PromptStatusItem, PromptRunStats } from './components/widgets/Prompt';
 export type { TableHeaderProp, TableReorderHandler, TableReorderMeta, TableSelectionChangeHandler, TableSelectionState } from './components/ui/Table';
-export type { GallerySelectionChangeHandler, GallerySelectionState } from './components/ui/Gallery';
-export type { GridAction, GridActions, GridAfterActionArgs, GridAfterActionHandler, GridArrayProps, GridColumn, GridCoreProps, GridDBPath, GridDBQuery, GridDBProps, GridFooterContext, GridFormContext, GridGalleryViewProps, GridHeaderContext, GridLayout, GridMutationDeleteArgs, GridMutationDeleteHandler, GridMutationSaveArgs, GridMutationSaveHandler, GridReorderHandler, GridReorderMeta, GridRecordKey, GridProps, GridSelectionChangeHandler, GridSelectionMode, GridSelectionState, GridSticky, GridTableViewProps, } from './components/widgets/Grid';
+export type { GalleryRecord, GallerySelectionChangeHandler, GallerySelectionState } from './components/ui/Gallery';
+export type { GridAction, GridActions, GridAfterActionArgs, GridAfterActionHandler, GridArrayProps, GridColumn, GridCoreProps, GridDBPath, GridDBQuery, GridDBProps, GridFooterContext, GridFormContext, GridGalleryViewProps, GridHeaderContext, GridLayout, GridMutationDeleteArgs, GridMutationDeleteHandler, GridMutationSaveArgs, GridMutationSaveHandler, GridReorderHandler, GridReorderMeta, GridRecordKey, GridProps, GridSelectionChangeHandler, GridSelectionMode, GridSelectionState, GridSticky, GridTableViewProps, GridCellContext, } from './components/widgets/Grid';
 export type { ProviderConfigurable, ProviderConfigurationState } from './providers/ProviderConfiguration';
 export { getProviderConfigurationState } from './providers/ProviderConfiguration';
+export type { ProviderAdapterMap, ProviderService, SetProviderFn, ProviderRegistrySnapshot } from './providers/ProviderRegistryContext';
+export { useSetProvider, useProvider } from './providers/ProviderRegistryContext';
+export type { ProviderSessionCredential, ProviderSessionAssignment, ProviderSessionResponse, ProviderSessionFactory, SwitchProviderSessionFn, ProviderSessionSwitchOptions, ProviderSessionSwitchResult } from './providers/ProviderSession';
+export { useProviderSession, registerProviderSessionFactory } from './providers/ProviderSession';
+export type { ApiProviderAdapter, ApiProviderRequest } from './providers/api/ApiProvider';
+export { useApiProvider } from './providers/api/ApiProvider';
+export type { DirectApiProviderConfig } from './providers/api/direct';
+export { DirectApiProviderAdapter } from './providers/api/direct';
+export { MockApiProviderAdapter } from './providers/api/mock';
+export type { FirebaseApiProviderConfig } from './providers/api/firebase';
+export { FirebaseApiProviderAdapter } from './providers/api/firebase';
+export type { SupabaseApiProviderConfig } from './providers/api/supabase';
+export { SupabaseApiProviderAdapter } from './providers/api/supabase';
 export type { MotionEffect, MotionReference, MotionRegistry, MotionStyle, MotionTransition, ReducedMotionMode, ResolvedMotionEffect } from './motion';
 export { createMotionTransition, resolveMotionEffect, useEnterMotion, useMotionEffect, useMotionState, usePressMotion } from './motion';
 export { FirebaseDataProvider } from './providers/data/firebase';
+export { FirestoreDataProvider } from './providers/data/firestore';
 export { SupabaseDataProvider } from './providers/data/supabase';
 export { MockDataProvider } from './providers/data/mock';
 export { useDataProvider, DataProvider } from './providers/data/DataProviderContext';
-export type { StorageProviderAdapter } from './providers/storage/StorageProvider';
+export type { StorageProviderAdapter, UploadOptions, StorageOptions, DeleteOptions, MoveOptions, ListOptions, StorageFileInfo, UploadHandle } from './providers/storage/StorageProvider';
 export { FirebaseStorageProvider } from './providers/storage/firebase';
 export { SupabaseStorageProvider } from './providers/storage/supabase';
 export { useStorageProvider, StorageProvider } from './providers/storage/StorageProviderContext';
 export type { AuthProviderAdapter, AuthIntent, AuthSignInOptions, UserProfile } from './providers/auth/AuthProvider';
 export { useAuthProvider, AuthProvider } from './providers/auth/AuthProviderContext';
 export { GoogleAuthProvider } from './providers/auth/google/GoogleAuthProvider';
+export { FirebaseAuthProvider } from './providers/auth/firebase/FirebaseAuthProvider';
+export { SupabaseAuthProvider } from './providers/auth/supabase/SupabaseAuthProvider';
 export { DropboxAuthProvider } from './providers/auth/dropbox/DropboxAuthProvider';
+export type { CredentialsAdapter } from './providers/credentials/CredentialsProvider';
+export { useCredentialsProvider } from './providers/credentials/CredentialsProviderContext';
+export { GoogleServiceAccountProvider } from './providers/credentials/google/GoogleServiceAccountProvider';
 export type { EmailProviderAdapter, EmailSendParams } from './providers/email/EmailProvider';
 export type { IconProviderAdapter, IconComponentProps } from './providers/icon/IconProvider';
 export { LucideIconProvider } from './providers/icon/LucideIconProvider';
@@ -40,16 +66,15 @@ export { IconProvider, useIconProvider, useIconController } from './providers/ic
 export type { AppIconProviderConfig, IconController } from './providers/icon/IconProviderContext';
 export { useEmailProvider, EmailProvider } from './providers/email/EmailProviderContext';
 export { GmailEmailProvider } from './providers/email/google/GmailEmailProvider';
-export type { AIFetchConfig } from './providers/ai';
-export { getAIProviderConfigurationState } from './providers/ai';
+export type { AIRequestOptions, AIAttachment, AIProviderAdapter, AIKeyValidationResult, AIModelDescriptor, AIProviderCapabilities, AIModelCatalog } from './providers/ai';
+export { createAIProviderRegistry, getAIModelCatalog, formatAIModelRef, parseAIModelRef } from './providers/ai';
+export { useAIProvider, useAIProviderRegistry, AIProvider } from './providers/ai/AIProviderContext';
+export { proxyFetch, useProxy, configureProxy, isProxyEnabled } from './providers/proxy';
 export { googleGetAccessToken } from './providers/auth/google/GoogleAuth';
 export { sendEmail } from './providers/email/google/email';
 export { getKeywordIdeas } from './providers/seo/google/keyword';
 export { getGoogleTrendsData, getGoogleTrendsRelated } from './providers/seo/google/trend';
-export { default as db } from './providers/data/firebase';
-export { default as storage } from './providers/storage/firebase';
 export { dropBox, useDropBoxConnect, DropBoxConnectButton } from './providers/storage/dropbox';
-export { AI } from './providers/ai';
 export { default as scrape } from './providers/scrape';
 export * from './components';
 export * from './libs';

package/dist/types/src/libs/converter.d.ts

@@ -10,9 +10,9 @@ interface ConverterCore {
     subStringCount: (str: string, subStr: string) => number;
 }
 interface Converter extends ConverterCore {
-    parse: (values: Record<string, any>, pattern: string, target?: {
+    parse: (values: Record<string, unknown>, pattern: string, target?: {
         key: string;
-        value: any;
+        value: Record<string, unknown>;
         hideEmpty: boolean;
     }) => string;
     truncate: (str: string, length?: number) => string;
@@ -21,8 +21,8 @@ interface Converter extends ConverterCore {
     padLeft: (str: string, length: number, char?: string, regex?: RegExp) => string;
     padRight: (str: string, length: number, char?: string, regex?: RegExp) => string;
     toQueryString: (params: Record<string, string>, startWith?: string, fill?: string) => string;
-    fillObject: <T>(obj: Record<string, T>, value?: any) => Record<string, any>;
-    [key: string]: ConverterCore[keyof ConverterCore] | any;
+    fillObject: (obj: Record<string, unknown>, value?: unknown) => Record<string, unknown>;
+    [key: string]: unknown;
 }
 export declare const converter: Converter;
 export {};

package/dist/types/src/libs/editorHeight.d.ts

@@ -0,0 +1,12 @@
+export interface EditorHeightOptions {
+    minHeight?: number;
+    maxHeight?: number;
+    paddingOffset?: number;
+}
+export interface EditorHeightResult {
+    adjustedMinHeight: number;
+    wrapperStyle: React.CSSProperties;
+    resolvedMinHeight: number;
+    resolvedMaxHeight: number | undefined;
+}
+export declare function useEditorHeight({ minHeight, maxHeight, paddingOffset }: EditorHeightOptions): EditorHeightResult;

package/dist/types/src/libs/fetch.d.ts

@@ -1,9 +1,9 @@
 interface FetchOptions {
     method?: "GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "PATCH";
     headers?: Record<string, string>;
-    body?: Record<string, any> | string;
+    body?: Record<string, unknown> | string;
 }
-export declare function fetchRest(url: string, options?: FetchOptions | null): Promise<any>;
-export declare function fetchJson(url: string, options?: FetchOptions | null): Promise<any>;
-export declare function fetchWithRetry(url: string, options?: RequestInit, maxRetries?: number, statusNoRetry?: number[]): Promise<any | Response>;
+export declare function fetchRest(url: string, options?: FetchOptions | null, fetchFn?: typeof fetch): Promise<any>;
+export declare function fetchJson(url: string, options?: FetchOptions | null, fetchFn?: typeof fetch): Promise<any>;
+export declare function fetchWithRetry(url: string, options?: RequestInit, maxRetries?: number, statusNoRetry?: number[], fetchFn?: typeof fetch): Promise<any | Response>;
 export {};

package/dist/types/src/libs/imageBuilder.d.ts

@@ -1,18 +1,22 @@
 /**
- * imageBuilder — pure utility for generating SEO/performance-optimised <img> tags
- * with srcset support. Does NOT resize images; assumes variant files already exist.
+ * imageBuilder - pure utility for generating SEO/performance-optimised <img> tags
+ * with srcset support.
  *
- * Two srcset modes:
- *   density — fixed-size images (logos, avatars): 1x / 2x / 3x descriptors
- *             naming: image.jpg → image@2x.jpg, image@3x.jpg
- *   width   — responsive/fluid images (hero, content): width descriptors + sizes
- *             naming: image.jpg → image-400w.jpg, image-800w.jpg …
+ * Three srcset modes:
+ *   density  - fixed-size images (logos, avatars): 1x / 2x / 3x descriptors
+ *              naming: image.jpg → image@2x.jpg, image@3x.jpg
+ *   width    - responsive/fluid images (hero, content): width descriptors + sizes
+ *              naming: image.jpg → image-400w.jpg, image-800w.jpg ...
+ *   explicit - variants already in hand (data URIs or uploaded URLs); no naming assumptions
+ *
+ * resizeVariants() generates width-based variants client-side via canvas (browser only).
+ * Pair it with explicit mode to go from a single src to a full srcset without a server.
  */
 export type ImgFit = 'cover' | 'contain' | 'fill' | 'scale-down' | 'none';
 export interface ImageBuilderConfig {
     /** URL, relative path, or data URI of the source image (used as src and as the 1x/base variant in srcset). */
     src: string;
-    /** Alt text — required for SEO and accessibility. */
+    /** Alt text - required for SEO and accessibility. */
     alt: string;
     title?: string;
     /** Intrinsic display width in px. Prevents CLS (Core Web Vitals). */
@@ -23,7 +27,7 @@ export interface ImageBuilderConfig {
     position?: string;
     /**
      * loading="lazy" for below-the-fold images.
-     * Do NOT use on LCP images — use priority=true instead.
+     * Do NOT use on LCP images - use priority=true instead.
      * Default: 'lazy'.
      */
     loading?: 'lazy' | 'eager';
@@ -32,7 +36,7 @@ export interface ImageBuilderConfig {
      * Sets fetchpriority="high" and loading="eager". Overrides `loading`.
      */
     priority?: boolean;
-    /** Default: 'async' — frees the main thread from image decoding. */
+    /** Default: 'async' - frees the main thread from image decoding. */
     decoding?: 'async' | 'sync' | 'auto';
     className?: string;
     crossorigin?: 'anonymous' | 'use-credentials';
@@ -61,13 +65,37 @@ export interface SrcsetWidthConfig {
      */
     suffix?: (width: number) => string;
     /**
-     * CSS sizes attribute — tells the browser how wide the image renders at each breakpoint.
+     * CSS sizes attribute - tells the browser how wide the image renders at each breakpoint.
      * Required for width-mode srcset to work correctly.
      * Example: '(max-width: 640px) 100vw, (max-width: 1024px) 50vw, 33vw'
      */
     sizes?: string;
 }
-export type SrcsetConfig = SrcsetDensityConfig | SrcsetWidthConfig;
+/**
+ * Explicit srcset: variants are already in hand (uploaded URLs or data URIs).
+ * No naming conventions assumed — each entry carries its own src.
+ * Use together with resizeVariants() for fully client-side srcset generation.
+ */
+export interface SrcsetExplicitConfig {
+    mode: 'explicit';
+    /**
+     * Each variant must carry either a `width` (w descriptor) or a `density` (x descriptor).
+     * Mix of both in the same srcset is invalid per spec — pick one.
+     */
+    variants: Array<{
+        src: string;
+        width: number;
+    } | {
+        src: string;
+        density: number;
+    }>;
+    /**
+     * CSS sizes attribute. Only meaningful when variants use width descriptors.
+     * Example: '(max-width: 640px) 100vw, 800px'
+     */
+    sizes?: string;
+}
+export type SrcsetConfig = SrcsetDensityConfig | SrcsetWidthConfig | SrcsetExplicitConfig;
 /** JSON-serialisable representation of all <img> attributes. */
 export interface ImageParams {
     src: string;
@@ -88,14 +116,13 @@ export interface ImageParams {
 export interface UseImageResult {
     /** Generates the <img> HTML string with all SEO/performance attributes. */
     toHtml: (srcset?: SrcsetConfig) => string;
-    /** Generates a JSON string of all img attributes — for CMS, SSR or metadata. */
+    /** Generates a JSON string of all img attributes - for CMS, SSR or metadata. */
     toJson: (srcset?: SrcsetConfig) => string;
     /** Returns the raw ImageParams object for custom serialisation. */
     params: (srcset?: SrcsetConfig) => ImageParams;
 }
 /**
  * Returns toHtml / toJson / params helpers bound to the given image config.
- * Does NOT resize images — assumes variant files already exist on the server.
  *
  * @example
  * const img = useImage({ src: 'hero.jpg', alt: 'Hero', width: 800, height: 450, priority: true })
@@ -106,7 +133,29 @@ export interface UseImageResult {
  * // Fixed-size HTML with density srcset (files: hero.jpg, hero@2x.jpg, hero@3x.jpg)
  * img.toHtml({ mode: 'density', densities: [1, 2, 3] })
  *
+ * // Explicit srcset from resizeVariants() or uploaded URLs — no naming assumptions
+ * const variants = await resizeVariants('photo.jpg', [400, 800])
+ * img.toHtml({ mode: 'explicit', variants, sizes: '(max-width: 640px) 100vw, 800px' })
+ *
  * // JSON params for CMS or SSR
  * img.toJson({ mode: 'width', widths: [400, 800, 1200], sizes: '100vw' })
  */
 export declare function useImage(config: ImageBuilderConfig): UseImageResult;
+/**
+ * Resizes a source image to multiple widths proportionally using canvas (browser only).
+ * Widths larger than the natural image width are skipped — the original is used as the
+ * largest variant instead, avoiding pointless upscaling.
+ *
+ * Returns an array of { src: dataURI, width } ready to pass as `variants` in explicit mode.
+ * After uploading each variant to storage, swap the data URIs for the resulting URLs.
+ *
+ * @example
+ * const variants = await resizeVariants(file, [400, 800, 1200])
+ * // upload variants to storage if needed, then:
+ * useImage({ src: variants.at(-1)!.src, alt: 'Photo' })
+ *   .toHtml({ mode: 'explicit', variants, sizes: '(max-width: 640px) 100vw, 800px' })
+ */
+export declare function resizeVariants(src: string, widths: number[]): Promise<Array<{
+    src: string;
+    width: number;
+}>>;

package/dist/types/src/libs/imageVariants.d.ts

@@ -0,0 +1,35 @@
+import type { StorageProviderAdapter } from '../providers/storage/StorageProvider';
+export interface ImageVariant {
+    width: number;
+    /** Canvas-generated data URI — safe to pass to storage.upload(). */
+    dataUri: string;
+    /** Blob URL — comma-safe for srcset strings (data URIs contain commas). */
+    localUrl: string;
+}
+/**
+ * Resize an image to each requested width, returning blob URLs (no original).
+ * Widths ≥ natural image width are silently skipped (no upscaling).
+ * Also returns naturalWidth so the caller can add the original to srcset.
+ */
+export declare function resizeToVariants(src: string, widths: number[]): Promise<{
+    variants: ImageVariant[];
+    naturalWidth: number;
+}>;
+/**
+ * Upload pre-generated variants to storage, replacing local URLs with remote ones.
+ * Each variant is stored as `<uploadPath>/<baseName>_<width>w.<ext>`.
+ * Falls back to the variant's local blob URL if upload fails.
+ */
+export declare function uploadVariants(variants: ImageVariant[], storage: StorageProviderAdapter, uploadPath: string, fileName: string): Promise<Array<{
+    url: string;
+    width: number;
+}>>;
+/** Build a width-based srcset string from `{url, width}` entries. */
+export declare function buildSrcset(entries: Array<{
+    url: string;
+    width: number;
+}>): string;
+/** Extract the filename from a URL path, data URI, or blob URL. */
+export declare function fileNameFromUrl(url: string): string;
+/** Derive a human-readable alt text from a filename (strips extension, replaces separators). */
+export declare function altFromFileName(fileName: string): string;

package/dist/types/src/libs/index.d.ts

@@ -1,8 +1,5 @@
-export { default as db } from './database';
-export { default as storage } from './storage';
 export { default as path } from './path';
-export { default as log } from './log';
-export { default as seo } from './seo';
+export * from './editorHeight';
 export * from './converter';
 export * from './sanitizer';
 export * from './email';

package/dist/types/src/libs/promptUtils.d.ts

@@ -0,0 +1,24 @@
+import { type AIAttachment } from '../providers/ai/AIProvider';
+export declare const PromptUtils: {
+    /**
+     * Rough token count: ~4 chars per token (heuristic, no tiktoken needed).
+     */
+    countTokens(text: string): number;
+    /**
+     * Returns the known context window for the model, or null if unknown.
+     */
+    modelContextWindow(modelRef: string): number | null;
+    /**
+     * Percentage of the model's context window used by `tokens`.
+     * Returns 0 if the model context window is unknown.
+     */
+    contextPercent(tokens: number, modelRef: string): number;
+    /**
+     * Estimated cost in USD. Returns NaN if pricing is unavailable for the model.
+     */
+    estimateCost(tokensIn: number, tokensOut: number, modelRef: string): number;
+    /**
+     * Convert a browser File into the transport-ready attachment shape used by AI providers.
+     */
+    fileToAttachment(file: File): Promise<AIAttachment>;
+};

package/dist/types/src/libs/sanitizer.d.ts

@@ -28,8 +28,8 @@ export declare class Sanitizer {
     private config;
     private matches;
     constructor(config?: SanitizerConfig, matches?: SanitizerMatch[]);
-    apply(ruleName: keyof SanitizerConfig, value: any, autoCast?: boolean): any;
-    applyMatches<T extends Record<string, any>>(obj: T, autoCast?: boolean): T;
+    apply(ruleName: keyof SanitizerConfig, value: unknown, autoCast?: boolean): unknown;
+    applyMatches<T extends Record<string, unknown>>(obj: T, autoCast?: boolean): T;
     getOptions(): Record<string, string>[];
     addRule(name: keyof SanitizerConfig, rule: SanitizerRule): void;
     addMatch(pattern: string, use: keyof SanitizerConfig): void;

package/dist/types/src/libs/utils.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { RecordProps } from '../providers/data/DataProvider';
-export declare const decodeJWT: (token: string) => any;
+export declare const decodeJWT: (token: string) => unknown;
 export declare const copyToClipboard: (text: string) => void;
 export declare const trimPath: (path?: string) => string;
 export declare const normalizePath: (path?: string) => string;
@@ -8,7 +8,6 @@ export declare const trimSlash: (path?: string | number | boolean) => string;
 export declare const normalizeKey: (key?: string | number | boolean) => string;
 export declare const dirname: (path: string) => string;
 export declare function sleep(ms: number): Promise<void>;
-export declare function proxy(url: string, format?: string): string;
 export declare function generateUniqueId(name?: null): string;
 export declare function eventClosest(e: Event, tagName: string): HTMLElement | null;
 export declare const substrCount: (str: string, sub: string) => number;
@@ -24,23 +23,23 @@ export declare const crc32: (str: string) => number;
 export declare const ucfirst: (str?: string) => string;
 export declare const loadScripts: (scriptData: Array<{
     src: string;
-    [key: string]: any;
+    [key: string]: unknown;
 }>) => void;
 export declare const intersectObjects: (obj1: {
-    [key: string]: any;
+    [key: string]: unknown;
 }, obj2: {
-    [key: string]: any;
+    [key: string]: unknown;
 }) => {
-    [key: string]: any;
+    [key: string]: unknown;
 };
 export declare const replaceVariables: (pattern: string, metaObject: {
     [key: string]: string | undefined;
 }) => string;
 export declare const arrayUnique: <T>(array: T[], key?: keyof T) => T[];
-export declare const isEmpty: (data: any) => boolean;
+export declare const isEmpty: (data: unknown) => boolean;
 export declare function safeClone<T>(obj: T): T;
 export declare function base64Encode(input: string | Buffer | ArrayBuffer): string;
-export declare function arraysEqual(a: any[], b: any[]): boolean;
+export declare function arraysEqual(a: unknown[], b: unknown[]): boolean;
 export declare function sanitizeKey(str: string): string;
 /**
  * Checks if the event target or any of its parent elements is an interactive element
@@ -52,6 +51,6 @@ export declare function isInteractiveElement(e: Event | React.MouseEvent, exclud
 export declare const render2Base64: (arrayBuffer: ArrayBuffer) => string;
 export declare const base64ToBlob: (base64: string, type: string) => Blob | undefined;
 export declare const base64ToUrl: (base64: string, type: string) => string | undefined;
-export declare const getRecordValue: (record?: RecordProps, name?: string) => any;
+export declare const getRecordValue: (record?: RecordProps, name?: string) => unknown;
 export declare const cleanRecord: (record: RecordProps | undefined) => RecordProps;
-export declare const smartTypeCast: (value: any) => string | number | boolean | null | undefined;
+export declare const smartTypeCast: (value: unknown) => string | number | boolean | null | undefined;

package/dist/types/src/pages/index.d.ts

@@ -1,3 +1 @@
 export { default as PageUsers } from './Users';
-export { default as PageHelper } from './Helper';
-export { default as PageBlog } from './Blog';

package/dist/types/src/providers/ProviderConfiguration.d.ts

@@ -6,6 +6,12 @@ export interface ProviderConfigurationState {
 export interface ProviderConfigurable {
     isConfigured?(): boolean;
     getConfigurationState?(): ProviderConfigurationState;
+    /**
+     * Optional teardown hook. Called by setProvider() before an adapter is replaced
+     * in the registry — e.g. unsubscribe realtime listeners, sign out, close connections.
+     * Never called on unmount; only on explicit replacement.
+     */
+    dispose?(): Promise<void> | void;
 }
 export declare const getMissingKeys: (config: Record<string, unknown> | undefined, keys: string[], prefix?: string) => string[];
 export declare const createConfigurationState: (provider: string, missingKeys: string[]) => ProviderConfigurationState;

package/dist/types/src/providers/ProviderRegistryContext.d.ts

@@ -0,0 +1,51 @@
+import React from 'react';
+import type { DataProviderAdapter } from './data/DataProvider';
+import type { StorageProviderAdapter } from './storage/StorageProvider';
+import type { AuthProviderAdapter } from './auth/AuthProvider';
+import type { EmailProviderAdapter } from './email/EmailProvider';
+import type { AIProviderAdapter } from './ai/AIProvider';
+import type { CredentialsAdapter } from './credentials/CredentialsProvider';
+export type ProviderAdapterMap = {
+    data: DataProviderAdapter;
+    storage: StorageProviderAdapter;
+    auth: AuthProviderAdapter;
+    email: EmailProviderAdapter;
+    ai: AIProviderAdapter;
+    credentials: CredentialsAdapter;
+};
+/** The 6 categories the framework ships out of the box. Any other string is a valid category too — see customCategories on <App>. */
+export type ProviderService = keyof ProviderAdapterMap;
+export type ProviderRegistrySnapshot = Record<string, {
+    registry: Record<string, unknown>;
+    defaultKey: string;
+}>;
+/**
+ * Replaces a single named adapter in a provider registry at runtime, in ANY
+ * category — one of the 6 built-in ones (typed) or an arbitrary custom one a
+ * vertical registered (string). Calls the previous adapter's dispose() (if
+ * defined) before swapping it in, then propagates the new registry to every
+ * useXProvider()/useProvider() consumer. If `category` didn't exist yet, it's
+ * created — categories can be registered after bootstrap, not only via <App providers>.
+ */
+export type SetProviderFn = {
+    <S extends ProviderService>(category: S, key: string, adapter: ProviderAdapterMap[S]): Promise<void>;
+    (category: string, key: string, adapter: unknown): Promise<void>;
+};
+type ProviderRegistryContextValue = {
+    registries: ProviderRegistrySnapshot;
+    setProvider: SetProviderFn;
+};
+declare const ProviderRegistryContext: React.Context<ProviderRegistryContextValue | null>;
+export declare const ProviderRegistryProvider: ({ registries, setProvider, children, }: ProviderRegistryContextValue & {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+/** Imperatively swap a provider adapter at runtime (e.g. reconnect data/storage to a different backend). */
+export declare const useSetProvider: () => SetProviderFn;
+/**
+ * Generic read access to any provider category — built-in or custom. Prefer the
+ * typed useDataProvider()/useStorageProvider()/... for the 6 built-ins; reach for
+ * this when consuming a category the framework doesn't know about (registered via
+ * providers.customCategories or a runtime setProvider() call).
+ */
+export declare const useProvider: <T = unknown>(category: string, key?: string) => T;
+export default ProviderRegistryContext;

package/dist/types/src/providers/ProviderSession.d.ts

@@ -0,0 +1,68 @@
+import type { SetProviderFn } from './ProviderRegistryContext';
+/**
+ * Generic multi-backend session switch — no domain vocabulary (tenant, workspace, ...).
+ * Given an endpoint that returns which backend project to connect to (per category —
+ * data, storage, or any custom category a vertical registered) and a scoped credential
+ * for it, resolves the right adapter and swaps it in via setProvider().
+ *
+ * A vertical app (e.g. a CMS with tenants) wraps this in its own thin, named provider
+ * (e.g. TenantProvider, mounted via <App contextProviders>) that knows what a "session"
+ * means for that app — this hook only knows how to connect to a backend and get out
+ * of the way.
+ */
+export type ProviderSessionCredential = {
+    type: string;
+} & Record<string, unknown>;
+export type ProviderSessionAssignment = {
+    /**
+     * Matched against the factory registry below — 'firebase'/'supabase'/'mock' are
+     * built in, a vertical can register more with registerProviderSessionFactory().
+     * An assignment whose (category, type) has no registered factory is discarded,
+     * not an error — a session response can describe categories/types this particular
+     * app build doesn't know about without breaking the switch for the ones it does.
+     */
+    type: string;
+    /** Client-safe config for this provider's project — never a secret. */
+    publicConfig: Record<string, unknown>;
+    /** Scoped, short-lived credential resolved server-side. Absent = anonymous/public access. */
+    credential?: ProviderSessionCredential;
+};
+/** category (data, storage, or any custom one) → assignment. Open-ended on purpose. */
+export type ProviderSessionResponse = {
+    providers: Record<string, ProviderSessionAssignment>;
+};
+export type ProviderSessionFactory = (assignment: ProviderSessionAssignment) => unknown | Promise<unknown>;
+/**
+ * Registers how to turn a ProviderSessionAssignment into a live adapter for a given
+ * (category, type) pair. Callable anytime — at module load, or later once a feature
+ * that needs it is loaded — not only at <App> bootstrap.
+ */
+export declare const registerProviderSessionFactory: (category: string, type: string, factory: ProviderSessionFactory) => void;
+export type ProviderSessionSwitchOptions = {
+    fetchOptions?: RequestInit;
+    /**
+     * Inspect or transform the raw response before it's applied — e.g. inject an extra
+     * category, filter one out, forward it to an audit log. Whatever this returns
+     * (defaults to the untouched response) is what actually gets applied.
+     */
+    onResponse?: (response: ProviderSessionResponse) => ProviderSessionResponse | Promise<ProviderSessionResponse>;
+};
+/** Which (category, type) pairs were actually applied vs had no matching factory. */
+export type ProviderSessionSwitchResult = {
+    applied: string[];
+    skipped: {
+        category: string;
+        type: string;
+    }[];
+};
+/**
+ * Either a URL to fetch (real backend) or a resolver function that produces the same
+ * response shape directly (e.g. a mock backend, or any non-HTTP source). Everything
+ * downstream of "here's the response body" is identical either way — only the transport
+ * differs, so swapping a mock resolver for a real endpoint later touches no other code.
+ */
+export type SwitchProviderSessionFn = (source: string | (() => Promise<ProviderSessionResponse>), options?: ProviderSessionSwitchOptions) => Promise<ProviderSessionSwitchResult>;
+export declare const useProviderSession: () => {
+    switchSession: SwitchProviderSessionFn;
+    setProvider: SetProviderFn;
+};

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

@@ -0,0 +1,57 @@
+import type { PromptVariables } from '../../conf/Prompt';
+import type { ProviderConfigurable } from '../ProviderConfiguration';
+export interface AIModelDescriptor {
+    id: string;
+    provider: string;
+    model: string;
+    label: string;
+    deprecated?: boolean;
+}
+export interface AIProviderCapabilities {
+    models: AIModelDescriptor[];
+    supportsTemperature?: boolean;
+    supportsVision?: boolean;
+    supportsDocuments?: boolean;
+}
+export interface AIAttachment {
+    mimeType: string;
+    base64: string;
+    name?: string;
+}
+export interface AIRequestOptions {
+    language?: string;
+    voice?: string;
+    style?: string;
+    role?: string;
+    model?: string;
+    temperature?: number;
+    attachments?: AIAttachment[];
+}
+export interface AICompleteRequest extends AIRequestOptions {
+    prompt: string;
+    data?: PromptVariables;
+}
+export interface AIKeyValidationResult {
+    valid: boolean;
+    /** Human-readable error from the provider API (e.g. "Incorrect API key provided"). */
+    error?: string;
+    /** URL to the provider's API key management page, for showing in UI. */
+    dashboardUrl?: string;
+}
+export interface AIProviderAdapter extends ProviderConfigurable {
+    id: string;
+    label: string;
+    defaultModel: string;
+    /** URL to the provider's API key management page. */
+    dashboardUrl?: string;
+    getCapabilities(forceRefresh?: boolean): Promise<AIProviderCapabilities>;
+    complete(request: AICompleteRequest): Promise<string | null>;
+    /** Makes a live API call to verify the key is accepted. Never uses cache. */
+    validateApiKey(): Promise<AIKeyValidationResult>;
+}
+export interface AIModelRef {
+    provider: string;
+    model: string;
+}
+export declare const formatAIModelRef: (provider: string, model: string) => string;
+export declare const parseAIModelRef: (value?: string | null) => AIModelRef | null;

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

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { AIProviderAdapter } from './AIProvider';
+type AIProviderContextValue = {
+    registry: Record<string, AIProviderAdapter>;
+    defaultKey: string;
+};
+declare const AIProviderContext: React.Context<AIProviderContextValue | null>;
+export declare const AIProvider: ({ registry, defaultKey, children, }: AIProviderContextValue & {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+export declare const useAIProvider: (name?: string) => AIProviderAdapter | null;
+export declare const useAIProviderRegistry: () => AIProviderContextValue | null;
+export default AIProviderContext;

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

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

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

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