@wakastellar/ui 0.1.0

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

@@ -0,0 +1,461 @@
+import { ColumnDef, PaginationState, SortingState, ColumnFiltersState, VisibilityState, ColumnOrderState, ExpandedState, GroupingState } from '@tanstack/react-table';
+import { ReactNode } from 'react';
+import { EditCellConfig } from './DataTableEditCell';
+/**
+ * Layout variants pour le DataTable
+ */
+export type DataTableLayout = "standard" | "card" | "compact" | "split" | "infinite";
+/**
+ * Variantes visuelles
+ */
+export type DataTableVariant = "bordered" | "minimal" | "striped" | "glass";
+/**
+ * Densité d'affichage
+ */
+export type DataTableDensity = "comfortable" | "compact" | "spacious";
+/**
+ * Mode de sélection
+ */
+export type SelectionMode = "single" | "multiple" | "range";
+/**
+ * Mode de tri
+ */
+export type SortMode = "single" | "multiple";
+/**
+ * Type de virtualisation
+ */
+export type VirtualizationType = "none" | "fixed" | "dynamic";
+/**
+ * Position des filtres
+ */
+export type FilterPosition = "top" | "bottom" | "left" | "right" | "modal";
+/**
+ * Configuration de pagination
+ */
+export interface PaginationConfig {
+    /** Mode de pagination */
+    mode?: "client" | "server";
+    /** Taille de page par défaut */
+    pageSize?: number;
+    /** Options de tailles de page */
+    pageSizeOptions?: number[];
+    /** Page courante (mode serveur) */
+    currentPage?: number;
+    /** Total d'items (mode serveur) */
+    totalItems?: number;
+    /** Callback de changement de page */
+    onPageChange?: (page: number) => void;
+    /** Callback de changement de taille */
+    onPageSizeChange?: (size: number) => void;
+}
+/**
+ * Configuration d'un filtre
+ */
+export interface FilterConfig {
+    /** ID unique du filtre */
+    id: string;
+    /** Libellé du filtre */
+    label: string;
+    /** Type de filtre */
+    type: "text" | "select" | "range" | "date" | "daterange" | "multiselect" | "checkbox" | "number" | "boolean";
+    /** Options pour select/multiselect */
+    options?: Array<{
+        label: string;
+        value: string | number;
+    }>;
+    /** Placeholder */
+    placeholder?: string;
+    /** Valeur par défaut */
+    defaultValue?: any;
+    /** Colonne associée */
+    column?: string;
+    /** Fonction de filtrage personnalisée */
+    filterFn?: (row: any, columnId: string, filterValue: any) => boolean;
+    /** Validation du filtre */
+    validate?: (value: any) => string | null;
+}
+/**
+ * Configuration de groupement
+ */
+export interface GroupingConfig {
+    /** Colonnes de groupement */
+    columns?: string[];
+    /** Fonction d'agrégation personnalisée */
+    aggregations?: Record<string, (values: any[]) => any>;
+    /** Affichage des totaux */
+    showTotals?: boolean;
+    /** Position des totaux */
+    totalsPosition?: "top" | "bottom" | "both";
+}
+/**
+ * Configuration de virtualisation
+ */
+export interface VirtualizationConfig {
+    /** Type de virtualisation */
+    type: VirtualizationType;
+    /** Hauteur fixe des lignes */
+    itemHeight?: number;
+    /** Hauteur estimée pour la virtualisation dynamique */
+    estimatedItemHeight?: number;
+    /** Nombre d'éléments à pré-rendre */
+    overscan?: number;
+    /** Hauteur du conteneur */
+    containerHeight?: number;
+}
+/**
+ * Configuration de redimensionnement des colonnes
+ */
+export interface ColumnResizeConfig {
+    /** Mode de redimensionnement */
+    mode?: "onChange" | "onEnd";
+    /** Colonnes redimensionnables */
+    resizable?: boolean;
+    /** Largeur minimale */
+    minSize?: number;
+    /** Largeur maximale */
+    maxSize?: number;
+    /** Largeur par défaut */
+    defaultSize?: number;
+}
+/**
+ * Configuration de réordonnancement
+ */
+export interface ColumnOrderConfig {
+    /** Activer le réordonnancement */
+    enabled?: boolean;
+    /** Colonnes non réordonnables */
+    disabled?: string[];
+    /** Callback de changement d'ordre */
+    onOrderChange?: (newOrder: string[]) => void;
+}
+/**
+ * Configuration d'expansion des lignes
+ */
+export interface RowExpansionConfig {
+    /** Activer l'expansion */
+    enabled?: boolean;
+    /** Colonne d'expansion */
+    columnId?: string;
+    /** Fonction de rendu du contenu étendu */
+    renderExpanded?: (row: any) => ReactNode;
+    /** État d'expansion initial */
+    initialExpanded?: Record<string, boolean>;
+}
+/**
+ * Action de la toolbar
+ */
+export interface TableAction {
+    /** ID unique */
+    id: string;
+    /** Libellé */
+    label: string;
+    /** Icône (composant React) */
+    icon?: ReactNode;
+    /** Callback */
+    onClick: (selectedRows: any[]) => void;
+    /** Visible seulement si sélection */
+    requiresSelection?: boolean;
+    /** Variant du bouton */
+    variant?: "default" | "destructive" | "outline" | "ghost";
+    /** Désactivé */
+    disabled?: boolean;
+}
+/**
+ * Configuration de la toolbar
+ */
+export interface ToolbarConfig {
+    /** Actions personnalisées */
+    actions?: TableAction[];
+    /** Afficher la recherche globale */
+    showSearch?: boolean;
+    /** Afficher le sélecteur de colonnes */
+    showColumnToggle?: boolean;
+    /** Afficher le changement de densité */
+    showDensity?: boolean;
+    /** Afficher le bouton de refresh */
+    showRefresh?: boolean;
+    /** Callback de refresh */
+    onRefresh?: () => void;
+}
+/**
+ * Configuration d'export
+ */
+export interface ExportConfig {
+    /** Formats supportés */
+    formats?: Array<"csv" | "xlsx" | "json" | "pdf" | "xml">;
+    /** Nom du fichier */
+    filename?: string;
+    /** Callback personnalisé */
+    onExport?: (data: any[], format: string) => void;
+    /** Colonnes à exporter */
+    columns?: string[];
+    /** Inclure les en-têtes */
+    includeHeaders?: boolean;
+    /** Formatage personnalisé */
+    formatters?: Record<string, (value: any) => string>;
+    /** Options spécifiques par format */
+    options?: {
+        csv?: {
+            delimiter?: string;
+            encoding?: string;
+        };
+        xlsx?: {
+            sheetName?: string;
+            includeStyles?: boolean;
+        };
+        pdf?: {
+            orientation?: "portrait" | "landscape";
+            pageSize?: string;
+        };
+    };
+}
+/**
+ * Configuration d'import
+ */
+export interface ImportConfig {
+    /** Formats acceptés */
+    accept?: string;
+    /** Callback de traitement */
+    onImport?: (data: any[]) => void;
+    /** Validation des données */
+    validate?: (data: any[]) => {
+        valid: boolean;
+        errors: string[];
+    };
+    /** Mapping des colonnes */
+    columnMapping?: Record<string, string>;
+    /** Options de parsing */
+    parseOptions?: {
+        csv?: {
+            delimiter?: string;
+            skipEmptyLines?: boolean;
+        };
+        xlsx?: {
+            sheetIndex?: number;
+            headerRow?: number;
+        };
+    };
+}
+/**
+ * État de sélection
+ */
+export interface SelectionState {
+    /** IDs sélectionnés */
+    selectedIds: Set<string>;
+    /** Tout sélectionné */
+    selectAll: boolean;
+}
+/**
+ * Props principales du DataTable
+ */
+export interface DataTableProps<TData> {
+    /** Données à afficher */
+    data: TData[];
+    /** Définition des colonnes */
+    columns: ColumnDef<TData, any>[];
+    /** Layout d'affichage */
+    layout?: DataTableLayout;
+    /** Variant visuel */
+    variant?: DataTableVariant;
+    /** Densité */
+    density?: DataTableDensity;
+    /** Configuration des filtres */
+    filters?: FilterConfig[];
+    /** Position des filtres */
+    filterPosition?: FilterPosition;
+    /** Configuration de la toolbar */
+    toolbar?: ToolbarConfig;
+    /** Configuration de la pagination */
+    pagination?: PaginationConfig;
+    /** Mode de sélection */
+    selection?: SelectionMode | boolean;
+    /** Actions sur les lignes */
+    actions?: TableAction[];
+    /** Namespace i18n */
+    i18nNamespace?: string;
+    /** État de chargement */
+    loading?: boolean;
+    /** Message d'erreur */
+    error?: string | null;
+    /** État vide personnalisé */
+    emptyState?: ReactNode;
+    /** Header sticky */
+    headerSticky?: boolean;
+    /** Toggle de visibilité des colonnes */
+    columnVisibilityToggle?: boolean;
+    /** Configuration de redimensionnement des colonnes */
+    columnResize?: boolean | ColumnResizeConfig;
+    /** Configuration de réordonnancement */
+    columnOrder?: ColumnOrderConfig;
+    /** Configuration de groupement */
+    grouping?: GroupingConfig;
+    /** Configuration d'expansion des lignes */
+    rowExpansion?: RowExpansionConfig;
+    /** Configuration de virtualisation */
+    virtualization?: VirtualizationConfig;
+    /** Mode de tri */
+    sortMode?: SortMode;
+    /** Activer l'export */
+    enableExport?: boolean | ExportConfig;
+    /** Activer l'import */
+    enableImport?: boolean | ImportConfig;
+    /** Activer le réordonnancement */
+    enableReorder?: boolean;
+    /** Menu contextuel */
+    enableContextMenu?: boolean;
+    /** Callback de clic sur ligne */
+    onRowClick?: (row: TData) => void;
+    /** Callback de double-clic */
+    onRowDoubleClick?: (row: TData) => void;
+    /** Callback de changement de tri */
+    onSortingChange?: (sorting: SortingState) => void;
+    /** Callback de changement de filtres */
+    onFiltersChange?: (filters: ColumnFiltersState) => void;
+    /** Callback de changement de sélection */
+    onSelectionChange?: (selectedRows: TData[]) => void;
+    /** Callback de changement d'ordre des colonnes */
+    onColumnOrderChange?: (order: ColumnOrderState) => void;
+    /** Callback de changement d'expansion */
+    onExpandedChange?: (expanded: ExpandedState) => void;
+    /** Callback de changement de groupement */
+    onGroupingChange?: (grouping: GroupingState) => void;
+    /** Classe CSS personnalisée */
+    className?: string;
+    /** ID unique pour la persistance */
+    tableId?: string;
+    /** Configuration d'édition */
+    edit?: EditConfig<TData>;
+    /** Thème personnalisé */
+    theme?: {
+        colors?: Record<string, string>;
+        spacing?: Record<string, string>;
+        typography?: Record<string, any>;
+    };
+    /** Options de performance */
+    performance?: {
+        /** Désactiver les animations */
+        disableAnimations?: boolean;
+        /** Limite de rendu */
+        renderLimit?: number;
+        /** Délai de debounce pour les filtres */
+        filterDebounceMs?: number;
+    };
+}
+/**
+ * Configuration d'édition pour une colonne
+ */
+export interface ColumnEditConfig<TData> {
+    /** Champ éditable */
+    field: keyof TData;
+    /** Configuration de la cellule d'édition */
+    config: EditCellConfig;
+    /** Validation personnalisée */
+    validate?: (value: any, row: TData) => string | null;
+    /** Callback de changement */
+    onChange?: (value: any, row: TData) => void;
+}
+/**
+ * Configuration d'édition du DataTable
+ */
+export interface EditConfig<TData> {
+    /** Colonnes éditables */
+    editableColumns?: ColumnEditConfig<TData>[];
+    /** Mode d'édition */
+    mode?: "inline" | "modal" | "row";
+    /** Auto-save */
+    autoSave?: boolean;
+    /** Délai d'auto-save en ms */
+    autoSaveDelay?: number;
+    /** Callback de sauvegarde */
+    onSave?: (rowId: string, data: Partial<TData>) => Promise<void>;
+    /** Callback d'annulation */
+    onCancel?: (rowId: string, originalData: TData) => void;
+    /** Validation globale */
+    validate?: (data: Partial<TData>, row: TData) => Record<string, string>;
+    /** Boutons d'action personnalisés */
+    actionButtons?: {
+        save?: ReactNode;
+        cancel?: ReactNode;
+        edit?: ReactNode;
+    };
+}
+/**
+ * État interne du DataTable
+ */
+export interface DataTableState {
+    sorting: SortingState;
+    columnFilters: ColumnFiltersState;
+    columnVisibility: VisibilityState;
+    columnOrder: ColumnOrderState;
+    expanded: ExpandedState;
+    grouping: GroupingState;
+    pagination: PaginationState;
+    globalFilter: string;
+    density: DataTableDensity;
+    layout: DataTableLayout;
+    rowSelection: Record<string, boolean>;
+}
+/**
+ * Configuration de thème personnalisé
+ */
+export interface DataTableTheme {
+    /** Couleurs personnalisées */
+    colors?: {
+        primary?: string;
+        secondary?: string;
+        accent?: string;
+        background?: string;
+        surface?: string;
+        text?: string;
+        textSecondary?: string;
+        border?: string;
+        hover?: string;
+        selected?: string;
+        disabled?: string;
+    };
+    /** Espacement personnalisé */
+    spacing?: {
+        xs?: string;
+        sm?: string;
+        md?: string;
+        lg?: string;
+        xl?: string;
+    };
+    /** Typographie personnalisée */
+    typography?: {
+        fontFamily?: string;
+        fontSize?: {
+            xs?: string;
+            sm?: string;
+            md?: string;
+            lg?: string;
+            xl?: string;
+        };
+        fontWeight?: {
+            normal?: string;
+            medium?: string;
+            semibold?: string;
+            bold?: string;
+        };
+    };
+    /** Bordures personnalisées */
+    borders?: {
+        radius?: {
+            sm?: string;
+            md?: string;
+            lg?: string;
+        };
+        width?: {
+            thin?: string;
+            medium?: string;
+            thick?: string;
+        };
+    };
+    /** Ombres personnalisées */
+    shadows?: {
+        sm?: string;
+        md?: string;
+        lg?: string;
+        xl?: string;
+    };
+}

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

@@ -0,0 +1,37 @@
+import { ClassValue } from 'clsx';
+/**
+ * Utilitaire pour merger les classes CSS
+ */
+export declare function cn(...inputs: ClassValue[]): string;
+/**
+ * Export des données en CSV
+ */
+export declare function exportToCSV<T extends Record<string, any>>(data: T[], filename?: string): void;
+/**
+ * Export des données en JSON
+ */
+export declare function exportToJSON<T>(data: T[], filename?: string): void;
+/**
+ * Parse un fichier CSV
+ */
+export declare function parseCSV(file: File): Promise<any[]>;
+/**
+ * Sauvegarde de l'état dans localStorage
+ */
+export declare function saveTableState(tableId: string, state: any): void;
+/**
+ * Chargement de l'état depuis localStorage
+ */
+export declare function loadTableState(tableId: string): any | null;
+/**
+ * Génère un ID unique
+ */
+export declare function generateId(): string;
+/**
+ * Debounce une fonction
+ */
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
+/**
+ * Filtre global sur les données
+ */
+export declare function globalFilterFn<T extends Record<string, any>>(row: T, columnId: string, filterValue: string): boolean;

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

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as AccordionPrimitive from "@radix-ui/react-accordion";
+declare const Accordion: typeof AccordionPrimitive.Root;
+declare const AccordionItem: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

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

@@ -0,0 +1,8 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const Alert: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { Alert, AlertTitle, AlertDescription };

package/dist/components/alert-dialog/index.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+declare const AlertDialog: typeof AlertDialogPrimitive.Root;
+declare const AlertDialogTrigger: typeof AlertDialogPrimitive.Trigger;
+declare const AlertDialogPortal: typeof AlertDialogPrimitive.Portal;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/dist/components/aspect-ratio/index.d.ts

@@ -0,0 +1,3 @@
+import * as AspectRatioPrimitive from "@radix-ui/react-aspect-ratio";
+declare const AspectRatio: typeof AspectRatioPrimitive.Root;
+export { AspectRatio };

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

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Avatar, AvatarImage, AvatarFallback };

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

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "secondary" | "outline" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

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

@@ -0,0 +1,11 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "destructive" | "secondary" | "outline" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+export declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export {};

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

@@ -0,0 +1,8 @@
+import { DayPicker } from 'react-day-picker';
+import * as React from "react";
+export type CalendarProps = React.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+export { Calendar };

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

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

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

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox };

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

@@ -0,0 +1,29 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const codeVariants: (props?: ({
+    variant?: "inline" | "block" | null | undefined;
+    size?: "base" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export interface CodeProps extends React.HTMLAttributes<HTMLElement>, VariantProps<typeof codeVariants> {
+    language?: string;
+    showLineNumbers?: boolean;
+    maxHeight?: string | number;
+    copyable?: boolean;
+    filename?: string;
+    theme?: 'light' | 'dark' | 'auto';
+}
+/**
+ * Code - Composant de code avec coloration syntaxique et responsivité complète
+ *
+ * @example
+ * ```tsx
+ * <Code>const hello = "world"</Code>
+ * <Code variant="block" language="typescript" copyable>
+ *   function greet(name: string) {
+ *     return `Hello, ${name}!`
+ *   }
+ * </Code>
+ * ```
+ */
+declare const Code: React.ForwardRefExoticComponent<CodeProps & React.RefAttributes<HTMLElement>>;
+export { Code, codeVariants };

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

@@ -0,0 +1,5 @@
+import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
+declare const Collapsible: typeof CollapsiblePrimitive.Root;
+declare const CollapsibleTrigger: typeof CollapsiblePrimitive.CollapsibleTrigger;
+declare const CollapsibleContent: typeof CollapsiblePrimitive.CollapsibleContent;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };