@wakastellar/ui 0.1.4 → 0.1.5

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

@@ -0,0 +1,81 @@
+import * as React from "react";
+export interface ComboboxOption<T = string> {
+    /** Valeur unique de l'option */
+    value: T;
+    /** Libellé affiché */
+    label: string;
+    /** Description secondaire */
+    description?: string;
+    /** Icône */
+    icon?: React.ReactNode;
+    /** Désactiver l'option */
+    disabled?: boolean;
+    /** Groupe de l'option */
+    group?: string;
+}
+export interface WakaComboboxProps<T = string> {
+    /** Options disponibles */
+    options: ComboboxOption<T>[];
+    /** Valeur sélectionnée (single) ou valeurs (multiple) */
+    value?: T | T[];
+    /** Callback lors du changement */
+    onChange?: (value: T | T[] | undefined) => void;
+    /** Placeholder */
+    placeholder?: string;
+    /** Placeholder de recherche */
+    searchPlaceholder?: string;
+    /** Message si aucune option */
+    emptyMessage?: string;
+    /** Mode multiple */
+    multiple?: boolean;
+    /** Permettre la création de nouvelles options */
+    creatable?: boolean;
+    /** Callback lors de la création */
+    onCreate?: (inputValue: string) => ComboboxOption<T> | Promise<ComboboxOption<T>>;
+    /** Texte du bouton de création */
+    createLabel?: string;
+    /** Recherche asynchrone */
+    onSearch?: (query: string) => Promise<ComboboxOption<T>[]>;
+    /** Délai de debounce pour la recherche (ms) */
+    searchDebounce?: number;
+    /** Désactivé */
+    disabled?: boolean;
+    /** Erreur */
+    error?: boolean;
+    /** Chargement */
+    loading?: boolean;
+    /** Taille */
+    size?: "sm" | "md" | "lg";
+    /** Permettre de vider la sélection */
+    clearable?: boolean;
+    /** Nombre maximum de sélections (multiple) */
+    maxSelections?: number;
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** ID pour l'accessibilité */
+    id?: string;
+    /** Nom du champ */
+    name?: string;
+}
+export declare function WakaCombobox<T = string>({ options: initialOptions, value, onChange, placeholder, searchPlaceholder, emptyMessage, multiple, creatable, onCreate, createLabel, onSearch, searchDebounce, disabled, error, loading: externalLoading, size, clearable, maxSelections, className, id, name, }: WakaComboboxProps<T>): import("react/jsx-runtime").JSX.Element;
+export interface UseComboboxOptions<T = string> {
+    /** Options initiales */
+    options?: ComboboxOption<T>[];
+    /** Valeur initiale */
+    initialValue?: T | T[];
+    /** Mode multiple */
+    multiple?: boolean;
+}
+export declare function useCombobox<T = string>(options?: UseComboboxOptions<T>): {
+    value: T | T[] | undefined;
+    onChange: React.Dispatch<React.SetStateAction<T | T[] | undefined>>;
+    options: ComboboxOption<T>[];
+    setOptions: React.Dispatch<React.SetStateAction<ComboboxOption<T>[]>>;
+    clear: () => void;
+    addOption: (option: ComboboxOption<T>) => void;
+    removeOption: (valueToRemove: T) => void;
+    selectAll: () => void;
+    selectNone: () => void;
+    multiple: boolean;
+};
+export default WakaCombobox;

package/dist/components/waka-date-range-picker/index.d.ts

@@ -0,0 +1,68 @@
+import { Locale } from 'date-fns';
+import { DateRange as RdpDateRange } from 'react-day-picker';
+import * as React from "react";
+export type { DateRange as WakaDateRange } from 'react-day-picker';
+export interface WakaDateRangePickerProps {
+    /** Plage de dates sélectionnée */
+    value?: RdpDateRange;
+    /** Callback lors du changement */
+    onChange?: (range: RdpDateRange | undefined) => void;
+    /** Placeholder */
+    placeholder?: string;
+    /** Format d'affichage */
+    dateFormat?: string;
+    /** Date minimum */
+    minDate?: Date;
+    /** Date maximum */
+    maxDate?: Date;
+    /** Désactivé */
+    disabled?: boolean;
+    /** Erreur */
+    error?: boolean;
+    /** Afficher les presets */
+    showPresets?: boolean;
+    /** Presets personnalisés */
+    presets?: DateRangePreset[];
+    /** Nombre de mois affichés */
+    numberOfMonths?: number;
+    /** Locale */
+    locale?: Locale;
+    /** Taille */
+    size?: "sm" | "md" | "lg";
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** ID pour l'accessibilité */
+    id?: string;
+    /** Nom du champ */
+    name?: string;
+    /** Permettre de vider la sélection */
+    clearable?: boolean;
+}
+export interface DateRangePreset {
+    label: string;
+    getValue: () => RdpDateRange;
+}
+declare const defaultPresets: DateRangePreset[];
+export declare function WakaDateRangePicker({ value, onChange, placeholder, dateFormat, minDate, maxDate, disabled, error, showPresets, presets, numberOfMonths, locale, size, className, id, name, clearable, }: WakaDateRangePickerProps): import("react/jsx-runtime").JSX.Element;
+export interface UseDateRangePickerOptions {
+    /** Valeur initiale */
+    initialValue?: RdpDateRange;
+    /** Date minimum */
+    minDate?: Date;
+    /** Date maximum */
+    maxDate?: Date;
+}
+export declare function useDateRangePicker(options?: UseDateRangePickerOptions): {
+    value: RdpDateRange | undefined;
+    onChange: React.Dispatch<React.SetStateAction<RdpDateRange | undefined>>;
+    clear: () => void;
+    setToday: () => void;
+    setThisWeek: () => void;
+    setThisMonth: () => void;
+    isValidRange: () => boolean;
+    dayCount: number | null;
+    minDate: Date | undefined;
+    maxDate: Date | undefined;
+};
+export { defaultPresets };
+export default WakaDateRangePicker;

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

@@ -0,0 +1,59 @@
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+export type DrawerPosition = "left" | "right" | "top" | "bottom";
+export type DrawerSize = "sm" | "md" | "lg" | "xl" | "full";
+export interface WakaDrawerProps {
+    /** État d'ouverture */
+    open: boolean;
+    /** Callback de fermeture */
+    onOpenChange: (open: boolean) => void;
+    /** Position du drawer */
+    position?: DrawerPosition;
+    /** Taille du drawer */
+    size?: DrawerSize;
+    /** Titre du drawer */
+    title?: string;
+    /** Description du drawer */
+    description?: string;
+    /** Afficher le bouton de fermeture */
+    showCloseButton?: boolean;
+    /** Fermer en cliquant sur l'overlay */
+    closeOnOverlayClick?: boolean;
+    /** Fermer avec la touche Escape */
+    closeOnEscape?: boolean;
+    /** Afficher l'overlay */
+    showOverlay?: boolean;
+    /** Contenu du drawer */
+    children?: React.ReactNode;
+    /** Footer avec actions */
+    footer?: React.ReactNode;
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** Classes CSS pour le contenu */
+    contentClassName?: string;
+}
+export declare const DrawerHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const DrawerBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const DrawerFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const DrawerTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+export declare const DrawerDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export declare function WakaDrawer({ open, onOpenChange, position, size, title, description, showCloseButton, closeOnOverlayClick, closeOnEscape, showOverlay, children, footer, className, contentClassName, }: WakaDrawerProps): import("react/jsx-runtime").JSX.Element;
+export interface UseDrawerOptions {
+    /** État initial */
+    defaultOpen?: boolean;
+    /** Callback lors de l'ouverture */
+    onOpen?: () => void;
+    /** Callback lors de la fermeture */
+    onClose?: () => void;
+}
+export interface UseDrawerReturn {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    openDrawer: () => void;
+    closeDrawer: () => void;
+    toggleDrawer: () => void;
+}
+export declare function useDrawer(options?: UseDrawerOptions): UseDrawerReturn;
+export declare const DrawerTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+export declare const DrawerClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+export default WakaDrawer;

package/dist/components/waka-file-upload/index.d.ts

@@ -0,0 +1,49 @@
+import * as React from "react";
+export type FileUploadVariant = "dropzone" | "button" | "inline";
+export interface UploadedFile {
+    id: string;
+    file: File;
+    progress: number;
+    status: "pending" | "uploading" | "success" | "error";
+    error?: string;
+    url?: string;
+}
+export interface WakaFileUploadProps {
+    /** Variant d'affichage */
+    variant?: FileUploadVariant;
+    /** Types de fichiers acceptés (ex: "image/*", ".pdf,.doc") */
+    accept?: string;
+    /** Taille max par fichier en bytes */
+    maxSize?: number;
+    /** Nombre max de fichiers */
+    maxFiles?: number;
+    /** Upload multiple */
+    multiple?: boolean;
+    /** Callback d'upload (retourne l'URL ou throw une erreur) */
+    onUpload?: (file: File, onProgress: (progress: number) => void) => Promise<string>;
+    /** Callback après tous les uploads */
+    onComplete?: (files: UploadedFile[]) => void;
+    /** Callback lors de la suppression */
+    onRemove?: (file: UploadedFile) => void;
+    /** Callback d'erreur */
+    onError?: (error: string, file?: File) => void;
+    /** Afficher la prévisualisation */
+    showPreview?: boolean;
+    /** Afficher la barre de progression */
+    showProgress?: boolean;
+    /** Désactivé */
+    disabled?: boolean;
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** Placeholder */
+    placeholder?: string;
+    /** Label */
+    label?: string;
+    /** Description */
+    description?: string;
+}
+/**
+ * Composant WakaFileUpload
+ */
+export declare const WakaFileUpload: React.ForwardRefExoticComponent<WakaFileUploadProps & React.RefAttributes<HTMLDivElement>>;
+export default WakaFileUpload;

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

@@ -0,0 +1,59 @@
+export interface WakaImageProps {
+    /** URL de l'image */
+    src: string;
+    /** Texte alternatif */
+    alt: string;
+    /** Largeur */
+    width?: number | string;
+    /** Hauteur */
+    height?: number | string;
+    /** Image placeholder (base64 ou URL) */
+    placeholder?: string;
+    /** Couleur de fond du placeholder */
+    placeholderColor?: string;
+    /** Activer le lazy loading */
+    lazy?: boolean;
+    /** Activer le zoom au clic */
+    zoomable?: boolean;
+    /** Niveau de zoom maximum */
+    maxZoom?: number;
+    /** Object fit */
+    objectFit?: "contain" | "cover" | "fill" | "none" | "scale-down";
+    /** Object position */
+    objectPosition?: string;
+    /** Arrondi des coins */
+    rounded?: "none" | "sm" | "md" | "lg" | "xl" | "full";
+    /** Afficher un indicateur de chargement */
+    showLoader?: boolean;
+    /** Callback quand l'image est chargée */
+    onLoad?: () => void;
+    /** Callback en cas d'erreur */
+    onError?: () => void;
+    /** Callback quand le zoom change */
+    onZoomChange?: (zoom: number) => void;
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** Classes CSS pour le conteneur */
+    containerClassName?: string;
+    /** Ratio d'aspect (ex: "16/9", "4/3", "1/1") */
+    aspectRatio?: string;
+}
+export declare function WakaImage({ src, alt, width, height, placeholder, placeholderColor, lazy, zoomable, maxZoom, objectFit, objectPosition, rounded, showLoader, onLoad, onError, onZoomChange, className, containerClassName, aspectRatio, }: WakaImageProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaImageGalleryProps {
+    /** Liste des images */
+    images: Array<{
+        src: string;
+        alt: string;
+        thumbnail?: string;
+    }>;
+    /** Nombre de colonnes */
+    columns?: number;
+    /** Gap entre les images */
+    gap?: number;
+    /** Aspect ratio des images */
+    aspectRatio?: string;
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export declare function WakaImageGallery({ images, columns, gap, aspectRatio, className, }: WakaImageGalleryProps): import("react/jsx-runtime").JSX.Element;
+export default WakaImage;

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

@@ -0,0 +1,68 @@
+import * as React from "react";
+export interface KanbanCard {
+    id: string;
+    title: string;
+    description?: string;
+    labels?: Array<{
+        id: string;
+        name: string;
+        color: string;
+    }>;
+    assignee?: {
+        id: string;
+        name: string;
+        avatar?: string;
+    };
+    priority?: "low" | "medium" | "high" | "urgent";
+    dueDate?: Date;
+    data?: Record<string, unknown>;
+}
+export interface KanbanColumn {
+    id: string;
+    title: string;
+    cards: KanbanCard[];
+    color?: string;
+    limit?: number;
+}
+export interface WakaKanbanProps {
+    /** Colonnes du kanban */
+    columns: KanbanColumn[];
+    /** Callback lors du déplacement d'une carte */
+    onCardMove?: (cardId: string, fromColumnId: string, toColumnId: string, newIndex: number) => void;
+    /** Callback lors du déplacement d'une colonne */
+    onColumnMove?: (columnId: string, newIndex: number) => void;
+    /** Callback lors de l'ajout d'une carte */
+    onCardAdd?: (columnId: string, card: Partial<KanbanCard>) => void;
+    /** Callback lors de la suppression d'une carte */
+    onCardDelete?: (cardId: string, columnId: string) => void;
+    /** Callback lors du clic sur une carte */
+    onCardClick?: (card: KanbanCard, columnId: string) => void;
+    /** Callback lors de l'ajout d'une colonne */
+    onColumnAdd?: (column: Partial<KanbanColumn>) => void;
+    /** Callback lors de la suppression d'une colonne */
+    onColumnDelete?: (columnId: string) => void;
+    /** Permettre l'ajout de cartes */
+    allowAddCard?: boolean;
+    /** Permettre l'ajout de colonnes */
+    allowAddColumn?: boolean;
+    /** Permettre le déplacement des colonnes */
+    allowColumnDrag?: boolean;
+    /** Fonction de rendu personnalisée pour les cartes */
+    renderCard?: (card: KanbanCard, columnId: string) => React.ReactNode;
+    /** Hauteur du kanban */
+    height?: number | string;
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export declare function WakaKanban({ columns, onCardMove, onColumnMove, onCardAdd, onCardDelete, onCardClick, onColumnAdd, onColumnDelete, allowAddCard, allowAddColumn, allowColumnDrag, renderCard, height, className, }: WakaKanbanProps): import("react/jsx-runtime").JSX.Element;
+export declare function useKanban(initialColumns: KanbanColumn[]): {
+    columns: KanbanColumn[];
+    setColumns: React.Dispatch<React.SetStateAction<KanbanColumn[]>>;
+    moveCard: (cardId: string, fromColumnId: string, toColumnId: string, newIndex: number) => void;
+    moveColumn: (columnId: string, newIndex: number) => void;
+    addCard: (columnId: string, card: Partial<KanbanCard>) => void;
+    deleteCard: (cardId: string, columnId: string) => void;
+    addColumn: (column: Partial<KanbanColumn>) => void;
+    deleteColumn: (columnId: string) => void;
+};
+export default WakaKanban;

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

@@ -0,0 +1,82 @@
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+export type ModalSize = "sm" | "md" | "lg" | "xl" | "full";
+export interface WakaModalProps {
+    /** État d'ouverture */
+    open: boolean;
+    /** Callback de fermeture */
+    onOpenChange: (open: boolean) => void;
+    /** Titre du modal */
+    title?: string;
+    /** Description du modal */
+    description?: string;
+    /** Contenu du modal */
+    children: React.ReactNode;
+    /** Taille du modal */
+    size?: ModalSize;
+    /** Afficher le bouton de fermeture */
+    showCloseButton?: boolean;
+    /** Fermer en cliquant sur l'overlay */
+    closeOnOverlayClick?: boolean;
+    /** Fermer avec la touche Escape */
+    closeOnEscape?: boolean;
+    /** Animation d'entrée/sortie */
+    animation?: "fade" | "slide" | "scale" | "none";
+    /** Centré verticalement */
+    centered?: boolean;
+    /** Sticky header */
+    stickyHeader?: boolean;
+    /** Sticky footer (pour les actions) */
+    stickyFooter?: boolean;
+    /** Footer avec actions */
+    footer?: React.ReactNode;
+    /** Classes CSS additionnelles pour le contenu */
+    className?: string;
+    /** Classes CSS pour l'overlay */
+    overlayClassName?: string;
+}
+declare const ModalOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    animation?: "fade" | "slide" | "scale" | "none";
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ModalContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    size?: ModalSize;
+    animation?: "fade" | "slide" | "scale" | "none";
+    centered?: boolean;
+    showCloseButton?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+interface ModalHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    sticky?: boolean;
+}
+declare const ModalHeader: React.ForwardRefExoticComponent<ModalHeaderProps & React.RefAttributes<HTMLDivElement>>;
+declare const ModalTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const ModalDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const ModalBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+interface ModalFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+    sticky?: boolean;
+}
+declare const ModalFooter: React.ForwardRefExoticComponent<ModalFooterProps & React.RefAttributes<HTMLDivElement>>;
+export declare function WakaModal({ open, onOpenChange, title, description, children, size, showCloseButton, closeOnOverlayClick, closeOnEscape, animation, centered, stickyHeader, stickyFooter, footer, className, overlayClassName, }: WakaModalProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaModalTriggerProps {
+    /** Contenu du trigger */
+    children: React.ReactNode;
+    /** Callback d'ouverture */
+    onOpen?: () => void;
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** Désactiver le trigger */
+    disabled?: boolean;
+}
+export declare function WakaModalTrigger({ children, onOpen, className, disabled, }: WakaModalTriggerProps): import("react/jsx-runtime").JSX.Element;
+export interface UseModalOptions {
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export declare function useModal(options?: UseModalOptions): {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    onOpenChange: (open: boolean) => void;
+};
+export { ModalOverlay, ModalContent, ModalHeader, ModalTitle, ModalDescription, ModalBody, ModalFooter, };
+export default WakaModal;

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-rich-text-editor/index.d.ts

@@ -0,0 +1,36 @@
+import * as React from "react";
+export type ToolbarButton = "bold" | "italic" | "underline" | "strike" | "h1" | "h2" | "h3" | "bulletList" | "orderedList" | "blockquote" | "code" | "link" | "alignLeft" | "alignCenter" | "alignRight" | "undo" | "redo";
+export interface WakaRichTextEditorProps {
+    /** Contenu HTML */
+    value?: string;
+    /** Callback de changement */
+    onChange?: (html: string) => void;
+    /** Configuration de la toolbar */
+    toolbar?: ToolbarButton[][];
+    /** Placeholder */
+    placeholder?: string;
+    /** Longueur max */
+    maxLength?: number;
+    /** Afficher le compteur de caractères */
+    showCharacterCount?: boolean;
+    /** Hauteur min */
+    minHeight?: number;
+    /** Désactivé */
+    disabled?: boolean;
+    /** Erreur */
+    error?: string;
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** Label */
+    label?: string;
+    /** Description */
+    description?: string;
+    /** Mode éditable */
+    editable?: boolean;
+}
+/**
+ * Composant WakaRichTextEditor
+ * Utilise Tiptap si disponible, sinon fallback sur textarea
+ */
+export declare const WakaRichTextEditor: React.ForwardRefExoticComponent<WakaRichTextEditorProps & React.RefAttributes<HTMLDivElement>>;
+export default WakaRichTextEditor;