@wakastellar/ui 0.1.10 → 0.1.12

package/dist/blocks/sidebar/index.d.ts

@@ -91,6 +91,8 @@ export interface WakaSidebarProps {
     footer?: React.ReactNode;
     /** Header personnalisé (après le logo) */
     header?: React.ReactNode;
+    /** Mode de positionnement : "fixed" pour app layout, "relative" pour preview/demo */
+    position?: "fixed" | "relative";
 }
 /**
  * WakaSidebar - Sidebar personnalisable avec menu hamburger responsive
@@ -119,7 +121,7 @@ export interface WakaSidebarProps {
  * />
  * ```
  */
-export declare function WakaSidebar({ logo, menu, user, width, mobileBreakpoint, open, onOpenChange, className, contentClassName, backgroundColor, textColor, activeColor, hoverColor, userPosition, showHamburger, hamburgerPosition, renderItem, footer, header, }: WakaSidebarProps): import("react/jsx-runtime").JSX.Element;
+export declare function WakaSidebar({ logo, menu, user, width, mobileBreakpoint, open, onOpenChange, className, contentClassName, backgroundColor, textColor, activeColor, hoverColor, userPosition, showHamburger, hamburgerPosition, renderItem, footer, header, position, }: WakaSidebarProps): import("react/jsx-runtime").JSX.Element;
 /**
  * Hook pour gérer l'état de la sidebar externalement
  */

package/dist/components/DataTable/DataTableCell.d.ts

@@ -30,5 +30,9 @@ export interface DataTableCellProps<TData extends Record<string, unknown>> {
  * - Cellules groupées
  * - Cellules agrégées
  * - Cellules placeholder
+ *
+ * Optimisé avec React.memo pour éviter les re-renders inutiles
  */
-export declare function DataTableCell<TData extends Record<string, unknown>>({ cell, row, editingRowId, editableColumns, onUpdateField, onStartEdit, onSaveEdit, onCancelEdit, }: DataTableCellProps<TData>): import("react/jsx-runtime").JSX.Element | null;
+declare function DataTableCellInner<TData extends Record<string, unknown>>({ cell, row, editingRowId, editableColumns, onUpdateField, onStartEdit, onSaveEdit, onCancelEdit, }: DataTableCellProps<TData>): import("react/jsx-runtime").JSX.Element | null;
+export declare const DataTableCell: typeof DataTableCellInner;
+export {};

package/dist/components/DataTable/DataTableRow.d.ts

@@ -23,6 +23,8 @@ interface DataTableRowProps<TData> {
  * DataTableRow - Composant pour le rendu d'une ligne standard du DataTable
  *
  * Extrait de DataTableAdvanced pour réduire la complexité
+ * Optimisé avec React.memo pour éviter les re-renders inutiles
  */
-export declare function DataTableRow<TData>({ row, onRowClick, onRowDoubleClick, themeDensityClasses, editState, editActions, edit, }: DataTableRowProps<TData>): import("react/jsx-runtime").JSX.Element;
+declare function DataTableRowInner<TData>({ row, onRowClick, onRowDoubleClick, themeDensityClasses, editState, editActions, edit, }: DataTableRowProps<TData>): import("react/jsx-runtime").JSX.Element;
+export declare const DataTableRow: typeof DataTableRowInner;
 export {};

package/dist/components/DataTable/hooks/useDataTableExport.d.ts

@@ -3,6 +3,10 @@ import { ExportConfig } from '../types';
 import { WakaError } from '../../../utils/error-handling';
 /**
  * Hook pour gérer l'export des données du DataTable
+ *
+ * Optimisé avec Web Workers pour les grandes tables (>1000 lignes)
+ * pour éviter de bloquer l'interface utilisateur.
+ *
  * @template TData - Type des données de la table
  */
 export declare function useDataTableExport<TData extends Record<string, unknown>>({ data, columns, exportConfig, onError, }: {
@@ -14,6 +18,9 @@ export declare function useDataTableExport<TData extends Record<string, unknown>
     exportData: (format: string, customData?: TData[], customFilename?: string) => Promise<void>;
     exportAll: (format: string) => Promise<void>;
     exportSelected: (format: string, selectedData: TData[]) => Promise<void>;
-    supportedFormats: ("json" | "csv" | "xlsx" | "pdf" | "xml")[] | readonly ["csv", "xlsx", "json"];
+    cancelExport: () => void;
+    exportProgress: number;
+    isExporting: boolean;
+    supportedFormats: ("csv" | "xlsx" | "json" | "pdf" | "xml")[] | readonly ["csv", "xlsx", "json"];
     isExportSupported: (format: string) => boolean;
 };

package/dist/components/DataTable/hooks/useDataTableImport.d.ts

@@ -2,6 +2,7 @@ import { ImportConfig } from '../types';
 import { WakaError } from '../../../utils/error-handling';
 /**
  * Hook pour gérer l'import des données dans le DataTable
+ * Supporte le streaming pour les fichiers volumineux
  */
 export declare function useDataTableImport<TData>({ importConfig, onError, }: {
     importConfig?: ImportConfig<TData>;
@@ -9,6 +10,17 @@ export declare function useDataTableImport<TData>({ importConfig, onError, }: {
 }): {
     importData: (file: File) => Promise<TData[]>;
     importWithUI: () => Promise<TData[]>;
+    importDataStreaming: (file: File, options?: {
+        onProgress?: (progress: number) => void;
+        onChunk?: (chunk: TData[], totalProcessed: number) => void;
+    }) => Promise<TData[]>;
+    importWithUIStreaming: (options?: {
+        onProgress?: (progress: number) => void;
+        onChunk?: (chunk: TData[], totalProcessed: number) => void;
+    }) => Promise<TData[]>;
+    cancelImport: () => void;
+    importProgress: number;
+    isImporting: boolean;
     supportedFormats: string[];
     isFormatSupported: (filename: string) => boolean;
 };

package/dist/components/DataTable/workers/exportWorker.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Web Worker pour l'export de grandes tables
+ *
+ * Ce worker gère la conversion de données en différents formats (CSV, JSON, XML)
+ * dans un thread séparé pour éviter de bloquer l'interface utilisateur.
+ *
+ * @example
+ * // Utilisation via le hook useDataTableExport
+ * const { exportDataAsync } = useDataTableExport({ data, columns })
+ * await exportDataAsync('csv') // Utilise automatiquement le worker pour >1000 lignes
+ */
+export interface ExportWorkerMessage {
+    type: 'export';
+    format: 'csv' | 'json' | 'xml';
+    data: Record<string, unknown>[];
+    columns: {
+        key: string;
+        header: string;
+    }[];
+    filename: string;
+}
+export interface ExportWorkerResponse {
+    type: 'success' | 'error' | 'progress';
+    content?: string;
+    blob?: Blob;
+    progress?: number;
+    error?: string;
+}
+export {};

package/dist/components/waka-charts/types.d.ts

@@ -89,9 +89,9 @@ export interface ChartAxisConfig {
     /** Afficher l'axe Y */
     showYAxis?: boolean;
     /** Format de l'axe X */
-    xAxisFormatter?: (value: string | number) => string;
+    xAxisFormatter?: (value: unknown) => string;
     /** Format de l'axe Y */
-    yAxisFormatter?: (value: number) => string;
+    yAxisFormatter?: (value: unknown) => string;
     /** Unité de l'axe Y */
     yAxisUnit?: string;
     /** Domaine de l'axe Y [min, max] */

package/dist/components/waka-theme-manager/index.d.ts

@@ -3,6 +3,9 @@ import * as React from "react";
 declare const themeManagerVariants: (props?: ({
     size?: "base" | "sm" | "lg" | "full" | null | undefined;
 } & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+/**
+ * Interface pour un thème au format simplifié (couleurs directes)
+ */
 export interface TweakCNTheme {
     name: string;
     description?: string;
@@ -36,17 +39,27 @@ export interface TweakCNTheme {
     };
 }
 export interface WakaThemeManagerProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof themeManagerVariants> {
+    /** Callback lors du changement de thème */
     onThemeChange?: (theme: TweakCNTheme) => void;
+    /** Callback lors du chargement d'un thème */
     onThemeLoad?: (theme: TweakCNTheme) => void;
+    /** Callback lors de la sauvegarde d'un thème */
     onThemeSave?: (theme: TweakCNTheme) => void;
+    /** Thème initial */
     initialTheme?: TweakCNTheme;
+    /** Afficher la prévisualisation */
     showPreview?: boolean;
+    /** Afficher l'export */
     showExport?: boolean;
+    /** Afficher l'import */
     showImport?: boolean;
+    /** Autoriser la modification des couleurs */
     allowCustomColors?: boolean;
 }
 /**
- * WakaThemeManager - Gestionnaire complet de thèmes TweakCN
+ * WakaThemeManager - Gestionnaire complet de thèmes
+ *
+ * Supporte le format shadcn/ui registry-item et peut charger des thèmes à la volée.
  *
  * @example
  * ```tsx

package/dist/context/index.d.ts

@@ -1,8 +1,8 @@
 export { ThemeProvider, useTheme } from './theme-provider';
-export type { ThemeContextValue, ThemeProviderProps, ThemeConfig, ThemeS3Config } from './theme-provider';
+export type { ThemeContextValue, ThemeProviderProps, ThemeConfig, ShadcnRegistryItem } from './theme-provider';
 export { ThemeProvider as LegacyThemeProvider, useTheme as useLegacyTheme } from './theme-context';
 export type { ThemeContextValue as LegacyThemeContextValue, ThemeProviderProps as LegacyThemeProviderProps } from './theme-context';
 export { LanguageProvider, useLanguage } from './language-context';
-export type { LanguageConfig, S3Config, LanguageProviderProps, LanguageContextValue } from './language-context';
+export type { LanguageConfig, LanguageProviderProps, LanguageContextValue, I18nTranslations, S3Config, TranslationsJSON } from './language-context';
 export { WakaProvider, useWaka } from './waka-provider';
 export type { WakaProviderConfig, WakaProviderProps } from './waka-provider';

package/dist/context/language-context.d.ts

@@ -3,73 +3,38 @@ import { WakaError } from '../utils/error-handling';
  * @fileoverview Contexte de gestion des langues pour WakaStart UI
  *
  * Ce module fournit un système complet de gestion de l'internationalisation:
- * - Chargement dynamique des traductions depuis S3 ou localement
+ * - Chargement dynamique des traductions depuis URL ou inline JSON
  * - Cache des traductions déjà chargées
  * - Intégration transparente avec i18next
  * - Persistance de la langue dans localStorage
+ * - Chargement à la volée de traductions JSON
  *
  * @module context/language-context
- *
- * @example
- * ```tsx
- * // Configuration avec S3
- * <LanguageProvider
- *   languages={[
- *     { code: "fr", label: "Français", flagEmoji: "🇫🇷" },
- *     { code: "en", label: "English", flagEmoji: "🇬🇧" }
- *   ]}
- *   defaultLanguage="fr"
- *   s3Config={{ baseUrl: "https://cdn.example.com/translations" }}
- * >
- *   <App />
- * </LanguageProvider>
- * ```
  */
 import * as React from "react";
 /**
- * Configuration pour le chargement des traductions depuis S3
- */
-export interface S3Config {
-    /** URL de base du bucket S3 (ex: "https://bucket.s3.region.amazonaws.com") */
-    baseUrl: string;
-    /** Préfixe des fichiers de traduction (ex: "translations/") */
-    prefix?: string;
-    /** Extension des fichiers (défaut: "json") */
-    extension?: string;
-    /** Headers HTTP personnalisés pour les requêtes */
-    headers?: Record<string, string>;
-}
-/**
- * Type pour les traductions JSON inline
- * Structure clé-valeur avec support des namespaces imbriqués
- */
-export type TranslationsJSON = Record<string, string | Record<string, unknown>>;
-/**
- * Configuration d'une langue disponible
+ * Format standard i18n pour les traductions
+ * Compatible avec i18next resource bundles
  *
  * @example
- * ```ts
- * // Avec traductions inline (recommandé pour éviter les dépendances externes)
- * const french: LanguageConfig = {
- *   code: "fr",
- *   label: "Français",
- *   flagEmoji: "🇫🇷",
- *   translations: {
- *     common: {
- *       save: "Enregistrer",
- *       cancel: "Annuler"
- *     }
+ * ```json
+ * {
+ *   "common": {
+ *     "save": "Enregistrer",
+ *     "cancel": "Annuler",
+ *     "confirm": "Confirmer"
+ *   },
+ *   "errors": {
+ *     "required": "Ce champ est requis",
+ *     "invalid_email": "Email invalide"
  *   }
  * }
- *
- * // Sans traductions inline (utilise S3)
- * const english: LanguageConfig = {
- *   code: "en",
- *   label: "English",
- *   flagEmoji: "🇬🇧"
- * }
  * ```
  */
+export type I18nTranslations = Record<string, string | Record<string, unknown>>;
+/**
+ * Configuration d'une langue disponible
+ */
 export interface LanguageConfig {
     /** Code ISO de la langue (ex: "fr", "en", "es") */
     code: string;
@@ -80,11 +45,34 @@ export interface LanguageConfig {
     /** URL de l'image du drapeau (optionnel) */
     flag?: string;
     /**
-     * Traductions inline au format JSON
-     * Si fourni, les traductions sont utilisées directement sans charger depuis S3
+     * Traductions inline au format i18n JSON
+     * Si fourni, les traductions sont utilisées directement
+     */
+    translations?: I18nTranslations;
+    /**
+     * URL pour charger le JSON des traductions (optionnel)
+     * Le JSON doit être au format I18nTranslations
      */
-    translations?: TranslationsJSON;
+    jsonUrl?: string;
 }
+/**
+ * Configuration pour le chargement distant (legacy, utiliser jsonUrl dans LanguageConfig)
+ * @deprecated Utiliser `jsonUrl` dans LanguageConfig à la place
+ */
+export interface S3Config {
+    /** URL de base */
+    baseUrl: string;
+    /** Préfixe des fichiers */
+    prefix?: string;
+    /** Extension des fichiers (défaut: "json") */
+    extension?: string;
+    /** Headers HTTP personnalisés */
+    headers?: Record<string, string>;
+}
+/**
+ * Type pour les traductions JSON (alias pour compatibilité)
+ */
+export type TranslationsJSON = I18nTranslations;
 /**
  * Valeur exposée par le contexte de langue
  */
@@ -99,6 +87,23 @@ export interface LanguageContextValue {
     isLoading: boolean;
     /** Set des codes de langues dont les traductions sont chargées */
     loadedLanguages: Set<string>;
+    /**
+     * Charge des traductions depuis un objet JSON à la volée
+     * @param langCode - Code de la langue
+     * @param translations - Traductions au format i18n JSON
+     * @param apply - Si true, change aussi la langue courante (défaut: true)
+     */
+    loadLanguageFromJSON: (langCode: string, translations: I18nTranslations, apply?: boolean) => Promise<void>;
+    /**
+     * Ajoute/met à jour une langue dans la liste
+     * @param config - Configuration de la langue
+     */
+    addLanguage: (config: LanguageConfig) => void;
+    /**
+     * Recharge les traductions d'une langue depuis son URL
+     * @param langCode - Code de la langue à recharger
+     */
+    reloadLanguage: (langCode: string) => Promise<void>;
 }
 /**
  * Props du provider de langue
@@ -110,30 +115,42 @@ export interface LanguageProviderProps {
     languages: LanguageConfig[];
     /** Code de la langue par défaut (défaut: "fr") */
     defaultLanguage?: string;
-    /** Configuration S3 pour le chargement distant des traductions */
+    /**
+     * Configuration S3 (legacy)
+     * @deprecated Utiliser `jsonUrl` dans chaque LanguageConfig à la place
+     */
     s3Config?: S3Config;
     /** Callback appelé après chaque changement de langue réussi */
     onLanguageChange?: (code: string) => void;
-    /** Callback en cas d'erreur (chargement traductions, parsing, etc.) */
+    /** Callback en cas d'erreur */
     onError?: (error: WakaError) => void;
+    /** Headers personnalisés pour les requêtes fetch */
+    fetchHeaders?: Record<string, string>;
+    /** Timeout en millisecondes pour les requêtes fetch (défaut: 10000) */
+    fetchTimeout?: number;
 }
 /**
- * Provider pour la gestion de l'internationalisation
+ * LanguageProvider
  *
- * Gère automatiquement:
- * - Le chargement des traductions depuis inline JSON ou S3
- * - Le cache des traductions déjà chargées
- * - La persistance de la langue dans localStorage
- * - L'intégration avec i18next
+ * Provider pour la gestion de l'internationalisation avec support
+ * du chargement dynamique de traductions JSON.
+ *
+ * Features:
+ * - Traductions inline ou chargées depuis URL
+ * - Chargement à la volée via loadLanguageFromJSON()
+ * - Cache des traductions déjà chargées
+ * - Intégration avec i18next
+ * - Persistance dans localStorage
  *
  * @example
  * ```tsx
- * // Configuration avec traductions inline (sans dépendance externe)
+ * // Configuration avec traductions inline
  * <LanguageProvider
  *   languages={[
  *     {
  *       code: "fr",
  *       label: "Français",
+ *       flagEmoji: "🇫🇷",
  *       translations: {
  *         common: { save: "Enregistrer", cancel: "Annuler" }
  *       }
@@ -141,36 +158,22 @@ export interface LanguageProviderProps {
  *     {
  *       code: "en",
  *       label: "English",
- *       translations: {
- *         common: { save: "Save", cancel: "Cancel" }
- *       }
+ *       flagEmoji: "🇬🇧",
+ *       jsonUrl: "https://example.com/i18n/en.json"
  *     }
  *   ]}
- * >
- *   <App />
- * </LanguageProvider>
- *
- * // Avec S3 pour chargement distant
- * <LanguageProvider
- *   languages={languages}
- *   s3Config={{ baseUrl: "https://cdn.example.com/i18n" }}
- *   onLanguageChange={(lang) => analytics.track("language_changed", { lang })}
+ *   defaultLanguage="fr"
  * >
  *   <App />
  * </LanguageProvider>
  * ```
  */
-export declare function LanguageProvider({ children, languages, defaultLanguage, s3Config, onLanguageChange, onError, }: LanguageProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function LanguageProvider({ children, languages: initialLanguages, defaultLanguage, s3Config, onLanguageChange, onError, fetchHeaders, fetchTimeout, }: LanguageProviderProps): import("react/jsx-runtime").JSX.Element;
 /**
  * Hook pour accéder au contexte de langue
  *
- * Fournit la langue courante, les langues disponibles et la fonction
- * de changement de langue.
- *
  * @throws {Error} Si utilisé en dehors d'un LanguageProvider
  *
- * @returns Valeur du contexte de langue
- *
  * @example
  * ```tsx
  * function LanguageSwitcher() {
@@ -190,6 +193,19 @@ export declare function LanguageProvider({ children, languages, defaultLanguage,
  *     </select>
  *   )
  * }
+ *
+ * // Charger des traductions à la volée
+ * function LoadCustomTranslations() {
+ *   const { loadLanguageFromJSON } = useLanguage()
+ *
+ *   const handleLoad = async () => {
+ *     await loadLanguageFromJSON("custom", {
+ *       common: { hello: "Bonjour" }
+ *     })
+ *   }
+ *
+ *   return <button onClick={handleLoad}>Load Custom</button>
+ * }
  * ```
  */
 export declare function useLanguage(): LanguageContextValue;

package/dist/context/theme-context.d.ts

@@ -6,17 +6,18 @@ export interface ThemeContextValue {
     themes: ThemeConfigItem[];
     systemTheme?: string;
     isLoadingThemes?: boolean;
-    themesSource?: "config" | "s3" | "fallback";
+    themesSource?: "config" | "fallback";
 }
 export interface ThemeProviderProps {
     children: React.ReactNode;
     config?: WakaThemeConfig;
 }
 /**
- * Provider de thème pour WakaStart UI
+ * Provider de thème legacy pour WakaStart UI
  *
  * Gère le thème actif, le stockage dans localStorage et la détection du thème système
- * Charge automatiquement les thèmes depuis S3 si non fournis dans la config
+ *
+ * @deprecated Utiliser ThemeProvider de theme-provider.tsx avec support shadcn registry-item
  *
  * @example
  * ```tsx

package/dist/context/theme-provider.d.ts

@@ -1,32 +1,33 @@
 import { WakaError } from '../utils/error-handling';
 import * as React from "react";
-export interface ThemeS3Config {
-    /** URL de base du bucket S3 */
-    baseUrl: string;
-    /** Préfixe des fichiers (ex: "themes/") */
-    prefix?: string;
-    /** Extension des fichiers (défaut: "css") */
-    extension?: string;
-    /** Headers personnalisés pour les requêtes */
-    headers?: Record<string, string>;
-    /** Timeout en millisecondes */
-    timeout?: number;
-}
 /**
- * Variables CSS pour un thème
- * Peut contenir des variables CSS standard ou des objets de couleur
+ * Format shadcn/ui registry-item pour les thèmes
+ * Compatible avec https://ui.shadcn.com/schema/registry-item.json
  */
-export type ThemeCSSVariables = Record<string, string | number | {
-    r?: number;
-    g?: number;
-    b?: number;
-    a?: number;
-    h?: number;
-    s?: number;
-    l?: number;
-}>;
+export interface ShadcnRegistryItem {
+    /** Schema URL (optionnel) */
+    $schema?: string;
+    /** Nom du thème */
+    name: string;
+    /** Type de registry item */
+    type?: "registry:style" | "registry:theme" | string;
+    /** CSS personnalisé avec support @layer */
+    css?: {
+        "@layer base"?: Record<string, Record<string, string>>;
+        [selector: string]: Record<string, string> | Record<string, Record<string, string>> | undefined;
+    };
+    /** Variables CSS par mode */
+    cssVars?: {
+        /** Variables communes au thème (fonts, radius, etc.) */
+        theme?: Record<string, string>;
+        /** Variables mode clair */
+        light?: Record<string, string>;
+        /** Variables mode sombre */
+        dark?: Record<string, string>;
+    };
+}
 /**
- * Configuration d'un thème avec variables CSS inline
+ * Configuration d'un thème
  */
 export interface ThemeConfig {
     /** Identifiant du thème (utilisé dans data-theme) */
@@ -38,24 +39,15 @@ export interface ThemeConfig {
     /** Couleur représentative du thème (pour preview) */
     previewColor?: string;
     /**
-     * Variables CSS du thème au format JSON
-     * Permet de définir le thème directement sans charger depuis S3
-     *
-     * @example
-     * ```ts
-     * cssVars: {
-     *   "--background": "0 0% 100%",
-     *   "--foreground": "222.2 84% 4.9%",
-     *   "--primary": "222.2 47.4% 11.2%"
-     * }
-     * ```
+     * Données du thème au format shadcn registry-item
+     * C'est le format recommandé pour définir les thèmes
      */
-    cssVars?: ThemeCSSVariables;
+    registryItem?: ShadcnRegistryItem;
     /**
-     * Variables CSS pour le mode sombre
-     * Utilisées quand .dark est appliqué
+     * URL pour charger le JSON du thème (optionnel)
+     * Le JSON doit être au format ShadcnRegistryItem
      */
-    darkCssVars?: ThemeCSSVariables;
+    jsonUrl?: string;
 }
 export interface ThemeContextValue {
     /** Thème courant */
@@ -76,6 +68,12 @@ export interface ThemeContextValue {
     preloadTheme: (id: string) => Promise<void>;
     /** Vérifier si un thème est chargé */
     isThemeLoaded: (id: string) => boolean;
+    /**
+     * Charger un thème depuis un objet JSON
+     * @param themeId - ID du thème à créer/mettre à jour
+     * @param registryItem - Données au format shadcn registry-item
+     */
+    loadThemeFromJSON: (themeId: string, registryItem: ShadcnRegistryItem) => Promise<void>;
 }
 export interface ThemeProviderProps {
     children: React.ReactNode;
@@ -83,29 +81,31 @@ export interface ThemeProviderProps {
     themes: ThemeConfig[];
     /** Thème par défaut */
     defaultTheme?: string;
-    /** Configuration S3 (optionnel - si non fourni, utilise les thèmes locaux) */
-    s3Config?: ThemeS3Config;
     /** Callback après changement de thème */
     onThemeChange?: (id: string) => void;
-    /** Callback en cas d'erreur (chargement thème, parsing, etc.) */
+    /** Callback en cas d'erreur */
     onError?: (error: WakaError) => void;
     /** Activer le mode sombre (optionnel) */
     enableDarkMode?: boolean;
+    /** Headers personnalisés pour les requêtes fetch (optionnel) */
+    fetchHeaders?: Record<string, string>;
+    /** Timeout en millisecondes pour les requêtes fetch (défaut: 10000) */
+    fetchTimeout?: number;
 }
 /**
  * ThemeProvider
  *
- * Provider pour gérer les thèmes et charger les CSS depuis S3 avec support TweakCN.
+ * Provider pour gérer les thèmes avec support du format shadcn/ui registry-item.
  *
  * Features:
- * - Chargement dynamique des thèmes depuis S3
+ * - Support complet du format shadcn registry-item JSON
+ * - Chargement dynamique depuis URL ou inline
  * - Cache des thèmes déjà chargés
- * - Support TweakCN avec data-theme
+ * - Support @layer base pour styles personnalisés
  * - Persistance dans localStorage
- * - Préchargement de thèmes
- * - Support des thèmes locaux si pas de S3
+ * - Support dark mode
  */
-export declare function ThemeProvider({ children, themes, defaultTheme, s3Config, onThemeChange, onError, enableDarkMode, }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function ThemeProvider({ children, themes, defaultTheme, onThemeChange, onError, enableDarkMode, fetchHeaders, fetchTimeout, }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
 /**
  * Hook pour utiliser le ThemeProvider
  */