@wakastellar/ui 0.1.3 → 0.1.5

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

@@ -0,0 +1,151 @@
+import * as React from "react";
+export interface SidebarMenuItem {
+    /** Identifiant unique */
+    id: string;
+    /** Label du menu */
+    label: string;
+    /** Icône (composant React) */
+    icon?: React.ReactNode;
+    /** URL de navigation */
+    href?: string;
+    /** Callback au clic */
+    onClick?: () => void;
+    /** Sous-menus */
+    children?: SidebarMenuItem[];
+    /** Menu actif */
+    active?: boolean;
+    /** Badge/compteur */
+    badge?: string | number;
+    /** Désactivé */
+    disabled?: boolean;
+}
+export interface SidebarUserConfig {
+    /** Nom de l'utilisateur */
+    name: string;
+    /** Email ou sous-titre */
+    email?: string;
+    /** URL de l'avatar */
+    avatarUrl?: string;
+    /** Initiales pour le fallback */
+    initials?: string;
+    /** Actions du menu utilisateur */
+    actions?: {
+        id: string;
+        label: string;
+        icon?: React.ReactNode;
+        onClick?: () => void;
+        href?: string;
+        variant?: "default" | "destructive";
+    }[];
+}
+export interface SidebarLogoConfig {
+    /** Image du logo */
+    src?: string;
+    /** Texte alternatif */
+    alt?: string;
+    /** Texte à côté du logo */
+    title?: string;
+    /** URL au clic sur le logo */
+    href?: string;
+    /** Callback au clic */
+    onClick?: () => void;
+    /** Composant logo personnalisé */
+    component?: React.ReactNode;
+}
+export interface WakaSidebarProps {
+    /** Configuration du logo */
+    logo?: SidebarLogoConfig;
+    /** Éléments du menu */
+    menu: SidebarMenuItem[];
+    /** Configuration utilisateur */
+    user?: SidebarUserConfig;
+    /** Largeur de la sidebar (desktop) */
+    width?: number;
+    /** Breakpoint pour le mode mobile (en px) */
+    mobileBreakpoint?: number;
+    /** Sidebar ouverte (mode mobile) */
+    open?: boolean;
+    /** Callback changement d'état (mode mobile) */
+    onOpenChange?: (open: boolean) => void;
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** Classes CSS du contenu */
+    contentClassName?: string;
+    /** Couleur de fond */
+    backgroundColor?: string;
+    /** Couleur du texte */
+    textColor?: string;
+    /** Couleur de l'élément actif */
+    activeColor?: string;
+    /** Couleur de survol */
+    hoverColor?: string;
+    /** Position du menu utilisateur */
+    userPosition?: "top" | "bottom";
+    /** Afficher le bouton hamburger */
+    showHamburger?: boolean;
+    /** Position du bouton hamburger (pour usage externe) */
+    hamburgerPosition?: "left" | "right";
+    /** Rendu personnalisé d'un item */
+    renderItem?: (item: SidebarMenuItem, isChild: boolean) => React.ReactNode;
+    /** Footer personnalisé */
+    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
+ *
+ * @example
+ * ```tsx
+ * <WakaSidebar
+ *   logo={{ src: "/logo.svg", title: "WAKASTART" }}
+ *   menu={[
+ *     { id: "dashboard", label: "Tableau de bord", icon: <Home /> },
+ *     {
+ *       id: "admin",
+ *       label: "Administration",
+ *       icon: <Settings />,
+ *       children: [
+ *         { id: "users", label: "Utilisateurs" },
+ *         { id: "roles", label: "Rôles" },
+ *       ],
+ *     },
+ *   ]}
+ *   user={{
+ *     name: "John Doe",
+ *     email: "john@example.com",
+ *     avatarUrl: "/avatar.jpg",
+ *   }}
+ * />
+ * ```
+ */
+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
+ */
+export declare function useSidebar(): {
+    isOpen: boolean;
+    setIsOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+};
+export interface SidebarLayoutProps {
+    /** Configuration de la sidebar */
+    sidebar: WakaSidebarProps;
+    /** Contenu principal */
+    children: React.ReactNode;
+    /** Largeur de la sidebar (override) */
+    sidebarWidth?: number;
+    /** Classes CSS du conteneur */
+    className?: string;
+    /** Classes CSS du contenu principal */
+    contentClassName?: string;
+}
+/**
+ * Layout avec sidebar intégrée
+ */
+export declare function SidebarLayout({ sidebar, children, sidebarWidth, className, contentClassName, }: SidebarLayoutProps): import("react/jsx-runtime").JSX.Element;
+export default WakaSidebar;

package/dist/blocks/theme-creator-block/index.d.ts

@@ -0,0 +1,86 @@
+import * as React from "react";
+export interface ThemeBlockColors {
+    background: string;
+    foreground: string;
+    card: string;
+    cardForeground: string;
+    popover: string;
+    popoverForeground: string;
+    primary: string;
+    primaryForeground: string;
+    secondary: string;
+    secondaryForeground: string;
+    muted: string;
+    mutedForeground: string;
+    accent: string;
+    accentForeground: string;
+    destructive: string;
+    destructiveForeground: string;
+    border: string;
+    input: string;
+    ring: string;
+    chart1: string;
+    chart2: string;
+    chart3: string;
+    chart4: string;
+    chart5: string;
+    sidebarBackground?: string;
+    sidebarForeground?: string;
+    sidebarPrimary?: string;
+    sidebarPrimaryForeground?: string;
+    sidebarAccent?: string;
+    sidebarAccentForeground?: string;
+    sidebarBorder?: string;
+    sidebarRing?: string;
+}
+export interface ThemeBlockAssets {
+    logoLight?: string;
+    logoDark?: string;
+    backgroundLight?: string;
+    backgroundDark?: string;
+    favicon?: string;
+    sponsorLight?: string;
+    sponsorDark?: string;
+}
+export interface ThemeCreatorBlockTheme {
+    id: string;
+    name: string;
+    description?: string;
+    author?: string;
+    lightColors: ThemeBlockColors;
+    darkColors: ThemeBlockColors;
+    assets?: ThemeBlockAssets;
+    radius?: string;
+    fonts?: {
+        sans?: string;
+        mono?: string;
+    };
+}
+export interface ThemeColorGroup {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    colors: {
+        key: keyof ThemeBlockColors;
+        label: string;
+        description?: string;
+    }[];
+}
+export interface WakaThemeCreatorBlockProps {
+    themes?: ThemeCreatorBlockTheme[];
+    initialTheme?: ThemeCreatorBlockTheme;
+    onThemeChange?: (theme: ThemeCreatorBlockTheme) => void;
+    onSave?: (theme: ThemeCreatorBlockTheme) => Promise<void>;
+    onUploadAsset?: (file: File, assetType: keyof ThemeBlockAssets) => Promise<string>;
+    onExport?: (theme: ThemeCreatorBlockTheme, format: 'json' | 'css') => void;
+    showTypography?: boolean;
+    showSidebarColors?: boolean;
+    previewTabs?: ('login' | 'dashboard' | 'chat')[];
+    customPreview?: React.ReactNode;
+    className?: string;
+}
+export declare const defaultThemes: ThemeCreatorBlockTheme[];
+export declare function WakaThemeCreatorBlock({ themes, initialTheme, onThemeChange, onSave, onUploadAsset, showSidebarColors, previewTabs, className, }: WakaThemeCreatorBlockProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaThemeCreatorBlock {
+    var displayName: string;
+}

package/dist/blocks/user-management/index.d.ts

@@ -0,0 +1,95 @@
+export type UserRole = "admin" | "moderator" | "user" | "guest";
+export type UserStatus = "active" | "inactive" | "pending" | "banned";
+export interface UserPermission {
+    id: string;
+    name: string;
+    description?: string;
+    category?: string;
+}
+export interface UserData {
+    id: string;
+    email: string;
+    displayName: string;
+    firstName?: string;
+    lastName?: string;
+    avatarUrl?: string;
+    role: UserRole;
+    status: UserStatus;
+    permissions?: string[];
+    createdAt: Date | string;
+    lastLogin?: Date | string;
+    metadata?: Record<string, unknown>;
+}
+export interface UserFormData {
+    email: string;
+    displayName: string;
+    firstName?: string;
+    lastName?: string;
+    role: UserRole;
+    status: UserStatus;
+    permissions?: string[];
+}
+export interface WakaUserManagementProps {
+    /** Liste des utilisateurs */
+    users: UserData[];
+    /** Rôles disponibles */
+    roles?: {
+        value: UserRole;
+        label: string;
+        color?: string;
+    }[];
+    /** Permissions disponibles */
+    permissions?: UserPermission[];
+    /** Utilisateurs sélectionnés */
+    selectedUsers?: string[];
+    /** Callback sélection */
+    onSelectionChange?: (userIds: string[]) => void;
+    /** Callback création */
+    onCreate?: (user: UserFormData) => void | Promise<void>;
+    /** Callback modification */
+    onEdit?: (userId: string, data: Partial<UserFormData>) => void | Promise<void>;
+    /** Callback suppression */
+    onDelete?: (userId: string) => void | Promise<void>;
+    /** Callback suppression multiple */
+    onBulkDelete?: (userIds: string[]) => void | Promise<void>;
+    /** Callback changement de rôle */
+    onRoleChange?: (userId: string, role: UserRole) => void | Promise<void>;
+    /** Callback changement de statut */
+    onStatusChange?: (userId: string, status: UserStatus) => void | Promise<void>;
+    /** Callback réinitialisation mot de passe */
+    onResetPassword?: (userId: string) => void | Promise<void>;
+    /** Callback export */
+    onExport?: () => void;
+    /** Callback rafraîchissement */
+    onRefresh?: () => void;
+    /** En cours de chargement */
+    loading?: boolean;
+    /** En cours d'action */
+    actionLoading?: boolean;
+    /** Recherche */
+    searchQuery?: string;
+    /** Callback recherche */
+    onSearchChange?: (query: string) => void;
+    /** Filtre par rôle */
+    roleFilter?: UserRole | "all";
+    /** Callback filtre rôle */
+    onRoleFilterChange?: (role: UserRole | "all") => void;
+    /** Filtre par statut */
+    statusFilter?: UserStatus | "all";
+    /** Callback filtre statut */
+    onStatusFilterChange?: (status: UserStatus | "all") => void;
+    /** Afficher les actions en masse */
+    showBulkActions?: boolean;
+    /** Afficher le bouton création */
+    showCreateButton?: boolean;
+    /** Titre */
+    title?: string;
+    /** Description */
+    description?: string;
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export declare function WakaUserManagement({ users, roles, permissions, selectedUsers, onSelectionChange, onCreate, onEdit, onDelete, onBulkDelete, onRoleChange, onStatusChange, onResetPassword, onExport, onRefresh, loading, actionLoading, searchQuery, onSearchChange, roleFilter, onRoleFilterChange, statusFilter, onStatusFilterChange, showBulkActions, showCreateButton, title, description, className, }: WakaUserManagementProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultUsers: UserData[];
+export declare const defaultPermissions: UserPermission[];
+export default WakaUserManagement;

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

@@ -0,0 +1,88 @@
+import * as React from "react";
+export type WizardStepStatus = "pending" | "current" | "completed" | "error" | "skipped";
+export interface WizardStep {
+    id: string;
+    title: string;
+    description?: string;
+    icon?: React.ReactNode;
+    content: React.ReactNode;
+    /** Étape optionnelle (peut être sautée) */
+    optional?: boolean;
+    /** Validation de l'étape */
+    validate?: () => boolean | Promise<boolean>;
+    /** Callback avant de quitter l'étape */
+    onLeave?: () => void | Promise<void>;
+    /** Callback en entrant dans l'étape */
+    onEnter?: () => void | Promise<void>;
+}
+export interface WizardSubmitData {
+    steps: {
+        id: string;
+        status: WizardStepStatus;
+    }[];
+    completedSteps: string[];
+    skippedSteps: string[];
+}
+export interface WakaWizardProps {
+    /** Étapes du wizard */
+    steps: WizardStep[];
+    /** Étape courante (contrôlé) */
+    currentStep?: number;
+    /** Callback changement d'étape */
+    onStepChange?: (step: number) => void;
+    /** Callback de soumission */
+    onSubmit?: (data: WizardSubmitData) => void | Promise<void>;
+    /** Callback d'annulation */
+    onCancel?: () => void;
+    /** Titre du wizard */
+    title?: string;
+    /** Description */
+    description?: string;
+    /** Texte du bouton précédent */
+    prevButtonText?: string;
+    /** Texte du bouton suivant */
+    nextButtonText?: string;
+    /** Texte du bouton terminer */
+    finishButtonText?: string;
+    /** Texte du bouton annuler */
+    cancelButtonText?: string;
+    /** Texte du bouton passer */
+    skipButtonText?: string;
+    /** Afficher le bouton annuler */
+    showCancelButton?: boolean;
+    /** Afficher la progression */
+    showProgress?: boolean;
+    /** Afficher les numéros d'étapes */
+    showStepNumbers?: boolean;
+    /** Afficher le stepper */
+    showStepper?: boolean;
+    /** Position du stepper */
+    stepperPosition?: "top" | "left";
+    /** Permettre la navigation vers les étapes précédentes */
+    allowBackNavigation?: boolean;
+    /** Confirmer l'annulation */
+    confirmCancel?: boolean;
+    /** Message de confirmation d'annulation */
+    cancelConfirmMessage?: string;
+    /** En cours de soumission */
+    submitting?: boolean;
+    /** Layout */
+    layout?: "card" | "page" | "minimal";
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+interface WizardContextValue {
+    currentStep: number;
+    totalSteps: number;
+    stepStatuses: WizardStepStatus[];
+    goToStep: (step: number) => void;
+    nextStep: () => void;
+    prevStep: () => void;
+    skipStep: () => void;
+    isFirstStep: boolean;
+    isLastStep: boolean;
+}
+export declare function useWizard(): WizardContextValue;
+export declare function WakaWizard({ steps, currentStep: externalCurrentStep, onStepChange, onSubmit, onCancel, title, description, prevButtonText, nextButtonText, finishButtonText, cancelButtonText, skipButtonText, showCancelButton, showProgress, showStepNumbers, showStepper, stepperPosition, allowBackNavigation, confirmCancel, cancelConfirmMessage, submitting, layout, className, }: WakaWizardProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultWizardSteps: WizardStep[];
+export default WakaWizard;

package/dist/charts.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Entry point pour les composants WakaCharts
+ *
+ * Usage:
+ * ```ts
+ * import { WakaBarChart, WakaLineChart, WakaPieChart } from "@wakastellar/ui/charts"
+ * ```
+ *
+ * Dépendances requises:
+ * - recharts (>=2.10.0)
+ *
+ * Installation:
+ * ```bash
+ * pnpm add recharts
+ * ```
+ */
+export * from './components/waka-charts';

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

@@ -0,0 +1,70 @@
+import { Table, Row } from '@tanstack/react-table';
+import { ColumnEditConfig, EditableCellValue, RowExpansionConfig } from './types';
+/**
+ * Props pour le composant DataTableBody
+ */
+export interface DataTableBodyProps<TData extends Record<string, unknown>> {
+    /** Instance de la table TanStack */
+    table: Table<TData>;
+    /** Configuration d'expansion des lignes */
+    rowExpansion?: RowExpansionConfig<TData>;
+    /** Classes CSS pour la densité */
+    densityClasses?: {
+        header?: string;
+        table?: string;
+        cell?: string;
+    };
+    /** Callback de clic sur ligne */
+    onRowClick?: (row: TData) => void;
+    /** Callback de double-clic */
+    onRowDoubleClick?: (row: TData) => void;
+    /** ID de la ligne en cours d'édition */
+    editingRowId?: string | null;
+    /** Configuration d'édition des colonnes */
+    editableColumns?: ColumnEditConfig<TData>[];
+    /** Callback pour mettre à jour un champ */
+    onUpdateField?: (field: keyof TData, value: EditableCellValue) => void;
+    /** Callback pour démarrer l'édition */
+    onStartEdit?: (rowId: string, originalData: TData) => void;
+    /** Callback pour sauvegarder */
+    onSaveEdit?: () => void;
+    /** Callback pour annuler */
+    onCancelEdit?: () => void;
+}
+/**
+ * Composant Body réutilisable pour DataTable
+ *
+ * Gère :
+ * - Le rendu des lignes
+ * - L'expansion des lignes
+ * - Le groupement
+ * - L'édition inline
+ */
+export declare function DataTableBody<TData extends Record<string, unknown>>({ table, rowExpansion, densityClasses, onRowClick, onRowDoubleClick, editingRowId, editableColumns, onUpdateField, onStartEdit, onSaveEdit, onCancelEdit, }: DataTableBodyProps<TData>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Props pour DataTableBodyRow
+ */
+interface DataTableBodyRowProps<TData extends Record<string, unknown>> {
+    row: Row<TData>;
+    rowExpansion?: RowExpansionConfig<TData>;
+    densityClasses: {
+        header?: string;
+        table?: string;
+        cell?: string;
+    };
+    onRowClick?: (row: TData) => void;
+    onRowDoubleClick?: (row: TData) => void;
+    editingRowId?: string | null;
+    editableColumns?: ColumnEditConfig<TData>[];
+    onUpdateField?: (field: keyof TData, value: EditableCellValue) => void;
+    onStartEdit?: (rowId: string, originalData: TData) => void;
+    onSaveEdit?: () => void;
+    onCancelEdit?: () => void;
+}
+/**
+ * Ligne individuelle du body
+ * Optimisé avec React.memo pour éviter les re-renders inutiles
+ */
+declare function DataTableBodyRowInner<TData extends Record<string, unknown>>({ row, rowExpansion, densityClasses, onRowClick, onRowDoubleClick, editingRowId, editableColumns, onUpdateField, onStartEdit, onSaveEdit, onCancelEdit, }: DataTableBodyRowProps<TData>): import("react/jsx-runtime").JSX.Element;
+declare const DataTableBodyRow: typeof DataTableBodyRowInner;
+export { DataTableBodyRow };

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

@@ -0,0 +1,38 @@
+import { Cell, Row } from '@tanstack/react-table';
+import { ColumnEditConfig, EditableCellValue } from './types';
+/**
+ * Props pour le composant DataTableCell
+ */
+export interface DataTableCellProps<TData extends Record<string, unknown>> {
+    /** Cellule TanStack Table */
+    cell: Cell<TData, unknown>;
+    /** Ligne parente */
+    row: Row<TData>;
+    /** ID de la ligne en cours d'édition */
+    editingRowId?: string | null;
+    /** Configuration d'édition des colonnes */
+    editableColumns?: ColumnEditConfig<TData>[];
+    /** Callback pour mettre à jour un champ */
+    onUpdateField?: (field: keyof TData, value: EditableCellValue) => void;
+    /** Callback pour démarrer l'édition */
+    onStartEdit?: (rowId: string, originalData: TData) => void;
+    /** Callback pour sauvegarder */
+    onSaveEdit?: () => void;
+    /** Callback pour annuler */
+    onCancelEdit?: () => void;
+}
+/**
+ * Composant de cellule réutilisable pour DataTable
+ *
+ * Gère tous les types de cellules :
+ * - Cellules normales
+ * - Cellules éditables
+ * - Cellules groupées
+ * - Cellules agrégées
+ * - Cellules placeholder
+ *
+ * Optimisé avec React.memo pour éviter les re-renders inutiles
+ */
+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/DataTableConflictResolver.d.ts

@@ -0,0 +1,45 @@
+import { ConflictEntry } from './services/IndexedDBService';
+/**
+ * DataTableConflictResolver - Interface de résolution des conflits
+ */
+import * as React from "react";
+export interface DataTableConflictResolverProps<TData> {
+    /** Liste des conflits */
+    conflicts: ConflictEntry<TData>[];
+    /** Callback de résolution */
+    onResolve: (conflictId: string, resolution: "local" | "server" | "merge", mergedData?: Partial<TData>) => Promise<void>;
+    /** Ouvert */
+    open?: boolean;
+    /** Callback de fermeture */
+    onOpenChange?: (open: boolean) => void;
+    /** Afficher en mode sheet (sidebar) ou dialog */
+    mode?: "dialog" | "sheet";
+    /** Labels personnalisés */
+    labels?: {
+        title?: string;
+        description?: string;
+        localVersion?: string;
+        serverVersion?: string;
+        keepLocal?: string;
+        keepServer?: string;
+        merge?: string;
+        resolve?: string;
+        skip?: string;
+        noConflicts?: string;
+        conflictType?: Record<"create" | "update" | "delete", string>;
+    };
+    /** Fonction de rendu personnalisé pour les données */
+    renderData?: (data: Partial<TData> | null, type: "local" | "server") => React.ReactNode;
+    /** Clés à afficher dans la comparaison */
+    displayKeys?: (keyof TData)[];
+    /** Labels des clés */
+    keyLabels?: Record<string, string>;
+}
+/**
+ * Interface de résolution des conflits de synchronisation
+ */
+export declare function DataTableConflictResolver<TData extends Record<string, unknown>>({ conflicts, onResolve, open, onOpenChange, mode, labels: customLabels, renderData, displayKeys, keyLabels, }: DataTableConflictResolverProps<TData>): import("react/jsx-runtime").JSX.Element;
+export declare namespace DataTableConflictResolver {
+    var displayName: string;
+}
+export default DataTableConflictResolver;

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

@@ -0,0 +1,14 @@
+import { FilterOperator, FilterableColumn, AdvancedFiltersState, AdvancedFiltersActions } from './types';
+interface DataTableFilterBuilderProps<TData> {
+    state: AdvancedFiltersState<TData>;
+    actions: AdvancedFiltersActions<TData>;
+    columns: FilterableColumn<TData>[];
+    getOperatorsForColumn: (column: keyof TData | string) => FilterOperator[];
+    className?: string;
+    maxNestingDepth?: number;
+}
+/**
+ * Composant de construction de filtres avancés
+ */
+export declare function DataTableFilterBuilder<TData>({ state, actions, columns, getOperatorsForColumn, className, maxNestingDepth, }: DataTableFilterBuilderProps<TData>): import("react/jsx-runtime").JSX.Element;
+export default DataTableFilterBuilder;

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

@@ -0,0 +1,50 @@
+import { Table, HeaderGroup } from '@tanstack/react-table';
+/**
+ * Props pour le composant DataTableHeader
+ */
+export interface DataTableHeaderProps<TData> {
+    /** Instance de la table TanStack */
+    table: Table<TData>;
+    /** Header sticky */
+    headerSticky?: boolean;
+    /** Classes CSS pour la densité */
+    densityClasses?: {
+        header?: string;
+        table?: string;
+        cell?: string;
+    };
+    /** Activer le redimensionnement des colonnes */
+    enableColumnResize?: boolean;
+    /** Mode de redimensionnement */
+    columnResizeMode?: "onChange" | "onEnd";
+}
+/**
+ * Composant Header réutilisable pour DataTable
+ *
+ * Gère :
+ * - Le tri des colonnes
+ * - Le redimensionnement
+ * - Le sticky header
+ */
+export declare function DataTableHeader<TData>({ table, headerSticky, densityClasses, enableColumnResize, columnResizeMode, }: DataTableHeaderProps<TData>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Props pour DataTableHeaderRow
+ */
+interface DataTableHeaderRowProps<TData> {
+    headerGroup: HeaderGroup<TData>;
+    densityClasses: {
+        header?: string;
+        table?: string;
+        cell?: string;
+    };
+    enableColumnResize: boolean;
+    columnResizeMode: "onChange" | "onEnd";
+    table: Table<TData>;
+}
+/**
+ * Ligne d'en-tête individuelle
+ * Optimisé avec React.memo pour éviter les re-renders inutiles
+ */
+declare function DataTableHeaderRowInner<TData>({ headerGroup, densityClasses, enableColumnResize, columnResizeMode, table, }: DataTableHeaderRowProps<TData>): import("react/jsx-runtime").JSX.Element;
+declare const DataTableHeaderRow: typeof DataTableHeaderRowInner;
+export { DataTableHeaderRow };