@wakastellar/ui 3.5.0 → 4.0.0-dev.0

package/dist/components/waka-pipeline-view/index.d.ts

@@ -0,0 +1,49 @@
+export type StageStatus = "pending" | "running" | "success" | "failed" | "skipped" | "cancelled";
+export interface PipelineJob {
+    /** Unique identifier */
+    id: string;
+    /** Job name */
+    name: string;
+    /** Job status */
+    status: StageStatus;
+    /** Duration in seconds */
+    duration?: number;
+}
+export interface PipelineStage {
+    /** Unique identifier */
+    id: string;
+    /** Stage name */
+    name: string;
+    /** Stage status */
+    status: StageStatus;
+    /** Duration in seconds */
+    duration?: number;
+    /** Parallel jobs within this stage */
+    jobs?: PipelineJob[];
+    /** When the stage started */
+    startedAt?: Date;
+    /** When the stage finished */
+    finishedAt?: Date;
+}
+export interface WakaPipelineViewProps {
+    /** Pipeline stages */
+    stages: PipelineStage[];
+    /** Callback when a stage is clicked */
+    onStageClick?: (stageId: string) => void;
+    /** Callback when retry is triggered on a failed stage */
+    onRetry?: (stageId: string) => void;
+    /** Layout variant */
+    variant?: "horizontal" | "vertical";
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Show duration for each stage */
+    showDuration?: boolean;
+    /** Show parallel jobs within stages */
+    showJobs?: boolean;
+    /** Enable animations */
+    animated?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaPipelineView({ stages, onStageClick, onRetry, variant, size, showDuration, showJobs, animated, className, }: WakaPipelineViewProps): import("react/jsx-runtime").JSX.Element;
+export default WakaPipelineView;

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

@@ -0,0 +1,36 @@
+import * as React from "react";
+export type PlayerRarity = "common" | "rare" | "epic" | "legendary" | "mythic";
+export interface PlayerStat {
+    name: string;
+    value: number;
+    max?: number;
+}
+export interface Player {
+    id: string;
+    name: string;
+    avatar: string;
+    title?: string;
+    level: number;
+    rarity: PlayerRarity;
+    stats: PlayerStat[];
+    achievements?: number;
+    joinedAt?: Date;
+}
+export interface WakaPlayerCardProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onClick"> {
+    /** Player data */
+    player: Player;
+    /** Card variant */
+    variant?: "default" | "compact" | "full";
+    /** Show back side on hover */
+    showBack?: boolean;
+    /** Custom back content */
+    backContent?: React.ReactNode;
+    /** Click handler */
+    onClick?: () => void;
+    /** Card size */
+    size?: "sm" | "md" | "lg";
+    /** Enable animations */
+    animated?: boolean;
+}
+export declare function WakaPlayerCard({ player, variant, showBack, backContent, onClick, size, animated, className, ...props }: WakaPlayerCardProps): import("react/jsx-runtime").JSX.Element;
+export default WakaPlayerCard;

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

@@ -0,0 +1,73 @@
+export type PodPhase = "Running" | "Pending" | "Succeeded" | "Failed" | "Unknown";
+export type ContainerState = "running" | "waiting" | "terminated";
+export interface PodContainer {
+    name: string;
+    image: string;
+    state: ContainerState;
+    ready: boolean;
+    restartCount: number;
+    startedAt?: Date;
+    reason?: string;
+    message?: string;
+    resources?: {
+        cpu: {
+            used: number;
+            limit: number;
+        };
+        memory: {
+            used: number;
+            limit: number;
+        };
+    };
+    ports?: Array<{
+        containerPort: number;
+        protocol: string;
+    }>;
+}
+export interface PodEvent {
+    type: "Normal" | "Warning";
+    reason: string;
+    message: string;
+    timestamp: Date;
+    count?: number;
+}
+export interface PodDetails {
+    name: string;
+    namespace: string;
+    phase: PodPhase;
+    nodeName?: string;
+    podIP?: string;
+    hostIP?: string;
+    startTime?: Date;
+    containers: PodContainer[];
+    events?: PodEvent[];
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+    conditions?: Array<{
+        type: string;
+        status: boolean;
+        reason?: string;
+        message?: string;
+        lastTransitionTime?: Date;
+    }>;
+}
+export interface WakaPodCardProps {
+    /** Pod details */
+    pod: PodDetails;
+    /** Callback when viewing logs */
+    onViewLogs?: (containerName: string) => void;
+    /** Callback when opening terminal */
+    onExec?: (containerName: string) => void;
+    /** Callback when deleting pod */
+    onDelete?: () => void;
+    /** Callback when restarting (deleting for recreation) */
+    onRestart?: () => void;
+    /** Show events section */
+    showEvents?: boolean;
+    /** Compact mode */
+    compact?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaPodCard({ pod, onViewLogs, onExec, onDelete, onRestart, showEvents, compact, className, }: WakaPodCardProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultPodDetails: PodDetails;

package/dist/components/waka-points-popup/index.d.ts

@@ -0,0 +1,75 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+export interface WakaPointsPopupProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof pointsPopupVariants> {
+    /** The points value to display (positive or negative) */
+    points: number;
+    /** X position (defaults to center) */
+    x?: number;
+    /** Y position (defaults to center) */
+    y?: number;
+    /** Custom color (overrides automatic color coding) */
+    color?: string;
+    /** Animation duration in milliseconds */
+    duration?: number;
+    /** Callback when animation completes */
+    onComplete?: () => void;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Optional prefix (e.g., "XP", "pts") */
+    prefix?: string;
+    /** Optional icon to display before the points */
+    icon?: React.ReactNode;
+}
+export interface PopupInstance {
+    id: string;
+    points: number;
+    x: number;
+    y: number;
+    color?: string;
+    duration: number;
+    size: "sm" | "md" | "lg";
+    prefix?: string;
+    icon?: React.ReactNode;
+}
+export interface TriggerOptions {
+    x?: number;
+    y?: number;
+    color?: string;
+    duration?: number;
+    size?: "sm" | "md" | "lg";
+    prefix?: string;
+    icon?: React.ReactNode;
+}
+export interface UsePointsPopupReturn {
+    /** Trigger a new popup */
+    trigger: (points: number, options?: TriggerOptions) => void;
+    /** Container component to render popups */
+    PopupContainer: React.FC;
+    /** Clear all active popups */
+    clearAll: () => void;
+}
+declare const pointsPopupVariants: (props?: {
+    size?: "sm" | "md" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string;
+export declare const WakaPointsPopup: React.ForwardRefExoticComponent<WakaPointsPopupProps & React.RefAttributes<HTMLDivElement>>;
+export declare function usePointsPopup(): UsePointsPopupReturn;
+export interface PointsPreset {
+    color: string;
+    prefix: string;
+    icon?: React.ReactNode;
+}
+export declare const POINTS_PRESETS: Record<string, PointsPreset>;
+export interface UsePointsPopupWithPresetsReturn extends UsePointsPopupReturn {
+    /** Trigger XP popup */
+    triggerXP: (points: number, options?: Omit<TriggerOptions, "prefix" | "color">) => void;
+    /** Trigger coins popup */
+    triggerCoins: (points: number, options?: Omit<TriggerOptions, "prefix" | "color">) => void;
+    /** Trigger health popup */
+    triggerHealth: (points: number, options?: Omit<TriggerOptions, "prefix" | "color">) => void;
+    /** Trigger mana popup */
+    triggerMana: (points: number, options?: Omit<TriggerOptions, "prefix" | "color">) => void;
+    /** Trigger score popup */
+    triggerScore: (points: number, options?: Omit<TriggerOptions, "prefix" | "color">) => void;
+}
+export declare function usePointsPopupWithPresets(): UsePointsPopupWithPresetsReturn;
+export {};

package/dist/components/waka-power-up/index.d.ts

@@ -0,0 +1,103 @@
+import { type LucideIcon } from "lucide-react";
+export type PowerUpType = "speed" | "shield" | "damage" | "time" | "star" | "boost" | "accuracy" | "health" | "coins" | "luck" | "custom";
+export interface PowerUp {
+    /** Unique identifier */
+    id: string;
+    /** Power-up type */
+    type: PowerUpType;
+    /** Display name */
+    name: string;
+    /** Description text */
+    description: string;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Multiplier or boost amount (e.g., 2 for x2, 1.5 for +50%) */
+    multiplier: number;
+    /** Stack count if multiple are active */
+    stackCount?: number;
+    /** Maximum stack count allowed */
+    maxStack?: number;
+    /** Custom icon (only used when type is "custom") */
+    customIcon?: LucideIcon;
+    /** Custom color (overrides type default) */
+    customColor?: string;
+    /** Whether the power-up is currently active */
+    isActive?: boolean;
+    /** Activation timestamp */
+    activatedAt?: number;
+}
+export interface WakaPowerUpProps {
+    /** Power-up data */
+    powerUp: PowerUp;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Visual style variant */
+    variant?: "card" | "badge" | "compact";
+    /** Show countdown timer */
+    showCountdown?: boolean;
+    /** Show description */
+    showDescription?: boolean;
+    /** Enable glow animation */
+    glowEnabled?: boolean;
+    /** Enable pulse animation */
+    pulseEnabled?: boolean;
+    /** Callback when power-up expires */
+    onExpire?: (powerUp: PowerUp) => void;
+    /** Callback when power-up is clicked */
+    onClick?: (powerUp: PowerUp) => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface UsePowerUpOptions {
+    /** Initial power-ups */
+    initialPowerUps?: PowerUp[];
+    /** Callback when any power-up expires */
+    onPowerUpExpire?: (powerUp: PowerUp) => void;
+    /** Callback when any power-up activates */
+    onPowerUpActivate?: (powerUp: PowerUp) => void;
+}
+export interface UsePowerUpReturn {
+    /** Active power-ups */
+    activePowerUps: PowerUp[];
+    /** Activate a power-up */
+    activate: (powerUp: Omit<PowerUp, "isActive" | "activatedAt">) => void;
+    /** Deactivate a power-up by ID */
+    deactivate: (id: string) => void;
+    /** Get remaining time for a power-up */
+    getRemainingTime: (id: string) => number;
+    /** Check if a specific power-up type is active */
+    isTypeActive: (type: PowerUpType) => boolean;
+    /** Get combined multiplier for a type (considering stacks) */
+    getCombinedMultiplier: (type: PowerUpType) => number;
+    /** Stack a power-up (increases stack count or extends duration) */
+    stack: (id: string, mode?: "count" | "duration") => void;
+    /** Clear all active power-ups */
+    clearAll: () => void;
+}
+export declare function WakaPowerUp({ powerUp, size, variant, showCountdown, showDescription, glowEnabled, pulseEnabled, onExpire, onClick, className, }: WakaPowerUpProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaPowerUp {
+    var displayName: string;
+}
+export declare function usePowerUp({ initialPowerUps, onPowerUpExpire, onPowerUpActivate, }?: UsePowerUpOptions): UsePowerUpReturn;
+export interface WakaPowerUpListProps {
+    /** List of power-ups to display */
+    powerUps: PowerUp[];
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Visual style variant */
+    variant?: "card" | "badge" | "compact";
+    /** Layout direction */
+    direction?: "horizontal" | "vertical";
+    /** Gap between items */
+    gap?: "sm" | "md" | "lg";
+    /** Callback when a power-up expires */
+    onExpire?: (powerUp: PowerUp) => void;
+    /** Callback when a power-up is clicked */
+    onClick?: (powerUp: PowerUp) => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaPowerUpList({ powerUps, size, variant, direction, gap, onExpire, onClick, className, }: WakaPowerUpListProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaPowerUpList {
+    var displayName: string;
+}

package/dist/components/waka-presence-indicator/index.d.ts

@@ -0,0 +1,188 @@
+export type PresenceStatus = "online" | "away" | "busy" | "offline" | "invisible";
+export interface PresenceState {
+    /** Current status */
+    status: PresenceStatus;
+    /** Custom status message */
+    customMessage?: string;
+    /** When the status was last updated */
+    updatedAt?: Date;
+    /** Last seen timestamp (for offline status) */
+    lastSeen?: Date;
+    /** Do not disturb mode */
+    doNotDisturb?: boolean;
+}
+export interface UsePresenceOptions {
+    /** Initial presence state */
+    initialState?: Partial<PresenceState>;
+    /** Callback when status changes */
+    onStatusChange?: (status: PresenceStatus) => void;
+    /** Auto-away timeout in milliseconds */
+    autoAwayTimeout?: number;
+    /** Persist state to localStorage */
+    persistKey?: string;
+}
+export interface UsePresenceReturn {
+    /** Current presence state */
+    presence: PresenceState;
+    /** Set presence status */
+    setStatus: (status: PresenceStatus) => void;
+    /** Set custom message */
+    setCustomMessage: (message: string | undefined) => void;
+    /** Toggle do not disturb */
+    toggleDoNotDisturb: () => void;
+    /** Set entire presence state */
+    setPresence: (state: Partial<PresenceState>) => void;
+    /** Get formatted status duration */
+    getStatusDuration: () => string | null;
+    /** Get formatted last seen */
+    getLastSeen: () => string | null;
+}
+export declare function usePresence(options?: UsePresenceOptions): UsePresenceReturn;
+export interface WakaPresenceIndicatorProps {
+    /** Current presence status */
+    status: PresenceStatus;
+    /** Size variant */
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    /** Show pulsing animation for online status */
+    pulse?: boolean;
+    /** Do not disturb mode */
+    doNotDisturb?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaPresenceIndicator({ status, size, pulse, doNotDisturb, className, }: WakaPresenceIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPresenceWithAvatarProps {
+    /** Avatar image source */
+    src?: string;
+    /** Avatar fallback text (usually initials) */
+    fallback?: string;
+    /** Alt text for avatar */
+    alt?: string;
+    /** Current presence status */
+    status: PresenceStatus;
+    /** Size variant */
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    /** Show pulsing animation */
+    pulse?: boolean;
+    /** Do not disturb mode */
+    doNotDisturb?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Avatar ring style */
+    showRing?: boolean;
+    /** Click handler */
+    onClick?: () => void;
+}
+export declare function WakaPresenceWithAvatar({ src, fallback, alt, status, size, pulse, doNotDisturb, className, showRing, onClick, }: WakaPresenceWithAvatarProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPresenceStatusBadgeProps {
+    /** Current presence status */
+    status: PresenceStatus;
+    /** Custom status message */
+    customMessage?: string;
+    /** Show status duration */
+    showDuration?: boolean;
+    /** Status updated timestamp */
+    updatedAt?: Date;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Do not disturb mode */
+    doNotDisturb?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaPresenceStatusBadge({ status, customMessage, showDuration, updatedAt, size, doNotDisturb, className, }: WakaPresenceStatusBadgeProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPresenceSelectorProps {
+    /** Current presence state */
+    presence: PresenceState;
+    /** Set status callback */
+    onStatusChange: (status: PresenceStatus) => void;
+    /** Toggle DND callback */
+    onToggleDND?: () => void;
+    /** Set custom message callback */
+    onSetCustomMessage?: (message: string | undefined) => void;
+    /** Show custom message input */
+    showCustomMessage?: boolean;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Disabled state */
+    disabled?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Avatar props for trigger */
+    avatar?: {
+        src?: string;
+        fallback?: string;
+        alt?: string;
+    };
+    /** Trigger variant */
+    triggerVariant?: "avatar" | "badge" | "minimal";
+}
+export declare function WakaPresenceSelector({ presence, onStatusChange, onToggleDND, onSetCustomMessage, showCustomMessage, size, disabled, className, avatar, triggerVariant, }: WakaPresenceSelectorProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPresenceLastSeenProps {
+    /** Last seen timestamp */
+    lastSeen: Date;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Show "Last seen" prefix */
+    showPrefix?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaPresenceLastSeen({ lastSeen, size, showPrefix, className, }: WakaPresenceLastSeenProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPresenceCardProps {
+    /** User name */
+    name: string;
+    /** Avatar source */
+    avatarSrc?: string;
+    /** Avatar fallback */
+    avatarFallback?: string;
+    /** Presence state */
+    presence: PresenceState;
+    /** Show status duration */
+    showDuration?: boolean;
+    /** Show last seen for offline */
+    showLastSeen?: boolean;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Custom class name */
+    className?: string;
+    /** Click handler */
+    onClick?: () => void;
+}
+export declare function WakaPresenceCard({ name, avatarSrc, avatarFallback, presence, showDuration, showLastSeen, size, className, onClick, }: WakaPresenceCardProps): import("react/jsx-runtime").JSX.Element;
+export interface PresenceUser {
+    id: string;
+    name: string;
+    avatarSrc?: string;
+    avatarFallback?: string;
+    presence: PresenceState;
+}
+export interface WakaPresenceListProps {
+    /** List of users with presence */
+    users: PresenceUser[];
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Show last seen for offline users */
+    showLastSeen?: boolean;
+    /** Group users by status */
+    groupByStatus?: boolean;
+    /** Max users to show (shows "+X more" for rest) */
+    maxVisible?: number;
+    /** User click handler */
+    onUserClick?: (userId: string) => void;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaPresenceList({ users, size, showLastSeen, groupByStatus, maxVisible, onUserClick, className, }: WakaPresenceListProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPresenceAvatarStackProps {
+    /** List of users with presence */
+    users: PresenceUser[];
+    /** Max avatars to show */
+    max?: number;
+    /** Size variant */
+    size?: "xs" | "sm" | "md" | "lg";
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaPresenceAvatarStack({ users, max, size, className, }: WakaPresenceAvatarStackProps): import("react/jsx-runtime").JSX.Element;
+export default WakaPresenceIndicator;

package/dist/components/waka-pricing-table/index.d.ts

@@ -0,0 +1,77 @@
+export interface PricingFeature {
+    /** Feature name/description */
+    name: string;
+    /** Tooltip/additional info */
+    tooltip?: string;
+}
+export interface PricingTierFeature {
+    /** Feature reference (matches PricingFeature.name) */
+    name: string;
+    /** Whether this feature is included */
+    included: boolean;
+    /** Custom value to display instead of checkmark (e.g., "10 GB", "Unlimited") */
+    value?: string;
+}
+export interface PricingTier {
+    /** Unique identifier */
+    id: string;
+    /** Tier name (e.g., "Free", "Pro", "Enterprise") */
+    name: string;
+    /** Short description */
+    description?: string;
+    /** Monthly price in cents (null for custom pricing) */
+    monthlyPrice: number | null;
+    /** Annual price in cents (null for custom pricing) */
+    annualPrice: number | null;
+    /** Custom price label (e.g., "Contact us") */
+    customPriceLabel?: string;
+    /** Currency symbol */
+    currency?: string;
+    /** Features included in this tier */
+    features: PricingTierFeature[];
+    /** Whether this tier is highlighted as popular/recommended */
+    highlighted?: boolean;
+    /** Highlight label (e.g., "Most Popular", "Best Value") */
+    highlightLabel?: string;
+    /** CTA button text */
+    ctaText?: string;
+    /** CTA button variant */
+    ctaVariant?: "default" | "primary" | "outline";
+    /** Whether the tier is disabled */
+    disabled?: boolean;
+}
+export interface WakaPricingTableProps {
+    /** Pricing tiers to display */
+    tiers: PricingTier[];
+    /** All available features (for comparison table) */
+    features?: PricingFeature[];
+    /** Currently selected billing period */
+    billingPeriod?: "monthly" | "annual";
+    /** Callback when billing period changes */
+    onBillingPeriodChange?: (period: "monthly" | "annual") => void;
+    /** Callback when CTA is clicked */
+    onCtaClick?: (tier: PricingTier) => void;
+    /** Annual discount percentage to display */
+    annualDiscount?: number;
+    /** Show billing toggle */
+    showBillingToggle?: boolean;
+    /** Layout variant */
+    variant?: "cards" | "table" | "auto";
+    /** Additional class names */
+    className?: string;
+}
+export declare function WakaPricingTable({ tiers, features, billingPeriod: controlledBillingPeriod, onBillingPeriodChange, onCtaClick, annualDiscount, showBillingToggle, variant, className, }: WakaPricingTableProps): import("react/jsx-runtime").JSX.Element;
+export interface UsePricingTableOptions {
+    initialBillingPeriod?: "monthly" | "annual";
+}
+export declare function usePricingTable(options?: UsePricingTableOptions): {
+    billingPeriod: "monthly" | "annual";
+    selectedTier: PricingTier;
+    onBillingPeriodChange: (period: "monthly" | "annual") => void;
+    onCtaClick: (tier: PricingTier) => void;
+    calculateSavings: (tier: PricingTier) => number;
+    getEffectiveMonthlyPrice: (tier: PricingTier) => number | null;
+};
+export declare const defaultTiers: PricingTier[];
+export declare const defaultFeatures: PricingFeature[];
+export default WakaPricingTable;

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

@@ -0,0 +1,81 @@
+import * as React from "react";
+export interface ProductImage {
+    src: string;
+    alt: string;
+}
+export interface ProductVariant {
+    id: string;
+    label: string;
+    value: string;
+    available?: boolean;
+}
+export interface ColorVariant extends ProductVariant {
+    color: string;
+}
+export interface SizeVariant extends ProductVariant {
+}
+export interface WakaProductCardProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Product name */
+    name: string;
+    /** Product price */
+    price: number;
+    /** Original price before discount */
+    originalPrice?: number;
+    /** Currency symbol */
+    currency?: string;
+    /** Product images */
+    images: ProductImage[];
+    /** Product rating (0-5) */
+    rating?: number;
+    /** Number of reviews */
+    reviewCount?: number;
+    /** Discount percentage badge */
+    discountBadge?: string;
+    /** Custom badge text */
+    customBadge?: string;
+    /** Color variants */
+    colorVariants?: ColorVariant[];
+    /** Size variants */
+    sizeVariants?: SizeVariant[];
+    /** Whether product is in stock */
+    inStock?: boolean;
+    /** Whether product is in wishlist */
+    isWishlisted?: boolean;
+    /** Show quick view button */
+    showQuickView?: boolean;
+    /** Image gallery mode */
+    galleryMode?: "thumbnails" | "dots";
+    /** Called when add to cart is clicked */
+    onAddToCart?: () => void;
+    /** Called when wishlist button is clicked */
+    onWishlistToggle?: (isWishlisted: boolean) => void;
+    /** Called when quick view is clicked */
+    onQuickView?: () => void;
+    /** Called when color variant is selected */
+    onColorSelect?: (variant: ColorVariant) => void;
+    /** Called when size variant is selected */
+    onSizeSelect?: (variant: SizeVariant) => void;
+    /** Selected color variant ID */
+    selectedColorId?: string;
+    /** Selected size variant ID */
+    selectedSizeId?: string;
+    /** Card size variant */
+    size?: "sm" | "default" | "lg";
+}
+export declare function WakaProductCard({ name, price, originalPrice, currency, images, rating, reviewCount, discountBadge, customBadge, colorVariants, sizeVariants, inStock, isWishlisted, showQuickView, galleryMode, onAddToCart, onWishlistToggle, onQuickView, onColorSelect, onSizeSelect, selectedColorId, selectedSizeId, size, className, ...props }: WakaProductCardProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaProductGridProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Number of columns */
+    columns?: 2 | 3 | 4 | 5;
+    /** Gap between items */
+    gap?: "sm" | "md" | "lg";
+    /** Children */
+    children: React.ReactNode;
+}
+export declare function WakaProductGrid({ columns, gap, className, children, ...props }: WakaProductGridProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaProductCardSkeletonProps {
+    /** Card size */
+    size?: "sm" | "default" | "lg";
+    /** Show variants placeholder */
+    showVariants?: boolean;
+}
+export declare function WakaProductCardSkeleton({ size, showVariants, }: WakaProductCardSkeletonProps): import("react/jsx-runtime").JSX.Element;