@wakastellar/ui 0.2.0 → 0.3.0

package/dist/components/waka-number-input/index.d.ts

@@ -0,0 +1,60 @@
+import * as React from "react";
+export interface WakaNumberInputProps {
+    /** Valeur courante */
+    value?: number;
+    /** Callback lors du changement */
+    onChange?: (value: number | undefined) => void;
+    /** Valeur minimum */
+    min?: number;
+    /** Valeur maximum */
+    max?: number;
+    /** Pas d'incrémentation */
+    step?: number;
+    /** Précision décimale */
+    precision?: number;
+    /** Placeholder */
+    placeholder?: string;
+    /** Désactivé */
+    disabled?: boolean;
+    /** Erreur */
+    error?: boolean;
+    /** Taille */
+    size?: "sm" | "md" | "lg";
+    /** Position des boutons */
+    buttonPosition?: "sides" | "right" | "none";
+    /** Permettre la valeur vide */
+    allowEmpty?: boolean;
+    /** Formater l'affichage */
+    formatValue?: (value: number) => string;
+    /** Parser la valeur saisie */
+    parseValue?: (value: string) => number | undefined;
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** ID pour l'accessibilité */
+    id?: string;
+    /** Nom du champ */
+    name?: string;
+}
+export declare function WakaNumberInput({ value, onChange, min, max, step, precision, placeholder, disabled, error, size, buttonPosition, allowEmpty, formatValue, parseValue, className, id, name, }: WakaNumberInputProps): import("react/jsx-runtime").JSX.Element;
+export interface UseNumberInputOptions {
+    /** Valeur initiale */
+    initialValue?: number;
+    /** Valeur minimum */
+    min?: number;
+    /** Valeur maximum */
+    max?: number;
+    /** Pas d'incrémentation */
+    step?: number;
+}
+export declare function useNumberInput(options?: UseNumberInputOptions): {
+    value: number | undefined;
+    onChange: React.Dispatch<React.SetStateAction<number | undefined>>;
+    increment: () => void;
+    decrement: () => void;
+    reset: () => void;
+    clear: () => void;
+    min: number | undefined;
+    max: number | undefined;
+    step: number;
+};
+export default WakaNumberInput;

package/dist/components/waka-pagination/index.d.ts

@@ -0,0 +1,67 @@
+export interface WakaPaginationProps {
+    /** Page courante (1-indexed) */
+    page: number;
+    /** Nombre total de pages */
+    totalPages: number;
+    /** Callback lors du changement de page */
+    onPageChange: (page: number) => void;
+    /** Nombre d'éléments par page */
+    pageSize?: number;
+    /** Options de taille de page */
+    pageSizeOptions?: number[];
+    /** Callback lors du changement de taille */
+    onPageSizeChange?: (size: number) => void;
+    /** Nombre total d'éléments (pour affichage) */
+    totalItems?: number;
+    /** Afficher la sélection de taille de page */
+    showPageSizeSelector?: boolean;
+    /** Afficher les infos sur les éléments */
+    showItemsInfo?: boolean;
+    /** Afficher les boutons premier/dernier */
+    showFirstLast?: boolean;
+    /** Nombre maximum de pages à afficher */
+    maxVisiblePages?: number;
+    /** Taille des boutons */
+    size?: "sm" | "md" | "lg";
+    /** Variante visuelle */
+    variant?: "default" | "outline" | "ghost";
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** Labels personnalisés */
+    labels?: {
+        page?: string;
+        of?: string;
+        items?: string;
+        itemsPerPage?: string;
+        first?: string;
+        previous?: string;
+        next?: string;
+        last?: string;
+    };
+}
+export declare function WakaPagination({ page, totalPages, onPageChange, pageSize, pageSizeOptions, onPageSizeChange, totalItems, showPageSizeSelector, showItemsInfo, showFirstLast, maxVisiblePages, size, variant, className, labels, }: WakaPaginationProps): import("react/jsx-runtime").JSX.Element;
+export interface UsePaginationOptions {
+    /** Total d'éléments */
+    totalItems: number;
+    /** Taille de page initiale */
+    initialPageSize?: number;
+    /** Page initiale */
+    initialPage?: number;
+}
+export interface UsePaginationReturn {
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    setPage: (page: number) => void;
+    setPageSize: (size: number) => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    firstPage: () => void;
+    lastPage: () => void;
+    canNextPage: boolean;
+    canPrevPage: boolean;
+    startIndex: number;
+    endIndex: number;
+}
+export declare function usePagination({ totalItems, initialPageSize, initialPage, }: UsePaginationOptions): UsePaginationReturn;
+export default WakaPagination;

package/dist/components/waka-qrcode/index.d.ts

@@ -0,0 +1,32 @@
+import * as React from "react";
+export interface WakaQRCodeProps {
+    /** Données à encoder */
+    value: string;
+    /** Taille en pixels */
+    size?: number;
+    /** Niveau de correction d'erreur */
+    errorCorrectionLevel?: "L" | "M" | "Q" | "H";
+    /** Couleur du QR code */
+    fgColor?: string;
+    /** Couleur de fond */
+    bgColor?: string;
+    /** Inclure une marge */
+    includeMargin?: boolean;
+    /** URL de l'image au centre (logo) */
+    logoUrl?: string;
+    /** Taille du logo en ratio (0-1) */
+    logoSize?: number;
+    /** Afficher les actions (télécharger, copier) */
+    showActions?: boolean;
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export declare function WakaQRCode({ value, size, errorCorrectionLevel, fgColor, bgColor, includeMargin, logoUrl, logoSize, showActions, className, }: WakaQRCodeProps): import("react/jsx-runtime").JSX.Element;
+export declare function useQRCode(initialValue?: string): {
+    value: string;
+    setValue: React.Dispatch<React.SetStateAction<string>>;
+    props: {
+        value: string;
+    };
+};
+export default WakaQRCode;

package/dist/components/waka-segmented-control/index.d.ts

@@ -0,0 +1,42 @@
+import * as React from "react";
+export interface SegmentOption<T = string> {
+    /** Valeur de l'option */
+    value: T;
+    /** Libellé affiché */
+    label: string;
+    /** Icône */
+    icon?: React.ReactNode;
+    /** Désactiver l'option */
+    disabled?: boolean;
+}
+export interface WakaSegmentedControlProps<T = string> {
+    /** Options disponibles */
+    options: SegmentOption<T>[];
+    /** Valeur sélectionnée */
+    value?: T;
+    /** Callback lors du changement */
+    onChange?: (value: T) => void;
+    /** Taille */
+    size?: "sm" | "md" | "lg";
+    /** Variante */
+    variant?: "default" | "pills";
+    /** Prendre toute la largeur */
+    fullWidth?: boolean;
+    /** Désactiver tout le contrôle */
+    disabled?: boolean;
+    /** Nom pour les formulaires */
+    name?: string;
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export declare function WakaSegmentedControl<T = string>({ options, value, onChange, size, variant, fullWidth, disabled, name, className, }: WakaSegmentedControlProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function useSegmentedControl<T = string>(options: SegmentOption<T>[], initialValue?: T): {
+    value: T | undefined;
+    onChange: React.Dispatch<React.SetStateAction<T | undefined>>;
+    selectNext: () => void;
+    selectPrevious: () => void;
+    selectFirst: () => void;
+    selectLast: () => void;
+    options: SegmentOption<T>[];
+};
+export default WakaSegmentedControl;

package/dist/components/waka-spinner/index.d.ts

@@ -1,46 +1,82 @@
 import { VariantProps } from 'class-variance-authority';
 import * as React from "react";
 /**
- * Variantes du spinner spatial WakaSpinner
- * Définit les différentes tailles disponibles pour l'animation
+ * Variantes du spinner Jarvis WakaSpinner
  */
 declare const spinnerVariants: (props?: ({
-    size?: "sm" | "lg" | "md" | "xl" | null | undefined;
+    size?: "sm" | "lg" | "md" | "xs" | "xl" | null | undefined;
 } & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
 export interface WakaSpinnerProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof spinnerVariants> {
     /**
-     * Affiche les astéroïdes en arrière-plan
-     * @default true
+     * Mode du spinner
+     * - "infinite": Animation continue style Jarvis (pour processus indéfinis)
+     * - "loading": Animation de chargement de données (visuellement différent pour indiquer une récupération)
+     * @default "infinite"
+     */
+    mode?: "infinite" | "loading";
+    /**
+     * Label affiché au centre du spinner
+     */
+    label?: string;
+    /**
+     * Sous-label affiché sous le label principal
      */
-    showAsteroids?: boolean;
+    subLabel?: string;
     /**
-     * Vitesse de rotation de la fusée (en secondes)
-     * @default 2
+     * Vitesse de rotation (en secondes pour un tour complet)
+     * @default 3
      */
     speed?: number;
     /**
-     * Couleur de la fusée (classe Tailwind ou couleur CSS)
-     * @default "text-primary"
+     * Couleur principale (classe Tailwind ou couleur CSS)
+     * @default "primary"
+     */
+    color?: "primary" | "secondary" | "accent" | "destructive" | "muted" | string;
+    /**
+     * Nombre de cercles concentriques
+     * @default 3
      */
-    rocketColor?: string;
+    rings?: 2 | 3 | 4 | 5;
     /**
-     * Couleur des astéroïdes (classe Tailwind ou couleur CSS)
-     * @default "text-muted-foreground"
+     * Afficher les particules flottantes
+     * @default true
      */
-    asteroidColor?: string;
+    showParticles?: boolean;
+    /**
+     * Afficher le pulse central
+     * @default true
+     */
+    showPulse?: boolean;
+    /**
+     * Opacité des anneaux (0-1)
+     * @default 0.6
+     */
+    ringOpacity?: number;
 }
 /**
- * WakaSpinner - Composant de chargement avec animation spatiale
+ * WakaSpinner - Composant de chargement style Jarvis/HUD futuriste
  *
- * Une fusée orbite autour d'un centre avec des astéroïdes flottants optionnels.
- * Idéal pour les écrans de chargement avec une touche ludique.
+ * Deux modes disponibles :
+ * - **infinite** : Cercles concentriques tournants pour processus continus
+ * - **loading** : Variante avec effet de scan pour indiquer une récupération de données
  *
  * @example
  * ```tsx
- * <WakaSpinner size="md" />
- * <WakaSpinner size="lg" showAsteroids={true} speed={3} />
- * <WakaSpinner rocketColor="text-blue-500" asteroidColor="text-gray-400" />
+ * // Mode infini simple
+ * <WakaSpinner mode="infinite" label="Processing" />
+ *
+ * // Mode loading avec sous-label
+ * <WakaSpinner mode="loading" label="Loading" subLabel="Fetching data..." />
+ *
+ * // Personnalisé
+ * <WakaSpinner
+ *   mode="infinite"
+ *   size="lg"
+ *   rings={4}
+ *   color="accent"
+ *   label="JARVIS"
+ * />
  * ```
  */
 export declare const WakaSpinner: React.ForwardRefExoticComponent<WakaSpinnerProps & React.RefAttributes<HTMLDivElement>>;
-export {};
+export default WakaSpinner;

package/dist/components/waka-stat/index.d.ts

@@ -0,0 +1,57 @@
+import * as React from "react";
+export type TrendDirection = "up" | "down" | "neutral";
+export interface WakaStatProps {
+    /** Libellé de la statistique */
+    label: string;
+    /** Valeur principale */
+    value: string | number;
+    /** Description ou sous-titre */
+    description?: string;
+    /** Icône à afficher */
+    icon?: React.ReactNode;
+    /** Direction de la tendance */
+    trend?: TrendDirection;
+    /** Valeur de la tendance (ex: "+12%") */
+    trendValue?: string;
+    /** Texte de la tendance (ex: "vs last month") */
+    trendText?: string;
+    /** Inverser les couleurs de tendance (down=good) */
+    invertTrend?: boolean;
+    /** Variante visuelle */
+    variant?: "default" | "card" | "minimal" | "gradient";
+    /** Taille */
+    size?: "sm" | "md" | "lg";
+    /** Couleur de l'icône/accent */
+    color?: "default" | "primary" | "success" | "warning" | "destructive" | "blue" | "purple";
+    /** Afficher un indicateur de chargement */
+    loading?: boolean;
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export interface WakaStatGroupProps {
+    /** Statistiques à afficher */
+    children: React.ReactNode;
+    /** Disposition */
+    layout?: "row" | "grid";
+    /** Nombre de colonnes (pour grid) */
+    columns?: 2 | 3 | 4;
+    /** Espacement */
+    gap?: "sm" | "md" | "lg";
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export declare function WakaStat({ label, value, description, icon, trend, trendValue, trendText, invertTrend, variant, size, color, loading, className, }: WakaStatProps): import("react/jsx-runtime").JSX.Element;
+export declare function WakaStatGroup({ children, layout, columns, gap, className, }: WakaStatGroupProps): import("react/jsx-runtime").JSX.Element;
+export interface UseStatOptions {
+    initialValue?: number;
+    format?: (value: number) => string;
+    previousValue?: number;
+}
+export declare function useStat(options?: UseStatOptions): {
+    value: string;
+    rawValue: number;
+    setValue: React.Dispatch<React.SetStateAction<number>>;
+    trend: TrendDirection;
+    trendValue: string | undefined;
+};
+export default WakaStat;

package/dist/components/waka-stepper/index.d.ts

@@ -0,0 +1,76 @@
+import * as React from "react";
+export type StepStatus = "pending" | "current" | "completed" | "error";
+export interface Step {
+    /** Identifiant unique de l'étape */
+    id: string;
+    /** Titre de l'étape */
+    title: string;
+    /** Description optionnelle */
+    description?: string;
+    /** Icône personnalisée (optionnel) */
+    icon?: React.ReactNode;
+    /** Contenu de l'étape */
+    content?: React.ReactNode;
+    /** Étape optionnelle (peut être sautée) */
+    optional?: boolean;
+    /** Désactiver l'étape */
+    disabled?: boolean;
+}
+export interface WakaStepperProps {
+    /** Liste des étapes */
+    steps: Step[];
+    /** Index de l'étape courante (0-indexed) */
+    currentStep: number;
+    /** Callback lors du changement d'étape */
+    onStepChange?: (stepIndex: number) => void;
+    /** Orientation du stepper */
+    orientation?: "horizontal" | "vertical";
+    /** Variante visuelle */
+    variant?: "default" | "simple" | "numbered";
+    /** Taille */
+    size?: "sm" | "md" | "lg";
+    /** Autoriser la navigation en cliquant sur les étapes */
+    clickable?: boolean;
+    /** Autoriser uniquement la navigation vers les étapes précédentes */
+    allowPrevious?: boolean;
+    /** Afficher le contenu de l'étape */
+    showContent?: boolean;
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export interface StepperContextValue {
+    currentStep: number;
+    orientation: "horizontal" | "vertical";
+    variant: "default" | "simple" | "numbered";
+    size: "sm" | "md" | "lg";
+    clickable: boolean;
+    allowPrevious: boolean;
+    goToStep: (index: number) => void;
+    nextStep: () => void;
+    prevStep: () => void;
+    getStepStatus: (index: number) => StepStatus;
+}
+export declare function useStepperContext(): StepperContextValue;
+export declare function WakaStepper({ steps, currentStep, onStepChange, orientation, variant, size, clickable, allowPrevious, showContent, className, }: WakaStepperProps): import("react/jsx-runtime").JSX.Element;
+export interface StepperNavigationProps {
+    /** Texte du bouton précédent */
+    prevLabel?: string;
+    /** Texte du bouton suivant */
+    nextLabel?: string;
+    /** Texte du bouton de fin */
+    finishLabel?: string;
+    /** Callback lors du clic sur Terminer */
+    onFinish?: () => void;
+    /** Afficher le bouton Annuler */
+    showCancel?: boolean;
+    /** Texte du bouton Annuler */
+    cancelLabel?: string;
+    /** Callback lors du clic sur Annuler */
+    onCancel?: () => void;
+    /** Désactiver le bouton Suivant */
+    disableNext?: boolean;
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export declare function StepperNavigation({ prevLabel, nextLabel, finishLabel, onFinish, showCancel, cancelLabel, onCancel, disableNext, className, }: StepperNavigationProps): import("react/jsx-runtime").JSX.Element;
+export default WakaStepper;

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

@@ -5,6 +5,40 @@ export interface ThemeVersion {
     changelog?: string;
     css: string;
 }
+/**
+ * Ressource personnalisée pour le thème
+ */
+export interface ThemeCustomResource {
+    /** Clé unique de la ressource */
+    key: string;
+    /** URL de la ressource (après upload S3) */
+    url: string;
+    /** Type de fichier */
+    type: "image" | "icon" | "font" | "other";
+    /** Nom du fichier original */
+    filename: string;
+    /** Taille en octets */
+    size?: number;
+}
+/**
+ * Configuration des assets du thème (login, etc.)
+ */
+export interface ThemeAssets {
+    /** Logo pour le mode clair */
+    logo_light?: string;
+    /** Logo pour le mode sombre */
+    logo_dark?: string;
+    /** Image de fond pour le mode clair */
+    background_light?: string;
+    /** Image de fond pour le mode sombre */
+    background_dark?: string;
+    /** Favicon */
+    favicon?: string;
+    /** Image de sponsor (mode clair) */
+    sponsor_light?: string;
+    /** Image de sponsor (mode sombre) */
+    sponsor_dark?: string;
+}
 export interface ThemeMetadata {
     id: string;
     label: string;
@@ -13,47 +47,64 @@ export interface ThemeMetadata {
     author?: string;
     versions: ThemeVersion[];
     currentVersion: string;
+    /** Assets du thème (logos, backgrounds) */
+    assets?: ThemeAssets;
+    /** Ressources personnalisées */
+    customResources?: ThemeCustomResource[];
 }
-export interface S3UploadConfig {
-    /** URL de base du bucket S3 */
-    baseUrl: string;
-    /** Méthode HTTP pour l'upload (PUT ou POST) */
-    method?: "PUT" | "POST";
-    /** Headers personnalisés pour l'authentification */
-    headers?: Record<string, string>;
-    /** Préfixe des fichiers */
-    prefix?: string;
-    /** Extension des fichiers */
-    extension?: string;
+/**
+ * Réponse de l'API d'upload de fichier
+ */
+export interface FileUploadResponse {
+    /** URL du fichier uploadé */
+    url: string;
+    /** Nom du fichier */
+    filename?: string;
+    /** Taille du fichier en octets */
+    size?: number;
 }
-export interface WakaThemeCreatorProps {
-    /** Configuration S3 pour l'upload */
-    s3Config: S3UploadConfig;
-    /** Callback après sauvegarde réussie */
-    onSave?: (theme: ThemeMetadata) => void;
-    /** Callback après suppression */
-    onDelete?: (themeId: string) => void;
-    /** Callback pour charger un thème depuis S3 */
+/**
+ * Configuration de l'API pour le ThemeCreator
+ */
+export interface ThemeCreatorApiConfig {
+    /** Callback pour uploader un fichier (logo, background, etc.) */
+    onUploadFile: (file: File, themeId: string, assetType: string) => Promise<FileUploadResponse>;
+    /** Callback pour sauvegarder le thème complet */
+    onSaveTheme: (theme: ThemeMetadata) => Promise<void>;
+    /** Callback pour supprimer un thème */
+    onDeleteTheme?: (themeId: string) => Promise<void>;
+    /** Callback pour charger les détails d'un thème */
     onLoadTheme?: (themeId: string) => Promise<ThemeMetadata | null>;
+    /** Callback pour supprimer un asset */
+    onDeleteAsset?: (themeId: string, assetType: string) => Promise<void>;
+}
+export interface WakaThemeCreatorProps {
+    /** Configuration de l'API */
+    apiConfig: ThemeCreatorApiConfig;
     /** Thèmes existants à charger */
     existingThemes?: ThemeMetadata[];
+    /** Callback après sauvegarde réussie */
+    onSaveSuccess?: (theme: ThemeMetadata) => void;
+    /** Callback après suppression */
+    onDeleteSuccess?: (themeId: string) => void;
     /** Classe CSS personnalisée */
     className?: string;
 }
 /**
  * WakaThemeCreator
  *
- * Composant d'administration pour créer, prévisualiser et publier des thèmes TweakCN sur S3.
+ * Composant d'administration pour créer, prévisualiser et publier des thèmes TweakCN.
  *
  * Features:
  * - Création de thèmes avec CSS TweakCN
  * - Prévisualisation en temps réel
  * - Gestion des versions
- * - Upload sur S3/MinIO
+ * - Upload via API (POST)
+ * - Gestion des ressources (logos, backgrounds, custom)
  * - Historique des modifications
  * - Validation du CSS
  */
-export declare function WakaThemeCreator({ s3Config, onSave, onDelete, onLoadTheme, existingThemes, className, }: WakaThemeCreatorProps): import("react/jsx-runtime").JSX.Element;
+export declare function WakaThemeCreator({ apiConfig, existingThemes, onSaveSuccess, onDeleteSuccess, className, }: WakaThemeCreatorProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace WakaThemeCreator {
     var displayName: string;
 }

package/dist/components/waka-time-picker/index.d.ts

@@ -0,0 +1,51 @@
+import * as React from "react";
+export interface WakaTimePickerProps {
+    /** Valeur sélectionnée (format HH:mm ou HH:mm:ss) */
+    value?: string;
+    /** Callback lors du changement */
+    onChange?: (value: string) => void;
+    /** Placeholder */
+    placeholder?: string;
+    /** Format d'affichage */
+    format?: "12h" | "24h";
+    /** Afficher les secondes */
+    showSeconds?: boolean;
+    /** Intervalle des minutes (5, 10, 15, 30) */
+    minuteStep?: number;
+    /** Intervalle des secondes */
+    secondStep?: number;
+    /** Heure minimum */
+    minTime?: string;
+    /** Heure maximum */
+    maxTime?: string;
+    /** Désactivé */
+    disabled?: boolean;
+    /** Erreur */
+    error?: boolean;
+    /** Taille */
+    size?: "sm" | "md" | "lg";
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** ID pour l'accessibilité */
+    id?: string;
+    /** Nom du champ */
+    name?: string;
+}
+export declare function WakaTimePicker({ value, onChange, placeholder, format, showSeconds, minuteStep, secondStep, minTime, maxTime, disabled, error, size, className, id, name, }: WakaTimePickerProps): import("react/jsx-runtime").JSX.Element;
+export interface UseTimePickerOptions {
+    /** Valeur initiale */
+    initialValue?: string;
+    /** Format */
+    format?: "12h" | "24h";
+    /** Afficher les secondes */
+    showSeconds?: boolean;
+}
+export declare function useTimePicker(options?: UseTimePickerOptions): {
+    value: string;
+    onChange: React.Dispatch<React.SetStateAction<string>>;
+    clear: () => void;
+    setNow: () => void;
+    format: "12h" | "24h";
+    showSeconds: boolean;
+};
+export default WakaTimePicker;

package/dist/components/waka-timeline/index.d.ts

@@ -0,0 +1,46 @@
+import * as React from "react";
+export type TimelineItemStatus = "completed" | "current" | "pending" | "error";
+export interface TimelineItem {
+    /** Identifiant unique */
+    id: string;
+    /** Titre de l'élément */
+    title: string;
+    /** Description */
+    description?: string;
+    /** Date/heure */
+    date?: Date | string;
+    /** Statut */
+    status?: TimelineItemStatus;
+    /** Icône personnalisée */
+    icon?: React.ReactNode;
+    /** Couleur personnalisée */
+    color?: string;
+    /** Contenu supplémentaire (collapsible) */
+    content?: React.ReactNode;
+    /** Données additionnelles */
+    data?: Record<string, unknown>;
+}
+export interface WakaTimelineProps {
+    /** Éléments de la timeline */
+    items: TimelineItem[];
+    /** Orientation */
+    orientation?: "vertical" | "horizontal";
+    /** Position de la ligne (vertical seulement) */
+    linePosition?: "left" | "center" | "right";
+    /** Taille */
+    size?: "sm" | "md" | "lg";
+    /** Afficher les dates */
+    showDates?: boolean;
+    /** Format de date */
+    dateFormat?: Intl.DateTimeFormatOptions;
+    /** Éléments collapsibles */
+    collapsible?: boolean;
+    /** Alterner les côtés (linePosition=center) */
+    alternate?: boolean;
+    /** Callback lors du clic sur un élément */
+    onItemClick?: (item: TimelineItem) => void;
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export declare function WakaTimeline({ items, orientation, linePosition, size, showDates, dateFormat, collapsible, alternate, onItemClick, className, }: WakaTimelineProps): import("react/jsx-runtime").JSX.Element;
+export default WakaTimeline;