@byldpartners/ui 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1543 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+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 * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { Drawer as Drawer$1 } from 'vaul';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
+import * as LabelPrimitive from '@radix-ui/react-label';
+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 { Separator as Separator$1, Panel } 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 * as SwitchPrimitive from '@radix-ui/react-switch';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as TogglePrimitive from '@radix-ui/react-toggle';
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+export { ThemeColors, ThemePreset, ThemeProvider, ThemeRadius, ThemeSpacing, ThemeTokens, auroraPreset, darkPreset, defaultPreset, useTheme } from './theme/web.js';
+
+declare const Accordion: react.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & react.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: react.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: react.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: react.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+type AccordionType = "single" | "multiple";
+interface AccordionProps {
+    type?: AccordionType;
+    collapsible?: boolean;
+    defaultValue?: string | string[];
+    value?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface AccordionItemProps {
+    value: string;
+    children?: React.ReactNode;
+    className?: string;
+    disabled?: boolean;
+}
+interface AccordionTriggerProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface AccordionContentProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+
+declare const Alert: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & react.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLHeadingElement> & react.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLParagraphElement> & react.RefAttributes<HTMLParagraphElement>>;
+
+type AlertVariant = "default" | "destructive";
+interface AlertProps {
+    variant?: AlertVariant;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface AlertTitleProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface AlertDescriptionProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+
+declare const AlertDialog: react.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: react.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: react.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitle: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & react.RefAttributes<HTMLHeadingElement>, "ref"> & react.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & react.RefAttributes<HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+interface AlertDialogProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface AlertDialogTriggerProps {
+    children?: React.ReactNode;
+    className?: string;
+    asChild?: boolean;
+}
+interface AlertDialogContentProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface AlertDialogHeaderProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface AlertDialogFooterProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface AlertDialogTitleProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface AlertDialogDescriptionProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface AlertDialogActionProps {
+    children?: React.ReactNode;
+    className?: string;
+    onPress?: () => void;
+}
+interface AlertDialogCancelProps {
+    children?: React.ReactNode;
+    className?: string;
+    onPress?: () => void;
+}
+
+declare const AspectRatio: react.ForwardRefExoticComponent<AspectRatioPrimitive.AspectRatioProps & react.RefAttributes<HTMLDivElement>>;
+
+interface AspectRatioProps {
+    ratio?: number;
+    children?: React.ReactNode;
+    className?: string;
+}
+
+declare const Avatar: react.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & react.RefAttributes<HTMLSpanElement>, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: react.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & react.RefAttributes<HTMLImageElement>, "ref"> & react.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: react.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & react.RefAttributes<HTMLSpanElement>, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+
+interface AvatarProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface AvatarImageProps {
+    src?: string;
+    alt?: string;
+    className?: string;
+    onLoadingStatusChange?: (status: "idle" | "loading" | "loaded" | "error") => void;
+}
+interface AvatarFallbackProps {
+    children?: React.ReactNode;
+    className?: string;
+    delayMs?: number;
+}
+
+type BadgeVariant = "default" | "secondary" | "destructive" | "outline";
+interface BadgeProps {
+    variant?: BadgeVariant;
+    children?: React.ReactNode;
+    className?: string;
+}
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeWebProps extends BadgeProps, React.HTMLAttributes<HTMLDivElement> {
+}
+declare const Badge: react.ForwardRefExoticComponent<BadgeWebProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const Breadcrumb: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React.ReactNode;
+} & react.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & react.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & react.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & react.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface BreadcrumbProps {
+    separator?: React.ReactNode;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface BreadcrumbListProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface BreadcrumbItemProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface BreadcrumbLinkProps {
+    href?: string;
+    asChild?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+    onPress?: () => void;
+}
+interface BreadcrumbPageProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface BreadcrumbSeparatorProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface BreadcrumbEllipsisProps {
+    className?: string;
+}
+
+type ButtonVariant = "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
+type ButtonSize = "default" | "sm" | "lg" | "icon";
+interface ButtonProps {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    disabled?: boolean;
+    children?: React.ReactNode;
+    onPress?: () => void;
+    className?: string;
+    asChild?: boolean;
+}
+
+interface ButtonWebProps extends ButtonProps, React.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+declare const Button: react.ForwardRefExoticComponent<ButtonWebProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface CalendarProps {
+    selected?: Date;
+    onSelect?: (date: Date | undefined) => void;
+    month?: Date;
+    onMonthChange?: (month: Date) => void;
+    disabled?: boolean;
+    className?: string;
+}
+
+declare const Calendar: react.ForwardRefExoticComponent<CalendarProps & Omit<react.HTMLAttributes<HTMLDivElement>, "onSelect"> & react.RefAttributes<HTMLDivElement>>;
+
+interface CardProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+
+declare const Card: react.ForwardRefExoticComponent<CardProps & react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+
+type CarouselOrientation = "horizontal" | "vertical";
+interface CarouselProps {
+    orientation?: CarouselOrientation;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface CarouselContentProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface CarouselItemProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface CarouselPreviousProps {
+    children?: React.ReactNode;
+    className?: string;
+    onPress?: () => void;
+}
+interface CarouselNextProps {
+    children?: React.ReactNode;
+    className?: string;
+    onPress?: () => void;
+}
+
+declare const Carousel: react.ForwardRefExoticComponent<CarouselProps & react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const CarouselContent: react.ForwardRefExoticComponent<CarouselContentProps & react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const CarouselItem: react.ForwardRefExoticComponent<CarouselItemProps & react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const CarouselPrevious: react.ForwardRefExoticComponent<react.ButtonHTMLAttributes<HTMLButtonElement> & react.RefAttributes<HTMLButtonElement>>;
+declare const CarouselNext: react.ForwardRefExoticComponent<react.ButtonHTMLAttributes<HTMLButtonElement> & react.RefAttributes<HTMLButtonElement>>;
+
+interface ChartConfig {
+    [key: string]: {
+        label?: string;
+        color?: string;
+        icon?: React.ComponentType;
+    };
+}
+interface ChartProps {
+    config: ChartConfig;
+    children?: React.ReactNode;
+    className?: string;
+}
+
+declare const Chart: react.ForwardRefExoticComponent<ChartProps & react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+
+declare const Checkbox: react.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+interface CheckboxProps {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    value?: string;
+    id?: string;
+    className?: string;
+    children?: React.ReactNode;
+}
+
+declare const Collapsible: react.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & react.RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: react.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: react.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & react.RefAttributes<HTMLDivElement>>;
+
+interface CollapsibleProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface CollapsibleTriggerProps {
+    children?: React.ReactNode;
+    className?: string;
+    asChild?: boolean;
+}
+interface CollapsibleContentProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+
+interface ComboboxOption {
+    label: string;
+    value: string;
+}
+interface ComboboxProps {
+    options: ComboboxOption[];
+    value?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyMessage?: string;
+    disabled?: boolean;
+    className?: string;
+}
+
+declare const Combobox: react.ForwardRefExoticComponent<ComboboxProps & react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+
+declare const Command: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const CommandInput: react.ForwardRefExoticComponent<react.InputHTMLAttributes<HTMLInputElement> & react.RefAttributes<HTMLInputElement>>;
+declare const CommandList: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & {
+    heading?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & {
+    disabled?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Command is a web-heavy component (command palette / cmdk-style).
+ * The native implementation is a placeholder — this component is primarily designed for web.
+ */
+interface CommandProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface CommandInputProps {
+    placeholder?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    className?: string;
+}
+interface CommandListProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface CommandEmptyProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface CommandGroupProps {
+    heading?: string;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface CommandItemProps {
+    children?: React.ReactNode;
+    onSelect?: () => void;
+    disabled?: boolean;
+    className?: string;
+}
+interface CommandSeparatorProps {
+    className?: string;
+}
+
+declare const ContextMenu: react.FC<ContextMenuPrimitive.ContextMenuProps>;
+declare const ContextMenuTrigger: react.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & react.RefAttributes<HTMLSpanElement>>;
+declare const ContextMenuGroup: react.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuPortal: react.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
+declare const ContextMenuSub: react.FC<ContextMenuPrimitive.ContextMenuSubProps>;
+declare const ContextMenuRadioGroup: react.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubTrigger: react.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubContent: react.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuContent: react.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuItem: react.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuCheckboxItem: react.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuCheckboxItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuRadioItem: react.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuLabel: react.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSeparator: react.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface ContextMenuProps {
+    children?: ReactNode;
+}
+interface ContextMenuTriggerProps {
+    children?: ReactNode;
+    className?: string;
+    asChild?: boolean;
+}
+interface ContextMenuContentProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface ContextMenuItemProps {
+    children?: ReactNode;
+    className?: string;
+    inset?: boolean;
+    disabled?: boolean;
+    onSelect?: () => void;
+}
+interface ContextMenuSeparatorProps {
+    className?: string;
+}
+interface ContextMenuLabelProps {
+    children?: ReactNode;
+    className?: string;
+    inset?: boolean;
+}
+interface ContextMenuCheckboxItemProps {
+    children?: ReactNode;
+    className?: string;
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+}
+interface ContextMenuRadioGroupProps {
+    children?: ReactNode;
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+interface ContextMenuRadioItemProps {
+    children?: ReactNode;
+    className?: string;
+    value: string;
+}
+interface ContextMenuSubProps {
+    children?: ReactNode;
+}
+interface ContextMenuSubTriggerProps {
+    children?: ReactNode;
+    className?: string;
+    inset?: boolean;
+}
+interface ContextMenuSubContentProps {
+    children?: ReactNode;
+    className?: string;
+}
+
+type SortDirection = "asc" | "desc" | null;
+interface ColumnDef<TData> {
+    id: string;
+    header: string;
+    accessorKey?: keyof TData;
+    accessorFn?: (row: TData) => unknown;
+    cell?: (value: unknown, row: TData) => React.ReactNode;
+    sortable?: boolean;
+}
+interface DataTableProps<TData> {
+    columns: ColumnDef<TData>[];
+    data: TData[];
+    className?: string;
+}
+
+declare const DataTable: <TData>(props: DataTableProps<TData> & React.HTMLAttributes<HTMLDivElement> & {
+    ref?: React.ForwardedRef<HTMLDivElement>;
+}) => React.ReactElement;
+
+interface DatePickerProps {
+    value?: Date;
+    onValueChange?: (date: Date | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+}
+
+declare const DatePicker: react.ForwardRefExoticComponent<DatePickerProps & react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+
+declare const Dialog: react.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: react.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: react.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: react.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & react.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & react.RefAttributes<HTMLHeadingElement>, "ref"> & react.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & react.RefAttributes<HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
+
+interface DialogProps {
+    children?: ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+interface DialogTriggerProps {
+    children?: ReactNode;
+    className?: string;
+    asChild?: boolean;
+}
+interface DialogContentProps {
+    children?: ReactNode;
+    className?: string;
+    onClose?: () => void;
+}
+interface DialogHeaderProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface DialogFooterProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface DialogTitleProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface DialogDescriptionProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface DialogCloseProps {
+    children?: ReactNode;
+    className?: string;
+    asChild?: boolean;
+}
+
+declare function Drawer({ ...props }: React.ComponentProps<typeof Drawer$1.Root>): react_jsx_runtime.JSX.Element;
+declare namespace Drawer {
+    var displayName: string;
+}
+declare function DrawerTrigger({ ...props }: React.ComponentProps<typeof Drawer$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare namespace DrawerTrigger {
+    var displayName: string;
+}
+declare function DrawerPortal({ ...props }: React.ComponentProps<typeof Drawer$1.Portal>): react_jsx_runtime.JSX.Element;
+declare namespace DrawerPortal {
+    var displayName: string;
+}
+declare function DrawerClose({ ...props }: React.ComponentProps<typeof Drawer$1.Close>): react_jsx_runtime.JSX.Element;
+declare namespace DrawerClose {
+    var displayName: string;
+}
+declare function DrawerOverlay({ className, ...props }: React.ComponentProps<typeof Drawer$1.Overlay>): react_jsx_runtime.JSX.Element;
+declare namespace DrawerOverlay {
+    var displayName: string;
+}
+declare function DrawerContent({ className, children, ...props }: React.ComponentProps<typeof Drawer$1.Content>): react_jsx_runtime.JSX.Element;
+declare namespace DrawerContent {
+    var displayName: string;
+}
+declare const DrawerHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DrawerFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare function DrawerTitle({ className, ...props }: React.ComponentProps<typeof Drawer$1.Title>): react_jsx_runtime.JSX.Element;
+declare namespace DrawerTitle {
+    var displayName: string;
+}
+declare function DrawerDescription({ className, ...props }: React.ComponentProps<typeof Drawer$1.Description>): react_jsx_runtime.JSX.Element;
+declare namespace DrawerDescription {
+    var displayName: string;
+}
+
+interface DrawerProps {
+    children?: ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+interface DrawerTriggerProps {
+    children?: ReactNode;
+    className?: string;
+    asChild?: boolean;
+}
+interface DrawerContentProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface DrawerHeaderProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface DrawerFooterProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface DrawerTitleProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface DrawerDescriptionProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface DrawerCloseProps {
+    children?: ReactNode;
+    className?: string;
+    asChild?: boolean;
+}
+
+declare const DropdownMenu: react.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: react.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: react.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: react.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: react.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: react.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface DropdownMenuProps {
+    children?: ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+interface DropdownMenuTriggerProps {
+    children?: ReactNode;
+    className?: string;
+    asChild?: boolean;
+}
+interface DropdownMenuContentProps {
+    children?: ReactNode;
+    className?: string;
+    align?: "start" | "center" | "end";
+    sideOffset?: number;
+}
+interface DropdownMenuItemProps {
+    children?: ReactNode;
+    className?: string;
+    inset?: boolean;
+    disabled?: boolean;
+    onSelect?: () => void;
+}
+interface DropdownMenuSeparatorProps {
+    className?: string;
+}
+interface DropdownMenuLabelProps {
+    children?: ReactNode;
+    className?: string;
+    inset?: boolean;
+}
+interface DropdownMenuCheckboxItemProps {
+    children?: ReactNode;
+    className?: string;
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+}
+interface DropdownMenuRadioGroupProps {
+    children?: ReactNode;
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+interface DropdownMenuRadioItemProps {
+    children?: ReactNode;
+    className?: string;
+    value: string;
+}
+interface DropdownMenuSubProps {
+    children?: ReactNode;
+}
+interface DropdownMenuSubTriggerProps {
+    children?: ReactNode;
+    className?: string;
+    inset?: boolean;
+}
+interface DropdownMenuSubContentProps {
+    children?: ReactNode;
+    className?: string;
+}
+
+declare const Form: react.ForwardRefExoticComponent<react.FormHTMLAttributes<HTMLFormElement> & react.RefAttributes<HTMLFormElement>>;
+interface FormFieldProps$1 {
+    name: string;
+    children?: React.ReactNode;
+}
+declare function FormField({ name, children }: FormFieldProps$1): react_jsx_runtime.JSX.Element;
+declare namespace FormField {
+    var displayName: string;
+}
+declare const FormItem: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const FormLabel: react.ForwardRefExoticComponent<react.LabelHTMLAttributes<HTMLLabelElement> & react.RefAttributes<HTMLLabelElement>>;
+declare const FormControl: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const FormDescription: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLParagraphElement> & react.RefAttributes<HTMLParagraphElement>>;
+declare const FormMessage: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLParagraphElement> & react.RefAttributes<HTMLParagraphElement>>;
+
+interface FormProps {
+    children?: React.ReactNode;
+    className?: string;
+    onSubmit?: () => void;
+}
+interface FormFieldProps {
+    name: string;
+    children?: React.ReactNode;
+}
+interface FormItemProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface FormLabelProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface FormControlProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface FormDescriptionProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface FormMessageProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+
+declare const HoverCard: react.FC<HoverCardPrimitive.HoverCardProps>;
+declare const HoverCardTrigger: react.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & react.RefAttributes<HTMLAnchorElement>>;
+declare const HoverCardContent: react.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+interface HoverCardProps {
+    openDelay?: number;
+    closeDelay?: number;
+    children?: React.ReactNode;
+}
+interface HoverCardTriggerProps {
+    children?: React.ReactNode;
+    className?: string;
+    asChild?: boolean;
+}
+interface HoverCardContentProps {
+    children?: React.ReactNode;
+    className?: string;
+    align?: "start" | "center" | "end";
+    sideOffset?: number;
+}
+
+declare const Input: react.ForwardRefExoticComponent<react.InputHTMLAttributes<HTMLInputElement> & react.RefAttributes<HTMLInputElement>>;
+
+interface InputProps {
+    type?: string;
+    placeholder?: string;
+    value?: string;
+    defaultValue?: string;
+    onChangeText?: (text: string) => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    className?: string;
+}
+
+interface InputOTPProps {
+    length?: number;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    className?: string;
+}
+interface InputOTPSlotProps {
+    index: number;
+    char?: string;
+    isActive?: boolean;
+    className?: string;
+}
+
+declare const InputOTP: react.ForwardRefExoticComponent<InputOTPProps & Omit<react.HTMLAttributes<HTMLDivElement>, "onChange"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const Label: react.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & react.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: class_variance_authority_types.ClassProp | undefined) => string> & react.RefAttributes<HTMLLabelElement>>;
+
+interface LabelProps {
+    htmlFor?: string;
+    children?: React.ReactNode;
+    className?: string;
+    disabled?: boolean;
+}
+
+declare const MenubarMenu: typeof MenubarPrimitive.Menu;
+declare const MenubarGroup: react.ForwardRefExoticComponent<MenubarPrimitive.MenubarGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const MenubarPortal: react.FC<MenubarPrimitive.MenubarPortalProps>;
+declare const MenubarSub: react.FC<MenubarPrimitive.MenubarSubProps>;
+declare const MenubarRadioGroup: react.ForwardRefExoticComponent<MenubarPrimitive.MenubarRadioGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const Menubar: react.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const MenubarTrigger: react.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const MenubarSubTrigger: react.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubTriggerProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const MenubarSubContent: react.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const MenubarContent: react.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const MenubarItem: react.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const MenubarCheckboxItem: react.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarCheckboxItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const MenubarRadioItem: react.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarRadioItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const MenubarLabel: react.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarLabelProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const MenubarSeparator: react.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSeparatorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const MenubarShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface MenubarProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface MenubarMenuProps {
+    children?: ReactNode;
+}
+interface MenubarTriggerProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface MenubarContentProps {
+    children?: ReactNode;
+    className?: string;
+    align?: "start" | "center" | "end";
+    alignOffset?: number;
+    sideOffset?: number;
+}
+interface MenubarItemProps {
+    children?: ReactNode;
+    className?: string;
+    inset?: boolean;
+    disabled?: boolean;
+    onSelect?: () => void;
+}
+interface MenubarSeparatorProps {
+    className?: string;
+}
+interface MenubarSubProps {
+    children?: ReactNode;
+}
+interface MenubarSubTriggerProps {
+    children?: ReactNode;
+    className?: string;
+    inset?: boolean;
+}
+interface MenubarSubContentProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface MenubarCheckboxItemProps {
+    children?: ReactNode;
+    className?: string;
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+}
+interface MenubarRadioGroupProps {
+    children?: ReactNode;
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+interface MenubarRadioItemProps {
+    children?: ReactNode;
+    className?: string;
+    value: string;
+}
+
+declare const NavigationMenu: react.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuProps & react.RefAttributes<HTMLElement>, "ref"> & react.RefAttributes<HTMLElement>>;
+declare const NavigationMenuList: react.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuListProps & react.RefAttributes<HTMLUListElement>, "ref"> & react.RefAttributes<HTMLUListElement>>;
+declare const NavigationMenuItem: react.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuItemProps & react.RefAttributes<HTMLLIElement>>;
+declare const navigationMenuTriggerStyle: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const NavigationMenuTrigger: react.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const NavigationMenuContent: react.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuLink: react.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuLinkProps & react.RefAttributes<HTMLAnchorElement>>;
+declare const NavigationMenuViewport: react.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuViewportProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuIndicator: react.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuIndicatorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+interface NavigationMenuProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface NavigationMenuListProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface NavigationMenuItemProps {
+    children?: ReactNode;
+    className?: string;
+    value?: string;
+}
+interface NavigationMenuTriggerProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface NavigationMenuContentProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface NavigationMenuLinkProps {
+    children?: ReactNode;
+    className?: string;
+    href?: string;
+    active?: boolean;
+    onPress?: () => void;
+}
+
+interface PaginationProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface PaginationContentProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface PaginationItemProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface PaginationLinkProps {
+    children?: React.ReactNode;
+    className?: string;
+    isActive?: boolean;
+    size?: "default" | "icon";
+    href?: string;
+    onPress?: () => void;
+}
+interface PaginationPreviousProps {
+    children?: React.ReactNode;
+    className?: string;
+    href?: string;
+    onPress?: () => void;
+}
+interface PaginationNextProps {
+    children?: React.ReactNode;
+    className?: string;
+    href?: string;
+    onPress?: () => void;
+}
+interface PaginationEllipsisProps {
+    className?: string;
+}
+
+declare const Pagination: react.ForwardRefExoticComponent<Omit<PaginationProps & react.ClassAttributes<HTMLElement> & react.HTMLAttributes<HTMLElement>, "ref"> & react.RefAttributes<HTMLElement>>;
+declare const PaginationContent: react.ForwardRefExoticComponent<Omit<PaginationContentProps & react.ClassAttributes<HTMLUListElement> & react.HTMLAttributes<HTMLUListElement>, "ref"> & react.RefAttributes<HTMLUListElement>>;
+declare const PaginationItem: react.ForwardRefExoticComponent<Omit<PaginationItemProps & react.ClassAttributes<HTMLLIElement> & react.LiHTMLAttributes<HTMLLIElement>, "ref"> & react.RefAttributes<HTMLLIElement>>;
+declare const paginationLinkVariants: (props?: ({
+    size?: "default" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface PaginationLinkWebProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+    isActive?: boolean;
+    size?: "default" | "icon";
+    className?: string;
+}
+declare const PaginationLink: react.ForwardRefExoticComponent<PaginationLinkWebProps & react.RefAttributes<HTMLAnchorElement>>;
+declare const PaginationPrevious: react.ForwardRefExoticComponent<PaginationLinkWebProps & react.RefAttributes<HTMLAnchorElement>>;
+declare const PaginationNext: react.ForwardRefExoticComponent<PaginationLinkWebProps & react.RefAttributes<HTMLAnchorElement>>;
+declare const PaginationEllipsis: react.ForwardRefExoticComponent<Omit<PaginationEllipsisProps & react.ClassAttributes<HTMLSpanElement> & react.HTMLAttributes<HTMLSpanElement>, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+
+declare const Popover: react.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: react.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: react.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & react.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+interface PopoverProps {
+    children?: ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+interface PopoverTriggerProps {
+    children?: ReactNode;
+    className?: string;
+    asChild?: boolean;
+}
+interface PopoverContentProps {
+    children?: ReactNode;
+    className?: string;
+    align?: "start" | "center" | "end";
+    sideOffset?: number;
+}
+
+declare const Progress: react.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+interface ProgressProps {
+    value?: number;
+    max?: number;
+    children?: React.ReactNode;
+    className?: string;
+}
+
+declare const RadioGroup: react.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const RadioGroupItem: react.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+interface RadioGroupProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface RadioGroupItemProps {
+    value: string;
+    disabled?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+    id?: string;
+}
+
+type ResizableDirection = "horizontal" | "vertical";
+interface ResizablePanelGroupProps {
+    direction?: ResizableDirection;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface ResizablePanelProps {
+    defaultSize?: number;
+    minSize?: number;
+    maxSize?: number;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface ResizableHandleProps {
+    withHandle?: boolean;
+    className?: string;
+}
+
+declare function ResizablePanelGroup({ className, direction, children, }: ResizablePanelGroupProps): react_jsx_runtime.JSX.Element;
+declare function ResizablePanel({ className, ...props }: ResizablePanelProps & React.ComponentProps<typeof Panel>): react_jsx_runtime.JSX.Element;
+declare function ResizableHandle({ className, withHandle, ...props }: ResizableHandleProps & React.ComponentProps<typeof Separator$1>): react_jsx_runtime.JSX.Element;
+
+declare const ScrollArea: react.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: react.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+interface ScrollAreaProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+type ScrollBarOrientation = "vertical" | "horizontal";
+interface ScrollBarProps {
+    orientation?: ScrollBarOrientation;
+    className?: string;
+}
+
+declare const Select: react.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: react.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: react.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & react.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: react.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const SelectContent: react.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: react.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: react.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: react.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+interface SelectProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    placeholder?: string;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface SelectItemOption {
+    label: string;
+    value: string;
+}
+
+declare const separatorVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Separator: react.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+type SeparatorOrientation = "horizontal" | "vertical";
+interface SeparatorProps {
+    orientation?: SeparatorOrientation;
+    decorative?: boolean;
+    className?: string;
+}
+
+declare const Sheet: react.FC<DialogPrimitive.DialogProps>;
+declare const SheetTrigger: react.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: react.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & react.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: react.FC<DialogPrimitive.DialogPortalProps>;
+declare const SheetOverlay: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: ({
+    side?: "left" | "right" | "bottom" | "top" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SheetContentProps$1 extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+declare const SheetContent: react.ForwardRefExoticComponent<SheetContentProps$1 & react.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & react.RefAttributes<HTMLHeadingElement>, "ref"> & react.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & react.RefAttributes<HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
+
+type SheetSide = "top" | "right" | "bottom" | "left";
+interface SheetProps {
+    children?: ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+interface SheetTriggerProps {
+    children?: ReactNode;
+    className?: string;
+    asChild?: boolean;
+}
+interface SheetContentProps {
+    children?: ReactNode;
+    className?: string;
+    side?: SheetSide;
+}
+interface SheetHeaderProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface SheetFooterProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface SheetTitleProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface SheetDescriptionProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface SheetCloseProps {
+    children?: ReactNode;
+    className?: string;
+    asChild?: boolean;
+}
+
+/**
+ * Sidebar - Web implementation
+ *
+ * Note: This is a web-heavy component. Sidebars on mobile are typically
+ * handled by navigation libraries (e.g., React Navigation drawer).
+ */
+interface SidebarContextValue {
+    open: boolean;
+    setOpen: (open: boolean | ((prev: boolean) => boolean)) => void;
+    toggleSidebar: () => void;
+}
+declare function useSidebarContext(): SidebarContextValue;
+interface SidebarProviderProps {
+    children?: ReactNode;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare const SidebarProvider: react.ForwardRefExoticComponent<SidebarProviderProps & react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const Sidebar: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & {
+    side?: "left" | "right";
+    collapsible?: "offcanvas" | "icon" | "none";
+} & react.RefAttributes<HTMLDivElement>>;
+declare const SidebarHeader: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const SidebarContent: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const SidebarFooter: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const SidebarTrigger: react.ForwardRefExoticComponent<react.ButtonHTMLAttributes<HTMLButtonElement> & react.RefAttributes<HTMLButtonElement>>;
+
+interface SidebarProps {
+    children?: ReactNode;
+    className?: string;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    collapsible?: "offcanvas" | "icon" | "none";
+    side?: "left" | "right";
+}
+interface SidebarHeaderProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface SidebarContentProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface SidebarFooterProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface SidebarTriggerProps {
+    children?: ReactNode;
+    className?: string;
+}
+
+declare const Skeleton: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+
+interface SkeletonProps {
+    className?: string;
+    width?: number | string;
+    height?: number | string;
+    borderRadius?: number;
+}
+
+declare const Slider: react.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & react.RefAttributes<HTMLSpanElement>, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+
+interface SliderProps {
+    value?: number[];
+    defaultValue?: number[];
+    onValueChange?: (value: number[]) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    className?: string;
+}
+
+declare const Switch: react.ForwardRefExoticComponent<Omit<SwitchPrimitive.SwitchProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+interface SwitchProps {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    className?: string;
+}
+
+declare const Table: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLTableElement> & react.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLTableSectionElement> & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLTableSectionElement> & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLTableSectionElement> & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLTableRowElement> & react.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: react.ForwardRefExoticComponent<react.ThHTMLAttributes<HTMLTableCellElement> & react.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: react.ForwardRefExoticComponent<react.TdHTMLAttributes<HTMLTableCellElement> & react.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLTableCaptionElement> & react.RefAttributes<HTMLTableCaptionElement>>;
+
+interface TableProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface TableHeaderProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface TableBodyProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface TableFooterProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface TableRowProps {
+    children?: React.ReactNode;
+    className?: string;
+    selected?: boolean;
+}
+interface TableHeadProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface TableCellProps {
+    children?: React.ReactNode;
+    className?: string;
+    colSpan?: number;
+}
+interface TableCaptionProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+
+declare const Tabs: react.ForwardRefExoticComponent<TabsPrimitive.TabsProps & react.RefAttributes<HTMLDivElement>>;
+declare const TabsList: react.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: react.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: react.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+interface TabsProps {
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface TabsListProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface TabsTriggerProps {
+    value: string;
+    children?: React.ReactNode;
+    className?: string;
+    disabled?: boolean;
+}
+interface TabsContentProps {
+    value: string;
+    children?: React.ReactNode;
+    className?: string;
+}
+
+declare const Textarea: react.ForwardRefExoticComponent<react.TextareaHTMLAttributes<HTMLTextAreaElement> & react.RefAttributes<HTMLTextAreaElement>>;
+
+interface TextareaProps {
+    placeholder?: string;
+    value?: string;
+    defaultValue?: string;
+    onChangeText?: (text: string) => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    rows?: number;
+    className?: string;
+}
+
+declare const toastVariants: (props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const ToastProvider: {
+    ({ children }: {
+        children?: ReactNode;
+    }): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const ToastViewport: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLOListElement> & react.RefAttributes<HTMLOListElement>>;
+interface ToastWebProps extends React.HTMLAttributes<HTMLLIElement>, VariantProps<typeof toastVariants> {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare const Toast: react.ForwardRefExoticComponent<ToastWebProps & react.RefAttributes<HTMLLIElement>>;
+declare const ToastClose: react.ForwardRefExoticComponent<react.ButtonHTMLAttributes<HTMLButtonElement> & react.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+type ToasterToast = {
+    id: string;
+    title?: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+    variant?: "default" | "destructive";
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+};
+declare const ToastAction: react.ForwardRefExoticComponent<react.ButtonHTMLAttributes<HTMLButtonElement> & {
+    altText?: string;
+} & react.RefAttributes<HTMLButtonElement>>;
+type ToastAction = {
+    type: "ADD_TOAST";
+    toast: ToasterToast;
+} | {
+    type: "UPDATE_TOAST";
+    toast: Partial<ToasterToast>;
+} | {
+    type: "DISMISS_TOAST";
+    toastId?: string;
+} | {
+    type: "REMOVE_TOAST";
+    toastId?: string;
+};
+declare function toast({ ...props }: Omit<ToasterToast, "id">): {
+    id: string;
+    dismiss: () => void;
+    update: (updateProps: Partial<ToasterToast>) => void;
+};
+declare function useToast(): {
+    toasts: ToasterToast[];
+    toast: typeof toast;
+    dismiss: (toastId?: string) => void;
+};
+
+type ToastVariant = "default" | "destructive";
+interface ToastProps {
+    children?: ReactNode;
+    className?: string;
+    variant?: ToastVariant;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+interface ToastProviderProps {
+    children?: ReactNode;
+}
+interface ToastViewportProps {
+    className?: string;
+}
+interface ToastTitleProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface ToastDescriptionProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface ToastActionProps {
+    children?: ReactNode;
+    className?: string;
+    altText: string;
+    onClick?: () => void;
+}
+interface ToastCloseProps {
+    className?: string;
+}
+
+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.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & react.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & react.RefAttributes<HTMLButtonElement>>;
+
+type ToggleVariant = "default" | "outline";
+type ToggleSize = "default" | "sm" | "lg";
+interface ToggleProps {
+    pressed?: boolean;
+    defaultPressed?: boolean;
+    onPressedChange?: (pressed: boolean) => void;
+    variant?: ToggleVariant;
+    size?: ToggleSize;
+    disabled?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}
+
+declare const ToggleGroup: react.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & react.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & react.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string>) & react.RefAttributes<HTMLDivElement>>;
+declare const ToggleGroupItem: react.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & react.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & react.RefAttributes<HTMLButtonElement>>;
+
+interface ToggleGroupProps {
+    type?: "single" | "multiple";
+    value?: string | string[];
+    defaultValue?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    variant?: ToggleVariant;
+    size?: ToggleSize;
+    disabled?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface ToggleGroupItemProps {
+    value: string;
+    variant?: ToggleVariant;
+    size?: ToggleSize;
+    disabled?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}
+
+declare const TooltipProvider: react.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: react.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: react.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: react.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+interface TooltipProps {
+    children?: ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    delayDuration?: number;
+}
+interface TooltipTriggerProps {
+    children?: ReactNode;
+    className?: string;
+    asChild?: boolean;
+}
+interface TooltipContentProps {
+    children?: ReactNode;
+    className?: string;
+    sideOffset?: number;
+    side?: "top" | "right" | "bottom" | "left";
+}
+interface TooltipProviderProps {
+    children?: ReactNode;
+    delayDuration?: number;
+    skipDelayDuration?: number;
+}
+
+export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, Alert, AlertDescription, type AlertDescriptionProps, AlertDialog, AlertDialogAction, type AlertDialogActionProps, AlertDialogCancel, type AlertDialogCancelProps, AlertDialogContent, type AlertDialogContentProps, AlertDialogDescription, type AlertDialogDescriptionProps, AlertDialogFooter, type AlertDialogFooterProps, AlertDialogHeader, type AlertDialogHeaderProps, AlertDialogOverlay, AlertDialogPortal, type AlertDialogProps, AlertDialogTitle, type AlertDialogTitleProps, AlertDialogTrigger, type AlertDialogTriggerProps, type AlertProps, AlertTitle, type AlertTitleProps, type AlertVariant, AspectRatio, type AspectRatioProps, Avatar, AvatarFallback, type AvatarFallbackProps, AvatarImage, type AvatarImageProps, type AvatarProps, Badge, type BadgeProps, type BadgeVariant, Breadcrumb, BreadcrumbEllipsis, type BreadcrumbEllipsisProps, BreadcrumbItem, type BreadcrumbItemProps, BreadcrumbLink, type BreadcrumbLinkProps, BreadcrumbList, type BreadcrumbListProps, BreadcrumbPage, type BreadcrumbPageProps, type BreadcrumbProps, BreadcrumbSeparator, type BreadcrumbSeparatorProps, Button, type ButtonProps, type ButtonSize, type ButtonVariant, Calendar, type CalendarProps, Card, type CardProps, Carousel, CarouselContent, type CarouselContentProps, CarouselItem, type CarouselItemProps, CarouselNext, type CarouselNextProps, type CarouselOrientation, CarouselPrevious, type CarouselPreviousProps, type CarouselProps, Chart, type ChartConfig, type ChartProps, Checkbox, type CheckboxProps, Collapsible, CollapsibleContent, type CollapsibleContentProps, type CollapsibleProps, CollapsibleTrigger, type CollapsibleTriggerProps, type ColumnDef, Combobox, type ComboboxProps, Command, CommandEmpty, type CommandEmptyProps, CommandGroup, type CommandGroupProps, CommandInput, type CommandInputProps, CommandItem, type CommandItemProps, CommandList, type CommandListProps, type CommandProps, CommandSeparator, type CommandSeparatorProps, ContextMenu, ContextMenuCheckboxItem, type ContextMenuCheckboxItemProps, ContextMenuContent, type ContextMenuContentProps, ContextMenuGroup, ContextMenuItem, type ContextMenuItemProps, ContextMenuLabel, type ContextMenuLabelProps, ContextMenuPortal, type ContextMenuProps, ContextMenuRadioGroup, type ContextMenuRadioGroupProps, ContextMenuRadioItem, type ContextMenuRadioItemProps, ContextMenuSeparator, type ContextMenuSeparatorProps, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, type ContextMenuSubContentProps, type ContextMenuSubProps, ContextMenuSubTrigger, type ContextMenuSubTriggerProps, ContextMenuTrigger, type ContextMenuTriggerProps, DataTable, type DataTableProps, DatePicker, type DatePickerProps, Dialog, DialogClose, type DialogCloseProps, DialogContent, type DialogContentProps, DialogDescription, type DialogDescriptionProps, DialogFooter, type DialogFooterProps, DialogHeader, type DialogHeaderProps, DialogOverlay, DialogPortal, type DialogProps, DialogTitle, type DialogTitleProps, DialogTrigger, type DialogTriggerProps, Drawer, DrawerClose, type DrawerCloseProps, DrawerContent, type DrawerContentProps, DrawerDescription, type DrawerDescriptionProps, DrawerFooter, type DrawerFooterProps, DrawerHeader, type DrawerHeaderProps, DrawerOverlay, DrawerPortal, type DrawerProps, DrawerTitle, type DrawerTitleProps, DrawerTrigger, type DrawerTriggerProps, DropdownMenu, DropdownMenuCheckboxItem, type DropdownMenuCheckboxItemProps, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuPortal, type DropdownMenuProps, DropdownMenuRadioGroup, type DropdownMenuRadioGroupProps, DropdownMenuRadioItem, type DropdownMenuRadioItemProps, DropdownMenuSeparator, type DropdownMenuSeparatorProps, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, type DropdownMenuSubContentProps, type DropdownMenuSubProps, DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, DropdownMenuTrigger, type DropdownMenuTriggerProps, Form, FormControl, type FormControlProps, FormDescription, type FormDescriptionProps, FormField, type FormFieldProps, FormItem, type FormItemProps, FormLabel, type FormLabelProps, FormMessage, type FormMessageProps, type FormProps, HoverCard, HoverCardContent, type HoverCardContentProps, type HoverCardProps, HoverCardTrigger, type HoverCardTriggerProps, Input, InputOTP, type InputOTPProps, type InputOTPSlotProps, type InputProps, Label, type LabelProps, Menubar, MenubarCheckboxItem, type MenubarCheckboxItemProps, MenubarContent, type MenubarContentProps, MenubarGroup, MenubarItem, type MenubarItemProps, MenubarLabel, MenubarMenu, type MenubarMenuProps, MenubarPortal, type MenubarProps, MenubarRadioGroup, type MenubarRadioGroupProps, MenubarRadioItem, type MenubarRadioItemProps, MenubarSeparator, type MenubarSeparatorProps, MenubarShortcut, MenubarSub, MenubarSubContent, type MenubarSubContentProps, type MenubarSubProps, MenubarSubTrigger, type MenubarSubTriggerProps, MenubarTrigger, type MenubarTriggerProps, NavigationMenu, NavigationMenuContent, type NavigationMenuContentProps, NavigationMenuIndicator, NavigationMenuItem, type NavigationMenuItemProps, NavigationMenuLink, type NavigationMenuLinkProps, NavigationMenuList, type NavigationMenuListProps, type NavigationMenuProps, NavigationMenuTrigger, type NavigationMenuTriggerProps, NavigationMenuViewport, Pagination, PaginationContent, type PaginationContentProps, PaginationEllipsis, type PaginationEllipsisProps, PaginationItem, type PaginationItemProps, PaginationLink, type PaginationLinkProps, type PaginationLinkWebProps, PaginationNext, type PaginationNextProps, PaginationPrevious, type PaginationPreviousProps, type PaginationProps, Popover, PopoverAnchor, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type PopoverTriggerProps, Progress, type ProgressProps, RadioGroup, RadioGroupItem, type RadioGroupItemProps, type RadioGroupProps, type ResizableDirection, ResizableHandle, type ResizableHandleProps, ResizablePanel, ResizablePanelGroup, type ResizablePanelGroupProps, type ResizablePanelProps, ScrollArea, type ScrollAreaProps, ScrollBar, type ScrollBarProps, Select, SelectContent, SelectGroup, SelectItem, type SelectItemOption, SelectLabel, type SelectProps, SelectSeparator, SelectTrigger, SelectValue, Separator, type SeparatorOrientation, type SeparatorProps, Sheet, SheetClose, type SheetCloseProps, SheetContent, type SheetContentProps, SheetDescription, type SheetDescriptionProps, SheetFooter, type SheetFooterProps, SheetHeader, type SheetHeaderProps, SheetOverlay, SheetPortal, type SheetProps, type SheetSide, SheetTitle, type SheetTitleProps, SheetTrigger, type SheetTriggerProps, Sidebar, SidebarContent, type SidebarContentProps, SidebarFooter, type SidebarFooterProps, SidebarHeader, type SidebarHeaderProps, type SidebarProps, SidebarProvider, SidebarTrigger, type SidebarTriggerProps, Skeleton, type SkeletonProps, Slider, type SliderProps, type SortDirection, Switch, type SwitchProps, Table, TableBody, type TableBodyProps, TableCaption, type TableCaptionProps, TableCell, type TableCellProps, TableFooter, type TableFooterProps, TableHead, type TableHeadProps, TableHeader, type TableHeaderProps, type TableProps, TableRow, type TableRowProps, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsListProps, type TabsProps, TabsTrigger, type TabsTriggerProps, Textarea, type TextareaProps, Toast, ToastAction, type ToastActionProps, ToastClose, type ToastCloseProps, ToastDescription, type ToastDescriptionProps, type ToastProps, ToastProvider, type ToastProviderProps, ToastTitle, type ToastTitleProps, type ToastVariant, ToastViewport, type ToastViewportProps, type ToastWebProps, type ToasterToast, Toggle, ToggleGroup, ToggleGroupItem, type ToggleGroupItemProps, type ToggleGroupProps, type ToggleProps, type ToggleSize, type ToggleVariant, Tooltip, TooltipContent, type TooltipContentProps, type TooltipProps, TooltipProvider, type TooltipProviderProps, TooltipTrigger, type TooltipTriggerProps, badgeVariants, navigationMenuTriggerStyle, paginationLinkVariants, separatorVariants, toast, toastVariants, toggleVariants, useSidebarContext, useToast };