@wakastellar/ui 0.1.0

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

@@ -0,0 +1,19 @@
+export interface FooterLink {
+    label: string;
+    href: string;
+}
+export interface FooterColumn {
+    title: string;
+    links: FooterLink[];
+}
+export interface SocialLink {
+    platform: "github" | "twitter" | "linkedin" | "email";
+    url: string;
+}
+export interface FooterProps {
+    columns?: FooterColumn[];
+    socialLinks?: SocialLink[];
+    copyright?: string;
+    className?: string;
+}
+export declare function Footer({ columns, socialLinks, copyright, className, }: FooterProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,27 @@
+import * as React from "react";
+export interface HeadtabItem {
+    id: string;
+    label: string;
+    href?: string;
+    content?: React.ReactNode;
+    disabled?: boolean;
+}
+export interface HeadtabProps {
+    items: HeadtabItem[];
+    defaultActiveId?: string;
+    variant?: "default" | "pills" | "underline";
+    size?: "sm" | "md" | "lg";
+    className?: string;
+    onTabChange?: (activeId: string) => void;
+}
+export declare function Headtab({ items, defaultActiveId, variant, size, className, onTabChange, }: HeadtabProps): import("react/jsx-runtime").JSX.Element;
+export interface BreadcrumbItem {
+    label: string;
+    href?: string;
+}
+export interface BreadcrumbProps {
+    items: BreadcrumbItem[];
+    separator?: React.ReactNode;
+    className?: string;
+}
+export declare function Breadcrumb({ items, separator, className, }: BreadcrumbProps): import("react/jsx-runtime").JSX.Element;

package/dist/blocks/index.d.ts

@@ -0,0 +1,5 @@
+export { Footer } from './footer';
+export { Headtab } from './headtab';
+export { LanguageSelector as BlockLanguageSelector } from './language-selector';
+export { Layout } from './layout';
+export { Login } from './login';

package/dist/blocks/language-selector/index.d.ts

@@ -0,0 +1,6 @@
+export interface LanguageSelectorProps {
+    variant?: "dropdown" | "select";
+    showFlags?: boolean;
+    className?: string;
+}
+export declare function LanguageSelector({ variant, showFlags, className, }: LanguageSelectorProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,28 @@
+import * as React from "react";
+export interface LayoutProps {
+    children: React.ReactNode;
+    header?: React.ReactNode;
+    sidebar?: React.ReactNode;
+    footer?: React.ReactNode;
+    collapsible?: boolean;
+    className?: string;
+}
+export declare function Layout({ children, header, sidebar, footer, collapsible, className, }: LayoutProps): import("react/jsx-runtime").JSX.Element;
+export interface SidebarProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function Sidebar({ children, className }: SidebarProps): import("react/jsx-runtime").JSX.Element;
+export interface SidebarItemProps {
+    children: React.ReactNode;
+    href?: string;
+    active?: boolean;
+    className?: string;
+    onClick?: () => void;
+}
+export declare function SidebarItem({ children, href, active, className, onClick, }: SidebarItemProps): import("react/jsx-runtime").JSX.Element;
+export interface HeaderProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function Header({ children, className }: HeaderProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,13 @@
+export interface LoginProps {
+    onSubmit?: (data: LoginFormData) => void;
+    onForgotPassword?: () => void;
+    onSignUp?: () => void;
+    showSocialLogin?: boolean;
+    className?: string;
+}
+export interface LoginFormData {
+    email: string;
+    password: string;
+    rememberMe?: boolean;
+}
+export declare function Login({ onSubmit, onForgotPassword, onSignUp, showSocialLogin, className, }: LoginProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,17 @@
+import { DataTableProps } from './types';
+/**
+ * Composant DataTable ultra-complet basé sur TanStack Table v8
+ *
+ * @example
+ * ```tsx
+ * <DataTable
+ *   data={users}
+ *   columns={userColumns}
+ *   layout="standard"
+ *   pagination={{ mode: "client", pageSize: 10 }}
+ *   selection
+ *   enableExport
+ * />
+ * ```
+ */
+export declare function DataTable<TData>({ data, columns: initialColumns, layout: layoutProp, variant, density: densityProp, filters, filterPosition, toolbar, pagination: paginationConfig, selection, actions, i18nNamespace, loading, error, emptyState, headerSticky, columnVisibilityToggle, columnResize, enableExport, enableImport, enableReorder, enableContextMenu, onRowClick, onRowDoubleClick, onSortingChange, onFiltersChange, onSelectionChange, className, tableId, virtualization, edit, }: DataTableProps<TData>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,27 @@
+import { DataTableProps } from './types';
+/**
+ * Composant DataTable ultra-complet avec toutes les fonctionnalités avancées
+ *
+ * @example
+ * ```tsx
+ * <DataTableAdvanced
+ *   data={users}
+ *   columns={userColumns}
+ *   layout="standard"
+ *   variant="bordered"
+ *   density="comfortable"
+ *   selection="multiple"
+ *   grouping={{ columns: ["department"], showTotals: true }}
+ *   rowExpansion={{ enabled: true, renderExpanded: (row) => <UserDetails user={row} /> }}
+ *   virtualization={{ type: "dynamic", estimatedItemHeight: 60 }}
+ *   columnResize={{ enabled: true, mode: "onChange" }}
+ *   enableExport={{ formats: ["csv", "xlsx", "json"] }}
+ *   enableImport={{ accept: ".csv,.xlsx,.json" }}
+ *   theme={{
+ *     colors: { primary: "#3b82f6", secondary: "#64748b" },
+ *     spacing: { md: "1.5rem" }
+ *   }}
+ * />
+ * ```
+ */
+export declare function DataTableAdvanced<TData>({ data, columns: initialColumns, layout: layoutProp, variant, density: densityProp, filters, filterPosition, toolbar, pagination: paginationConfig, selection, actions, i18nNamespace, loading, error, emptyState, headerSticky, columnVisibilityToggle, columnResize, columnOrder: columnOrderConfig, grouping, rowExpansion, virtualization, sortMode, enableExport, enableImport, enableReorder, enableContextMenu, onRowClick, onRowDoubleClick, onSortingChange, onFiltersChange, onSelectionChange, onColumnOrderChange, onExpandedChange, onGroupingChange, className, tableId, edit, theme, performance, }: DataTableProps<TData>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+/**
+ * Composant pour le redimensionnement des colonnes
+ */
+export declare function DataTableColumnResizer<TData>({ header, column, className, }: {
+    header: any;
+    column: any;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,47 @@
+import * as React from "react";
+/**
+ * Props pour le menu contextuel du DataTable
+ */
+export interface DataTableContextMenuProps<TData> {
+    /** Données de la ligne */
+    row: TData;
+    /** Index de la ligne */
+    rowIndex: number;
+    /** Actions disponibles */
+    actions?: Array<{
+        id: string;
+        label: string;
+        icon?: React.ReactNode;
+        onClick: (row: TData) => void;
+        disabled?: boolean;
+        destructive?: boolean;
+    }>;
+    /** Actions de colonnes */
+    columnActions?: Array<{
+        id: string;
+        label: string;
+        icon?: React.ReactNode;
+        onClick: (columnId: string) => void;
+        disabled?: boolean;
+    }>;
+    /** Callback de copie */
+    onCopy?: (row: TData) => void;
+    /** Callback d'export */
+    onExport?: (row: TData) => void;
+    /** Callback d'édition */
+    onEdit?: (row: TData) => void;
+    /** Callback de suppression */
+    onDelete?: (row: TData) => void;
+    /** Callback de visibilité des colonnes */
+    onToggleColumnVisibility?: (columnId: string) => void;
+    /** Colonnes visibles */
+    visibleColumns?: string[];
+    /** Classe CSS personnalisée */
+    className?: string;
+    /** Enfants à wrapper */
+    children: React.ReactNode;
+}
+/**
+ * Composant de menu contextuel pour le DataTable
+ */
+export declare function DataTableContextMenu<TData>({ row, rowIndex, actions, columnActions, onCopy, onExport, onEdit, onDelete, onToggleColumnVisibility, visibleColumns, className, children, }: DataTableContextMenuProps<TData>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,29 @@
+export interface EditCellConfig {
+    type: "text" | "number" | "email" | "url" | "textarea" | "select" | "checkbox" | "switch" | "date" | "datetime";
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    placeholder?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    rows?: number;
+    disabled?: boolean;
+    required?: boolean;
+    pattern?: string;
+    title?: string;
+}
+export interface DataTableEditCellProps<TData> {
+    value: any;
+    field: keyof TData;
+    config: EditCellConfig;
+    isEditing: boolean;
+    error?: string;
+    onChange: (value: any) => void;
+    onStartEdit: () => void;
+    onSave: () => void;
+    onCancel: () => void;
+    className?: string;
+}
+export declare function DataTableEditCell<TData>({ value, field, config, isEditing, error, onChange, onStartEdit, onSave, onCancel, className, }: DataTableEditCellProps<TData>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,14 @@
+import { Table } from '@tanstack/react-table';
+import { FilterConfig, FilterPosition } from './types';
+interface DataTableFiltersProps<TData> {
+    table: Table<TData>;
+    filters?: FilterConfig[];
+    position?: FilterPosition;
+    onFiltersChange?: (filters: any[]) => void;
+}
+/**
+ * Composant de filtrage avancé pour DataTable
+ * Supporte autocomplete, multi-select, date ranges, etc.
+ */
+export declare function DataTableFilters<TData>({ table, filters, position, onFiltersChange, }: DataTableFiltersProps<TData>): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,25 @@
+/**
+ * Composant pour l'affichage des groupes dans le DataTable
+ */
+export declare function DataTableGrouping<TData>({ row, table, className, }: {
+    row: any;
+    table: any;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Composant pour les totaux de groupe
+ */
+export declare function DataTableGroupTotals<TData>({ row, table, className, }: {
+    row: any;
+    table: any;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * Composant pour les contrôles de groupement
+ */
+export declare function DataTableGroupingControls<TData>({ table, groupingColumns, onGroupingChange, className, }: {
+    table: any;
+    groupingColumns: string[];
+    onGroupingChange: (columns: string[]) => void;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+import { Table } from '@tanstack/react-table';
+interface DataTablePaginationProps<TData> {
+    table: Table<TData>;
+    pageSizeOptions?: number[];
+    showInfo?: boolean;
+}
+export declare function DataTablePagination<TData>({ table, pageSizeOptions, showInfo, }: DataTablePaginationProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,46 @@
+import * as React from "react";
+/**
+ * Props pour la sélection avancée du DataTable
+ */
+export interface DataTableSelectionProps<TData> {
+    /** Table instance */
+    table: any;
+    /** Mode de sélection */
+    selectionMode?: "single" | "multiple" | "range";
+    /** Données sélectionnées */
+    selectedRows: TData[];
+    /** Callback de changement de sélection */
+    onSelectionChange?: (selectedRows: TData[]) => void;
+    /** Actions sur la sélection */
+    selectionActions?: Array<{
+        id: string;
+        label: string;
+        icon?: React.ReactNode;
+        onClick: (selectedRows: TData[]) => void;
+        disabled?: boolean;
+        destructive?: boolean;
+    }>;
+    /** Classe CSS personnalisée */
+    className?: string;
+}
+/**
+ * Composant pour la sélection avancée du DataTable
+ */
+export declare function DataTableSelection<TData>({ table, selectionMode, selectedRows, onSelectionChange, selectionActions, className, }: DataTableSelectionProps<TData>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook pour la sélection avancée
+ */
+export declare function useDataTableSelection<TData>({ table, selectionMode, onSelectionChange, }: {
+    table: any;
+    selectionMode?: "single" | "multiple" | "range";
+    onSelectionChange?: (selectedRows: TData[]) => void;
+}): {
+    selectedRows: TData[];
+    selectRow: (rowIndex: number, selected?: boolean) => void;
+    selectAll: (selected?: boolean) => void;
+    selectRange: (start: number, end: number, selected?: boolean) => void;
+    selectByCriteria: (criteria: (row: TData) => boolean) => void;
+    clearSelection: () => void;
+    isAllSelected: any;
+    isSomeSelected: any;
+};

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

@@ -0,0 +1,14 @@
+import { Table } from '@tanstack/react-table';
+import { ToolbarConfig, DataTableDensity } from './types';
+interface DataTableToolbarProps<TData> {
+    table: Table<TData>;
+    config?: ToolbarConfig;
+    globalFilter: string;
+    onGlobalFilterChange: (value: string) => void;
+    density?: DataTableDensity;
+    onDensityChange?: (density: DataTableDensity) => void;
+    onExport?: (format: string) => void;
+    onImport?: (file: File) => void;
+}
+export declare function DataTableToolbar<TData>({ table, config, globalFilter, onGlobalFilterChange, density, onDensityChange, onExport, onImport, }: DataTableToolbarProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/DataTable/examples/EditExample.d.ts

@@ -0,0 +1,2 @@
+export declare function EditExample(): import("react/jsx-runtime").JSX.Element;
+export default EditExample;

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

@@ -0,0 +1,24 @@
+import { PaginationState, SortingState, ColumnFiltersState, VisibilityState } from '@tanstack/react-table';
+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">): {
+    table: import('@tanstack/react-table').Table<TData>;
+    sorting: SortingState;
+    setSorting: import('react').Dispatch<import('react').SetStateAction<SortingState>>;
+    columnFilters: ColumnFiltersState;
+    setColumnFilters: import('react').Dispatch<import('react').SetStateAction<ColumnFiltersState>>;
+    columnVisibility: VisibilityState;
+    setColumnVisibility: import('react').Dispatch<import('react').SetStateAction<VisibilityState>>;
+    rowSelection: {};
+    setRowSelection: import('react').Dispatch<import('react').SetStateAction<{}>>;
+    globalFilter: any;
+    setGlobalFilter: import('react').Dispatch<any>;
+    pagination: PaginationState;
+    setPagination: import('react').Dispatch<import('react').SetStateAction<PaginationState>>;
+    selectedRows: TData[];
+    resetFilters: () => void;
+    resetSelection: () => void;
+    exportData: () => TData[];
+};

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

@@ -0,0 +1,38 @@
+import { PaginationState, SortingState, ColumnFiltersState, VisibilityState, ColumnOrderState, ExpandedState, GroupingState, RowSelectionState } from '@tanstack/react-table';
+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>;
+    sorting: SortingState;
+    setSorting: import('react').Dispatch<import('react').SetStateAction<SortingState>>;
+    columnFilters: ColumnFiltersState;
+    setColumnFilters: import('react').Dispatch<import('react').SetStateAction<ColumnFiltersState>>;
+    columnVisibility: VisibilityState;
+    setColumnVisibility: import('react').Dispatch<import('react').SetStateAction<VisibilityState>>;
+    columnOrder: ColumnOrderState;
+    setColumnOrder: import('react').Dispatch<import('react').SetStateAction<ColumnOrderState>>;
+    expanded: ExpandedState;
+    setExpanded: import('react').Dispatch<import('react').SetStateAction<ExpandedState>>;
+    grouping: GroupingState;
+    setGrouping: import('react').Dispatch<import('react').SetStateAction<GroupingState>>;
+    rowSelection: RowSelectionState;
+    setRowSelection: import('react').Dispatch<import('react').SetStateAction<RowSelectionState>>;
+    globalFilter: string;
+    setGlobalFilter: import('react').Dispatch<import('react').SetStateAction<string>>;
+    pagination: PaginationState;
+    setPagination: import('react').Dispatch<import('react').SetStateAction<PaginationState>>;
+    selectedRows: TData[];
+    resetFilters: () => void;
+    resetSelection: () => void;
+    resetAll: () => void;
+    exportData: () => TData[];
+    getGroupedData: () => TData[];
+    getExpandedData: () => TData[];
+    toggleGrouping: (columnId: string) => void;
+    clearGrouping: () => void;
+    toggleRowExpansion: (rowId: string) => void;
+    expandAll: () => void;
+    collapseAll: () => void;
+};

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

@@ -0,0 +1,22 @@
+import { Table } from '@tanstack/react-table';
+export interface EditState<TData> {
+    editingRowId: string | null;
+    editedData: Partial<TData>;
+    hasChanges: boolean;
+    isDirty: boolean;
+}
+export interface EditActions<TData> {
+    startEdit: (rowId: string, initialData: TData) => void;
+    cancelEdit: () => void;
+    saveEdit: () => Promise<void>;
+    updateField: (field: keyof TData, value: any) => void;
+    resetEdit: () => void;
+}
+export interface UseDataTableEditOptions<TData> {
+    onSave?: (rowId: string, data: Partial<TData>) => Promise<void>;
+    onCancel?: (rowId: string, originalData: TData) => void;
+    validateField?: (field: keyof TData, value: any) => string | null;
+    autoSave?: boolean;
+    autoSaveDelay?: number;
+}
+export declare function useDataTableEdit<TData>(table: Table<TData>, options?: UseDataTableEditOptions<TData>): [EditState<TData>, EditActions<TData>];

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

@@ -0,0 +1,15 @@
+import { ExportConfig } from '../types';
+/**
+ * Hook pour gérer l'export des données du DataTable
+ */
+export declare function useDataTableExport<TData>({ data, columns, exportConfig, }: {
+    data: TData[];
+    columns: any[];
+    exportConfig?: ExportConfig;
+}): {
+    exportData: (format: string, customData?: TData[], customFilename?: string) => Promise<void>;
+    exportAll: (format: string) => Promise<void>;
+    exportSelected: (format: string, selectedData: TData[]) => Promise<void>;
+    supportedFormats: ("csv" | "xlsx" | "json" | "pdf" | "xml")[] | readonly ["csv", "xlsx", "json"];
+    isExportSupported: (format: string) => boolean;
+};

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

@@ -0,0 +1,12 @@
+import { ImportConfig } from '../types';
+/**
+ * Hook pour gérer l'import des données dans le DataTable
+ */
+export declare function useDataTableImport<TData>({ importConfig, }: {
+    importConfig?: ImportConfig;
+}): {
+    importData: (file: File) => Promise<TData[]>;
+    importWithUI: () => Promise<TData[]>;
+    supportedFormats: string[];
+    isFormatSupported: (filename: string) => boolean;
+};

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

@@ -0,0 +1,16 @@
+import { DataTableTheme } from '../types';
+/**
+ * Hook pour gérer les thèmes personnalisés du DataTable
+ */
+export declare function useDataTableTheme({ theme, variant, density, }: {
+    theme?: DataTableTheme;
+    variant?: "bordered" | "minimal" | "striped" | "glass";
+    density?: "comfortable" | "compact" | "spacious";
+}): {
+    theme: DataTableTheme;
+    variantClasses: string;
+    densityClasses: Record<string, string>;
+    customStyles: Record<string, string>;
+    getThemedClass: (baseClass: string, themeKey?: string) => string;
+    getThemedStyles: (baseStyles?: React.CSSProperties) => React.CSSProperties;
+};

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

@@ -0,0 +1,19 @@
+import { VirtualizationConfig } from '../types';
+/**
+ * Hook pour gérer la virtualisation du DataTable
+ */
+export declare function useDataTableVirtualization<TData>({ data, virtualization, containerRef, }: {
+    data: TData[];
+    virtualization?: VirtualizationConfig;
+    containerRef: React.RefObject<HTMLElement>;
+}): {
+    virtualizer: import('@tanstack/react-virtual').Virtualizer<HTMLElement, Element> | null;
+    isVirtualized: boolean;
+    containerHeight: number;
+    scrollToIndex: (index: number, align?: "start" | "center" | "end") => void;
+    scrollToOffset: (offset: number) => void;
+    getVirtualItems: () => import('@tanstack/react-virtual').VirtualItem[];
+    getTotalSize: () => number;
+    virtualItems: import('@tanstack/react-virtual').VirtualItem[];
+    totalSize: number;
+};

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

@@ -0,0 +1,26 @@
+import { DataTableLayout, DataTableDensity } from '../types';
+/**
+ * Hook pour gérer le layout et la densité du DataTable
+ */
+export declare function useTableLayout(initialLayout?: DataTableLayout, initialDensity?: DataTableDensity): {
+    layout: DataTableLayout;
+    setLayout: import('react').Dispatch<import('react').SetStateAction<DataTableLayout>>;
+    density: DataTableDensity;
+    setDensity: import('react').Dispatch<import('react').SetStateAction<DataTableDensity>>;
+    toggleLayout: () => void;
+    toggleDensity: () => void;
+    isMobile: boolean;
+    densityClasses: {
+        table: string;
+        cell: string;
+        header: string;
+    } | {
+        table: string;
+        cell: string;
+        header: string;
+    } | {
+        table: string;
+        cell: string;
+        header: string;
+    };
+};

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

@@ -0,0 +1,37 @@
+/**
+ * DataTable - Composant ultra-complet basé sur TanStack Table v8
+ *
+ * @module DataTable
+ * @description
+ * Composant de table de données hautement configurable avec support de :
+ * - Tri, filtrage, pagination
+ * - Sélection multiple
+ * - Export/Import (CSV, JSON)
+ * - 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
+ */
+export { DataTable } from './DataTable';
+export { DataTableAdvanced } from './DataTableAdvanced';
+export { DataTableToolbar } from './DataTableToolbar';
+export { DataTablePagination } from './DataTablePagination';
+export { DataTableFilters } from './DataTableFilters';
+export { DataTableEditCell } from './DataTableEditCell';
+export { DataTableColumnResizer } from './DataTableColumnResizer';
+export { DataTableGrouping, DataTableGroupTotals, DataTableGroupingControls } from './DataTableGrouping';
+export { DataTableContextMenu } from './DataTableContextMenu';
+export { DataTableSelection, useDataTableSelection } from './DataTableSelection';
+export { useDataTable } from './hooks/useDataTable';
+export { useDataTableAdvanced } from './hooks/useDataTableAdvanced';
+export { useDataTableVirtualization } from './hooks/useDataTableVirtualization';
+export { useDataTableExport } from './hooks/useDataTableExport';
+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 type { EditCellConfig } from './DataTableEditCell';
+export { exportToCSV, exportToJSON, parseCSV, saveTableState, loadTableState, } from './utils';