@wakastellar/ui 3.5.0 → 4.0.0-dev.0

package/dist/components/waka-sponsored-feed/index.d.ts

@@ -0,0 +1,31 @@
+import * as React from "react";
+import { type SponsoredCardVariant } from "../waka-sponsored-card";
+export interface WakaSponsoredFeedProps<T> {
+    /** Content items */
+    items: T[];
+    /** Render function for content items */
+    renderItem: (item: T, index: number) => React.ReactNode;
+    /** Ad slot IDs to inject */
+    adSlots: Array<{
+        slotId: string;
+        adUnitPath?: string;
+    }>;
+    /** Insert ad every N items */
+    adFrequency?: number;
+    /** Starting position for first ad (0-indexed) */
+    adStartPosition?: number;
+    /** Card variant for ads */
+    adVariant?: SponsoredCardVariant;
+    /** Maximum number of ads to show */
+    maxAds?: number;
+    /** Grid columns for items */
+    columns?: 1 | 2 | 3 | 4;
+    /** Gap between items */
+    gap?: "sm" | "md" | "lg";
+    /** Custom class name */
+    className?: string;
+    /** Key extractor for items */
+    keyExtractor?: (item: T, index: number) => string;
+}
+export declare function WakaSponsoredFeed<T>({ items, renderItem, adSlots, adFrequency, adStartPosition, adVariant, maxAds, columns, gap, className, keyExtractor, }: WakaSponsoredFeedProps<T>): import("react/jsx-runtime").JSX.Element;
+export default WakaSponsoredFeed;

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

@@ -0,0 +1,47 @@
+import * as React from "react";
+export type SpotlightResultType = "page" | "action" | "user" | "file" | "setting" | "external";
+export interface SpotlightResult {
+    id: string;
+    title: string;
+    subtitle?: string;
+    type: SpotlightResultType;
+    icon?: React.ReactNode;
+    preview?: React.ReactNode;
+    action?: () => void;
+    href?: string;
+    meta?: string;
+}
+export interface SpotlightFilter {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    type?: SpotlightResultType;
+}
+export interface WakaSpotlightProps {
+    /** Whether spotlight is open */
+    open: boolean;
+    /** Callback when open state changes */
+    onOpenChange: (open: boolean) => void;
+    /** Search function - can be async */
+    onSearch: (query: string, filter?: string) => Promise<SpotlightResult[]> | SpotlightResult[];
+    /** Available filters */
+    filters?: SpotlightFilter[];
+    /** Placeholder text */
+    placeholder?: string;
+    /** Recently accessed items */
+    recentItems?: SpotlightResult[];
+    /** Quick actions shown when empty */
+    quickActions?: SpotlightResult[];
+    /** Debounce delay in ms */
+    debounceMs?: number;
+    /** Show preview panel */
+    showPreview?: boolean;
+}
+export declare function WakaSpotlight({ open, onOpenChange, onSearch, filters, placeholder, recentItems, quickActions, debounceMs, showPreview, }: WakaSpotlightProps): import("react/jsx-runtime").JSX.Element;
+export declare function useSpotlight(): {
+    open: boolean;
+    onOpenChange: React.Dispatch<React.SetStateAction<boolean>>;
+    openSpotlight: () => void;
+    closeSpotlight: () => void;
+    toggleSpotlight: () => void;
+};

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;
+};
+export default WakaStat;

package/dist/components/waka-stats-hexagon/index.d.ts

@@ -0,0 +1,149 @@
+import * as React from "react";
+export interface HexagonStat {
+    /** Unique identifier for the stat */
+    id: string;
+    /** Label displayed at the vertex */
+    label: string;
+    /** Current value (0-100 by default) */
+    value: number;
+    /** Maximum value (defaults to 100) */
+    max?: number;
+    /** Optional icon for the stat */
+    icon?: React.ReactNode;
+    /** Optional description for tooltip */
+    description?: string;
+}
+export interface HexagonProfile {
+    /** Unique identifier */
+    id: string;
+    /** Profile name */
+    name: string;
+    /** Stats data (must have exactly 6 values) */
+    stats: number[];
+    /** Color for the profile */
+    color?: string;
+    /** Fill opacity (0-1) */
+    fillOpacity?: number;
+}
+export type HexagonColorTheme = "default" | "blue" | "green" | "purple" | "orange" | "pink" | "cyan" | "gradient";
+export interface WakaStatsHexagonProps {
+    /** Array of exactly 6 stats */
+    stats: HexagonStat[];
+    /** Primary profile data */
+    profile: HexagonProfile;
+    /** Optional comparison profile */
+    comparisonProfile?: HexagonProfile;
+    /** Size of the hexagon in pixels */
+    size?: number;
+    /** Number of grid levels */
+    levels?: number;
+    /** Color theme */
+    theme?: HexagonColorTheme;
+    /** Custom primary color (overrides theme) */
+    primaryColor?: string;
+    /** Show grid lines */
+    showGrid?: boolean;
+    /** Show stat labels */
+    showLabels?: boolean;
+    /** Show stat values in labels */
+    showValues?: boolean;
+    /** Show data points */
+    showPoints?: boolean;
+    /** Enable tooltips */
+    showTooltips?: boolean;
+    /** Enable animations */
+    animated?: boolean;
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Show legend */
+    showLegend?: boolean;
+    /** Custom className */
+    className?: string;
+    /** Callback when a stat point is clicked */
+    onStatClick?: (stat: HexagonStat, value: number) => void;
+}
+export interface UseStatsHexagonOptions {
+    /** Initial stats */
+    initialStats?: HexagonStat[];
+    /** Initial profile */
+    initialProfile?: HexagonProfile;
+    /** Animation enabled */
+    animated?: boolean;
+}
+export interface UseStatsHexagonReturn {
+    /** Current stats */
+    stats: HexagonStat[];
+    /** Update stats */
+    setStats: React.Dispatch<React.SetStateAction<HexagonStat[]>>;
+    /** Current profile */
+    profile: HexagonProfile;
+    /** Update profile */
+    setProfile: React.Dispatch<React.SetStateAction<HexagonProfile>>;
+    /** Comparison profile */
+    comparisonProfile: HexagonProfile | null;
+    /** Set comparison profile */
+    setComparisonProfile: React.Dispatch<React.SetStateAction<HexagonProfile | null>>;
+    /** Update a single stat value */
+    updateStat: (id: string, value: number) => void;
+    /** Update all profile stats at once */
+    updateProfileStats: (stats: number[]) => void;
+    /** Reset to initial values */
+    reset: () => void;
+    /** Active/hovered stat index */
+    activeStatIndex: number | null;
+    /** Set active stat */
+    setActiveStatIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    /** Comparison mode enabled */
+    isComparing: boolean;
+    /** Toggle comparison mode */
+    toggleComparison: () => void;
+}
+export declare function useStatsHexagon(options?: UseStatsHexagonOptions): UseStatsHexagonReturn;
+export declare function WakaStatsHexagon({ stats, profile, comparisonProfile, size, levels, theme, primaryColor, showGrid, showLabels, showValues, showPoints, showTooltips, animated, animationDuration, showLegend, className, onStatClick, }: WakaStatsHexagonProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaStatsHexagonSimpleProps extends Omit<WakaStatsHexagonProps, "stats" | "profile"> {
+    /** Simple data format: array of { label, value } */
+    data: Array<{
+        label: string;
+        value: number;
+        max?: number;
+    }>;
+    /** Profile name */
+    profileName?: string;
+}
+export declare function WakaStatsHexagonSimple({ data, profileName, ...props }: WakaStatsHexagonSimpleProps): import("react/jsx-runtime").JSX.Element;
+export interface CharacterStats {
+    strength: number;
+    dexterity: number;
+    intelligence: number;
+    wisdom: number;
+    charisma: number;
+    constitution: number;
+}
+export interface WakaStatsHexagonRPGProps extends Omit<WakaStatsHexagonProps, "stats" | "profile" | "comparisonProfile"> {
+    /** Character stats */
+    characterStats: CharacterStats;
+    /** Character name */
+    characterName?: string;
+    /** Optional comparison character */
+    comparisonStats?: CharacterStats;
+    /** Comparison character name */
+    comparisonName?: string;
+    /** Max stat value (default 20 for D&D style) */
+    maxStat?: number;
+}
+export declare function WakaStatsHexagonRPG({ characterStats, characterName, comparisonStats, comparisonName, maxStat, theme, ...props }: WakaStatsHexagonRPGProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaStatsHexagonSkillsProps extends Omit<WakaStatsHexagonProps, "stats" | "profile"> {
+    /** Skill categories with values 0-100 */
+    skills: {
+        technical: number;
+        communication: number;
+        leadership: number;
+        problemSolving: number;
+        creativity: number;
+        teamwork: number;
+    };
+    /** Person/team name */
+    name?: string;
+}
+export declare function WakaStatsHexagonSkills({ skills, name, theme, ...props }: WakaStatsHexagonSkillsProps): import("react/jsx-runtime").JSX.Element;
+export default WakaStatsHexagon;

package/dist/components/waka-status-matrix/index.d.ts

@@ -0,0 +1,38 @@
+export type StatusType = "up" | "down" | "degraded" | "maintenance";
+export type ViewType = "year" | "quarter" | "month" | "week";
+export type ColorScheme = "green" | "blue" | "purple" | "orange" | "status";
+export type CellSize = "sm" | "md" | "lg";
+export interface StatusMatrixDataPoint {
+    /** Date for the data point */
+    date: string | Date;
+    /** Value (typically 0-100 or count) */
+    value: number;
+    /** Status for uptime view */
+    status?: StatusType;
+}
+export interface WakaStatusMatrixProps {
+    /** Data points for the matrix */
+    data: StatusMatrixDataPoint[];
+    /** Start date for the range */
+    startDate?: Date;
+    /** End date for the range */
+    endDate?: Date;
+    /** View type */
+    view?: ViewType;
+    /** Color scheme */
+    colorScheme?: ColorScheme;
+    /** Cell size */
+    cellSize?: CellSize;
+    /** Show month/week labels */
+    showLabels?: boolean;
+    /** Show legend */
+    showLegend?: boolean;
+    /** Callback when a cell is clicked */
+    onCellClick?: (date: Date, value: number) => void;
+    /** Color for empty cells */
+    emptyColor?: string;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaStatusMatrix({ data, startDate, endDate, view, colorScheme, cellSize, showLabels, showLegend, onCellClick, emptyColor, className, }: WakaStatusMatrixProps): import("react/jsx-runtime").JSX.Element;
+export default WakaStatusMatrix;

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-streak-counter/index.d.ts

@@ -0,0 +1,27 @@
+export interface WakaStreakCounterProps {
+    /** Current streak count */
+    count: number;
+    /** Label for the streak */
+    label?: string;
+    /** Size variant */
+    size?: "sm" | "default" | "lg" | "xl";
+    /** Visual variant */
+    variant?: "flame" | "lightning" | "trophy" | "star";
+    /** Show animation when count changes */
+    animate?: boolean;
+    /** Show milestone celebration */
+    milestones?: number[];
+    /** Best streak for comparison */
+    bestStreak?: number;
+    /** Custom className */
+    className?: string;
+    /** Show confetti on milestone */
+    confetti?: boolean;
+}
+export declare function WakaStreakCounter({ count, label, size, variant, animate, milestones, bestStreak, className, confetti, }: WakaStreakCounterProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaMiniStreakProps {
+    count: number;
+    variant?: "flame" | "lightning" | "trophy" | "star";
+    className?: string;
+}
+export declare function WakaMiniStreak({ count, variant, className }: WakaMiniStreakProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/waka-success-explosion/index.d.ts

@@ -0,0 +1,51 @@
+import * as React from "react";
+export interface WakaSuccessExplosionProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Trigger the explosion animation */
+    trigger?: boolean;
+    /** Callback when animation completes */
+    onComplete?: () => void;
+    /** Number of confetti particles */
+    particleCount?: number;
+    /** Duration of the animation in ms */
+    duration?: number;
+    /** Size of the explosion area */
+    size?: "sm" | "md" | "lg" | "xl";
+    /** Primary color for particles (CSS color or Tailwind class) */
+    primaryColor?: string;
+    /** Secondary color for particles (CSS color or Tailwind class) */
+    secondaryColor?: string;
+    /** Accent color for particles (CSS color or Tailwind class) */
+    accentColor?: string;
+    /** Show the checkmark animation */
+    showCheckmark?: boolean;
+    /** Checkmark color */
+    checkmarkColor?: string;
+    /** Auto-hide after animation completes */
+    autoHide?: boolean;
+}
+export interface WakaSuccessExplosionRef {
+    /** Trigger the explosion animation */
+    explode: () => void;
+    /** Reset the component to its initial state */
+    reset: () => void;
+}
+export declare const WakaSuccessExplosion: React.ForwardRefExoticComponent<WakaSuccessExplosionProps & React.RefAttributes<WakaSuccessExplosionRef>>;
+export interface UseSuccessExplosionOptions {
+    particleCount?: number;
+    duration?: number;
+    size?: WakaSuccessExplosionProps["size"];
+    primaryColor?: string;
+    secondaryColor?: string;
+    accentColor?: string;
+    showCheckmark?: boolean;
+    checkmarkColor?: string;
+    autoHide?: boolean;
+    onComplete?: () => void;
+}
+export declare function useSuccessExplosion(options?: UseSuccessExplosionOptions): {
+    ref: React.MutableRefObject<WakaSuccessExplosionRef>;
+    isExploding: boolean;
+    explode: () => void;
+    reset: () => void;
+    ExplosionComponent: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/components/waka-swipe-card/index.d.ts

@@ -0,0 +1,64 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+export type SwipeDirection = "left" | "right" | "up" | "down";
+export interface SwipeCardData {
+    id: string | number;
+    [key: string]: unknown;
+}
+export interface WakaSwipeCardProps<T extends SwipeCardData> extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof swipeCardVariants> {
+    /** Array of card data to display */
+    cards: T[];
+    /** Render function for each card */
+    renderCard: (card: T, index: number) => React.ReactNode;
+    /** Called when a card is swiped */
+    onSwipe?: (card: T, direction: SwipeDirection) => void;
+    /** Called when swiping starts */
+    onSwipeStart?: (card: T, direction: SwipeDirection) => void;
+    /** Called during swipe with progress (0-1) */
+    onSwipeProgress?: (card: T, direction: SwipeDirection, progress: number) => void;
+    /** Threshold to trigger swipe (0-1, default 0.3) */
+    swipeThreshold?: number;
+    /** Enable/disable specific swipe directions */
+    allowedDirections?: SwipeDirection[];
+    /** Show overlay indicators during swipe */
+    showOverlay?: boolean;
+    /** Custom overlay content for each direction */
+    overlayContent?: Partial<Record<SwipeDirection, React.ReactNode>>;
+    /** Number of visible cards in stack */
+    stackSize?: number;
+    /** Scale factor for stacked cards */
+    stackScale?: number;
+    /** Vertical offset for stacked cards */
+    stackOffset?: number;
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Enable haptic feedback (if available) */
+    hapticFeedback?: boolean;
+    /** Disable interactions */
+    disabled?: boolean;
+    /** Called when all cards are swiped */
+    onEmpty?: () => void;
+}
+export interface WakaSwipeCardRef {
+    swipe: (direction: SwipeDirection) => void;
+    rewind: () => void;
+    getCurrentCard: () => SwipeCardData | null;
+}
+declare const swipeCardVariants: (props?: {
+    size?: "default" | "sm" | "lg" | "full";
+} & import("class-variance-authority/types").ClassProp) => string;
+export declare const WakaSwipeCard: <T extends SwipeCardData>(props: WakaSwipeCardProps<T> & {
+    ref?: React.ForwardedRef<WakaSwipeCardRef>;
+}) => React.ReactElement;
+export interface WakaSwipeCardActionsProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Reference to the SwipeCard component */
+    swipeCardRef: React.RefObject<WakaSwipeCardRef>;
+    /** Show rewind button */
+    showRewind?: boolean;
+    /** Allowed directions to show buttons for */
+    directions?: SwipeDirection[];
+    /** Button size */
+    size?: "sm" | "default" | "lg";
+}
+export declare function WakaSwipeCardActions({ swipeCardRef, showRewind, directions, size, className, ...props }: WakaSwipeCardActionsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/waka-tabs-morph/index.d.ts

@@ -0,0 +1,66 @@
+import * as React from "react";
+export interface TabItem {
+    /** Unique identifier */
+    id: string;
+    /** Tab label */
+    label: string;
+    /** Icon element */
+    icon?: React.ReactNode;
+    /** Badge content (number or text) */
+    badge?: number | string;
+    /** Disable the tab */
+    disabled?: boolean;
+    /** Tab content (for controlled usage) */
+    content?: React.ReactNode;
+}
+export interface WakaTabsMorphProps {
+    /** Tab items */
+    tabs: TabItem[];
+    /** Currently active tab id */
+    activeTab?: string;
+    /** Default active tab id */
+    defaultTab?: string;
+    /** Callback when tab changes */
+    onChange?: (tabId: string) => void;
+    /** Orientation */
+    orientation?: "horizontal" | "vertical";
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Style variant */
+    variant?: "default" | "pills" | "underline" | "enclosed";
+    /** Full width tabs */
+    fullWidth?: boolean;
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Custom className for the tab list */
+    className?: string;
+    /** Custom className for the tab content */
+    contentClassName?: string;
+    /** Render function for tab content */
+    renderContent?: (tab: TabItem) => React.ReactNode;
+}
+export declare function WakaTabsMorph({ tabs, activeTab, defaultTab, onChange, orientation, size, variant, fullWidth, animationDuration, className, contentClassName, renderContent, }: WakaTabsMorphProps): import("react/jsx-runtime").JSX.Element;
+export declare function useTabs(tabs: TabItem[], initialTab?: string): {
+    activeTab: string;
+    activeTabData: TabItem;
+    setActiveTab: React.Dispatch<React.SetStateAction<string>>;
+    goToTab: (tabId: string) => void;
+    goToNext: () => void;
+    goToPrevious: () => void;
+    goToFirst: () => void;
+    goToLast: () => void;
+};
+export interface WakaTabPanelProps {
+    /** Tab id this panel corresponds to */
+    tabId: string;
+    /** Current active tab id */
+    activeTab: string;
+    /** Panel content */
+    children: React.ReactNode;
+    /** Keep panel mounted when not active */
+    keepMounted?: boolean;
+    /** Custom className */
+    className?: string;
+}
+export declare function WakaTabPanel({ tabId, activeTab, children, keepMounted, className, }: WakaTabPanelProps): import("react/jsx-runtime").JSX.Element;
+export default WakaTabsMorph;