@wakastellar/ui 0.1.0

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

@@ -0,0 +1,85 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const textVariants: (props?: ({
+    variant?: "default" | "link" | "muted" | "destructive" | "success" | "warning" | null | undefined;
+    size?: "base" | "sm" | "lg" | "xs" | "xl" | null | undefined;
+    weight?: "bold" | "normal" | "medium" | "semibold" | null | undefined;
+    align?: "center" | "left" | "right" | "justify" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export interface TextProps extends React.HTMLAttributes<HTMLParagraphElement>, VariantProps<typeof textVariants> {
+    asChild?: boolean;
+    truncate?: boolean;
+}
+/**
+ * Text - Composant de texte avec variantes de style
+ *
+ * @example
+ * ```tsx
+ * <Text variant="muted" size="sm">Texte secondaire</Text>
+ * <Text variant="destructive" weight="bold">Erreur importante</Text>
+ * ```
+ */
+declare const Text: React.ForwardRefExoticComponent<TextProps & React.RefAttributes<HTMLParagraphElement>>;
+declare const headingVariants: (props?: ({
+    level?: "h2" | "h3" | "h1" | "h4" | "h5" | "h6" | null | undefined;
+    variant?: "default" | "muted" | "gradient" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export interface HeadingProps extends React.HTMLAttributes<HTMLHeadingElement>, VariantProps<typeof headingVariants> {
+    asChild?: boolean;
+}
+/**
+ * Heading - Composant de titre avec niveaux sémantiques
+ *
+ * @example
+ * ```tsx
+ * <Heading level="h1">Titre principal</Heading>
+ * <Heading level="h2" variant="gradient">Sous-titre avec gradient</Heading>
+ * ```
+ */
+declare const Heading: React.ForwardRefExoticComponent<HeadingProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const blockquoteVariants: (props?: ({
+    variant?: "default" | "destructive" | "success" | "warning" | "primary" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export interface BlockquoteProps extends React.BlockquoteHTMLAttributes<HTMLQuoteElement>, VariantProps<typeof blockquoteVariants> {
+    cite?: string;
+    author?: string;
+}
+/**
+ * Blockquote - Citation avec bordure et style
+ *
+ * @example
+ * ```tsx
+ * <Blockquote author="Oscar Wilde">
+ *   Soyez vous-même, tous les autres sont déjà pris.
+ * </Blockquote>
+ * ```
+ */
+declare const Blockquote: React.ForwardRefExoticComponent<BlockquoteProps & React.RefAttributes<HTMLQuoteElement>>;
+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;
+}
+declare const kbdVariants: (props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export interface KbdProps extends React.HTMLAttributes<HTMLElement>, VariantProps<typeof kbdVariants> {
+}
+/**
+ * Kbd - Affichage de touches clavier
+ *
+ * @example
+ * ```tsx
+ * <Kbd>Ctrl</Kbd> + <Kbd>C</Kbd>
+ * <Kbd size="lg">⌘ Command</Kbd>
+ * ```
+ */
+declare const Kbd: React.ForwardRefExoticComponent<KbdProps & React.RefAttributes<HTMLElement>>;
+export { Text, Heading, Blockquote, Kbd };
+export { textVariants, headingVariants, blockquoteVariants, kbdVariants };

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

@@ -0,0 +1,41 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+export interface AdmincrumbItem {
+    id: string;
+    name: string;
+    type: "partner" | "network" | "customer";
+    metadata?: Record<string, any>;
+}
+export interface AdmincrumbLevel {
+    type: "partner" | "network" | "customer";
+    items: AdmincrumbItem[];
+    selected?: AdmincrumbItem;
+    isLoading?: boolean;
+    onSelect: (item: AdmincrumbItem) => void;
+    placeholder?: string;
+    emptyText?: string;
+}
+declare const admincrumbVariants: (props?: ({
+    variant?: "default" | "inline" | "compact" | "minimal" | "pills" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export interface WakaAdmincrumbProps extends VariantProps<typeof admincrumbVariants> {
+    levels: AdmincrumbLevel[];
+    separator?: React.ReactNode;
+    className?: string;
+    onLevelChange?: (level: number, item: AdmincrumbItem) => void;
+    showIcons?: boolean;
+    showBadges?: boolean;
+    showHome?: boolean;
+    maxWidth?: string;
+    resetable?: boolean;
+    onReset?: () => void;
+}
+export declare const WakaAdmincrumb: React.ForwardRefExoticComponent<WakaAdmincrumbProps & React.RefAttributes<HTMLDivElement>>;
+export declare function useAdmincrumb(): {
+    partner: AdmincrumbItem | undefined;
+    network: AdmincrumbItem | undefined;
+    customer: AdmincrumbItem | undefined;
+    handleLevelChange: (level: number, item: AdmincrumbItem) => void;
+    reset: () => void;
+};
+export {};

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

@@ -0,0 +1,105 @@
+import { default as React } from 'react';
+export interface CarouselImage {
+    src: string;
+    alt: string;
+    title?: string;
+    description?: string;
+    caption?: string;
+    downloadUrl?: string;
+    shareUrl?: string;
+    metadata?: {
+        width?: number;
+        height?: number;
+        size?: string;
+        format?: string;
+    };
+}
+export type CarouselTransition = 'fade' | 'slide' | 'zoom' | 'flip';
+export type CarouselLayout = 'default' | 'fullscreen' | 'compact' | 'gallery';
+export type CarouselTheme = 'light' | 'dark' | 'auto';
+export interface WakaCarouselProps {
+    images: CarouselImage[];
+    autoplay?: boolean;
+    autoplayInterval?: number;
+    showIndicators?: boolean;
+    showNavigation?: boolean;
+    showThumbnails?: boolean;
+    showFullscreen?: boolean;
+    showDownload?: boolean;
+    showShare?: boolean;
+    showCounter?: boolean;
+    showProgress?: boolean;
+    transition?: CarouselTransition;
+    layout?: CarouselLayout;
+    theme?: CarouselTheme;
+    aspectRatio?: '16/9' | '4/3' | '1/1' | '3/2' | 'auto';
+    maxHeight?: string | number;
+    className?: string;
+    imageClassName?: string;
+    indicatorClassName?: string;
+    navigationClassName?: string;
+    thumbnailClassName?: string;
+    overlayClassName?: string;
+    counterClassName?: string;
+    progressClassName?: string;
+    onImageChange?: (index: number, image: CarouselImage) => void;
+    onImageClick?: (image: CarouselImage, index: number) => void;
+    onFullscreenToggle?: (isFullscreen: boolean) => void;
+    onDownload?: (image: CarouselImage, index: number) => void;
+    onShare?: (image: CarouselImage, index: number) => void;
+    onPlayPause?: (isPlaying: boolean) => void;
+    onThumbnailClick?: (index: number) => void;
+    onIndicatorClick?: (index: number) => void;
+    onNavigationClick?: (direction: 'prev' | 'next') => void;
+    onKeyboardNavigation?: (key: string) => void;
+    onTouchStart?: (event: React.TouchEvent) => void;
+    onTouchEnd?: (event: React.TouchEvent) => void;
+    onSwipeLeft?: () => void;
+    onSwipeRight?: () => void;
+    onSwipeUp?: () => void;
+    onSwipeDown?: () => void;
+    onLoadStart?: (index: number) => void;
+    onLoadEnd?: (index: number) => void;
+    onError?: (index: number, error: Error) => void;
+    onReady?: () => void;
+    onDestroy?: () => void;
+    loop?: boolean;
+    pauseOnHover?: boolean;
+    pauseOnFocus?: boolean;
+    pauseOnTouch?: boolean;
+    keyboardNavigation?: boolean;
+    touchNavigation?: boolean;
+    swipeThreshold?: number;
+    animationDuration?: number;
+    preloadImages?: boolean;
+    lazyLoading?: boolean;
+    imageQuality?: 'low' | 'medium' | 'high' | 'auto';
+    placeholder?: string;
+    errorImage?: string;
+    loadingSpinner?: React.ReactNode;
+    emptyState?: React.ReactNode;
+    customControls?: React.ReactNode;
+    customOverlay?: React.ReactNode;
+    customThumbnails?: React.ReactNode;
+    customIndicators?: React.ReactNode;
+    customNavigation?: React.ReactNode;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+    ariaDescribedBy?: string;
+    role?: string;
+    virtualScrolling?: boolean;
+    maxVisibleThumbnails?: number;
+    thumbnailSize?: 'small' | 'medium' | 'large';
+    overlayOpacity?: number;
+    overlayGradient?: string;
+    navigationSize?: 'small' | 'medium' | 'large';
+    indicatorSize?: 'small' | 'medium' | 'large';
+    indicatorShape?: 'circle' | 'square' | 'diamond' | 'line';
+    thumbnailAspectRatio?: '1/1' | '4/3' | '16/9' | 'auto';
+    onMount?: () => void;
+    onUnmount?: () => void;
+    onBeforeChange?: (fromIndex: number, toIndex: number) => boolean;
+    onAfterChange?: (index: number) => void;
+}
+export declare const WakaCarousel: React.FC<WakaCarouselProps>;
+export default WakaCarousel;

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

@@ -0,0 +1,135 @@
+import * as React from "react";
+/**
+ * Configuration des presets de dates rapides
+ */
+export interface DatePreset {
+    label: string;
+    value?: Date | (() => Date);
+    range?: {
+        from: Date;
+        to: Date;
+    } | (() => {
+        from: Date;
+        to: Date;
+    });
+}
+/**
+ * Configuration de validation
+ */
+export interface DateValidation {
+    /** Validation personnalisée */
+    validate?: (date: Date) => boolean | string;
+    /** Message d'erreur personnalisé */
+    message?: string;
+    /** Dates désactivées (patterns) */
+    disabledDates?: Date[];
+    /** Fonction pour désactiver des dates */
+    disabledDatesFn?: (date: Date) => boolean;
+    /** Jours de la semaine désactivés (0-6, 0 = Dimanche) */
+    disabledDaysOfWeek?: number[];
+    /** Dates highlightées */
+    highlightedDates?: Date[];
+    /** Fonction pour highlighter des dates */
+    highlightedDatesFn?: (date: Date) => boolean;
+}
+/**
+ * Range de dates
+ */
+export interface DateRange {
+    from: Date | undefined;
+    to: Date | undefined;
+}
+/**
+ * Props du WakaDateTimePicker
+ */
+export interface WakaDateTimePickerProps {
+    /** Valeur actuelle (Date simple ou DateRange) */
+    value?: Date | DateRange | Date[] | null;
+    /** Callback de changement */
+    onChange?: (date: Date | DateRange | Date[] | null) => void;
+    /** Placeholder du champ */
+    placeholder?: string;
+    /** Désactiver le picker */
+    disabled?: boolean;
+    /** Classe CSS supplémentaire */
+    className?: string;
+    /** Variant du picker */
+    variant?: "date" | "time" | "datetime" | "range" | "multiple";
+    /** Format d'affichage personnalisé */
+    format?: string;
+    /** Date minimum */
+    minDate?: Date;
+    /** Date maximum */
+    maxDate?: Date;
+    /** Afficher les secondes */
+    showSeconds?: boolean;
+    /** Afficher le bouton clear */
+    showClear?: boolean;
+    /** Afficher les presets rapides */
+    showPresets?: boolean;
+    /** Presets personnalisés */
+    presets?: DatePreset[];
+    /** Locale (fr, en, es, etc.) */
+    locale?: string;
+    /** Format d'heure (12h ou 24h) */
+    timeFormat?: "12h" | "24h";
+    /** Taille du composant */
+    size?: "sm" | "md" | "lg";
+    /** Message d'erreur */
+    error?: string;
+    /** Label du champ */
+    label?: string;
+    /** Champ requis */
+    required?: boolean;
+    /** Mode inline (sans popover) */
+    inline?: boolean;
+    /** Nombre de mois à afficher */
+    monthsShown?: number;
+    /** Intervalle de temps (en minutes) */
+    timeIntervals?: number;
+    /** Validation */
+    validation?: DateValidation;
+    /** Afficher les numéros de semaine */
+    showWeekNumbers?: boolean;
+    /** Afficher le bouton "Aujourd'hui" */
+    showTodayButton?: boolean;
+    /** Afficher les infos de sélection */
+    showSelectionInfo?: boolean;
+    /** Autoriser la sélection de plage de temps */
+    allowTimeRange?: boolean;
+    /** Timezone (pour affichage avancé) */
+    timezone?: string;
+    /** Callback avant changement (peut annuler) */
+    onBeforeChange?: (date: Date | DateRange | Date[] | null) => boolean;
+    /** Callback après changement */
+    onAfterChange?: (date: Date | DateRange | Date[] | null) => void;
+    /** Render personnalisé pour une date */
+    renderDay?: (date: Date) => React.ReactNode;
+    /** Classe pour le container du popover */
+    popoverClassName?: string;
+    /** Désactiver les animations */
+    disableAnimations?: boolean;
+    /** Mode lecture seule */
+    readOnly?: boolean;
+    /** ID du champ (pour les tests) */
+    id?: string;
+    /** Name du champ (pour les formulaires) */
+    name?: string;
+    /** Auto-focus */
+    autoFocus?: boolean;
+}
+/**
+ * WakaDateTimePicker
+ *
+ * Composant datetime picker ultra-complet avec support de :
+ * - Date, time, datetime, range, multiple selection
+ * - Presets rapides
+ * - Validation avancée
+ * - I18n complet
+ * - Thème dynamique
+ * - Keyboard navigation
+ * - Accessibilité (ARIA)
+ * - Time zones
+ * - Custom renders
+ */
+export declare const WakaDateTimePicker: React.ForwardRefExoticComponent<WakaDateTimePickerProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/waka-datetime-picker.form-integration/index.d.ts

@@ -0,0 +1,69 @@
+import { Control, FieldValues, Path } from 'react-hook-form';
+import { WakaDateTimePickerProps, DateRange } from '../waka-datetime-picker';
+/**
+ * Props pour le wrapper React Hook Form
+ */
+interface WakaDateTimePickerFormProps<T extends FieldValues> extends Omit<WakaDateTimePickerProps, "value" | "onChange"> {
+    name: Path<T>;
+    control: Control<T>;
+    defaultValue?: Date | DateRange | null;
+}
+/**
+ * Wrapper pour React Hook Form
+ *
+ * @example
+ * ```tsx
+ * import { useForm } from "react-hook-form"
+ * import { WakaDateTimePickerForm } from "@wakastart/ui"
+ *
+ * function MyForm() {
+ *   const { control, handleSubmit } = useForm()
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit(onSubmit)}>
+ *       <WakaDateTimePickerForm
+ *         name="birthdate"
+ *         control={control}
+ *         label="Date de naissance"
+ *         required
+ *       />
+ *     </form>
+ *   )
+ * }
+ * ```
+ */
+export declare function WakaDateTimePickerForm<T extends FieldValues>({ name, control, defaultValue, ...props }: WakaDateTimePickerFormProps<T>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Exemple d'utilisation complète avec React Hook Form
+ */
+/**
+ * Exemple avec validation personnalisée
+ */
+/**
+ * Exemple avec plusieurs dates (congés)
+ */
+/**
+ * Exemple avec dépendances entre dates
+ */
+/**
+ * Hook personnalisé pour les formulaires de dates
+ */
+export declare function useDateForm<T extends FieldValues>(defaultValues?: Partial<T>): {
+    formatDateForSubmit: (date: Date | null) => string | null;
+    formatRangeForSubmit: (range: DateRange | null) => {
+        from: string;
+        to: string;
+    } | null;
+    parseDateFromServer: (dateString: string | null) => Date | null;
+    parseRangeFromServer: (rangeData: {
+        from: string;
+        to: string;
+    } | null) => {
+        from: Date;
+        to: Date;
+    } | null;
+};
+export {};
+/**
+ * Exemple avec transformation des données
+ */

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

@@ -0,0 +1,40 @@
+import * as React from "react";
+export interface Notification {
+    id: string;
+    title: string;
+    message: string;
+    type: "info" | "success" | "warning" | "error";
+    read: boolean;
+    timestamp: Date;
+    icon?: React.ReactNode;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+export interface WakaNotificationsProps {
+    notifications: Notification[];
+    onMarkAsRead?: (id: string) => void;
+    onMarkAllAsRead?: () => void;
+    onDelete?: (id: string) => void;
+    onDeleteAll?: () => void;
+    onSettingsClick?: () => void;
+    maxHeight?: string;
+    className?: string;
+    iconClassName?: string;
+    badgeClassName?: string;
+    showBadge?: boolean;
+    showTabs?: boolean;
+    emptyMessage?: string;
+    emptyIcon?: React.ReactNode;
+}
+export declare const WakaNotifications: React.ForwardRefExoticComponent<WakaNotificationsProps & React.RefAttributes<HTMLButtonElement>>;
+export declare function useNotifications(initialNotifications?: Notification[]): {
+    notifications: Notification[];
+    addNotification: (notification: Omit<Notification, "id" | "timestamp" | "read">) => void;
+    markAsRead: (id: string) => void;
+    markAllAsRead: () => void;
+    deleteNotification: (id: string) => void;
+    deleteAllNotifications: () => void;
+    unreadCount: number;
+};

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

@@ -0,0 +1,46 @@
+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
+ */
+declare const spinnerVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | "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
+     */
+    showAsteroids?: boolean;
+    /**
+     * Vitesse de rotation de la fusée (en secondes)
+     * @default 2
+     */
+    speed?: number;
+    /**
+     * Couleur de la fusée (classe Tailwind ou couleur CSS)
+     * @default "text-primary"
+     */
+    rocketColor?: string;
+    /**
+     * Couleur des astéroïdes (classe Tailwind ou couleur CSS)
+     * @default "text-muted-foreground"
+     */
+    asteroidColor?: string;
+}
+/**
+ * WakaSpinner - Composant de chargement avec animation spatiale
+ *
+ * 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.
+ *
+ * @example
+ * ```tsx
+ * <WakaSpinner size="md" />
+ * <WakaSpinner size="lg" showAsteroids={true} speed={3} />
+ * <WakaSpinner rocketColor="text-blue-500" asteroidColor="text-gray-400" />
+ * ```
+ */
+export declare const WakaSpinner: React.ForwardRefExoticComponent<WakaSpinnerProps & React.RefAttributes<HTMLDivElement>>;
+export {};

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

@@ -0,0 +1,59 @@
+export interface ThemeVersion {
+    version: string;
+    createdAt: Date;
+    createdBy?: string;
+    changelog?: string;
+    css: string;
+}
+export interface ThemeMetadata {
+    id: string;
+    label: string;
+    description?: string;
+    previewColor?: string;
+    author?: string;
+    versions: ThemeVersion[];
+    currentVersion: string;
+}
+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;
+}
+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 */
+    onLoadTheme?: (themeId: string) => Promise<ThemeMetadata | null>;
+    /** Thèmes existants à charger */
+    existingThemes?: ThemeMetadata[];
+    /** Classe CSS personnalisée */
+    className?: string;
+}
+/**
+ * WakaThemeCreator
+ *
+ * Composant d'administration pour créer, prévisualiser et publier des thèmes TweakCN sur S3.
+ *
+ * Features:
+ * - Création de thèmes avec CSS TweakCN
+ * - Prévisualisation en temps réel
+ * - Gestion des versions
+ * - Upload sur S3/MinIO
+ * - 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 namespace WakaThemeCreator {
+    var displayName: string;
+}

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

@@ -0,0 +1,62 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const themeManagerVariants: (props?: ({
+    size?: "base" | "sm" | "lg" | "full" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export interface TweakCNTheme {
+    name: string;
+    description?: string;
+    author?: string;
+    version?: string;
+    colors: {
+        background: string;
+        foreground: string;
+        card: string;
+        cardForeground: string;
+        popover: string;
+        popoverForeground: string;
+        primary: string;
+        primaryForeground: string;
+        secondary: string;
+        secondaryForeground: string;
+        muted: string;
+        mutedForeground: string;
+        accent: string;
+        accentForeground: string;
+        destructive: string;
+        destructiveForeground: string;
+        border: string;
+        input: string;
+        ring: string;
+        chart1?: string;
+        chart2?: string;
+        chart3?: string;
+        chart4?: string;
+        chart5?: string;
+    };
+}
+export interface WakaThemeManagerProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof themeManagerVariants> {
+    onThemeChange?: (theme: TweakCNTheme) => void;
+    onThemeLoad?: (theme: TweakCNTheme) => void;
+    onThemeSave?: (theme: TweakCNTheme) => void;
+    initialTheme?: TweakCNTheme;
+    showPreview?: boolean;
+    showExport?: boolean;
+    showImport?: boolean;
+    allowCustomColors?: boolean;
+}
+/**
+ * WakaThemeManager - Gestionnaire complet de thèmes TweakCN
+ *
+ * @example
+ * ```tsx
+ * <WakaThemeManager
+ *   onThemeChange={(theme) => console.log('Theme changed:', theme)}
+ *   showPreview={true}
+ *   showExport={true}
+ *   showImport={true}
+ * />
+ * ```
+ */
+declare const WakaThemeManager: React.ForwardRefExoticComponent<WakaThemeManagerProps & React.RefAttributes<HTMLDivElement>>;
+export { WakaThemeManager, themeManagerVariants };

package/dist/context/admincrumb-context.d.ts

@@ -0,0 +1,34 @@
+import * as React from "react";
+export interface AdmincrumbItem {
+    id: string;
+    name: string;
+    type: "partner" | "network" | "customer";
+    metadata?: Record<string, any>;
+}
+export interface AdmincrumbSelection {
+    partner?: AdmincrumbItem;
+    network?: AdmincrumbItem;
+    customer?: AdmincrumbItem;
+}
+export interface AdmincrumbContextValue {
+    selection: AdmincrumbSelection;
+    setPartner: (item: AdmincrumbItem | undefined) => void;
+    setNetwork: (item: AdmincrumbItem | undefined) => void;
+    setCustomer: (item: AdmincrumbItem | undefined) => void;
+    reset: () => void;
+    isFiltered: boolean;
+    getFilterQuery: () => {
+        partnerId?: string;
+        networkId?: string;
+        customerId?: string;
+    };
+}
+export interface AdmincrumbProviderProps {
+    children: React.ReactNode;
+    initialSelection?: AdmincrumbSelection;
+    onSelectionChange?: (selection: AdmincrumbSelection) => void;
+    persistKey?: string;
+}
+export declare function AdmincrumbProvider({ children, initialSelection, onSelectionChange, persistKey }: AdmincrumbProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useAdmincrumbContext(): AdmincrumbContextValue;
+export declare function useAdmincrumbContextOptional(): AdmincrumbContextValue | undefined;