@wakastellar/ui 0.1.6 → 0.1.10

package/dist/components/DataTable/formatters/index.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Formatters utilitaires pour le DataTable
+ * @module formatters
+ */
+/**
+ * Formate une date
+ * @param value - Valeur à formater (Date, string ISO, timestamp)
+ * @param formatStr - Format de sortie (default: 'PP' = 16 déc. 2025)
+ * @param locale - Locale (default: 'fr')
+ * @returns Date formatée ou chaîne vide
+ * @example formatters.date(new Date(), 'PP', 'fr') // "16 déc. 2025"
+ */
+export declare function date(value: unknown, formatStr?: string, locale?: string): string;
+/**
+ * Formate une date avec heure
+ * @param value - Valeur à formater
+ * @param formatStr - Format de sortie (default: 'PPpp')
+ * @param locale - Locale
+ * @returns Date/heure formatée
+ * @example formatters.datetime(new Date()) // "16 déc. 2025, 14:30"
+ */
+export declare function datetime(value: unknown, formatStr?: string, locale?: string): string;
+/**
+ * Formate une heure
+ * @param value - Valeur à formater
+ * @param formatStr - Format de sortie (default: 'HH:mm')
+ * @param locale - Locale
+ * @returns Heure formatée
+ * @example formatters.time(new Date()) // "14:30"
+ */
+export declare function time(value: unknown, formatStr?: string, locale?: string): string;
+/**
+ * Formate une valeur monétaire
+ * @param value - Valeur numérique
+ * @param currencyCode - Code devise (default: 'EUR')
+ * @param locale - Locale (default: 'fr-FR')
+ * @param options - Options Intl.NumberFormat additionnelles
+ * @returns Valeur formatée
+ * @example formatters.currency(1234.56, 'EUR', 'fr-FR') // "1 234,56 €"
+ */
+export declare function currency(value: unknown, currencyCode?: string, locale?: string, options?: Partial<Intl.NumberFormatOptions>): string;
+/**
+ * Formate un pourcentage
+ * @param value - Valeur (0-100 ou 0-1)
+ * @param decimals - Nombre de décimales (default: 0)
+ * @param isDecimal - Si true, value est entre 0 et 1
+ * @returns Pourcentage formaté
+ * @example formatters.percentage(42.5) // "42.5%"
+ * @example formatters.percentage(0.425, 1, true) // "42.5%"
+ */
+export declare function percentage(value: unknown, decimals?: number, isDecimal?: boolean): string;
+/**
+ * Formate un nombre
+ * @param value - Valeur numérique
+ * @param locale - Locale (default: 'fr-FR')
+ * @param options - Options Intl.NumberFormat
+ * @returns Nombre formaté
+ * @example formatters.number(1234567.89, 'fr-FR') // "1 234 567,89"
+ */
+export declare function number(value: unknown, locale?: string, options?: Intl.NumberFormatOptions): string;
+/**
+ * Formate un numéro de téléphone
+ * @param value - Numéro de téléphone
+ * @param countryCode - Code pays (default: 'FR')
+ * @returns Numéro formaté
+ * @example formatters.phone('+33612345678') // "+33 6 12 34 56 78"
+ * @example formatters.phone('0612345678', 'FR') // "06 12 34 56 78"
+ */
+export declare function phone(value: unknown, countryCode?: string): string;
+/**
+ * Formate une taille en bytes
+ * @param value - Taille en bytes
+ * @param decimals - Nombre de décimales (default: 2)
+ * @returns Taille formatée (KB, MB, GB, etc.)
+ * @example formatters.bytes(1048576) // "1 MB"
+ * @example formatters.bytes(1536, 1) // "1.5 KB"
+ */
+export declare function bytes(value: unknown, decimals?: number): string;
+/**
+ * Formate un texte tronqué
+ * @param value - Texte
+ * @param maxLength - Longueur max (default: 50)
+ * @param suffix - Suffixe de troncature (default: '...')
+ * @returns Texte tronqué
+ */
+export declare function truncate(value: unknown, maxLength?: number, suffix?: string): string;
+/**
+ * Récupère les initiales d'un nom
+ * @param value - Nom complet
+ * @param maxInitials - Nombre max d'initiales (default: 2)
+ * @returns Initiales
+ * @example formatters.initials("Jean Dupont") // "JD"
+ */
+export declare function initials(value: unknown, maxInitials?: number): string;
+/**
+ * Formate un booléen
+ * @param value - Valeur booléenne
+ * @param trueLabel - Label pour true (default: 'Oui')
+ * @param falseLabel - Label pour false (default: 'Non')
+ * @returns Label correspondant
+ */
+export declare function boolean(value: unknown, trueLabel?: string, falseLabel?: string): string;
+/**
+ * Formate du JSON
+ * @param value - Valeur à sérialiser
+ * @param indent - Indentation (default: 2)
+ * @returns JSON formaté
+ */
+export declare function json(value: unknown, indent?: number): string;
+/**
+ * Objet contenant tous les formatters
+ */
+export declare const formatters: {
+    date: typeof date;
+    datetime: typeof datetime;
+    time: typeof time;
+    currency: typeof currency;
+    percentage: typeof percentage;
+    number: typeof number;
+    phone: typeof phone;
+    bytes: typeof bytes;
+    truncate: typeof truncate;
+    initials: typeof initials;
+    boolean: typeof boolean;
+    json: typeof json;
+};
+export default formatters;

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

@@ -3,7 +3,7 @@ import { DataTableProps } from '../types';
 /**
  * Hook principal pour gérer l'état et la logique du DataTable
  */
-export declare function useDataTable<TData>({ data, columns, pagination: paginationConfig, tableId, onSortingChange, onFiltersChange, onSelectionChange, }: Pick<DataTableProps<TData>, "data" | "columns" | "pagination" | "tableId" | "onSortingChange" | "onFiltersChange" | "onSelectionChange">): {
+export declare function useDataTable<TData extends Record<string, unknown>>({ data, columns, pagination: paginationConfig, tableId, onSortingChange, onFiltersChange, onSelectionChange, }: Pick<DataTableProps<TData>, "data" | "columns" | "pagination" | "tableId" | "onSortingChange" | "onFiltersChange" | "onSelectionChange">): {
     table: import('@tanstack/react-table').Table<TData>;
     sorting: SortingState;
     setSorting: import('react').Dispatch<import('react').SetStateAction<SortingState>>;

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

@@ -3,8 +3,8 @@ import { DataTableProps } from '../types';
 /**
  * Hook avancé pour gérer toutes les fonctionnalités du DataTable
  */
-export declare function useDataTableAdvanced<TData>({ data, columns, pagination: paginationConfig, tableId, onSortingChange, onFiltersChange, onSelectionChange, onColumnOrderChange, onExpandedChange, onGroupingChange, grouping, virtualization, sortMode, performance, }: Pick<DataTableProps<TData>, "data" | "columns" | "pagination" | "tableId" | "onSortingChange" | "onFiltersChange" | "onSelectionChange" | "onColumnOrderChange" | "onExpandedChange" | "onGroupingChange" | "grouping" | "virtualization" | "sortMode" | "performance">): {
-    table: import('@tanstack/react-table').Table<TData>;
+export declare function useDataTableAdvanced<TData extends Record<string, unknown>>({ data, columns, pagination: paginationConfig, tableId, onSortingChange, onFiltersChange, onSelectionChange, onColumnOrderChange, onExpandedChange, onGroupingChange, grouping, virtualization, sortMode, performance, }: Pick<DataTableProps<TData>, "data" | "columns" | "pagination" | "tableId" | "onSortingChange" | "onFiltersChange" | "onSelectionChange" | "onColumnOrderChange" | "onExpandedChange" | "onGroupingChange" | "grouping" | "virtualization" | "sortMode" | "performance">): {
+    table: import('@tanstack/react-table').Table<any>;
     sorting: SortingState;
     setSorting: import('react').Dispatch<import('react').SetStateAction<SortingState>>;
     columnFilters: ColumnFiltersState;
@@ -23,13 +23,13 @@ export declare function useDataTableAdvanced<TData>({ data, columns, pagination:
     setGlobalFilter: import('react').Dispatch<import('react').SetStateAction<string>>;
     pagination: PaginationState;
     setPagination: import('react').Dispatch<import('react').SetStateAction<PaginationState>>;
-    selectedRows: TData[];
+    selectedRows: any[];
     resetFilters: () => void;
     resetSelection: () => void;
     resetAll: () => void;
-    exportData: () => TData[];
-    getGroupedData: () => TData[];
-    getExpandedData: () => TData[];
+    exportData: () => any[];
+    getGroupedData: () => any[];
+    getExpandedData: () => any[];
     toggleGrouping: (columnId: string) => void;
     clearGrouping: () => void;
     toggleRowExpansion: (rowId: string) => void;

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

@@ -0,0 +1,18 @@
+import { FilterOperator, FilterColumnType, AdvancedFiltersConfig, AdvancedFiltersResult } from '../types';
+/**
+ * Opérateurs par type de colonne
+ */
+declare const OPERATORS_BY_TYPE: Record<FilterColumnType, FilterOperator[]>;
+/**
+ * Labels des opérateurs pour l'affichage
+ */
+export declare const OPERATOR_LABELS: Record<FilterOperator, string>;
+/**
+ * Hook pour gérer les filtres avancés du DataTable
+ */
+export declare function useDataTableAdvancedFilters<TData extends Record<string, unknown>>({ data, config, }: {
+    data: TData[];
+    config: AdvancedFiltersConfig<TData>;
+}): AdvancedFiltersResult<TData>;
+export { OPERATORS_BY_TYPE };
+export default useDataTableAdvancedFilters;

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

@@ -0,0 +1,28 @@
+import { ColumnTemplatesConfig, ColumnTemplatesResult } from '../types';
+/**
+ * Hook pour créer des colonnes DataTable à partir de templates prédéfinis
+ *
+ * @template TData - Type des données de la table
+ * @param config - Configuration des templates (locale, currency, etc.)
+ * @returns Fonctions pour créer des colonnes et accéder aux formatters
+ *
+ * @example
+ * ```tsx
+ * const { createColumns, getFormatter } = useDataTableColumnTemplates({
+ *   locale: 'fr-FR',
+ *   currency: 'EUR',
+ * })
+ *
+ * const columns = createColumns<User>([
+ *   { accessorKey: 'email', template: 'email' },
+ *   { accessorKey: 'salary', template: 'currency' },
+ *   { accessorKey: 'status', template: 'status', options: {
+ *     templateOptions: {
+ *       statusColors: { active: 'bg-green-100 text-green-800' }
+ *     }
+ *   }},
+ * ])
+ * ```
+ */
+export declare function useDataTableColumnTemplates<TData extends Record<string, unknown>>(config?: ColumnTemplatesConfig): ColumnTemplatesResult<TData>;
+export default useDataTableColumnTemplates;

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

@@ -1,11 +1,15 @@
+import { ColumnDef } from '@tanstack/react-table';
 import { ExportConfig } from '../types';
+import { WakaError } from '../../../utils/error-handling';
 /**
  * Hook pour gérer l'export des données du DataTable
+ * @template TData - Type des données de la table
  */
-export declare function useDataTableExport<TData>({ data, columns, exportConfig, }: {
+export declare function useDataTableExport<TData extends Record<string, unknown>>({ data, columns, exportConfig, onError, }: {
     data: TData[];
-    columns: any[];
-    exportConfig?: ExportConfig;
+    columns: ColumnDef<TData, unknown>[];
+    exportConfig?: ExportConfig<TData>;
+    onError?: (error: WakaError) => void;
 }): {
     exportData: (format: string, customData?: TData[], customFilename?: string) => Promise<void>;
     exportAll: (format: string) => Promise<void>;

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

@@ -1,9 +1,11 @@
 import { ImportConfig } from '../types';
+import { WakaError } from '../../../utils/error-handling';
 /**
  * Hook pour gérer l'import des données dans le DataTable
  */
-export declare function useDataTableImport<TData>({ importConfig, }: {
-    importConfig?: ImportConfig;
+export declare function useDataTableImport<TData>({ importConfig, onError, }: {
+    importConfig?: ImportConfig<TData>;
+    onError?: (error: WakaError) => void;
 }): {
     importData: (file: File) => Promise<TData[]>;
     importWithUI: () => Promise<TData[]>;

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

@@ -0,0 +1,80 @@
+import { SyncQueueItem, ConflictEntry } from '../services/IndexedDBService';
+export type ConflictResolution = "client-wins" | "server-wins" | "latest-wins" | "manual";
+export interface SyncResult<TData> {
+    id: string;
+    success: boolean;
+    data?: Partial<TData>;
+    error?: string;
+    serverData?: Partial<TData>;
+    serverTimestamp?: Date;
+}
+export interface OfflineConfig<TData> {
+    /** ID unique de la table pour le stockage */
+    tableId: string;
+    /** Activer le mode offline */
+    enabled?: boolean;
+    /** Stratégie de résolution des conflits */
+    conflictResolution?: ConflictResolution;
+    /** Callback de synchronisation vers le serveur */
+    onSync?: (changes: SyncQueueItem<TData>[]) => Promise<SyncResult<TData>[]>;
+    /** Intervalle de synchronisation automatique (ms) */
+    autoSyncInterval?: number;
+    /** Taille max du cache (nombre d'entrées) */
+    maxCacheSize?: number;
+    /** Durée d'expiration du cache (ms) */
+    cacheExpiration?: number;
+    /** Callback quand le statut online change */
+    onOnlineStatusChange?: (isOnline: boolean) => void;
+    /** Callback après synchronisation */
+    onSyncComplete?: (results: SyncResult<TData>[]) => void;
+    /** Callback sur conflit */
+    onConflict?: (conflict: ConflictEntry<TData>) => void;
+}
+export interface OfflineState<TData> {
+    /** Connexion internet disponible */
+    isOnline: boolean;
+    /** Synchronisation en cours */
+    isSyncing: boolean;
+    /** Nombre de changements en attente */
+    pendingChangesCount: number;
+    /** Données en cache */
+    cachedData: TData[] | null;
+    /** Timestamp du dernier cache */
+    lastCacheUpdate: Date | null;
+    /** Conflits à résoudre */
+    conflicts: ConflictEntry<TData>[];
+    /** Erreur de synchronisation */
+    syncError: string | null;
+    /** Dernière synchronisation réussie */
+    lastSyncTime: Date | null;
+    /** IndexedDB disponible */
+    isAvailable: boolean;
+}
+export interface OfflineActions<TData> {
+    /** Cache les données */
+    cacheData: (data: TData[]) => Promise<void>;
+    /** Ajoute un changement à la queue */
+    queueChange: (change: {
+        rowId: string;
+        type: SyncQueueItem<TData>["type"];
+        data: Partial<TData> | null;
+    }) => Promise<void>;
+    /** Lance la synchronisation */
+    sync: () => Promise<void>;
+    /** Résout un conflit */
+    resolveConflict: (conflictId: string, resolution: "local" | "server" | "merge", mergedData?: Partial<TData>) => Promise<void>;
+    /** Récupère les données du cache */
+    loadFromCache: () => Promise<TData[] | null>;
+    /** Vide le cache */
+    clearCache: () => Promise<void>;
+    /** Vide la queue de synchronisation */
+    clearQueue: () => Promise<void>;
+    /** Force le rafraîchissement de l'état */
+    refresh: () => Promise<void>;
+}
+export type UseDataTableOfflineResult<TData> = [OfflineState<TData>, OfflineActions<TData>];
+/**
+ * Hook pour gérer le mode offline du DataTable
+ */
+export declare function useDataTableOffline<TData extends Record<string, unknown>>(config: OfflineConfig<TData>): UseDataTableOfflineResult<TData>;
+export default useDataTableOffline;

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

@@ -2,7 +2,7 @@ import { VirtualizationConfig } from '../types';
 /**
  * Hook pour gérer la virtualisation du DataTable
  */
-export declare function useDataTableVirtualization<TData>({ data, virtualization, containerRef, }: {
+export declare function useDataTableVirtualization<TData extends Record<string, unknown>>({ data, virtualization, containerRef, }: {
     data: TData[];
     virtualization?: VirtualizationConfig;
     containerRef: React.RefObject<HTMLElement>;

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

@@ -6,13 +6,38 @@
  * Composant de table de données hautement configurable avec support de :
  * - Tri, filtrage, pagination
  * - Sélection multiple
- * - Export/Import (CSV, JSON)
+ * - Export/Import (CSV, JSON, XLSX)
  * - Layouts multiples (standard, card, compact, split, infinite)
  * - Thème clair/sombre via TweakCN
  * - i18n complet
  * - Virtualisation pour grandes données
  * - Toolbar customisable
  * - Actions par ligne et groupées
+ * - Édition inline
+ * - Groupement avec agrégations
+ * - Redimensionnement des colonnes
+ *
+ * @example
+ * ```tsx
+ * import {
+ *   DataTableAdvanced,
+ *   useDataTableAdvanced,
+ *   type DataTableProps,
+ *   type ColumnDef
+ * } from '@wakastellar/ui'
+ *
+ * const columns: ColumnDef<User>[] = [
+ *   { accessorKey: 'name', header: 'Name' },
+ *   { accessorKey: 'email', header: 'Email' },
+ * ]
+ *
+ * <DataTableAdvanced
+ *   data={users}
+ *   columns={columns}
+ *   selection="multiple"
+ *   enableExport={{ formats: ['csv', 'xlsx'] }}
+ * />
+ * ```
  */
 export { DataTable } from './DataTable';
 export { DataTableAdvanced } from './DataTableAdvanced';
@@ -24,6 +49,14 @@ export { DataTableColumnResizer } from './DataTableColumnResizer';
 export { DataTableGrouping, DataTableGroupTotals, DataTableGroupingControls } from './DataTableGrouping';
 export { DataTableContextMenu } from './DataTableContextMenu';
 export { DataTableSelection, useDataTableSelection } from './DataTableSelection';
+export { DataTableCell } from './DataTableCell';
+export type { DataTableCellProps } from './DataTableCell';
+export { DataTableHeader, DataTableHeaderRow } from './DataTableHeader';
+export type { DataTableHeaderProps } from './DataTableHeader';
+export { DataTableBody, DataTableBodyRow } from './DataTableBody';
+export type { DataTableBodyProps } from './DataTableBody';
+export { DataTableRow } from './DataTableRow';
+export { DataTableGroupRow } from './DataTableGroupRow';
 export { useDataTable } from './hooks/useDataTable';
 export { useDataTableAdvanced } from './hooks/useDataTableAdvanced';
 export { useDataTableVirtualization } from './hooks/useDataTableVirtualization';
@@ -32,6 +65,19 @@ export { useDataTableImport } from './hooks/useDataTableImport';
 export { useDataTableTheme } from './hooks/useDataTableTheme';
 export { useTableLayout } from './hooks/useTableLayout';
 export { useDataTableEdit } from './hooks/useDataTableEdit';
-export type { DataTableProps, DataTableLayout, DataTableVariant, DataTableDensity, DataTableState, FilterConfig, FilterPosition, PaginationConfig, ToolbarConfig, TableAction, ExportConfig, ImportConfig, SelectionState, EditConfig, ColumnEditConfig, SelectionMode, SortMode, VirtualizationType, GroupingConfig, VirtualizationConfig, ColumnResizeConfig, ColumnOrderConfig, RowExpansionConfig, DataTableTheme, } from './types';
+export { useDataTableColumnTemplates } from './hooks/useDataTableColumnTemplates';
+export { useDataTableAdvancedFilters, OPERATORS_BY_TYPE, OPERATOR_LABELS } from './hooks/useDataTableAdvancedFilters';
+export { useDataTableOffline } from './hooks/useDataTableOffline';
+export type { OfflineConfig, OfflineState, OfflineActions, SyncResult, ConflictResolution, UseDataTableOfflineResult, } from './hooks/useDataTableOffline';
+export { DataTableFilterBuilder } from './DataTableFilterBuilder';
+export { DataTableSyncStatus } from './DataTableSyncStatus';
+export type { DataTableSyncStatusProps } from './DataTableSyncStatus';
+export { DataTableConflictResolver } from './DataTableConflictResolver';
+export type { DataTableConflictResolverProps } from './DataTableConflictResolver';
+export { IndexedDBService, getIndexedDBService } from './services/IndexedDBService';
+export type { CacheEntry, SyncQueueItem, ConflictEntry, } from './services/IndexedDBService';
+export { formatters } from './formatters';
+export { templatesMap, getTemplate, availableTemplateNames, createActionsTemplate, dateTemplate, datetimeTemplate, timeTemplate, currencyTemplate, percentageTemplate, numberTemplate, statusTemplate, badgeTemplate, emailTemplate, phoneTemplate, urlTemplate, avatarTemplate, booleanTemplate, actionsTemplate, indexTemplate, idTemplate, ratingTemplate, progressTemplate, tagsTemplate, jsonTemplate, textTemplate, } from './templates';
+export type { DataTableProps, DataTableLayout, DataTableVariant, DataTableDensity, DataTableState, FilterConfig, FilterPosition, FilterValue, PaginationConfig, ToolbarConfig, TableAction, ExportConfig, ImportConfig, SelectionState, EditConfig, ColumnEditConfig, EditableCellValue, SelectionMode, SortMode, VirtualizationType, GroupingConfig, VirtualizationConfig, ColumnResizeConfig, ColumnOrderConfig, RowExpansionConfig, DataTableTheme, RangeValue, DateRangeValue, AggregatedValue, ExportableCellValue, ImportedRowData, TypographyConfig, ColumnTemplateName, FormatterType, ColumnTemplateAction, ColumnTemplateOptions, ColumnTemplateDefinition, ColumnTemplate, ColumnTemplatesConfig, ColumnTemplatesResult, FilterOperator, FilterColumnType, FilterRule, FilterGroup, FilterPreset, FilterableColumn, AdvancedFiltersConfig, AdvancedFiltersState, AdvancedFiltersActions, AdvancedFiltersResult, } from './types';
 export type { EditCellConfig } from './DataTableEditCell';
 export { exportToCSV, exportToJSON, parseCSV, saveTableState, loadTableState, } from './utils';

package/dist/components/DataTable/services/IndexedDBService.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Service IndexedDB pour le mode offline du DataTable
+ * Gère le cache des données, la queue de synchronisation et les conflits
+ */
+export interface CacheEntry<TData> {
+    id: string;
+    tableId: string;
+    data: TData[];
+    timestamp: Date;
+    version: number;
+}
+export interface SyncQueueItem<TData> {
+    id: string;
+    tableId: string;
+    rowId: string;
+    type: "create" | "update" | "delete";
+    data: Partial<TData> | null;
+    timestamp: Date;
+    attempts: number;
+    lastError?: string;
+}
+export interface ConflictEntry<TData> {
+    id: string;
+    tableId: string;
+    rowId: string;
+    localData: Partial<TData> | null;
+    serverData: Partial<TData> | null;
+    localTimestamp: Date;
+    serverTimestamp: Date;
+    type: "create" | "update" | "delete";
+}
+/**
+ * Service pour gérer IndexedDB
+ */
+export declare class IndexedDBService {
+    private db;
+    private initPromise;
+    /**
+     * Initialise la connexion à IndexedDB
+     */
+    init(): Promise<void>;
+    /**
+     * Vérifie si IndexedDB est disponible
+     */
+    isAvailable(): boolean;
+    /**
+     * Ferme la connexion
+     */
+    close(): void;
+    /**
+     * Sauvegarde les données en cache
+     */
+    cacheData<TData>(tableId: string, data: TData[], version?: number): Promise<void>;
+    /**
+     * Récupère les données du cache
+     */
+    getCachedData<TData>(tableId: string): Promise<CacheEntry<TData> | null>;
+    /**
+     * Supprime les données du cache
+     */
+    clearCache(tableId: string): Promise<void>;
+    /**
+     * Supprime les entrées de cache expirées
+     */
+    cleanExpiredCache(maxAgeMs: number): Promise<number>;
+    /**
+     * Ajoute un changement à la queue de synchronisation
+     */
+    queueChange<TData>(tableId: string, rowId: string, type: SyncQueueItem<TData>["type"], data: Partial<TData> | null): Promise<string>;
+    /**
+     * Récupère les changements en attente
+     */
+    getPendingChanges<TData>(tableId: string): Promise<SyncQueueItem<TData>[]>;
+    /**
+     * Compte les changements en attente
+     */
+    countPendingChanges(tableId: string): Promise<number>;
+    /**
+     * Marque un changement comme traité (le supprime)
+     */
+    removeFromQueue(id: string): Promise<void>;
+    /**
+     * Met à jour le nombre de tentatives d'un changement
+     */
+    updateAttempts<TData>(id: string, error?: string): Promise<void>;
+    /**
+     * Vide la queue de synchronisation
+     */
+    clearQueue(tableId: string): Promise<void>;
+    /**
+     * Ajoute un conflit
+     */
+    addConflict<TData>(conflict: Omit<ConflictEntry<TData>, "id">): Promise<string>;
+    /**
+     * Récupère les conflits d'une table
+     */
+    getConflicts<TData>(tableId: string): Promise<ConflictEntry<TData>[]>;
+    /**
+     * Supprime un conflit résolu
+     */
+    resolveConflict(id: string): Promise<void>;
+    /**
+     * Vide tous les conflits d'une table
+     */
+    clearConflicts(tableId: string): Promise<void>;
+    /**
+     * Obtient des statistiques sur la base de données
+     */
+    getStats(tableId: string): Promise<{
+        cacheSize: number;
+        pendingChanges: number;
+        conflicts: number;
+        lastCacheUpdate: Date | null;
+    }>;
+}
+export declare function getIndexedDBService(): IndexedDBService;
+export default IndexedDBService;

package/dist/components/DataTable/templates/index.d.ts

@@ -0,0 +1,104 @@
+import { ColumnTemplate } from '../types';
+/**
+ * Template Date
+ */
+export declare const dateTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template DateTime
+ */
+export declare const datetimeTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Time
+ */
+export declare const timeTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Currency
+ */
+export declare const currencyTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Percentage
+ */
+export declare const percentageTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Number
+ */
+export declare const numberTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Status/Badge
+ */
+export declare const statusTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Badge (alias de status)
+ */
+export declare const badgeTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Email
+ */
+export declare const emailTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Phone
+ */
+export declare const phoneTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template URL
+ */
+export declare const urlTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Avatar
+ */
+export declare const avatarTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Boolean
+ */
+export declare const booleanTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Actions
+ */
+export declare function createActionsTemplate<TData>(): ColumnTemplate<TData, unknown>;
+/**
+ * Template Actions par défaut
+ */
+export declare const actionsTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Index (numéro de ligne)
+ */
+export declare const indexTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template ID
+ */
+export declare const idTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Rating (étoiles)
+ */
+export declare const ratingTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Progress
+ */
+export declare const progressTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Tags
+ */
+export declare const tagsTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template JSON
+ */
+export declare const jsonTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Text (par défaut)
+ */
+export declare const textTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Map des templates par nom
+ * Note: Les templates sont typés avec `unknown` pour permettre l'accès dynamique par nom.
+ * Le typage précis est assuré lors de l'utilisation via useDataTableColumnTemplates.
+ */
+export declare const templatesMap: Record<string, ColumnTemplate<unknown, unknown>>;
+/**
+ * Récupère un template par son nom
+ */
+export declare function getTemplate(name: string): ColumnTemplate<unknown, unknown> | undefined;
+/**
+ * Liste des noms de templates disponibles
+ */
+export declare const availableTemplateNames: string[];
+export default templatesMap;