@getdashfy/ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1408 @@
+import * as _getdashfy_types from '@getdashfy/types';
+import { WidgetComponent, WidgetMetadata, DashfyConfig, ThemeId, Dashboard, Subscription, ApiData, WebSocketStatus, Notification } from '@getdashfy/types';
+export { ApiConfig, Dashboard, DashboardConfig, DashfyConfig, Notification, NotificationType, Subscription, WebSocketStatus, WidgetComponent, WidgetConfig, WidgetProps } from '@getdashfy/types';
+import * as React$1 from 'react';
+import { OverlayScrollbarsComponent } from 'overlayscrollbars-react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { ThemeMode, Theme } from '@getdashfy/themes';
+import { Socket } from 'socket.io-client';
+import { ClassValue } from 'clsx';
+import * as zustand from 'zustand';
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import * as AspectRatioPrimitive from '@radix-ui/react-aspect-ratio';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+import { DayPicker, DayButton } from 'react-day-picker';
+import useEmblaCarousel, { UseEmblaCarouselType } from 'embla-carousel-react';
+import * as recharts_types_util_payload_getUniqPayload from 'recharts/types/util/payload/getUniqPayload';
+import * as recharts_types_component_Tooltip from 'recharts/types/component/Tooltip';
+import * as recharts_types_util_types from 'recharts/types/util/types';
+import * as recharts_types_component_DefaultTooltipContent from 'recharts/types/component/DefaultTooltipContent';
+import * as RechartsPrimitive from 'recharts';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { DialogProps } from '@radix-ui/react-dialog';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import * as vaul from 'vaul';
+import { Drawer as Drawer$1 } from 'vaul';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as _radix_ui_react_slot from '@radix-ui/react-slot';
+import * as react_hook_form from 'react-hook-form';
+import { FieldValues, FieldPath, ControllerProps } from 'react-hook-form';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
+import * as input_otp from 'input-otp';
+import * as MenubarPrimitive from '@radix-ui/react-menubar';
+import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as ProgressPrimitive from '@radix-ui/react-progress';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import * as ResizablePrimitive from 'react-resizable-panels';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+import { Toaster as Toaster$1 } from 'sonner';
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import * as TogglePrimitive from '@radix-ui/react-toggle';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+
+type Extension = Record<string, WidgetComponent>;
+interface WidgetRegistryEntry {
+    component: WidgetComponent;
+    metadata?: WidgetMetadata;
+}
+/**
+ * Global registry for managing widget components and extensions.
+ *
+ * Provides a centralized system for registering, retrieving, and managing widget
+ * components from different extensions. Widgets are identified by namespaced keys
+ * in the format "extension:widget" (e.g., "json:status", "github:issues").
+ *
+ * Supports:
+ * - Individual widget registration with optional metadata
+ * - Bulk extension registration with multiple widgets
+ * - Widget lookup by key or extension/widget name
+ * - Metadata storage for widget configuration and documentation
+ *
+ * @example
+ * ```tsx
+ * // Register a single widget
+ * WidgetRegistry.register('myExtension:counter', CounterWidget, {
+ *   displayName: 'Counter',
+ *   description: 'Shows a counter value'
+ * })
+ *
+ * // Register an extension with multiple widgets
+ * WidgetRegistry.addExtension('json', {
+ *   status: StatusWidget,
+ *   data: DataWidget
+ * })
+ *
+ * // Retrieve a widget
+ * const widget = WidgetRegistry.get('json:status')
+ * ```
+ */
+declare class WidgetRegistryClass {
+    private widgets;
+    /**
+     * Register a single widget component.
+     *
+     * @param key - Widget key in format "extension:widget"
+     * @param component - React component
+     * @param metadata - Optional widget metadata
+     */
+    register(key: string, component: WidgetComponent, metadata?: WidgetMetadata): void;
+    /**
+     * Register an entire extension with multiple widgets.
+     *
+     * @param extensionId - Extension identifier (e.g. "json", "github")
+     * @param widgets - Object mapping widget names to components
+     */
+    addExtension(extensionId: string, widgets: Extension): void;
+    /**
+     * Register multiple extensions at once.
+     *
+     * @param extensions - Object mapping extension IDs to widget objects
+     */
+    addExtensions(extensions: Record<string, Extension>): void;
+    /**
+     * Unregister a widget component.
+     *
+     * @param key - Widget key in format "extension:widget"
+     */
+    unregister(key: string): void;
+    /**
+     * Get a widget component by key.
+     *
+     * @param key - Widget key in format "extension:widget"
+     * @returns Widget component or undefined if not found
+     */
+    get(key: string): WidgetComponent | undefined;
+    /**
+     * Get full registry entry (component + metadata).
+     *
+     * @param key - Widget key in format "extension:widget"
+     * @returns Registry entry or undefined if not found
+     */
+    getEntry(key: string): WidgetRegistryEntry | undefined;
+    /**
+     * Check if a widget type is registered.
+     *
+     * @param key - Widget key in format "extension:widget"
+     * @returns true if widget is registered
+     */
+    has(key: string): boolean;
+    /**
+     * Check if a widget exists for extension and widget name.
+     *
+     * @param extension - Extension identifier
+     * @param widget - Widget name
+     * @returns true if widget is registered
+     */
+    hasWidget(extension: string, widget: string): boolean;
+    /**
+     * Get widget component by extension and widget name.
+     *
+     * @param extension - Extension identifier
+     * @param widget - Widget name
+     * @returns Widget component or undefined if not found
+     */
+    getComponent(extension: string, widget: string): WidgetComponent | undefined;
+    /**
+     * Get all registered widget keys.
+     *
+     * @returns Array of widget keys
+     */
+    getTypes(): string[];
+    /**
+     * Get count of registered widgets.
+     *
+     * @returns Number of registered widgets
+     */
+    widgetsCount(): number;
+    /**
+     * Get all registered widgets as an object.
+     *
+     * @returns Object mapping widget keys to entries
+     */
+    list(): Record<string, WidgetRegistryEntry>;
+    /**
+     * Clear all registered widgets.
+     */
+    clear(): void;
+}
+declare const WidgetRegistry: WidgetRegistryClass;
+
+/**
+ * Development-only debug component that logs Dashfy state to console.
+ * Provides real-time insights into configuration, WebSocket status,
+ * dashboards, API subscriptions, and more.
+ *
+ * Usage: Add <DebugInfo /> to your component tree during development.
+ */
+declare const DebugInfo: () => null;
+
+declare const ExternalLink: ({ children, className, href, rel, target, ...props }: React$1.ComponentProps<"a">) => React$1.JSX.Element;
+
+interface ScrollableProps extends Omit<React$1.ComponentProps<typeof OverlayScrollbarsComponent>, 'options'> {
+    options?: React$1.ComponentProps<typeof OverlayScrollbarsComponent>['options'];
+}
+declare const Scrollable: ({ className, options, defer, ...props }: ScrollableProps) => React$1.JSX.Element;
+
+declare const textVariants: (props?: ({
+    variant?: "small" | "strong" | "display" | "default" | "mono" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TextProps extends React$1.HTMLAttributes<HTMLElement>, VariantProps<typeof textVariants> {
+    as?: 'span' | 'p' | 'div' | 'label' | 'code';
+}
+declare const Text: ({ children, className, variant, as: Component, ...props }: TextProps) => React$1.JSX.Element;
+
+interface DashfyProps {
+    children?: (dashboard: DashfyConfig['dashboards'][0]) => React$1.ReactNode;
+    config?: DashfyConfig;
+    logo?: React$1.ReactNode;
+    serverUrl?: string;
+}
+declare const Dashfy: ({ children, config, logo, serverUrl }: DashfyProps) => React$1.JSX.Element;
+
+interface WidgetProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare const Widget: ({ children, className, ...props }: WidgetProps) => React$1.JSX.Element;
+
+interface WidgetBodyProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    disablePadding?: boolean;
+    scrollable?: boolean;
+}
+declare const WidgetBody: ({ children, className, disablePadding, scrollable, ...props }: WidgetBodyProps) => React$1.JSX.Element;
+
+interface WidgetEmptyProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    icon?: React$1.ReactNode;
+    message?: string;
+}
+declare const WidgetEmpty: ({ className, icon, message, ...props }: WidgetEmptyProps) => React$1.JSX.Element;
+
+interface WidgetErrorProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    error: string | Error;
+    onRetry?: () => void;
+}
+declare const WidgetError: ({ className, error, onRetry, ...props }: WidgetErrorProps) => React$1.JSX.Element;
+
+interface WidgetHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    actions?: React$1.ReactNode;
+    count?: number;
+    icon?: React$1.ReactNode;
+    subject?: string;
+    title?: string;
+}
+declare const WidgetHeader: ({ actions, className, count, icon, subject, title, ...props }: WidgetHeaderProps) => React$1.JSX.Element;
+
+interface WidgetLoaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    message?: string;
+}
+declare const WidgetLoader: ({ className, message, ...props }: WidgetLoaderProps) => React$1.JSX.Element;
+interface WidgetSkeletonProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare const WidgetSkeleton: ({ className, ...props }: WidgetSkeletonProps) => React$1.JSX.Element;
+
+interface WidgetWrapperProps {
+    actions?: React$1.ReactNode;
+    children: (data: unknown) => React$1.ReactNode;
+    count?: number;
+    data?: unknown;
+    emptyMessage?: string;
+    error?: string | Error | null;
+    icon?: React$1.ReactNode;
+    subject?: string;
+    title?: string;
+    disablePadding?: boolean;
+    loading?: boolean;
+    scrollable?: boolean;
+}
+declare const WidgetWrapper: ({ actions, children, count, data, emptyMessage, error, icon, subject, title, disablePadding, loading, scrollable, }: WidgetWrapperProps) => React$1.JSX.Element;
+
+interface WidgetAvatarProps {
+    children?: React$1.ReactNode;
+    className?: string;
+    size?: number | string;
+    src?: string;
+    alt?: string;
+}
+declare const WidgetAvatar: ({ children, className, size, src, alt }: WidgetAvatarProps) => React$1.JSX.Element;
+
+interface WidgetCounterProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    align?: 'left' | 'center' | 'right';
+    count: number;
+    unit?: string;
+    preLabel?: React$1.ReactNode;
+    postLabel?: React$1.ReactNode;
+}
+declare const WidgetCounter: ({ align, className, count, unit, preLabel, postLabel, ...props }: WidgetCounterProps) => React$1.JSX.Element;
+
+interface WidgetLabelProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, 'label' | 'prefix' | 'suffix'> {
+    label: React$1.ReactNode;
+    prefix?: React$1.ReactNode;
+    suffix?: React$1.ReactNode;
+}
+declare const WidgetLabel: ({ className, label, prefix, suffix, ...props }: WidgetLabelProps) => React$1.JSX.Element;
+
+interface ErrorBoundaryProps {
+    children: React$1.ReactNode;
+    /**
+     * Custom fallback UI to render when error occurs.
+     * If not provided, uses the default Dashfy error UI.
+     */
+    fallback?: React$1.ReactNode;
+    /**
+     * Keys that when changed will reset the error boundary
+     */
+    resetKeys?: unknown[];
+    /**
+     * Callback when an error is caught (useful for logging/analytics)
+     */
+    onError?: (error: Error, info: React$1.ErrorInfo) => void;
+    /**
+     * Called when error boundary resets (e.g., after retry)
+     */
+    onReset?: () => void;
+}
+/**
+ * Error boundary for catching and displaying errors in widgets.
+ * Wraps react-error-boundary with Dashfy-specific defaults.
+ *
+ * @example
+ * // Basic usage
+ * <WidgetErrorBoundary>
+ *   <MyWidget />
+ * </WidgetErrorBoundary>
+ *
+ * @example
+ * // With custom fallback
+ * <WidgetErrorBoundary fallback={<div>Custom error</div>}>
+ *   <MyWidget />
+ * </WidgetErrorBoundary>
+ *
+ * @example
+ * // With error logging
+ * <WidgetErrorBoundary onError={(error) => logToSentry(error)}>
+ *   <MyWidget />
+ * </WidgetErrorBoundary>
+ */
+declare const WidgetErrorBoundary: ({ children, fallback, onError, onReset, resetKeys, }: ErrorBoundaryProps) => React$1.JSX.Element;
+
+interface WidgetErrorUnknown {
+    extension: string;
+    widget: string;
+}
+declare const WidgetErrorUnknown: ({ extension, widget }: WidgetErrorUnknown) => React$1.JSX.Element;
+
+interface WidgetListItemProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, 'title'> {
+    icon?: React$1.ReactNode;
+    meta?: string;
+    title: React$1.ReactNode;
+    value?: React$1.ReactNode;
+}
+declare const WidgetListItem: ({ className, icon, meta, title, value, ...props }: WidgetListItemProps) => React$1.JSX.Element;
+
+declare const statusVariants: (props?: ({
+    status?: "error" | "success" | "warning" | "unknown" | null | undefined;
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface WidgetStatusBadgeProps extends VariantProps<typeof statusVariants> {
+    className?: string;
+    label?: string;
+}
+declare const WidgetStatusBadge: ({ className, status, size, label }: WidgetStatusBadgeProps) => React$1.JSX.Element;
+
+declare const chipVariants: (props?: ({
+    status?: "error" | "info" | "success" | "warning" | "unknown" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface WidgetStatusChipProps extends VariantProps<typeof chipVariants> {
+    className?: string;
+    label: string;
+    pulse?: boolean;
+    showDot?: boolean;
+}
+declare const WidgetStatusChip: ({ className, status, label, pulse, showDot, }: WidgetStatusChipProps) => React$1.JSX.Element;
+
+interface WidgetTableProps extends React$1.HTMLAttributes<HTMLTableElement> {
+}
+declare const WidgetTable: ({ children, className, ...props }: WidgetTableProps) => React$1.JSX.Element;
+
+interface WidgetTableCellProps extends React$1.TdHTMLAttributes<HTMLTableCellElement> {
+}
+declare const WidgetTableCell: ({ align, children, className, ...props }: WidgetTableCellProps) => React$1.JSX.Element;
+
+interface WidgetTableHeadCellProps extends React$1.ThHTMLAttributes<HTMLTableCellElement> {
+}
+declare const WidgetTableHeadCell: ({ align, children, className, ...props }: WidgetTableHeadCellProps) => React$1.JSX.Element;
+
+interface UseApiSubscriptionOptions {
+    api: string;
+    endpoint: string;
+    params?: Record<string, unknown>;
+    enabled?: boolean;
+}
+/**
+ * Hook for subscribing to API data updates via WebSocket connection.
+ *
+ * Automatically manages subscription lifecycle: creates subscription on mount,
+ * sends it to the server when connected, and cleans up on unmount. Returns
+ * the current data state including loading and error states.
+ *
+ * @param options - Subscription configuration
+ * @param options.api - API name to subscribe to
+ * @param options.endpoint - API endpoint/method to call
+ * @param options.params - Optional parameters to pass to the endpoint
+ * @param options.enabled - Whether the subscription is active (default: true)
+ *
+ * @returns Object containing:
+ * - `data` - The current data
+ * - `error` - The current error
+ * - `loading` - Whether the data is loading
+ * - `lastUpdate` - The last update timestamp
+ *
+ * @example
+ * ```tsx
+ * // No params: subscription ID = "myApi.getData"
+ * const { data, error, loading } = useApiSubscription({
+ *   api: 'myApi',
+ *   endpoint: 'getData',
+ *   enabled: true
+ * })
+ *
+ * // Simple param: subscription ID = "myApi.getData.id=123"
+ * const { data, error, loading } = useApiSubscription({
+ *   api: 'myApi',
+ *   endpoint: 'getData',
+ *   params: { id: '123' },
+ *   enabled: true
+ * })
+ *
+ * // Multiple params: subscription ID = "myApi.getData.user=john.sort=stars.limit=10"
+ * const { data, error, loading } = useApiSubscription({
+ *   api: 'myApi',
+ *   endpoint: 'getData',
+ *   params: { user: 'john', sort: 'stars', limit: 10 },
+ *   enabled: true
+ * })
+ * ```
+ */
+declare function useApiSubscription({ api, endpoint, params, enabled, }: UseApiSubscriptionOptions): {
+    data: {} | null;
+    error: string | null;
+    loading: boolean;
+    lastUpdate: number | undefined;
+};
+
+/**
+ * Hook to manage light/dark mode state and transitions.
+ * Syncs with localStorage and observes DOM changes.
+ *
+ * Note: This hook only manages the mode (light/dark).
+ * Theme application is handled by ThemeProvider.
+ *
+ * @returns Object containing:
+ * - `mode` - The current mode (light/dark)
+ * - `toggleMode` - Function to toggle the mode
+ * - `isLight` - Whether the mode is light
+ * - `isDark` - Whether the mode is dark
+ *
+ * @example
+ * ```tsx
+ * const { mode, toggleMode, isLight, isDark } = useMode()
+ *
+ * return (
+ *   <div>
+ *     <button onClick={toggleMode}>{isLight ? 'Dark' : 'Light'}</button>
+ *   </div>
+ * )
+ * ```
+ */
+declare function useMode(): {
+    mode: ThemeMode;
+    toggleMode: () => void;
+    isLight: boolean;
+    isDark: boolean;
+};
+
+interface UseWebSocketOptions {
+    url: string;
+    autoConnect?: boolean;
+    reconnect?: boolean;
+}
+/**
+ * Hook for managing WebSocket connection lifecycle with automatic reconnection.
+ *
+ * Establishes and maintains a Socket.IO connection to the Dashfy server, handling
+ * connection state, reconnection logic, and automatic resubscription of API endpoints
+ * on reconnect. Integrates with the store to sync configuration, API data, and
+ * subscription states.
+ *
+ * @param options - WebSocket configuration options
+ * @param options.url - Server URL to connect to
+ * @param options.autoConnect - Whether to connect automatically on mount (default: true)
+ * @param options.reconnect - Whether to automatically reconnect on disconnect (default: true)
+ *
+ * @returns Socket.IO client instance or null if not connected
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const socket = useWebSocket({
+ *     url: 'http://localhost:5001',
+ *     autoConnect: true,
+ *     reconnect: true
+ *   })
+ *
+ *   if (!socket) {
+ *     return <div>Connecting...</div>
+ *   }
+ *
+ *   return <Dashboard />
+ * }
+ * ```
+ */
+declare function useWebSocket({ url, autoConnect, reconnect, }: UseWebSocketOptions): Socket | null;
+
+/**
+ * Hook for retrieving widget components from the global widget registry.
+ *
+ * Looks up a widget component by extension and widget name, returning the component,
+ * its metadata (if available), and whether it exists in the registry. Useful for
+ * dynamic widget rendering and validation.
+ *
+ * @param extension - Extension identifier (e.g., "json", "github")
+ * @param widget - Widget name within the extension (e.g., "status", "data")
+ *
+ * @returns Object containing:
+ * - `component` - The widget React component or undefined if not found
+ * - `metadata` - Widget metadata (displayName, description, etc.) or undefined
+ * - `exists` - Boolean indicating if the widget is registered
+ *
+ * @example
+ * ```tsx
+ * function WidgetRenderer({ extension, widget }) {
+ *   const { component: Widget, metadata, exists } = useWidget(extension, widget)
+ *
+ *   if (!exists) {
+ *     return <div>Widget not found: {extension}:{widget}</div>
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <h3>{metadata?.displayName || widget}</h3>
+ *       <Widget />
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useWidget(extension: string, widget: string): {
+    component: _getdashfy_types.WidgetComponent<any> | undefined;
+    metadata: _getdashfy_types.WidgetMetadata | undefined;
+    exists: boolean;
+};
+
+/**
+ * Merges multiple class names using clsx and tailwind-merge.
+ *
+ * @param inputs - Class values to merge
+ * @returns Merged class names
+ *
+ * @example
+ * ```ts
+ * cn('bg-red-500', 'text-white', 'p-4') // => 'bg-red-500 text-white p-4'
+ * ```
+ */
+declare function cn(...inputs: ClassValue[]): string;
+/**
+ * Generates a unique key for React elements.
+ *
+ * @param prefix - Prefix for the key (usually component or list name)
+ * @param identifier - Unique identifier (like id, slug, or other unique value)
+ * @param index - Optional index for list items
+ * @returns A string to be used as React key
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * generateReactKey('user', 'john-doe') // => 'user_john-doe'
+ *
+ * // With index
+ * generateReactKey('list', 'item', 0) // => 'list_item_0'
+ *
+ * // With number identifier
+ * generateReactKey('product', 123) // => 'product_123'
+ * ```
+ */
+declare function generateReactKey(prefix: string, identifier: string | number, index?: number): string;
+
+/**
+ * Global registry for managing theme configurations.
+ *
+ * Provides a centralized system for registering, retrieving, and managing themes.
+ * Themes are identified by unique IDs (e.g., "default", "nord", "midnightBlue").
+ *
+ * Supports:
+ * - Individual theme registration
+ * - Bulk theme registration
+ * - Load all built-in themes from @getdashfy/themes
+ * - Default theme configuration
+ * - Theme lookup by ID
+ *
+ * @example
+ * ```tsx
+ * // Load all themes from @getdashfy/themes
+ * ThemeRegistry.loadAllThemes()
+ *
+ * // Or register themes individually
+ * ThemeRegistry.add(defaultTheme)
+ * ThemeRegistry.add(nordTheme)
+ *
+ * // Or register multiple at once
+ * ThemeRegistry.addAll([defaultTheme, nordTheme, minimalTheme])
+ *
+ * // Set default theme
+ * ThemeRegistry.defaultTheme = 'nord'
+ *
+ * // Retrieve a theme
+ * const theme = ThemeRegistry.get('nord')
+ * ```
+ */
+declare class ThemeRegistryClass {
+    private themes;
+    private _defaultTheme;
+    /**
+     * Register a single theme.
+     *
+     * @param theme - Theme configuration object
+     */
+    add(theme: Theme): void;
+    /**
+     * Register multiple themes at once.
+     *
+     * @param themes - Array of theme configuration objects
+     */
+    addAll(themes: Theme[]): void;
+    /**
+     * Register all themes from @getdashfy/themes.
+     */
+    loadAllThemes(): void;
+    /**
+     * Get a theme by ID.
+     *
+     * @param id - Theme identifier
+     * @returns Theme object or undefined if not found
+     */
+    get(id: ThemeId): Theme | undefined;
+    /**
+     * Check if a theme is registered.
+     *
+     * @param id - Theme identifier
+     * @returns true if theme is registered
+     */
+    has(id: ThemeId): boolean;
+    /**
+     * Unregister a theme.
+     *
+     * @param id - Theme identifier
+     */
+    remove(id: ThemeId): void;
+    /**
+     * Get all registered theme IDs.
+     *
+     * @returns Array of theme IDs
+     */
+    list(): ThemeId[];
+    /**
+     * Get all registered themes as an object.
+     *
+     * @returns Object mapping theme IDs to theme objects
+     */
+    getAll(): Record<ThemeId, Theme>;
+    /**
+     * Get count of registered themes.
+     *
+     * @returns Number of registered themes
+     */
+    get size(): number;
+    /**
+     * Set the default theme ID.
+     *
+     * @param themeId - Theme identifier to set as default
+     * @throws Error if theme is not registered
+     */
+    set defaultTheme(themeId: ThemeId);
+    /**
+     * Get the default theme ID.
+     *
+     * @returns Default theme identifier
+     */
+    get defaultTheme(): ThemeId;
+    /**
+     * Get the default theme object.
+     *
+     * @returns Default theme or undefined if not found
+     */
+    getDefault(): Theme | undefined;
+    /**
+     * Clear all registered themes.
+     */
+    clear(): void;
+}
+declare const ThemeRegistry: ThemeRegistryClass;
+
+interface DashfyStore extends ConfigurationSlice, DashboardsSlice, ApiSlice, WsSlice, ThemesSlice, NotificationsSlice, PanelSlice, SettingsSlice {
+}
+interface ConfigurationSlice {
+    config: DashfyConfig | null;
+    isLoading: boolean;
+    error: string | null;
+    setConfig: (config: DashfyConfig) => void;
+    setLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    fetchConfig: () => Promise<void>;
+}
+interface DashboardsSlice {
+    dashboards: Dashboard[];
+    currentDashboard: number;
+    isPlaying: boolean;
+    setDashboards: (dashboards: Dashboard[]) => void;
+    setCurrentDashboard: (index: number) => void;
+    nextDashboard: () => void;
+    previousDashboard: () => void;
+    play: () => void;
+    pause: () => void;
+    togglePlay: () => void;
+}
+interface ApiSlice {
+    apiSubscriptions: Map<string, Subscription>;
+    apiData: Record<string, ApiData>;
+    subscribeApi: (subscription: Subscription) => void;
+    unsubscribeApi: (id: string) => void;
+    setApiSubscribed: (id: string) => void;
+    setAllApiUnsubscribed: () => void;
+    setApiData: (id: string, data: unknown) => void;
+    setApiError: (id: string, error: string) => void;
+    setApiLoading: (id: string, loading: boolean) => void;
+    getApiPendingSubscriptions: () => Subscription[];
+    hasApiSubscription: (id: string) => boolean;
+    clearApiData: (id: string) => void;
+}
+interface WsSlice {
+    socket: Socket | null;
+    status: WebSocketStatus;
+    reconnectAttempt: number;
+    setSocket: (socket: Socket | null) => void;
+    setStatus: (status: WebSocketStatus) => void;
+    setReconnectAttempt: (attempt: number) => void;
+    incrementReconnectAttempt: () => void;
+    resetReconnectAttempt: () => void;
+}
+interface ThemesSlice {
+    currentTheme: ThemeId | null;
+    availableThemes: ThemeId[];
+    setTheme: (themeId: ThemeId) => void;
+    setAvailableThemes: (themes: ThemeId[]) => void;
+}
+interface NotificationsSlice {
+    notifications: Notification[];
+    addNotification: (notification: Omit<Notification, 'id' | 'createdAt'>) => string;
+    removeNotification: (id: string) => void;
+    clearNotifications: () => void;
+    notifySuccess: (message: string, ttl?: number) => string;
+    notifyError: (message: string, ttl?: number) => string;
+    notifyWarning: (message: string, ttl?: number) => string;
+    notifyInfo: (message: string, ttl?: number) => string;
+}
+interface PanelSlice {
+    isPanelOpen: boolean;
+    panelHeight: number;
+    activeTab: string;
+    availableTabs: {
+        id: string;
+        label: string;
+        icon?: React.ReactNode;
+    }[];
+    togglePanel: () => void;
+    openPanel: () => void;
+    closePanel: () => void;
+    setPanelHeight: (height: number) => void;
+    setActiveTab: (tabId: string) => void;
+    registerTab: (tab: {
+        id: string;
+        label: string;
+        icon?: React.ReactNode;
+    }) => void;
+    unregisterTab: (tabId: string) => void;
+}
+interface SettingsSlice {
+    wakeLockEnabled: boolean;
+    setWakeLockEnabled: (enabled: boolean) => void;
+}
+
+/**
+ * Main Dashfy store combining all slices.
+ * Uses Zustand with devtools middleware for debugging.
+ */
+declare const useDashfyStore: zustand.UseBoundStore<Omit<zustand.StoreApi<DashfyStore>, "setState" | "devtools"> & {
+    setState(partial: DashfyStore | Partial<DashfyStore> | ((state: DashfyStore) => DashfyStore | Partial<DashfyStore>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: DashfyStore | ((state: DashfyStore) => DashfyStore), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}>;
+
+declare const Accordion: React$1.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React$1.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const AlertDialog: React$1.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: React$1.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: React$1.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitle: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const Alert: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const AspectRatio: React$1.ForwardRefExoticComponent<AspectRatioPrimitive.AspectRatioProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Avatar: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React$1.RefAttributes<HTMLImageElement>, "ref"> & React$1.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): React$1.JSX.Element;
+
+declare const Breadcrumb: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React$1.ReactNode;
+} & React$1.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React$1.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & React$1.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React$1.ComponentProps<"li">): React$1.JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+    displayName: string;
+};
+
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, formatters, components, ...props }: React$1.ComponentProps<typeof DayPicker> & {
+    buttonVariant?: React$1.ComponentProps<typeof Button>["variant"];
+}): React$1.JSX.Element;
+declare function CalendarDayButton({ className, day, modifiers, ...props }: React$1.ComponentProps<typeof DayButton>): React$1.JSX.Element;
+
+declare const Card: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+type CarouselProps = {
+    opts?: CarouselOptions;
+    plugins?: CarouselPlugin;
+    orientation?: "horizontal" | "vertical";
+    setApi?: (api: CarouselApi) => void;
+};
+declare const Carousel: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & CarouselProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const CarouselContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CarouselItem: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CarouselPrevious: React$1.ForwardRefExoticComponent<Omit<ButtonProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const CarouselNext: React$1.ForwardRefExoticComponent<Omit<ButtonProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+type ChartConfig = {
+    [k in string]: {
+        label?: React$1.ReactNode;
+        icon?: React$1.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+declare const ChartContainer: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
+    config: ChartConfig;
+    children: React$1.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
+}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ChartStyle: ({ id, config }: {
+    id: string;
+    config: ChartConfig;
+}) => React$1.JSX.Element | null;
+declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
+declare const ChartTooltipContent: React$1.ForwardRefExoticComponent<Omit<RechartsPrimitive.DefaultTooltipContentProps<recharts_types_component_DefaultTooltipContent.ValueType, recharts_types_component_DefaultTooltipContent.NameType> & {
+    accessibilityLayer?: boolean;
+    active?: boolean | undefined;
+    includeHidden?: boolean | undefined;
+    allowEscapeViewBox?: recharts_types_util_types.AllowInDimension;
+    animationDuration?: recharts_types_util_types.AnimationDuration;
+    animationEasing?: recharts_types_util_types.AnimationTiming;
+    content?: recharts_types_component_Tooltip.ContentType<recharts_types_component_DefaultTooltipContent.ValueType, recharts_types_component_DefaultTooltipContent.NameType> | undefined;
+    coordinate?: Partial<recharts_types_util_types.Coordinate>;
+    cursor?: boolean | React$1.ReactElement | React$1.SVGProps<SVGElement>;
+    filterNull?: boolean;
+    defaultIndex?: number;
+    isAnimationActive?: boolean;
+    offset?: number;
+    payloadUniqBy?: recharts_types_util_payload_getUniqPayload.UniqueOption<recharts_types_component_DefaultTooltipContent.Payload<recharts_types_component_DefaultTooltipContent.ValueType, recharts_types_component_DefaultTooltipContent.NameType>> | undefined;
+    position?: Partial<recharts_types_util_types.Coordinate>;
+    reverseDirection?: recharts_types_util_types.AllowInDimension;
+    shared?: boolean;
+    trigger?: "hover" | "click";
+    useTranslate3d?: boolean;
+    viewBox?: recharts_types_util_types.CartesianViewBox;
+    wrapperStyle?: React$1.CSSProperties;
+} & React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    indicator?: "line" | "dot" | "dashed";
+    nameKey?: string;
+    labelKey?: string;
+}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ChartLegend: typeof RechartsPrimitive.Legend;
+declare const ChartLegendContent: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & Pick<RechartsPrimitive.LegendProps, "verticalAlign" | "payload"> & {
+    hideIcon?: boolean;
+    nameKey?: string;
+}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Checkbox: React$1.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const Collapsible: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Command: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React$1.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandDialog: ({ children, ...props }: DialogProps) => React$1.JSX.Element;
+declare const CommandInput: React$1.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React$1.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React$1.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React$1.InputHTMLAttributes<HTMLInputElement>>, "onChange" | "type" | "value"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React$1.RefAttributes<HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React$1.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React$1.HTMLAttributes<HTMLDivElement> | "asChild"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React$1.HTMLAttributes<HTMLDivElement> | "asChild">, "heading" | "value"> & {
+    heading?: React$1.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React$1.ForwardRefExoticComponent<Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React$1.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    alwaysRender?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React$1.HTMLAttributes<HTMLDivElement> | "asChild">, "onSelect" | "disabled" | "value"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): React$1.JSX.Element;
+    displayName: string;
+};
+
+declare const ContextMenu: React$1.FC<ContextMenuPrimitive.ContextMenuProps>;
+declare const ContextMenuTrigger: React$1.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React$1.RefAttributes<HTMLSpanElement>>;
+declare const ContextMenuGroup: React$1.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuPortal: React$1.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
+declare const ContextMenuSub: React$1.FC<ContextMenuPrimitive.ContextMenuSubProps>;
+declare const ContextMenuRadioGroup: React$1.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubContent: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuContent: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuItem: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuLabel: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSeparator: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuShortcut: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): React$1.JSX.Element;
+    displayName: string;
+};
+
+declare const Dialog: React$1.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const Drawer: {
+    ({ shouldScaleBackground, ...props }: React$1.ComponentProps<typeof Drawer$1.Root>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const DrawerTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DrawerPortal: typeof vaul.Portal;
+declare const DrawerClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DrawerOverlay: React$1.ForwardRefExoticComponent<Omit<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DrawerContent: React$1.ForwardRefExoticComponent<Omit<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DrawerHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const DrawerFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const DrawerTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DrawerDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const DropdownMenu: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React$1.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): React$1.JSX.Element;
+    displayName: string;
+};
+
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>(props: react_hook_form.FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React$1.JSX.Element;
+declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => React$1.JSX.Element;
+declare const useFormField: () => {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: react_hook_form.FieldError;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+declare const FormItem: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const FormLabel: React$1.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React$1.RefAttributes<HTMLLabelElement>, "ref"> & React$1.RefAttributes<HTMLLabelElement>>;
+declare const FormControl: React$1.ForwardRefExoticComponent<Omit<_radix_ui_react_slot.SlotProps & React$1.RefAttributes<HTMLElement>, "ref"> & React$1.RefAttributes<HTMLElement>>;
+declare const FormDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const FormMessage: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+interface ContributionDay {
+    date: string;
+    count: number;
+    level: 0 | 1 | 2 | 3 | 4;
+}
+interface GitmapColors {
+    empty: string;
+    level1: string;
+    level2: string;
+    level3: string;
+    level4: string;
+}
+interface GitmapProps {
+    contributions: ContributionDay[];
+    from: Date;
+    to: Date;
+    colors: GitmapColors;
+    cellSize?: number;
+    cellGap?: number;
+    showMonths?: boolean;
+    showDays?: boolean;
+    showCounts?: boolean;
+    className?: string;
+}
+declare function Gitmap({ contributions, from, to, colors, cellSize, cellGap, showMonths, showDays, showCounts, className, }: GitmapProps): React$1.JSX.Element;
+
+declare const HoverCard: React$1.FC<HoverCardPrimitive.HoverCardProps>;
+declare const HoverCardTrigger: React$1.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & React$1.RefAttributes<HTMLAnchorElement>>;
+declare const HoverCardContent: React$1.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const InputOTP: React$1.ForwardRefExoticComponent<(Omit<Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "textAlign" | "maxLength" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
+    value?: string;
+    onChange?: (newValue: string) => unknown;
+    maxLength: number;
+    textAlign?: "left" | "center" | "right";
+    onComplete?: (...args: any[]) => unknown;
+    pushPasswordManagerStrategy?: "increase-width" | "none";
+    pasteTransformer?: (pasted: string) => string;
+    containerClassName?: string;
+    noScriptCSSFallback?: string | null;
+} & {
+    render: (props: input_otp.RenderProps) => React$1.ReactNode;
+    children?: never;
+} & React$1.RefAttributes<HTMLInputElement>, "ref"> | Omit<Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "textAlign" | "maxLength" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
+    value?: string;
+    onChange?: (newValue: string) => unknown;
+    maxLength: number;
+    textAlign?: "left" | "center" | "right";
+    onComplete?: (...args: any[]) => unknown;
+    pushPasswordManagerStrategy?: "increase-width" | "none";
+    pasteTransformer?: (pasted: string) => string;
+    containerClassName?: string;
+    noScriptCSSFallback?: string | null;
+} & {
+    render?: never;
+    children: React$1.ReactNode;
+} & React$1.RefAttributes<HTMLInputElement>, "ref">) & React$1.RefAttributes<HTMLInputElement>>;
+declare const InputOTPGroup: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSlot: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    index: number;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSeparator: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Input: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+
+declare const Label: React$1.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React$1.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: class_variance_authority_types.ClassProp | undefined) => string> & React$1.RefAttributes<HTMLLabelElement>>;
+
+declare function MenubarMenu({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Menu>): React$1.JSX.Element;
+declare function MenubarGroup({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Group>): React$1.JSX.Element;
+declare function MenubarPortal({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Portal>): React$1.JSX.Element;
+declare function MenubarRadioGroup({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.RadioGroup>): React$1.JSX.Element;
+declare function MenubarSub({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Sub>): React$1.JSX.Element;
+declare const Menubar: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const MenubarTrigger: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const MenubarSubTrigger: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const MenubarSubContent: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const MenubarContent: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const MenubarItem: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const MenubarCheckboxItem: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const MenubarRadioItem: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const MenubarLabel: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const MenubarSeparator: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const MenubarShortcut: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): React$1.JSX.Element;
+    displayname: string;
+};
+
+declare const NavigationMenu: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuProps & React$1.RefAttributes<HTMLElement>, "ref"> & React$1.RefAttributes<HTMLElement>>;
+declare const NavigationMenuList: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuListProps & React$1.RefAttributes<HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
+declare const NavigationMenuItem: React$1.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuItemProps & React$1.RefAttributes<HTMLLIElement>>;
+declare const navigationMenuTriggerStyle: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const NavigationMenuTrigger: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const NavigationMenuContent: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuLink: React$1.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuLinkProps & React$1.RefAttributes<HTMLAnchorElement>>;
+declare const NavigationMenuViewport: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuViewportProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuIndicator: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuIndicatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Pagination: {
+    ({ className, ...props }: React$1.ComponentProps<"nav">): React$1.JSX.Element;
+    displayName: string;
+};
+declare const PaginationContent: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
+declare const PaginationItem: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<ButtonProps, 'size'> & React$1.ComponentProps<'a'>;
+declare const PaginationLink: {
+    ({ className, isActive, size, ...props }: PaginationLinkProps): React$1.JSX.Element;
+    displayName: string;
+};
+declare const PaginationPrevious: {
+    ({ className, ...props }: React$1.ComponentProps<typeof PaginationLink>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const PaginationNext: {
+    ({ className, ...props }: React$1.ComponentProps<typeof PaginationLink>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const PaginationEllipsis: {
+    ({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+    displayName: string;
+};
+
+declare const Popover: React$1.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Progress: React$1.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const RadioGroup: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const RadioGroupItem: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const ResizablePanelGroup: ({ className, ...props }: React.ComponentProps<typeof ResizablePrimitive.PanelGroup>) => React$1.JSX.Element;
+declare const ResizablePanel: React$1.ForwardRefExoticComponent<Omit<React$1.HTMLAttributes<HTMLDivElement | HTMLElement | HTMLObjectElement | HTMLSlotElement | HTMLStyleElement | HTMLTitleElement | HTMLLinkElement | HTMLMapElement | HTMLButtonElement | HTMLDialogElement | HTMLFormElement | HTMLImageElement | HTMLOptionElement | HTMLTableElement | HTMLAnchorElement | HTMLAreaElement | HTMLAudioElement | HTMLBaseElement | HTMLQuoteElement | HTMLBodyElement | HTMLBRElement | HTMLCanvasElement | HTMLTableColElement | HTMLDataElement | HTMLDataListElement | HTMLModElement | HTMLDetailsElement | HTMLDListElement | HTMLEmbedElement | HTMLFieldSetElement | HTMLHeadingElement | HTMLHeadElement | HTMLHRElement | HTMLHtmlElement | HTMLIFrameElement | HTMLInputElement | HTMLLabelElement | HTMLLegendElement | HTMLLIElement | HTMLMetaElement | HTMLMeterElement | HTMLOListElement | HTMLOptGroupElement | HTMLOutputElement | HTMLParagraphElement | HTMLPreElement | HTMLProgressElement | HTMLScriptElement | HTMLSelectElement | HTMLSourceElement | HTMLSpanElement | HTMLTemplateElement | HTMLTableSectionElement | HTMLTableCellElement | HTMLTextAreaElement | HTMLTimeElement | HTMLTableRowElement | HTMLTrackElement | HTMLUListElement | HTMLVideoElement | HTMLTableCaptionElement | HTMLMenuElement | HTMLPictureElement>, "id" | "onResize"> & {
+    className?: string;
+    collapsedSize?: number | undefined;
+    collapsible?: boolean | undefined;
+    defaultSize?: number | undefined;
+    id?: string;
+    maxSize?: number | undefined;
+    minSize?: number | undefined;
+    onCollapse?: ResizablePrimitive.PanelOnCollapse;
+    onExpand?: ResizablePrimitive.PanelOnExpand;
+    onResize?: ResizablePrimitive.PanelOnResize;
+    order?: number;
+    style?: object;
+    tagName?: keyof HTMLElementTagNameMap | undefined;
+} & {
+    children?: React$1.ReactNode | undefined;
+} & React$1.RefAttributes<ResizablePrimitive.ImperativePanelHandle>>;
+declare const ResizableHandle: ({ withHandle, className, ...props }: React.ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
+    withHandle?: boolean;
+}) => React$1.JSX.Element;
+
+declare const ScrollArea: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Select: React$1.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React$1.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Separator: React$1.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Sheet: React$1.FC<DialogPrimitive.DialogProps>;
+declare const SheetTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const SheetOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: ({
+    side?: "left" | "right" | "top" | "bottom" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SheetContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+declare const SheetContent: React$1.ForwardRefExoticComponent<SheetContentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+
+declare const Slider: React$1.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+
+type ToasterProps = React.ComponentProps<typeof Toaster$1>;
+declare const Toaster: ({ ...props }: ToasterProps) => React$1.JSX.Element;
+
+declare function Spinner({ className, ...props }: React.ComponentProps<"svg">): React$1.JSX.Element;
+
+declare const Switch: React$1.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const Table: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & React$1.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
+
+declare const Tabs: React$1.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Textarea: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React$1.RefAttributes<HTMLTextAreaElement>>;
+
+declare const ToggleGroup: React$1.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React$1.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React$1.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string>) & React$1.RefAttributes<HTMLDivElement>>;
+declare const ToggleGroupItem: React$1.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Toggle: React$1.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const TooltipProvider: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React$1.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Alert, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AlertTitle, AspectRatio, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, type ButtonProps, Calendar, CalendarDayButton, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Carousel, type CarouselApi, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, type ChartConfig, ChartContainer, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent, Checkbox, Collapsible, CollapsibleContent, CollapsibleTrigger, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, type ContributionDay, Dashfy, type DashfyProps, DebugInfo, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, type ErrorBoundaryProps, ExternalLink, Form, FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage, Gitmap, type GitmapColors, HoverCard, HoverCardContent, HoverCardTrigger, Input, InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot, Label, Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, MenubarPortal, MenubarRadioGroup, MenubarRadioItem, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger, NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, NavigationMenuViewport, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, Progress, RadioGroup, RadioGroupItem, ResizableHandle, ResizablePanel, ResizablePanelGroup, ScrollArea, ScrollBar, Scrollable, type ScrollableProps, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Skeleton, Slider, Spinner, Switch, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, Text, type TextProps, Textarea, ThemeRegistry, Toaster, Toggle, ToggleGroup, ToggleGroupItem, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type UseApiSubscriptionOptions, type UseWebSocketOptions, Widget, WidgetAvatar, type WidgetAvatarProps, WidgetBody, type WidgetBodyProps, WidgetCounter, type WidgetCounterProps, WidgetEmpty, type WidgetEmptyProps, WidgetError, WidgetErrorBoundary, type WidgetErrorProps, WidgetErrorUnknown, WidgetHeader, type WidgetHeaderProps, WidgetLabel, type WidgetLabelProps, WidgetListItem, type WidgetListItemProps, WidgetLoader, type WidgetLoaderProps, WidgetRegistry, type WidgetRegistryEntry, WidgetSkeleton, type WidgetSkeletonProps, WidgetStatusBadge, type WidgetStatusBadgeProps, WidgetStatusChip, type WidgetStatusChipProps, WidgetTable, WidgetTableCell, type WidgetTableCellProps, WidgetTableHeadCell, type WidgetTableHeadCellProps, type WidgetTableProps, WidgetWrapper, type WidgetWrapperProps, badgeVariants, buttonVariants, cn, generateReactKey, navigationMenuTriggerStyle, toggleVariants, useApiSubscription, useDashfyStore, useFormField, useMode, useWebSocket, useWidget };