@moontra/moonui-pro 2.1.0 → 2.1.1

package/dist/index.d.ts

@@ -0,0 +1,790 @@
+import * as class_variance_authority_dist_types from 'class-variance-authority/dist/types';
+import * as React from 'react';
+import React__default, { ReactNode, ErrorInfo } from 'react';
+import { VariantProps } from 'class-variance-authority';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+
+declare const animatedButtonVariants: (props?: ({
+    variant?: "default" | "outline" | "link" | "secondary" | "ghost" | "destructive" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface AnimatedButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof animatedButtonVariants> {
+    state?: "idle" | "loading" | "success" | "error";
+    onStateChange?: (state: "idle" | "loading" | "success" | "error") => void;
+}
+declare const AnimatedButton: React__default.ForwardRefExoticComponent<AnimatedButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+    className?: string;
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+declare function ErrorBoundaryWrapper(props: ErrorBoundaryProps): react_jsx_runtime.JSX.Element;
+declare const ErrorBoundary: typeof ErrorBoundaryWrapper;
+
+interface FloatingActionButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    actions?: Array<{
+        icon: React__default.ReactNode;
+        label: string;
+        onClick: () => void;
+    }>;
+    position?: "bottom-right" | "bottom-left" | "top-right" | "top-left";
+    size?: "sm" | "default" | "lg";
+}
+declare const FloatingActionButton: React__default.ForwardRefExoticComponent<FloatingActionButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface HoverCard3DProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    perspective?: number;
+    rotationIntensity?: number;
+    springConfig?: {
+        stiffness?: number;
+        damping?: number;
+    };
+}
+declare const HoverCard3D: React__default.ForwardRefExoticComponent<HoverCard3DProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface MagneticButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    strength?: number;
+    range?: number;
+    springConfig?: {
+        stiffness?: number;
+        damping?: number;
+    };
+}
+declare const MagneticButton: React__default.ForwardRefExoticComponent<MagneticButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface PinchZoomProps {
+    children: React__default.ReactNode;
+    minZoom?: number;
+    maxZoom?: number;
+    initialZoom?: number;
+    className?: string;
+    contentClassName?: string;
+    onZoomChange?: (zoom: number) => void;
+}
+declare const PinchZoom: React__default.ForwardRefExoticComponent<PinchZoomProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface SpotlightCardProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    spotlightColor?: string;
+    spotlightSize?: number;
+    intensity?: number;
+    borderGlow?: boolean;
+}
+declare const SpotlightCard: React__default.ForwardRefExoticComponent<SpotlightCardProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface CalendarEvent {
+    id: string;
+    title: string;
+    description?: string;
+    date: Date;
+    startTime?: string;
+    endTime?: string;
+    location?: string;
+    attendees?: string[];
+    color?: string;
+    type?: 'meeting' | 'task' | 'reminder' | 'event';
+}
+interface CalendarProps {
+    events?: CalendarEvent[];
+    onEventClick?: (event: CalendarEvent) => void;
+    onEventAdd?: (eventData: Omit<CalendarEvent, 'id'> & {
+        id?: string;
+    }) => void;
+    onEventEdit?: (eventData: Omit<CalendarEvent, 'id'> & {
+        id: string;
+    }) => void;
+    onEventDelete?: (eventId: string) => void;
+    className?: string;
+    showWeekends?: boolean;
+    showEventDetails?: boolean;
+    disabled?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    highlightToday?: boolean;
+    height?: number;
+    showProUpgrade?: boolean;
+}
+declare function Calendar({ events, onEventClick, onEventAdd, onEventEdit, onEventDelete, className, showWeekends, showEventDetails, disabled, minDate, maxDate, highlightToday, height, showProUpgrade }: CalendarProps): react_jsx_runtime.JSX.Element;
+
+interface KanbanCard {
+    id: string;
+    title: string;
+    description?: string;
+    assignee?: {
+        name: string;
+        avatar?: string;
+        email?: string;
+    };
+    dueDate?: Date;
+    priority?: 'low' | 'medium' | 'high' | 'urgent';
+    tags?: string[];
+    attachments?: number;
+    comments?: number;
+    completed?: boolean;
+}
+interface KanbanColumn {
+    id: string;
+    title: string;
+    color?: string;
+    cards: KanbanCard[];
+    limit?: number;
+}
+interface KanbanProps {
+    columns: KanbanColumn[];
+    onCardMove?: (cardId: string, fromColumn: string, toColumn: string, newIndex: number) => void;
+    onCardClick?: (card: KanbanCard) => void;
+    onCardEdit?: (card: KanbanCard) => void;
+    onCardDelete?: (card: KanbanCard) => void;
+    onAddCard?: (columnId: string) => void;
+    onAddColumn?: () => void;
+    className?: string;
+    showAddColumn?: boolean;
+    showCardDetails?: boolean;
+    disabled?: boolean;
+}
+declare function Kanban({ columns, onCardMove, onCardClick, onCardEdit, onCardDelete, onAddCard, onAddColumn, className, showAddColumn, showCardDetails, disabled }: KanbanProps): react_jsx_runtime.JSX.Element;
+
+interface RichTextEditorProps {
+    value?: string;
+    onChange?: (value: string) => void;
+    placeholder?: string;
+    className?: string;
+    height?: number | string;
+    features?: {
+        bold?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        strike?: boolean;
+        heading?: boolean;
+        lists?: boolean;
+        blockquote?: boolean;
+        code?: boolean;
+        link?: boolean;
+        image?: boolean;
+        table?: boolean;
+        align?: boolean;
+        color?: boolean;
+        ai?: boolean;
+    };
+    aiConfig?: {
+        provider?: 'openai' | 'claude' | 'gemini' | 'cohere';
+        apiKey?: string;
+        model?: string;
+        temperature?: number;
+        maxTokens?: number;
+    };
+}
+declare function RichTextEditor({ placeholder, className, height, features, aiConfig, }: RichTextEditorProps): react_jsx_runtime.JSX.Element | null;
+
+interface MemoryConfig {
+    chunkSize?: number;
+    maxMemoryItems?: number;
+    cacheStrategy?: 'lru' | 'fifo' | 'lfu';
+    compression?: boolean;
+    autoCleanup?: boolean;
+    cleanupThreshold?: number;
+    streamingMode?: boolean;
+    enableAnalytics?: boolean;
+    analyticsCallback?: (stats: MemoryStats) => void;
+}
+interface MemoryStats {
+    memoryUsage: number;
+    itemCount: number;
+    cacheHitRate: number;
+    compressionRatio?: number;
+    lastCleanup?: number;
+}
+interface MemoryEfficientDataProps<T = any> {
+    data: T[];
+    config?: MemoryConfig;
+    renderItem: (item: T, index: number) => React__default.ReactNode;
+    height?: number;
+    onMemoryUpdate?: (stats: MemoryStats) => void;
+    className?: string;
+}
+declare function MemoryEfficientData<T = any>({ data, config, renderItem, height, onMemoryUpdate, className }: MemoryEfficientDataProps<T>): react_jsx_runtime.JSX.Element;
+interface MemoryAnalyticsProps {
+    onStatsUpdate?: (stats: MemoryStats) => void;
+    showRealTime?: boolean;
+    className?: string;
+}
+declare function MemoryAnalytics({ onStatsUpdate, showRealTime, className }: MemoryAnalyticsProps): react_jsx_runtime.JSX.Element | null;
+declare function useStreamingData<T>(initialData?: T[], streamingConfig?: {
+    interval?: number;
+    maxItems?: number;
+}): {
+    data: T[];
+    addItem: (newItem: T) => void;
+    clearData: () => void;
+};
+
+interface VirtualListProps<T = any> {
+    items: T[];
+    height: number;
+    itemHeight?: number;
+    estimatedItemHeight?: number;
+    variableHeight?: boolean;
+    overscan?: number;
+    renderItem: (item: T, index: number) => React__default.ReactNode;
+    onScroll?: (scrollTop: number) => void;
+    className?: string;
+}
+declare function VirtualList<T = any>({ items, height, itemHeight, estimatedItemHeight, variableHeight, overscan, renderItem, onScroll, className }: VirtualListProps<T>): react_jsx_runtime.JSX.Element;
+declare function useVirtualList<T>(items: T[], initialConfig?: Partial<VirtualListProps<T>>): {
+    config: Partial<VirtualListProps<T>>;
+    updateConfig: (newConfig: Partial<VirtualListProps<T>>) => void;
+    selectedItems: Set<number>;
+    selectItem: (index: number) => void;
+    deselectItem: (index: number) => void;
+    clearSelection: () => void;
+};
+interface SelectableVirtualListProps<T = any> extends VirtualListProps<T> {
+    selectable?: boolean;
+    multiSelect?: boolean;
+    selectedItems?: Set<number>;
+    onSelectionChange?: (selectedItems: Set<number>) => void;
+}
+declare function SelectableVirtualList<T = any>({ selectable, multiSelect, selectedItems, onSelectionChange, renderItem: originalRenderItem, ...props }: SelectableVirtualListProps<T>): react_jsx_runtime.JSX.Element;
+
+interface SwipeableCardProps {
+    children: ReactNode;
+    onSwipeLeft?: () => void;
+    onSwipeRight?: () => void;
+    onSwipeStart?: () => void;
+    onSwipeEnd?: () => void;
+    threshold?: number;
+    disabled?: boolean;
+    className?: string;
+    style?: React__default.CSSProperties;
+}
+declare const SwipeableCard: React__default.ForwardRefExoticComponent<SwipeableCardProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface TimelineEvent {
+    id: string;
+    title: string;
+    description?: string;
+    date: Date;
+    type: 'success' | 'warning' | 'error' | 'info' | 'pending';
+    user?: {
+        name: string;
+        avatar?: string;
+        email?: string;
+    };
+    metadata?: {
+        location?: string;
+        duration?: string;
+        tags?: string[];
+        attachments?: number;
+        comments?: number;
+        externalLink?: string;
+    };
+    icon?: React__default.ReactNode;
+    color?: string;
+}
+interface TimelineProps {
+    events: TimelineEvent[];
+    onEventClick?: (event: TimelineEvent) => void;
+    className?: string;
+    showUserInfo?: boolean;
+    showMetadata?: boolean;
+    showRelativeTime?: boolean;
+    groupByDate?: boolean;
+    orientation?: 'vertical' | 'horizontal';
+    compact?: boolean;
+    interactive?: boolean;
+}
+declare function Timeline({ events, onEventClick, className, showUserInfo, showMetadata, showRelativeTime, groupByDate, orientation, compact, interactive }: TimelineProps): react_jsx_runtime.JSX.Element;
+
+type ChartType = 'line' | 'bar' | 'area' | 'pie' | 'scatter';
+interface ChartDataPoint {
+    [key: string]: string | number | null;
+}
+interface ChartSeries {
+    dataKey: string;
+    name: string;
+    color: string;
+    type?: 'monotone' | 'linear' | 'step';
+    strokeWidth?: number;
+    fillOpacity?: number;
+    hide?: boolean;
+}
+interface AdvancedChartProps {
+    data: ChartDataPoint[];
+    type: ChartType;
+    series: ChartSeries[];
+    title?: string;
+    subtitle?: string;
+    height?: number;
+    width?: number | string;
+    xAxisKey?: string;
+    yAxisKey?: string;
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    showLegend?: boolean;
+    showBrush?: boolean;
+    showReference?: boolean;
+    referenceLines?: Array<{
+        value: number;
+        label?: string;
+        color?: string;
+    }>;
+    referenceAreas?: Array<{
+        x1: string | number;
+        x2: string | number;
+        label?: string;
+        color?: string;
+    }>;
+    colors?: string[];
+    className?: string;
+    onDataPointClick?: (data: ChartDataPoint) => void;
+    onExport?: (format: 'png' | 'svg' | 'pdf') => void;
+    onRefresh?: () => void;
+    customTooltip?: React__default.ComponentType<any>;
+    customLegend?: React__default.ComponentType<any>;
+    loading?: boolean;
+    error?: string | null;
+    animated?: boolean;
+    responsive?: boolean;
+}
+declare function AdvancedChart({ data, type, series, title, subtitle, height, width, xAxisKey, yAxisKey, showGrid, showTooltip, showLegend, showBrush, showReference, referenceLines, referenceAreas, colors, className, onDataPointClick, onExport, onRefresh, customTooltip, customLegend, loading, error, animated, responsive, }: AdvancedChartProps): react_jsx_runtime.JSX.Element;
+
+interface DashboardMetric {
+    id: string;
+    title: string;
+    value: string | number;
+    change?: {
+        value: number;
+        type: 'increase' | 'decrease' | 'neutral';
+        period: string;
+    };
+    icon?: React__default.ReactNode;
+    color?: string;
+    description?: string;
+    trend?: number[];
+}
+interface DashboardWidget {
+    id: string;
+    title: string;
+    description?: string;
+    content: React__default.ReactNode;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    loading?: boolean;
+    error?: string;
+}
+interface DashboardProps {
+    metrics?: DashboardMetric[];
+    widgets?: DashboardWidget[];
+    onMetricClick?: (metric: DashboardMetric) => void;
+    onWidgetAction?: (widgetId: string, action: string) => void;
+    className?: string;
+    showHeader?: boolean;
+    title?: string;
+    description?: string;
+    refreshable?: boolean;
+    onRefresh?: () => void;
+    loading?: boolean;
+}
+declare function Dashboard({ metrics, widgets, onMetricClick, onWidgetAction, className, showHeader, title, description, refreshable, onRefresh, loading }: DashboardProps): react_jsx_runtime.JSX.Element;
+
+interface DraggableListProps<T> {
+    items: T[];
+    onReorder: (items: T[]) => void;
+    renderItem: (item: T, index: number) => ReactNode;
+    keyExtractor: (item: T) => string;
+    direction?: "vertical" | "horizontal";
+    className?: string;
+    droppableId?: string;
+    disabled?: boolean;
+}
+declare function DraggableList<T>({ items, onReorder, renderItem, keyExtractor, direction, className, droppableId, disabled, }: DraggableListProps<T>): react_jsx_runtime.JSX.Element;
+
+interface AdvancedFormField {
+    name: string;
+    label: string;
+    type: "text" | "email" | "password" | "textarea" | "select" | "checkbox" | "switch" | "file" | "number" | "url" | "tel";
+    placeholder?: string;
+    required?: boolean;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    validation?: {
+        minLength?: number;
+        maxLength?: number;
+        pattern?: RegExp;
+        custom?: (value: any) => string | true;
+    };
+    description?: string;
+    defaultValue?: any;
+}
+interface AdvancedFormsProps {
+    fields: AdvancedFormField[];
+    onSubmit: (data: any) => void | Promise<void>;
+    title?: string;
+    description?: string;
+    submitText?: string;
+    enableAutoSave?: boolean;
+    showProgress?: boolean;
+    className?: string;
+    layout?: "vertical" | "horizontal" | "grid";
+    columns?: number;
+}
+declare const AdvancedForms: React__default.FC<AdvancedFormsProps>;
+
+interface ColorPickerProps {
+    value?: string;
+    onChange?: (color: string) => void;
+    disabled?: boolean;
+    showPresets?: boolean;
+    showAlpha?: boolean;
+    showInput?: boolean;
+    showCopy?: boolean;
+    presetColors?: string[];
+    className?: string;
+    size?: "sm" | "default" | "lg";
+}
+declare const ColorPicker: React__default.FC<ColorPickerProps>;
+
+interface GitHubRepository {
+    id: number;
+    name: string;
+    full_name: string;
+    description: string | null;
+    html_url: string;
+    homepage: string | null;
+    stargazers_count: number;
+    watchers_count: number;
+    forks_count: number;
+    language: string | null;
+    topics: string[];
+    created_at: string;
+    updated_at: string;
+    owner: {
+        login: string;
+        avatar_url: string;
+        html_url: string;
+    };
+}
+interface GitHubStarsProps {
+    username: string;
+    repositories?: string[];
+    showDescription?: boolean;
+    showTopics?: boolean;
+    showStats?: boolean;
+    showOwner?: boolean;
+    sortBy?: "stars" | "forks" | "updated" | "created";
+    layout?: "grid" | "list";
+    maxItems?: number;
+    autoRefresh?: boolean;
+    refreshInterval?: number;
+    className?: string;
+    onRepositoryClick?: (repo: GitHubRepository) => void;
+}
+declare const GitHubStars: React__default.FC<GitHubStarsProps>;
+
+interface HealthCheckEndpoint {
+    id: string;
+    name: string;
+    url: string;
+    method: "GET" | "POST" | "PUT" | "DELETE" | "HEAD";
+    expectedStatus?: number[];
+    timeout?: number;
+    headers?: Record<string, string>;
+    body?: string;
+    critical?: boolean;
+}
+interface HealthCheckResult {
+    id: string;
+    name: string;
+    status: "healthy" | "unhealthy" | "warning" | "pending";
+    responseTime: number;
+    statusCode?: number;
+    error?: string;
+    timestamp: Date;
+    uptime?: number;
+}
+interface HealthCheckProps {
+    endpoints: HealthCheckEndpoint[];
+    interval?: number;
+    autoRefresh?: boolean;
+    showResponseTime?: boolean;
+    showUptime?: boolean;
+    showHistory?: boolean;
+    maxHistory?: number;
+    onStatusChange?: (results: HealthCheckResult[]) => void;
+    className?: string;
+}
+declare const HealthCheck: React__default.FC<HealthCheckProps>;
+
+interface LazyComponentProps {
+    children: React__default.ReactNode;
+    fallback?: React__default.ReactNode;
+    threshold?: number;
+    rootMargin?: string;
+    triggerOnce?: boolean;
+    disabled?: boolean;
+    onLoad?: () => void;
+    onVisible?: () => void;
+    showLoadingState?: boolean;
+    delay?: number;
+    className?: string;
+}
+interface LazyImageProps extends React__default.ImgHTMLAttributes<HTMLImageElement> {
+    src: string;
+    alt: string;
+    fallbackSrc?: string;
+    showPlaceholder?: boolean;
+    threshold?: number;
+    rootMargin?: string;
+    onLoad?: () => void;
+    onError?: () => void;
+    className?: string;
+}
+declare const LazyImage: React__default.FC<LazyImageProps>;
+interface LazyListProps<T> {
+    items: T[];
+    renderItem: (item: T, index: number) => React__default.ReactNode;
+    itemHeight?: number;
+    batchSize?: number;
+    threshold?: number;
+    className?: string;
+}
+declare function LazyList<T>({ items, renderItem, itemHeight, batchSize, threshold, className }: LazyListProps<T>): react_jsx_runtime.JSX.Element;
+declare const LazyComponent: React__default.FC<LazyComponentProps>;
+
+interface OptimizedImageProps {
+    src: string;
+    alt: string;
+    width?: number;
+    height?: number;
+    quality?: number;
+    format?: "webp" | "avif" | "jpeg" | "png" | "auto";
+    lazy?: boolean;
+    blur?: boolean;
+    priority?: boolean;
+    sizes?: string;
+    srcSet?: string;
+    fallbackSrc?: string;
+    showPreview?: boolean;
+    showZoom?: boolean;
+    showDownload?: boolean;
+    showInfo?: boolean;
+    zoomLevel?: number;
+    className?: string;
+    onLoad?: () => void;
+    onError?: (error: Error) => void;
+    onZoom?: (level: number) => void;
+}
+declare const OptimizedImage: React__default.FC<OptimizedImageProps>;
+
+interface PerformanceMetric {
+    name: string;
+    value: number;
+    unit: string;
+    threshold?: {
+        good: number;
+        needs_improvement: number;
+    };
+    description?: string;
+}
+interface PerformanceEntry {
+    timestamp: number;
+    metrics: PerformanceMetric[];
+    url: string;
+    userAgent: string;
+}
+interface PerformanceDebuggerProps {
+    autoCapture?: boolean;
+    captureInterval?: number;
+    maxEntries?: number;
+    showRealTime?: boolean;
+    showWebVitals?: boolean;
+    showResourceTiming?: boolean;
+    showNavigationTiming?: boolean;
+    onMetricChange?: (metrics: PerformanceMetric[]) => void;
+    className?: string;
+}
+declare const PerformanceDebugger: React__default.FC<PerformanceDebuggerProps>;
+
+interface PerformanceMetrics {
+    cpu: {
+        usage: number;
+        cores: number;
+        temperature?: number;
+    };
+    memory: {
+        used: number;
+        total: number;
+        available: number;
+        percentage: number;
+    };
+    disk: {
+        used: number;
+        total: number;
+        free: number;
+        percentage: number;
+    };
+    network: {
+        download: number;
+        upload: number;
+        latency: number;
+    };
+    system: {
+        uptime: number;
+        loadAverage: number[];
+        processes: number;
+    };
+    browser?: {
+        jsHeapUsed: number;
+        jsHeapTotal: number;
+        jsHeapLimit: number;
+    };
+}
+interface PerformanceAlert {
+    id: string;
+    type: "warning" | "critical" | "info";
+    metric: string;
+    message: string;
+    value: number;
+    threshold: number;
+    timestamp: Date;
+}
+interface PerformanceMonitorProps {
+    autoRefresh?: boolean;
+    refreshInterval?: number;
+    showAlerts?: boolean;
+    alertThresholds?: {
+        cpu: number;
+        memory: number;
+        disk: number;
+        network: number;
+    };
+    showCharts?: boolean;
+    chartDuration?: number;
+    maxDataPoints?: number;
+    onAlert?: (alert: PerformanceAlert) => void;
+    onMetricsUpdate?: (metrics: PerformanceMetrics) => void;
+    className?: string;
+}
+declare const PerformanceMonitor: React__default.FC<PerformanceMonitorProps>;
+
+declare const enhancedButtonVariants: (props?: ({
+    variant?: "default" | "glow" | "outline" | "gradient" | "link" | "secondary" | "ghost" | "destructive" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+    animation?: "ripple" | "morph" | "particles" | "magnetic" | "glitch" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface ButtonProProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof enhancedButtonVariants> {
+    state?: "idle" | "loading" | "success" | "error";
+    onStateChange?: (state: "idle" | "loading" | "success" | "error") => void;
+    enableRipple?: boolean;
+    enableMorph?: boolean;
+    enableParticles?: boolean;
+    enableMagnetic?: boolean;
+    enableGlitch?: boolean;
+}
+declare const ButtonPro: React__default.ForwardRefExoticComponent<ButtonProProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface CardProProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    enableGlassmorphism?: boolean;
+    enableParallax?: boolean;
+    enableTilt?: boolean;
+    enableGlow?: boolean;
+    enableReveal?: boolean;
+    tiltMaxAngle?: number;
+    glowColor?: string;
+    parallaxOffset?: number;
+}
+declare const CardPro: React__default.ForwardRefExoticComponent<CardProProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const CardProHeader: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
+declare const EnhancedCardTitle: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLHeadingElement> & React__default.RefAttributes<HTMLParagraphElement>>;
+declare const EnhancedCardDescription: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLParagraphElement> & React__default.RefAttributes<HTMLParagraphElement>>;
+declare const CardProContent: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
+declare const CardProFooter: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+interface DialogProOverlayProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay> {
+    blur?: "none" | "sm" | "md" | "lg" | "xl";
+    variant?: "default" | "dark" | "light" | "gradient";
+}
+interface DialogProContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+    animation?: "fade" | "scale" | "slide" | "rotate" | "bounce";
+    animationDuration?: number;
+    overlay?: boolean;
+    overlayProps?: DialogProOverlayProps;
+}
+declare const DialogProContent: React.ForwardRefExoticComponent<DialogProContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const DialogProHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogProFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogProTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogProDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | "destructive" | "success" | "pro" | "warning" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface BadgeProProps extends React__default.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+    enablePulse?: boolean;
+    enableGlow?: boolean;
+    enableShimmer?: boolean;
+    removable?: boolean;
+    onRemove?: () => void;
+    leftIcon?: React__default.ReactNode;
+    rightIcon?: React__default.ReactNode;
+}
+declare const BadgePro: React__default.ForwardRefExoticComponent<BadgeProProps & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const index_BadgePro: typeof BadgePro;
+type index_BadgeProProps = BadgeProProps;
+declare const index_ButtonPro: typeof ButtonPro;
+type index_ButtonProProps = ButtonProProps;
+declare const index_CardPro: typeof CardPro;
+declare const index_CardProContent: typeof CardProContent;
+declare const index_CardProFooter: typeof CardProFooter;
+declare const index_CardProHeader: typeof CardProHeader;
+type index_CardProProps = CardProProps;
+declare const index_DialogProContent: typeof DialogProContent;
+declare const index_DialogProDescription: typeof DialogProDescription;
+declare const index_DialogProFooter: typeof DialogProFooter;
+declare const index_DialogProHeader: typeof DialogProHeader;
+declare const index_DialogProTitle: typeof DialogProTitle;
+declare const index_EnhancedCardDescription: typeof EnhancedCardDescription;
+declare const index_EnhancedCardTitle: typeof EnhancedCardTitle;
+declare const index_badgeVariants: typeof badgeVariants;
+declare const index_enhancedButtonVariants: typeof enhancedButtonVariants;
+declare namespace index {
+  export {
+    index_BadgePro as BadgePro,
+    index_BadgeProProps as BadgeProProps,
+    index_ButtonPro as ButtonPro,
+    index_ButtonProProps as ButtonProProps,
+    index_CardPro as CardPro,
+    index_CardProContent as CardProContent,
+    index_CardProFooter as CardProFooter,
+    index_CardProHeader as CardProHeader,
+    index_CardProProps as CardProProps,
+    Dialog as DialogPro,
+    DialogClose as DialogProClose,
+    index_DialogProContent as DialogProContent,
+    index_DialogProDescription as DialogProDescription,
+    index_DialogProFooter as DialogProFooter,
+    index_DialogProHeader as DialogProHeader,
+    index_DialogProTitle as DialogProTitle,
+    DialogTrigger as DialogProTrigger,
+    index_EnhancedCardDescription as EnhancedCardDescription,
+    index_EnhancedCardTitle as EnhancedCardTitle,
+    index_badgeVariants as badgeVariants,
+    index_enhancedButtonVariants as enhancedButtonVariants,
+  };
+}
+
+export { AdvancedChart, AdvancedFormField, AdvancedForms, AdvancedFormsProps, AnimatedButton, AnimatedButtonProps, Calendar, CalendarEvent, ChartType, ColorPicker, ColorPickerProps, Dashboard, DraggableList, DraggableListProps, index as Enhanced, ErrorBoundary, FloatingActionButton, FloatingActionButtonProps, GitHubRepository, GitHubStars, GitHubStarsProps, HealthCheck, HealthCheckEndpoint, HealthCheckProps, HealthCheckResult, HoverCard3D, HoverCard3DProps, Kanban, LazyComponent, LazyImage, LazyImageProps, LazyList, LazyListProps, MagneticButton, MagneticButtonProps, MemoryAnalytics, MemoryAnalyticsProps, MemoryConfig, MemoryEfficientData, MemoryEfficientDataProps, MemoryStats, OptimizedImage, OptimizedImageProps, PerformanceAlert, PerformanceDebugger, PerformanceDebuggerProps, PerformanceEntry, PerformanceMetric, PerformanceMetrics, PerformanceMonitor, PerformanceMonitorProps, PinchZoom, RichTextEditor, SelectableVirtualList, SelectableVirtualListProps, SpotlightCard, SpotlightCardProps, SwipeableCard, Timeline, VirtualList, VirtualListProps, animatedButtonVariants, useStreamingData, useVirtualList };