@wakastellar/ui 1.0.12 → 2.0.0

package/dist/components/waka-haptic-button/index.d.ts

@@ -0,0 +1,45 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+export type HapticPattern = "light" | "medium" | "heavy" | "success" | "warning" | "error" | "selection" | number[];
+export interface WakaHapticButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof hapticButtonVariants> {
+    /** Render as child component */
+    asChild?: boolean;
+    /** Haptic pattern on press */
+    hapticPattern?: HapticPattern;
+    /** Enable/disable haptic feedback */
+    hapticEnabled?: boolean;
+    /** Enable ripple effect */
+    ripple?: boolean;
+    /** Ripple color (CSS color value) */
+    rippleColor?: string;
+    /** Ripple duration in ms */
+    rippleDuration?: number;
+    /** Enable press scale animation */
+    pressScale?: boolean;
+    /** Scale factor on press (0-1) */
+    pressScaleFactor?: number;
+    /** Enable glow effect on press */
+    glowOnPress?: boolean;
+    /** Glow color (CSS color value) */
+    glowColor?: string;
+    /** Loading state */
+    loading?: boolean;
+    /** Icon to show before children */
+    leftIcon?: React.ReactNode;
+    /** Icon to show after children */
+    rightIcon?: React.ReactNode;
+}
+declare const hapticButtonVariants: (props?: ({
+    variant?: "default" | "destructive" | "secondary" | "outline" | "ghost" | "gradient" | "glass" | "neon" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "xl" | "icon-sm" | "icon-lg" | null | undefined;
+    rounded?: "default" | "sm" | "lg" | "full" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export declare const WakaHapticButton: React.ForwardRefExoticComponent<WakaHapticButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export interface WakaHapticIconButtonProps extends Omit<WakaHapticButtonProps, "children" | "leftIcon" | "rightIcon"> {
+    /** Icon to display */
+    icon: React.ReactNode;
+    /** Accessible label */
+    "aria-label": string;
+}
+export declare const WakaHapticIconButton: React.ForwardRefExoticComponent<WakaHapticIconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/components/waka-health-pulse/index.d.ts

@@ -0,0 +1,28 @@
+export type HealthStatus = "healthy" | "warning" | "critical" | "down" | "unknown";
+export interface WakaHealthPulseProps {
+    /** Current health status of the service */
+    status: HealthStatus;
+    /** Pulse rate in beats per minute (affects animation speed) */
+    pulseRate?: number;
+    /** Actual metric value to display */
+    value?: number;
+    /** Label for the health monitor */
+    label?: string;
+    /** Unit for the value (e.g., "req/s", "ms") */
+    unit?: string;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Whether to show the value display */
+    showValue?: boolean;
+    /** Whether to animate the pulse */
+    animated?: boolean;
+    /** Custom colors per status */
+    colors?: Partial<Record<HealthStatus, string>>;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaHealthPulse({ status, pulseRate, value, label, unit, size, showValue, animated, colors, className, }: WakaHealthPulseProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaHealthPulse {
+    var displayName: string;
+}
+export default WakaHealthPulse;

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

@@ -0,0 +1,135 @@
+export interface HeatmapCell {
+    /** Row index */
+    row: number;
+    /** Column index */
+    col: number;
+    /** Cell value */
+    value: number;
+    /** Optional custom label for the cell */
+    label?: string;
+}
+export interface HeatmapData {
+    /** 2D array of values (rows x cols) */
+    values: number[][];
+    /** Row labels */
+    rowLabels?: string[];
+    /** Column labels */
+    columnLabels?: string[];
+}
+export type ColorSchemeType = "sequential" | "diverging";
+export interface ColorScheme {
+    /** Type of color scheme */
+    type: ColorSchemeType;
+    /** Colors array (for sequential: low to high, for diverging: negative to neutral to positive) */
+    colors: string[];
+}
+export interface HeatmapSelection {
+    /** Selected cell row */
+    row: number;
+    /** Selected cell column */
+    col: number;
+    /** Cell value */
+    value: number;
+}
+export interface UseHeatmapOptions {
+    /** Initial zoom level */
+    initialZoom?: number;
+    /** Minimum zoom level */
+    minZoom?: number;
+    /** Maximum zoom level */
+    maxZoom?: number;
+    /** Initial pan position */
+    initialPan?: {
+        x: number;
+        y: number;
+    };
+    /** Callback when selection changes */
+    onSelectionChange?: (selection: HeatmapSelection | null) => void;
+}
+export interface UseHeatmapReturn {
+    /** Current zoom level */
+    zoom: number;
+    /** Current pan position */
+    pan: {
+        x: number;
+        y: number;
+    };
+    /** Currently selected cell */
+    selectedCell: HeatmapSelection | null;
+    /** Whether the user is currently panning */
+    isPanning: boolean;
+    /** Zoom in by a step */
+    zoomIn: () => void;
+    /** Zoom out by a step */
+    zoomOut: () => void;
+    /** Reset zoom to initial level */
+    resetZoom: () => void;
+    /** Set pan position */
+    setPan: (pan: {
+        x: number;
+        y: number;
+    }) => void;
+    /** Reset pan to initial position */
+    resetPan: () => void;
+    /** Select a cell */
+    selectCell: (selection: HeatmapSelection | null) => void;
+    /** Start panning */
+    startPanning: () => void;
+    /** Stop panning */
+    stopPanning: () => void;
+    /** Handle mouse movement for panning */
+    handlePanMove: (dx: number, dy: number) => void;
+}
+export interface WakaHeatmapProps {
+    /** Heatmap data */
+    data: HeatmapData;
+    /** Width of the heatmap container */
+    width?: number;
+    /** Height of the heatmap container */
+    height?: number;
+    /** Cell size in pixels */
+    cellSize?: number;
+    /** Gap between cells in pixels */
+    cellGap?: number;
+    /** Color scheme to use */
+    colorScheme?: ColorScheme;
+    /** Predefined color scheme name */
+    colorSchemeName?: "blues" | "greens" | "reds" | "viridis" | "plasma" | "coolwarm" | "rdylgn";
+    /** Show row labels */
+    showRowLabels?: boolean;
+    /** Show column labels */
+    showColumnLabels?: boolean;
+    /** Show color scale legend */
+    showLegend?: boolean;
+    /** Show min/max value indicators */
+    showMinMax?: boolean;
+    /** Show tooltip on hover */
+    showTooltip?: boolean;
+    /** Enable cell selection on click */
+    enableSelection?: boolean;
+    /** Enable zoom functionality */
+    enableZoom?: boolean;
+    /** Enable pan functionality when zoomed */
+    enablePan?: boolean;
+    /** Enable export as image */
+    enableExport?: boolean;
+    /** Initial zoom level */
+    initialZoom?: number;
+    /** Minimum zoom level */
+    minZoom?: number;
+    /** Maximum zoom level */
+    maxZoom?: number;
+    /** Custom value formatter for tooltip */
+    valueFormatter?: (value: number) => string;
+    /** Callback when a cell is clicked */
+    onCellClick?: (cell: HeatmapSelection) => void;
+    /** Callback when selection changes */
+    onSelectionChange?: (selection: HeatmapSelection | null) => void;
+    /** Additional CSS classes */
+    className?: string;
+    /** Heatmap title */
+    title?: string;
+}
+export declare function useHeatmap(options?: UseHeatmapOptions): UseHeatmapReturn;
+export declare function WakaHeatmap({ data, width, height, cellSize, cellGap, colorScheme, colorSchemeName, showRowLabels, showColumnLabels, showLegend, showMinMax, showTooltip, enableSelection, enableZoom, enablePan, enableExport, initialZoom, minZoom, maxZoom, valueFormatter, onCellClick, onSelectionChange, className, title, }: WakaHeatmapProps): import("react/jsx-runtime").JSX.Element;
+export default WakaHeatmap;

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

@@ -0,0 +1,106 @@
+import * as React from "react";
+export type HotspotVariant = "dot" | "icon" | "badge";
+export type HotspotSize = "sm" | "default" | "lg";
+export type HotspotPosition = "top" | "bottom" | "left" | "right" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
+export type HotspotTrigger = "click" | "hover" | "both";
+export type HotspotIconType = "help" | "info" | "lightbulb" | "star" | "zap" | "alert";
+export interface WakaHotspotProps {
+    /** Unique identifier for seen state persistence */
+    id: string;
+    /** Tooltip content */
+    content: React.ReactNode;
+    /** Optional title for the tooltip */
+    title?: string;
+    /** Hotspot variant */
+    variant?: HotspotVariant;
+    /** Icon type for icon/badge variants */
+    iconType?: HotspotIconType;
+    /** Custom icon element */
+    customIcon?: React.ReactNode;
+    /** Size of the hotspot */
+    size?: HotspotSize;
+    /** Tooltip position relative to hotspot */
+    position?: HotspotPosition;
+    /** How to trigger the tooltip */
+    trigger?: HotspotTrigger;
+    /** Auto-dismiss tooltip after ms (0 to disable) */
+    autoDismissMs?: number;
+    /** Show only once (remember seen state in localStorage) */
+    showOnce?: boolean;
+    /** Storage key prefix for seen state */
+    storageKeyPrefix?: string;
+    /** Primary color for the hotspot */
+    color?: "primary" | "secondary" | "destructive" | "warning" | "success" | "info";
+    /** Custom color (CSS color value) */
+    customColor?: string;
+    /** Z-index for the hotspot and tooltip */
+    zIndex?: number;
+    /** Disable pulse animation */
+    disablePulse?: boolean;
+    /** Disable appear animation */
+    disableAppearAnimation?: boolean;
+    /** Called when hotspot is shown */
+    onShow?: () => void;
+    /** Called when hotspot is hidden */
+    onHide?: () => void;
+    /** Called when tooltip is dismissed */
+    onDismiss?: () => void;
+    /** Called when seen for first time (showOnce mode) */
+    onFirstSeen?: () => void;
+    /** Custom className for hotspot */
+    className?: string;
+    /** Custom className for tooltip */
+    tooltipClassName?: string;
+    /** Badge text (for badge variant) */
+    badgeText?: string;
+    /** Children to wrap (hotspot will be positioned relative to this) */
+    children?: React.ReactNode;
+}
+export interface HotspotState {
+    isVisible: boolean;
+    hasSeen: boolean;
+}
+export declare function WakaHotspot({ id, content, title, variant, iconType, customIcon, size, position, trigger, autoDismissMs, showOnce, storageKeyPrefix, color, customColor, zIndex, disablePulse, disableAppearAnimation, onShow, onHide, onDismiss, onFirstSeen, className, tooltipClassName, badgeText, children, }: WakaHotspotProps): import("react/jsx-runtime").JSX.Element | null;
+export interface UseHotspotOptions {
+    /** Unique identifier for the hotspot */
+    id: string;
+    /** Show only once (remember seen state) */
+    showOnce?: boolean;
+    /** Storage key prefix */
+    storageKeyPrefix?: string;
+    /** Auto-show on mount */
+    autoShow?: boolean;
+    /** Delay before auto-show (ms) */
+    autoShowDelay?: number;
+}
+export declare function useHotspot({ id, showOnce, storageKeyPrefix, autoShow, autoShowDelay, }: UseHotspotOptions): HotspotState & {
+    show: () => void;
+    hide: () => void;
+    dismiss: () => void;
+    reset: () => void;
+};
+export interface HotspotStep {
+    id: string;
+    content: React.ReactNode;
+    title?: string;
+    position?: HotspotPosition;
+}
+export interface WakaHotspotGroupProps {
+    /** Steps to show in sequence */
+    steps: HotspotStep[];
+    /** Whether the tour is active */
+    active: boolean;
+    /** Current step index */
+    currentStep?: number;
+    /** Called when step changes */
+    onStepChange?: (step: number) => void;
+    /** Called when tour completes */
+    onComplete?: () => void;
+    /** Called when tour is skipped */
+    onSkip?: () => void;
+    /** Show step indicator */
+    showStepIndicator?: boolean;
+    /** Common props for all hotspots */
+    hotspotProps?: Partial<WakaHotspotProps>;
+}
+export declare function WakaHotspotGroup({ steps, active, currentStep: controlledStep, onStepChange, onComplete, onSkip, showStepIndicator, hotspotProps, }: WakaHotspotGroupProps): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,38 @@
+export type IncidentSeverity = "critical" | "major" | "minor" | "info";
+export type IncidentStatus = "investigating" | "identified" | "monitoring" | "resolved";
+export interface IncidentUpdate {
+    message: string;
+    timestamp: Date;
+    status: string;
+}
+export interface IncidentImpact {
+    services?: number;
+    users?: number;
+}
+export interface Incident {
+    id: string;
+    title: string;
+    description?: string;
+    severity: IncidentSeverity;
+    status: IncidentStatus;
+    startedAt: Date;
+    resolvedAt?: Date;
+    impact?: IncidentImpact;
+    updates?: IncidentUpdate[];
+}
+export interface WakaIncidentTimelineProps {
+    /** List of incidents to display */
+    incidents: Incident[];
+    /** Callback when an incident is clicked */
+    onIncidentClick?: (id: string) => void;
+    /** Whether to show filter controls */
+    showFilters?: boolean;
+    /** Whether to show impact indicators */
+    showImpact?: boolean;
+    /** Maximum number of incidents to display */
+    maxItems?: number;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaIncidentTimeline({ incidents, onIncidentClick, showFilters, showImpact, maxItems, className, }: WakaIncidentTimelineProps): import("react/jsx-runtime").JSX.Element;
+export default WakaIncidentTimeline;

package/dist/components/waka-invoice-preview/index.d.ts

@@ -0,0 +1,137 @@
+export type InvoiceStatus = "paid" | "pending" | "overdue" | "draft";
+export type CurrencyCode = "USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD" | "CHF" | "CNY" | "INR" | "BRL";
+export interface Address {
+    /** Company or person name */
+    name: string;
+    /** Street address line 1 */
+    street1: string;
+    /** Street address line 2 (optional) */
+    street2?: string;
+    /** City */
+    city: string;
+    /** State/Province/Region */
+    state?: string;
+    /** Postal/ZIP code */
+    postalCode: string;
+    /** Country */
+    country: string;
+}
+export interface CompanyInfo {
+    /** Company name */
+    name: string;
+    /** Company logo URL (optional) */
+    logo?: string;
+    /** Company address */
+    address: Address;
+    /** Company email */
+    email?: string;
+    /** Company phone */
+    phone?: string;
+    /** Tax ID / VAT number */
+    taxId?: string;
+    /** Website */
+    website?: string;
+}
+export interface LineItem {
+    /** Unique identifier */
+    id: string;
+    /** Item description */
+    description: string;
+    /** Quantity */
+    quantity: number;
+    /** Unit (optional, e.g., "hrs", "pcs", "units") */
+    unit?: string;
+    /** Unit price */
+    unitPrice: number;
+    /** Tax rate for this item (as decimal, e.g., 0.20 for 20%) */
+    taxRate?: number;
+    /** Discount for this item (as decimal, e.g., 0.10 for 10%) */
+    discount?: number;
+}
+export interface BankDetails {
+    /** Bank name */
+    bankName: string;
+    /** Account holder name */
+    accountName: string;
+    /** Account number or IBAN */
+    accountNumber: string;
+    /** Routing number / Sort code / BIC/SWIFT */
+    routingNumber?: string;
+    /** Additional reference */
+    reference?: string;
+}
+export interface InvoiceData {
+    /** Invoice number */
+    invoiceNumber: string;
+    /** Invoice date */
+    invoiceDate: Date | string;
+    /** Due date */
+    dueDate: Date | string;
+    /** Invoice status */
+    status: InvoiceStatus;
+    /** Company/Sender information */
+    company: CompanyInfo;
+    /** Bill to address */
+    billTo: Address;
+    /** Ship to address (optional, if different from bill to) */
+    shipTo?: Address;
+    /** Line items */
+    items: LineItem[];
+    /** Currency code */
+    currency: CurrencyCode;
+    /** Global tax rate (if not per-item) */
+    taxRate?: number;
+    /** Global discount amount */
+    discountAmount?: number;
+    /** Global discount percentage (as decimal) */
+    discountPercentage?: number;
+    /** Shipping cost */
+    shippingCost?: number;
+    /** Payment terms */
+    paymentTerms?: string;
+    /** Notes to customer */
+    notes?: string;
+    /** Bank details for payment */
+    bankDetails?: BankDetails;
+    /** Purchase order number */
+    poNumber?: string;
+}
+export interface WakaInvoicePreviewProps {
+    /** Invoice data */
+    invoice: InvoiceData;
+    /** Show print button */
+    showPrintButton?: boolean;
+    /** Show download button */
+    showDownloadButton?: boolean;
+    /** Callback when print is clicked */
+    onPrint?: () => void;
+    /** Callback when download is clicked */
+    onDownload?: () => void;
+    /** Compact mode for smaller displays */
+    compact?: boolean;
+    /** Show bank details section */
+    showBankDetails?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare function formatCurrency(amount: number, currency: CurrencyCode): string;
+declare function formatDate(date: Date | string, locale?: string): string;
+export declare function WakaInvoicePreview({ invoice, showPrintButton, showDownloadButton, onPrint, onDownload, compact, showBankDetails, className, }: WakaInvoicePreviewProps): import("react/jsx-runtime").JSX.Element;
+export interface UseInvoiceOptions {
+    items: LineItem[];
+    taxRate?: number;
+    discountAmount?: number;
+    discountPercentage?: number;
+    shippingCost?: number;
+}
+export declare function useInvoice({ items, taxRate, discountAmount, discountPercentage, shippingCost, }: UseInvoiceOptions): {
+    subtotal: number;
+    taxAmount: number;
+    discount: number;
+    shippingCost: number;
+    total: number;
+    itemCount: number;
+    totalQuantity: number;
+};
+export { formatCurrency, formatDate };
+export default WakaInvoicePreview;

package/dist/components/waka-kpi-dashboard/index.d.ts

@@ -0,0 +1,80 @@
+import * as React from "react";
+export type TrendDirection = "up" | "down" | "neutral";
+export type KPICardSize = "1x1" | "2x1" | "1x2" | "2x2";
+export interface SparklineData {
+    value: number;
+    timestamp?: number | Date;
+}
+export interface KPIData {
+    id: string;
+    title: string;
+    value: string | number;
+    previousValue?: string | number;
+    trend?: TrendDirection;
+    trendValue?: string;
+    unit?: string;
+    sparklineData?: SparklineData[];
+    target?: {
+        value: number;
+        label?: string;
+    };
+    color?: "default" | "primary" | "success" | "warning" | "destructive" | "blue" | "purple";
+    icon?: React.ReactNode;
+    size?: KPICardSize;
+    loading?: boolean;
+    lastUpdated?: Date;
+    data?: Record<string, unknown>;
+}
+export interface WakaKPIDashboardProps {
+    /** KPI data items */
+    kpis: KPIData[];
+    /** Number of columns in the grid */
+    columns?: 2 | 3 | 4 | 6;
+    /** Gap between cards */
+    gap?: "sm" | "md" | "lg";
+    /** Enable drag to reorder */
+    draggable?: boolean;
+    /** Callback when KPIs are reordered */
+    onReorder?: (kpis: KPIData[]) => void;
+    /** Callback to refresh a specific KPI */
+    onRefresh?: (kpiId: string) => void;
+    /** Callback when a KPI card is clicked */
+    onCardClick?: (kpi: KPIData) => void;
+    /** Show loading skeleton for all cards */
+    loading?: boolean;
+    /** Custom card renderer */
+    renderCard?: (kpi: KPIData) => React.ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface KPICardProps {
+    kpi: KPIData;
+    onRefresh?: (kpiId: string) => void;
+    onClick?: (kpi: KPIData) => void;
+    draggable?: boolean;
+    onDragStart?: (e: React.DragEvent, kpiId: string) => void;
+}
+export declare function KPICard({ kpi, onRefresh, onClick, draggable, onDragStart, }: KPICardProps): import("react/jsx-runtime").JSX.Element;
+export declare function WakaKPIDashboard({ kpis, columns, gap, draggable, onReorder, onRefresh, onCardClick, loading, renderCard, className, }: WakaKPIDashboardProps): import("react/jsx-runtime").JSX.Element;
+export interface UseKPIDashboardOptions {
+    initialKPIs?: KPIData[];
+    refreshInterval?: number;
+    onRefresh?: (kpiId: string) => Promise<KPIData | null>;
+}
+export declare function useKPIDashboard(options?: UseKPIDashboardOptions): {
+    kpis: KPIData[];
+    setKPIs: React.Dispatch<React.SetStateAction<KPIData[]>>;
+    loading: boolean;
+    refreshKPI: (kpiId: string) => Promise<void>;
+    refreshAll: () => Promise<void>;
+    updateKPI: (kpiId: string, updates: Partial<KPIData>) => void;
+    addKPI: (kpi: KPIData) => void;
+    removeKPI: (kpiId: string) => void;
+    reorderKPIs: (newKPIs: KPIData[]) => void;
+    calculateTrend: (currentValue: number, previousValue: number) => {
+        direction: TrendDirection;
+        value: string;
+    };
+    isRefreshing: (kpiId: string) => boolean;
+};
+export default WakaKPIDashboard;

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

@@ -0,0 +1,85 @@
+export interface LeaderboardEntry {
+    /** Unique identifier */
+    id: string;
+    /** User display name */
+    name: string;
+    /** Avatar URL or initials */
+    avatar?: string;
+    /** Current score/points */
+    score: number;
+    /** Current rank position */
+    rank: number;
+    /** Previous rank (for animation) */
+    previousRank?: number;
+    /** Additional metadata */
+    metadata?: Record<string, string | number>;
+    /** Whether this is the current user */
+    isCurrentUser?: boolean;
+}
+export interface WakaLeaderboardProps {
+    /** Leaderboard entries */
+    entries: LeaderboardEntry[];
+    /** Title of the leaderboard */
+    title?: string;
+    /** Show podium for top 3 */
+    showPodium?: boolean;
+    /** Animate rank changes */
+    animateRankChanges?: boolean;
+    /** Maximum entries to show (excluding podium) */
+    maxEntries?: number;
+    /** Score label (e.g., "points", "XP", "wins") */
+    scoreLabel?: string;
+    /** Format score function */
+    formatScore?: (score: number) => string;
+    /** Current user ID (for highlighting) */
+    currentUserId?: string;
+    /** Callback when entry is clicked */
+    onEntryClick?: (entry: LeaderboardEntry) => void;
+    /** Show rank change indicators */
+    showRankChange?: boolean;
+    /** Size variant */
+    size?: "sm" | "default" | "lg";
+    /** Custom className */
+    className?: string;
+}
+export interface WakaPodiumProps {
+    /** Top 3 entries */
+    entries: LeaderboardEntry[];
+    /** Size variant */
+    size?: "sm" | "default" | "lg";
+    /** Score label */
+    scoreLabel?: string;
+    /** Format score function */
+    formatScore?: (score: number) => string;
+    /** Callback when entry is clicked */
+    onEntryClick?: (entry: LeaderboardEntry) => void;
+    /** Custom className */
+    className?: string;
+}
+export declare function WakaPodium({ entries, size, scoreLabel, formatScore, onEntryClick, className, }: WakaPodiumProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function WakaLeaderboard({ entries, title, showPodium, animateRankChanges, maxEntries, scoreLabel, formatScore, currentUserId, onEntryClick, showRankChange, size, className, }: WakaLeaderboardProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaMiniLeaderboardProps {
+    entries: LeaderboardEntry[];
+    maxEntries?: number;
+    currentUserId?: string;
+    className?: string;
+}
+export declare function WakaMiniLeaderboard({ entries, maxEntries, currentUserId, className, }: WakaMiniLeaderboardProps): import("react/jsx-runtime").JSX.Element;
+export interface UseLeaderboardOptions {
+    /** Initial entries */
+    entries: LeaderboardEntry[];
+    /** Sort direction */
+    sortDirection?: "asc" | "desc";
+    /** Auto-update rankings when scores change */
+    autoRank?: boolean;
+}
+export declare function useLeaderboard({ entries: initialEntries, sortDirection, autoRank, }: UseLeaderboardOptions): {
+    entries: LeaderboardEntry[];
+    updateScore: (id: string, score: number) => void;
+    addEntry: (entry: Omit<LeaderboardEntry, "rank">) => void;
+    removeEntry: (id: string) => void;
+    refresh: (newEntries: LeaderboardEntry[]) => void;
+    topEntry: LeaderboardEntry;
+    getEntry: (id: string) => LeaderboardEntry | undefined;
+    getRank: (id: string) => number | undefined;
+};