@vashu96/ui 0.0.1

package/dist/Alert.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode, HTMLAttributes } from 'react';
+type AlertVariant = "info" | "success" | "warning" | "danger";
+interface AlertProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: AlertVariant;
+    title?: string;
+    icon?: ReactNode;
+    dismissible?: boolean;
+    onDismiss?: () => void;
+    children?: ReactNode;
+}
+declare const Alert: import('react').ForwardRefExoticComponent<AlertProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Alert, type AlertProps, type AlertVariant };

package/dist/Avatar.d.ts

@@ -0,0 +1,10 @@
+import { HTMLAttributes } from 'react';
+type AvatarSize = "xs" | "sm" | "md" | "lg" | "xl";
+interface AvatarProps extends HTMLAttributes<HTMLDivElement> {
+    src?: string;
+    alt?: string;
+    fallback?: string;
+    size?: AvatarSize;
+}
+declare const Avatar: import('react').ForwardRefExoticComponent<AvatarProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Avatar, type AvatarProps, type AvatarSize };

package/dist/Badge.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes } from 'react';
+type BadgeVariant = "default" | "success" | "warning" | "danger" | "info";
+interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    variant?: BadgeVariant;
+}
+declare const Badge: import('react').ForwardRefExoticComponent<BadgeProps & import('react').RefAttributes<HTMLSpanElement>>;
+export { Badge, type BadgeProps, type BadgeVariant };

package/dist/Breadcrumb.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode, HTMLAttributes } from 'react';
+declare const Breadcrumb: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLElement> & import('react').RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLOListElement> & import('react').RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLLIElement> & import('react').RefAttributes<HTMLLIElement>>;
+interface BreadcrumbLinkProps extends HTMLAttributes<HTMLAnchorElement> {
+    href?: string;
+    active?: boolean;
+}
+declare const BreadcrumbLink: import('react').ForwardRefExoticComponent<BreadcrumbLinkProps & import('react').RefAttributes<HTMLAnchorElement>>;
+declare function BreadcrumbSeparator({ children, className, }: {
+    children?: ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbSeparator, type BreadcrumbLinkProps, };

package/dist/Button.d.ts

@@ -0,0 +1,10 @@
+import { ButtonHTMLAttributes } from 'react';
+type ButtonVariant = "primary" | "secondary" | "ghost" | "danger";
+type ButtonSize = "sm" | "md" | "lg";
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    loading?: boolean;
+}
+declare const Button: import('react').ForwardRefExoticComponent<ButtonProps & import('react').RefAttributes<HTMLButtonElement>>;
+export { Button, type ButtonProps, type ButtonVariant, type ButtonSize };

package/dist/Card.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes } from 'react';
+type CardVariant = "glass" | "solid" | "outline";
+interface CardProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: CardVariant;
+    padding?: "none" | "sm" | "md" | "lg";
+}
+declare const Card: import('react').ForwardRefExoticComponent<CardProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Card, type CardProps, type CardVariant };

package/dist/Checkbox.d.ts

@@ -0,0 +1,7 @@
+import { InputHTMLAttributes } from 'react';
+interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type"> {
+    label?: string;
+    indeterminate?: boolean;
+}
+declare const Checkbox: import('react').ForwardRefExoticComponent<CheckboxProps & import('react').RefAttributes<HTMLInputElement>>;
+export { Checkbox, type CheckboxProps };

package/dist/Command.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+interface CommandItem {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    shortcut?: string;
+    onSelect: () => void;
+    group?: string;
+    disabled?: boolean;
+}
+interface CommandProps {
+    open: boolean;
+    onClose: () => void;
+    items: CommandItem[];
+    placeholder?: string;
+    emptyMessage?: string;
+    loading?: boolean;
+    onQueryChange?: (query: string) => void;
+}
+declare function Command({ open, onClose, items, placeholder, emptyMessage, loading, onQueryChange, }: CommandProps): import('react').ReactPortal | null;
+export { Command, type CommandProps, type CommandItem };

package/dist/ConfirmDialog.d.ts

@@ -0,0 +1,13 @@
+interface ConfirmDialogProps {
+    open: boolean;
+    onClose: () => void;
+    onConfirm: () => void | Promise<void>;
+    title: string;
+    description: string;
+    confirmText?: string;
+    cancelText?: string;
+    variant?: "danger" | "default";
+    loading?: boolean;
+}
+export declare function ConfirmDialog({ open, onClose, onConfirm, title, description, confirmText, cancelText, variant, loading, }: ConfirmDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/DataTable.d.ts

@@ -0,0 +1,12 @@
+import { ColumnDef, Column } from '@tanstack/react-table';
+interface DataTableProps<TData, TValue> {
+    columns: ColumnDef<TData, TValue>[];
+    data: TData[];
+    searchPlaceholder?: string;
+}
+export declare function DataTable<TData, TValue>({ columns, data, searchPlaceholder, }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTableColumnHeader<TData, TValue>({ column, title, }: {
+    column: Column<TData, TValue>;
+    title: string;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Dialog.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode, HTMLAttributes } from 'react';
+type DialogSize = "sm" | "md" | "lg";
+interface DialogProps {
+    open: boolean;
+    onClose: () => void;
+    size?: DialogSize;
+    children: ReactNode;
+}
+declare function Dialog({ open, onClose, size, children }: DialogProps): import("react/jsx-runtime").JSX.Element;
+declare const DialogHeader: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import('react').RefAttributes<HTMLDivElement>>;
+declare const DialogFooter: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import('react').RefAttributes<HTMLDivElement>>;
+declare const DialogTitle: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLHeadingElement> & import('react').RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLParagraphElement> & import('react').RefAttributes<HTMLParagraphElement>>;
+declare function DialogClose({ children, className, ...props }: HTMLAttributes<HTMLButtonElement>): import("react/jsx-runtime").JSX.Element;
+export { Dialog, DialogHeader, DialogFooter, DialogTitle, DialogDescription, DialogClose, type DialogProps, type DialogSize, };

package/dist/Dropdown.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode, HTMLAttributes } from 'react';
+interface DropdownProps {
+    children: ReactNode;
+}
+declare function Dropdown({ children }: DropdownProps): import("react/jsx-runtime").JSX.Element;
+declare const DropdownTrigger: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLButtonElement> & import('react').RefAttributes<HTMLButtonElement>>;
+interface DropdownMenuProps extends HTMLAttributes<HTMLDivElement> {
+    align?: "left" | "right";
+}
+declare function DropdownMenu({ align, className, children, ...props }: DropdownMenuProps): import('react').ReactPortal | null;
+interface DropdownItemProps extends HTMLAttributes<HTMLDivElement> {
+    disabled?: boolean;
+    destructive?: boolean;
+}
+declare const DropdownItem: import('react').ForwardRefExoticComponent<DropdownItemProps & import('react').RefAttributes<HTMLDivElement>>;
+declare function DropdownSeparator({ className }: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export { Dropdown, DropdownTrigger, DropdownMenu, DropdownItem, DropdownSeparator, type DropdownProps, type DropdownMenuProps, type DropdownItemProps, };

package/dist/EmptyState.d.ts

@@ -0,0 +1,9 @@
+import { HTMLAttributes, ReactNode } from 'react';
+interface EmptyStateProps extends HTMLAttributes<HTMLDivElement> {
+    icon?: ReactNode;
+    title: string;
+    description?: string;
+    action?: ReactNode;
+}
+declare const EmptyState: import('react').ForwardRefExoticComponent<EmptyStateProps & import('react').RefAttributes<HTMLDivElement>>;
+export { EmptyState, type EmptyStateProps };

package/dist/FormField.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+interface FormFieldProps {
+    label?: string;
+    error?: string | boolean;
+    description?: string;
+    children: ReactNode;
+    className?: string;
+    htmlFor?: string;
+}
+export declare function FormField({ label, error, description, children, className, htmlFor, }: FormFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Input.d.ts

@@ -0,0 +1,6 @@
+import { InputHTMLAttributes } from 'react';
+interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
+    error?: string;
+}
+declare const Input: import('react').ForwardRefExoticComponent<InputProps & import('react').RefAttributes<HTMLInputElement>>;
+export { Input, type InputProps };

package/dist/Label.d.ts

@@ -0,0 +1,7 @@
+import { LabelHTMLAttributes } from 'react';
+interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
+    required?: boolean;
+    error?: boolean;
+}
+declare const Label: import('react').ForwardRefExoticComponent<LabelProps & import('react').RefAttributes<HTMLLabelElement>>;
+export { Label, type LabelProps };

package/dist/Pagination.d.ts

@@ -0,0 +1,9 @@
+import { HTMLAttributes } from 'react';
+interface PaginationProps extends HTMLAttributes<HTMLElement> {
+    page: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+    siblingCount?: number;
+}
+declare function Pagination({ page, totalPages, onPageChange, siblingCount, className, ...props }: PaginationProps): import("react/jsx-runtime").JSX.Element;
+export { Pagination, type PaginationProps };

package/dist/Progress.d.ts

@@ -0,0 +1,11 @@
+import { HTMLAttributes } from 'react';
+type ProgressVariant = "default" | "success" | "warning" | "danger";
+interface ProgressProps extends HTMLAttributes<HTMLDivElement> {
+    value: number;
+    max?: number;
+    variant?: ProgressVariant;
+    label?: string;
+    showValue?: boolean;
+}
+declare const Progress: import('react').ForwardRefExoticComponent<ProgressProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Progress, type ProgressProps, type ProgressVariant };

package/dist/SearchCommand.d.ts

@@ -0,0 +1,6 @@
+interface SearchCommandProps {
+    open: boolean;
+    onClose: () => void;
+}
+export declare function SearchCommand({ open, onClose }: SearchCommandProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Select.d.ts

@@ -0,0 +1,15 @@
+interface SelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface SelectProps {
+    options: SelectOption[];
+    value?: string;
+    onChange?: (value: string) => void;
+    placeholder?: string;
+    error?: boolean;
+    className?: string;
+}
+declare function Select({ options, value, onChange, placeholder, error, className, }: SelectProps): import("react/jsx-runtime").JSX.Element;
+export { Select, type SelectProps, type SelectOption };

package/dist/Separator.d.ts

@@ -0,0 +1,6 @@
+import { HTMLAttributes } from 'react';
+interface SeparatorProps extends HTMLAttributes<HTMLDivElement> {
+    orientation?: "horizontal" | "vertical";
+}
+declare const Separator: import('react').ForwardRefExoticComponent<SeparatorProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Separator, type SeparatorProps };

package/dist/Sheet.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode, HTMLAttributes } from 'react';
+type SheetSide = "left" | "right" | "top" | "bottom";
+interface SheetProps {
+    open: boolean;
+    onClose: () => void;
+    side?: SheetSide;
+    children: ReactNode;
+    className?: string;
+}
+declare function Sheet({ open, onClose, side, children, className, }: SheetProps): import('react').ReactPortal | null;
+declare const SheetHeader: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import('react').RefAttributes<HTMLDivElement>>;
+declare const SheetTitle: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLHeadingElement> & import('react').RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLParagraphElement> & import('react').RefAttributes<HTMLParagraphElement>>;
+declare function SheetClose({ onClose }: {
+    onClose: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+declare const SheetFooter: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import('react').RefAttributes<HTMLDivElement>>;
+export { Sheet, SheetHeader, SheetTitle, SheetDescription, SheetClose, SheetFooter, type SheetProps, type SheetSide, };

package/dist/Sidebar.d.ts

@@ -0,0 +1,43 @@
+import { ReactNode, HTMLAttributes } from 'react';
+interface IndicatorState {
+    top: number;
+    left: number;
+    height: number;
+    width: number;
+    opacity: number;
+}
+interface SidebarContextValue {
+    collapsed: boolean;
+    toggle: () => void;
+    indicator: IndicatorState;
+    setIndicator: (state: IndicatorState) => void;
+    contentRef: React.RefObject<HTMLDivElement | null>;
+    contentReady: boolean;
+    setContentReady: (ready: boolean) => void;
+}
+declare function useSidebar(): SidebarContextValue;
+interface SidebarProps extends HTMLAttributes<HTMLElement> {
+    defaultCollapsed?: boolean;
+    collapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    children: ReactNode;
+}
+declare function Sidebar({ defaultCollapsed, collapsed: controlledCollapsed, onCollapsedChange, className, children, ...props }: SidebarProps): import("react/jsx-runtime").JSX.Element;
+declare const SidebarHeader: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import('react').RefAttributes<HTMLDivElement>>;
+declare const SidebarContent: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import('react').RefAttributes<HTMLDivElement>>;
+interface SidebarGroupProps extends HTMLAttributes<HTMLDivElement> {
+    label?: string;
+}
+declare const SidebarGroup: import('react').ForwardRefExoticComponent<SidebarGroupProps & import('react').RefAttributes<HTMLDivElement>>;
+interface SidebarItemProps extends HTMLAttributes<HTMLButtonElement> {
+    icon?: ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+    tooltip?: string;
+}
+declare const SidebarItem: import('react').ForwardRefExoticComponent<SidebarItemProps & import('react').RefAttributes<HTMLButtonElement>>;
+declare const SidebarFooter: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import('react').RefAttributes<HTMLDivElement>>;
+declare function SidebarToggle({ className }: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export { Sidebar, SidebarHeader, SidebarContent, SidebarGroup, SidebarItem, SidebarFooter, SidebarToggle, useSidebar, type SidebarProps, type SidebarGroupProps, type SidebarItemProps, };

package/dist/Skeleton.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes } from 'react';
+interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: "text" | "circular" | "rectangular";
+    width?: string | number;
+    height?: string | number;
+}
+declare const Skeleton: import('react').ForwardRefExoticComponent<SkeletonProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Skeleton, type SkeletonProps };

package/dist/Slider.d.ts

@@ -0,0 +1,7 @@
+import { InputHTMLAttributes } from 'react';
+interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type"> {
+    label?: string;
+    showValue?: boolean;
+}
+declare const Slider: import('react').ForwardRefExoticComponent<SliderProps & import('react').RefAttributes<HTMLInputElement>>;
+export { Slider, type SliderProps };

package/dist/Spinner.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes } from 'react';
+type SpinnerSize = "sm" | "md" | "lg";
+interface SpinnerProps extends HTMLAttributes<HTMLDivElement> {
+    size?: SpinnerSize;
+    label?: string;
+}
+declare const Spinner: import('react').ForwardRefExoticComponent<SpinnerProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Spinner, type SpinnerProps, type SpinnerSize };

package/dist/SpotlightCard.d.ts

@@ -0,0 +1,6 @@
+import { HTMLAttributes } from 'react';
+interface SpotlightCardProps extends HTMLAttributes<HTMLDivElement> {
+    padding?: "none" | "sm" | "md" | "lg";
+}
+declare const SpotlightCard: import('react').ForwardRefExoticComponent<SpotlightCardProps & import('react').RefAttributes<HTMLDivElement>>;
+export { SpotlightCard, type SpotlightCardProps };

package/dist/Switch.d.ts

@@ -0,0 +1,10 @@
+import { ButtonHTMLAttributes } from 'react';
+type SwitchSize = "sm" | "md";
+interface SwitchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onChange"> {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    label?: string;
+    size?: SwitchSize;
+}
+declare const Switch: import('react').ForwardRefExoticComponent<SwitchProps & import('react').RefAttributes<HTMLButtonElement>>;
+export { Switch, type SwitchProps, type SwitchSize };

package/dist/Table.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes, TdHTMLAttributes, ThHTMLAttributes } from 'react';
+declare const Table: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLTableElement> & import('react').RefAttributes<HTMLTableElement>>;
+declare const TableHeader: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLTableSectionElement> & import('react').RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLTableSectionElement> & import('react').RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLTableRowElement> & import('react').RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: import('react').ForwardRefExoticComponent<ThHTMLAttributes<HTMLTableCellElement> & import('react').RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: import('react').ForwardRefExoticComponent<TdHTMLAttributes<HTMLTableCellElement> & import('react').RefAttributes<HTMLTableCellElement>>;
+export { Table, TableHeader, TableBody, TableRow, TableHead, TableCell };

package/dist/Tabs.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+interface TabsProps {
+    defaultValue: string;
+    value?: string;
+    onChange?: (value: string) => void;
+    children: ReactNode;
+    className?: string;
+}
+declare function Tabs({ defaultValue, value, onChange, children, className, }: TabsProps): import("react/jsx-runtime").JSX.Element;
+declare function TabsList({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+interface TabsTriggerProps {
+    value: string;
+    children: ReactNode;
+    className?: string;
+    disabled?: boolean;
+}
+declare function TabsTrigger({ value, children, className, disabled, }: TabsTriggerProps): import("react/jsx-runtime").JSX.Element;
+interface TabsContentProps {
+    value: string;
+    children: ReactNode;
+    className?: string;
+}
+declare function TabsContent({ value, children, className }: TabsContentProps): import("react/jsx-runtime").JSX.Element | null;
+export { Tabs, TabsList, TabsTrigger, TabsContent, type TabsProps, type TabsTriggerProps, type TabsContentProps, };

package/dist/Tag.d.ts

@@ -0,0 +1,10 @@
+import { HTMLAttributes, ReactNode } from 'react';
+type TagVariant = "default" | "primary" | "success" | "warning" | "danger" | "info";
+interface TagProps extends HTMLAttributes<HTMLSpanElement> {
+    variant?: TagVariant;
+    removable?: boolean;
+    onRemove?: () => void;
+    icon?: ReactNode;
+}
+declare const Tag: import('react').ForwardRefExoticComponent<TagProps & import('react').RefAttributes<HTMLSpanElement>>;
+export { Tag, type TagProps, type TagVariant };

package/dist/Textarea.d.ts

@@ -0,0 +1,8 @@
+import { TextareaHTMLAttributes } from 'react';
+type TextareaResize = "none" | "vertical" | "both";
+interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    error?: boolean;
+    resize?: TextareaResize;
+}
+declare const Textarea: import('react').ForwardRefExoticComponent<TextareaProps & import('react').RefAttributes<HTMLTextAreaElement>>;
+export { Textarea, type TextareaProps, type TextareaResize };

package/dist/Toast.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+type ToastVariant = "info" | "success" | "warning" | "danger";
+interface ToastData {
+    id: string;
+    variant: ToastVariant;
+    title: string;
+    description?: string;
+    duration?: number;
+}
+interface ToastContextValue {
+    toast: (data: Omit<ToastData, "id">) => void;
+}
+export declare function useToast(): ToastContextValue;
+interface ToastProviderProps {
+    children: ReactNode;
+    maxToasts?: number;
+}
+declare function ToastProvider({ children, maxToasts }: ToastProviderProps): import("react/jsx-runtime").JSX.Element;
+export { ToastProvider, type ToastData, type ToastVariant, type ToastProviderProps, };

package/dist/Tooltip.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+type TooltipSide = "top" | "bottom" | "left" | "right";
+interface TooltipProps {
+    content: ReactNode;
+    side?: TooltipSide;
+    delay?: number;
+    children: ReactNode;
+    className?: string;
+}
+declare function Tooltip({ content, side, delay, children, className, }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, type TooltipProps, type TooltipSide };

package/dist/hooks/useDebounce.d.ts

@@ -0,0 +1 @@
+export declare function useDebounce<T>(value: T, delay?: number): T;

package/dist/hooks/useSpotlight.d.ts

@@ -0,0 +1,15 @@
+import { RefObject } from 'react';
+/**
+ * useSpotlight — Tracks mouse position relative to an element
+ * and sets CSS custom properties (--mouse-x, --mouse-y) for
+ * radial gradient border effects (the "moving sheen").
+ *
+ * Usage:
+ *   const { ref, onMouseMove, onMouseLeave } = useSpotlight<HTMLDivElement>();
+ *   <div ref={ref} onMouseMove={onMouseMove} onMouseLeave={onMouseLeave} />
+ */
+export declare function useSpotlight<T extends HTMLElement = HTMLDivElement>(): {
+    ref: RefObject<T | null>;
+    onMouseMove: (e: React.MouseEvent<T>) => void;
+    onMouseLeave: () => void;
+};