@reeverdev/ui 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/dist/index.cjs +19 -0
  2. package/dist/index.cjs.map +1 -0
  3. package/dist/index.d.cts +4230 -0
  4. package/dist/index.d.ts +4230 -0
  5. package/dist/index.js +19 -0
  6. package/dist/index.js.map +1 -0
  7. package/dist/styles.css +2 -0
  8. package/package.json +156 -0
package/dist/index.d.ts ADDED
@@ -0,0 +1,4230 @@
1
+ import * as class_variance_authority_types from 'class-variance-authority/types';
2
+ import * as React$1 from 'react';
3
+ import { VariantProps } from 'class-variance-authority';
4
+ import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
5
+ import * as react_jsx_runtime from 'react/jsx-runtime';
6
+ import * as DialogPrimitive from '@radix-ui/react-dialog';
7
+ import { DialogProps } from '@radix-ui/react-dialog';
8
+ import * as LabelPrimitive from '@radix-ui/react-label';
9
+ import * as SeparatorPrimitive from '@radix-ui/react-separator';
10
+ import * as SwitchPrimitives from '@radix-ui/react-switch';
11
+ import * as AvatarPrimitive from '@radix-ui/react-avatar';
12
+ import * as TooltipPrimitive from '@radix-ui/react-tooltip';
13
+ import * as SelectPrimitive from '@radix-ui/react-select';
14
+ import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
15
+ import * as PopoverPrimitive from '@radix-ui/react-popover';
16
+ import * as TabsPrimitive from '@radix-ui/react-tabs';
17
+ import { Toaster as Toaster$1 } from 'sonner';
18
+ export { toast } from 'sonner';
19
+ import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
20
+ import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
21
+ import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
22
+ import * as TogglePrimitive from '@radix-ui/react-toggle';
23
+ import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
24
+ import * as SliderPrimitive from '@radix-ui/react-slider';
25
+ import * as AccordionPrimitive from '@radix-ui/react-accordion';
26
+ import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
27
+ import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
28
+ import * as ProgressPrimitive from '@radix-ui/react-progress';
29
+ import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
30
+ import * as AspectRatioPrimitive from '@radix-ui/react-aspect-ratio';
31
+ import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu';
32
+ import * as vaul from 'vaul';
33
+ import { Drawer as Drawer$1 } from 'vaul';
34
+ import { DayPicker, DateRange } from 'react-day-picker';
35
+ import { GroupProps, Panel, SeparatorProps } from 'react-resizable-panels';
36
+ export { PanelProps as ResizablePanelProps } from 'react-resizable-panels';
37
+ import * as lucide_react from 'lucide-react';
38
+ import * as MenubarPrimitive from '@radix-ui/react-menubar';
39
+ import * as VisuallyHiddenPrimitive from '@radix-ui/react-visually-hidden';
40
+ import useEmblaCarousel, { UseEmblaCarouselType } from 'embla-carousel-react';
41
+ import { Editor } from '@tiptap/react';
42
+ import { Crop } from 'react-image-crop';
43
+ export { useTheme } from 'next-themes';
44
+ import { Transition } from 'framer-motion';
45
+ import { ClassValue } from 'clsx';
46
+
47
+ declare const Alert: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
48
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | "destructive" | null | undefined;
49
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLDivElement>>;
50
+ declare const AlertTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLParagraphElement>>;
51
+ declare const AlertDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
52
+
53
+ declare const badgeVariants: (props?: ({
54
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | "destructive" | null | undefined;
55
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
56
+ interface BadgeProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
57
+ }
58
+ declare const Badge: React$1.ForwardRefExoticComponent<BadgeProps & React$1.RefAttributes<HTMLDivElement>>;
59
+
60
+ declare const buttonVariants: (props?: ({
61
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | "destructive" | "link" | null | undefined;
62
+ size?: "sm" | "md" | "lg" | "icon" | null | undefined;
63
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
64
+ interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
65
+ asChild?: boolean;
66
+ }
67
+ declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
68
+
69
+ declare const Card: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
70
+ declare const CardHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
71
+ declare const CardTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLParagraphElement>>;
72
+ declare const CardDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
73
+ declare const CardContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
74
+ declare const CardFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
75
+
76
+ declare const Checkbox: React$1.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
77
+
78
+ declare const Dialog: React$1.FC<DialogPrimitive.DialogProps>;
79
+ declare const DialogTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
80
+ declare const DialogPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
81
+ declare const DialogClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
82
+ declare const DialogOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
83
+ declare const DialogContent: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
84
+ declare const DialogHeader: {
85
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
86
+ displayName: string;
87
+ };
88
+ declare const DialogFooter: {
89
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
90
+ displayName: string;
91
+ };
92
+ declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
93
+ declare const DialogDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
94
+
95
+ interface InputProps extends React$1.InputHTMLAttributes<HTMLInputElement> {
96
+ }
97
+ declare const Input: React$1.ForwardRefExoticComponent<InputProps & React$1.RefAttributes<HTMLInputElement>>;
98
+
99
+ declare const Label: React$1.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React$1.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: class_variance_authority_types.ClassProp | undefined) => string> & React$1.RefAttributes<HTMLLabelElement>>;
100
+
101
+ declare const Separator: React$1.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
102
+
103
+ declare const Switch: React$1.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
104
+
105
+ interface TextareaProps extends React$1.TextareaHTMLAttributes<HTMLTextAreaElement> {
106
+ }
107
+ declare const Textarea: React$1.ForwardRefExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>;
108
+
109
+ declare const skeletonVariants: (props?: ({
110
+ variant?: "pulse" | "wave" | "shimmer" | "static" | null | undefined;
111
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
112
+ interface SkeletonProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof skeletonVariants> {
113
+ }
114
+ declare const Skeleton: React$1.ForwardRefExoticComponent<SkeletonProps & React$1.RefAttributes<HTMLDivElement>>;
115
+
116
+ declare const Avatar: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
117
+ declare const AvatarImage: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React$1.RefAttributes<HTMLImageElement>, "ref"> & React$1.RefAttributes<HTMLImageElement>>;
118
+ declare const AvatarFallback: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
119
+
120
+ declare const TooltipProvider: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
121
+ declare const Tooltip: React$1.FC<TooltipPrimitive.TooltipProps>;
122
+ declare const TooltipTrigger: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
123
+ declare const TooltipContent: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
124
+
125
+ declare const Select: React$1.FC<SelectPrimitive.SelectProps>;
126
+ declare const SelectGroup: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React$1.RefAttributes<HTMLDivElement>>;
127
+ declare const SelectValue: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React$1.RefAttributes<HTMLSpanElement>>;
128
+ declare const SelectTrigger: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
129
+ declare const SelectScrollUpButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
130
+ declare const SelectScrollDownButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
131
+ declare const SelectContent: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
132
+ declare const SelectLabel: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
133
+ declare const SelectItem: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
134
+ declare const SelectSeparator: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
135
+
136
+ declare const DropdownMenu: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
137
+ declare const DropdownMenuTrigger: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
138
+ declare const DropdownMenuGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
139
+ declare const DropdownMenuPortal: React$1.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
140
+ declare const DropdownMenuSub: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
141
+ declare const DropdownMenuRadioGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
142
+ declare const DropdownMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
143
+ inset?: boolean;
144
+ } & React$1.RefAttributes<HTMLDivElement>>;
145
+ declare const DropdownMenuSubContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
146
+ declare const DropdownMenuContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
147
+ declare const DropdownMenuItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
148
+ inset?: boolean;
149
+ } & React$1.RefAttributes<HTMLDivElement>>;
150
+ declare const DropdownMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
151
+ declare const DropdownMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
152
+ declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
153
+ inset?: boolean;
154
+ } & React$1.RefAttributes<HTMLDivElement>>;
155
+ declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
156
+ declare const DropdownMenuShortcut: {
157
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
158
+ displayName: string;
159
+ };
160
+
161
+ declare const Popover: React$1.FC<PopoverPrimitive.PopoverProps>;
162
+ declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
163
+ declare const PopoverAnchor: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React$1.RefAttributes<HTMLDivElement>>;
164
+ declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
165
+
166
+ declare const Tabs: React$1.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>>;
167
+ declare const TabsList: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
168
+ declare const TabsTrigger: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
169
+ declare const TabsContent: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
170
+
171
+ declare const Sheet: React$1.FC<DialogPrimitive.DialogProps>;
172
+ declare const SheetTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
173
+ declare const SheetClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
174
+ declare const SheetPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
175
+ declare const SheetOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
176
+ declare const sheetVariants: (props?: ({
177
+ side?: "top" | "right" | "bottom" | "left" | null | undefined;
178
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
179
+ interface SheetContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
180
+ }
181
+ declare const SheetContent: React$1.ForwardRefExoticComponent<SheetContentProps & React$1.RefAttributes<HTMLDivElement>>;
182
+ declare const SheetHeader: {
183
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
184
+ displayName: string;
185
+ };
186
+ declare const SheetFooter: {
187
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
188
+ displayName: string;
189
+ };
190
+ declare const SheetTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
191
+ declare const SheetDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
192
+
193
+ type ToasterProps = React.ComponentProps<typeof Toaster$1>;
194
+ interface CustomToasterProps extends ToasterProps {
195
+ theme?: "light" | "dark" | "system";
196
+ }
197
+ declare const Toaster: ({ theme, ...props }: CustomToasterProps) => react_jsx_runtime.JSX.Element;
198
+
199
+ declare const ScrollArea: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
200
+ declare const ScrollBar: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
201
+
202
+ declare const ContextMenu: React$1.FC<ContextMenuPrimitive.ContextMenuProps>;
203
+ declare const ContextMenuTrigger: React$1.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React$1.RefAttributes<HTMLSpanElement>>;
204
+ declare const ContextMenuGroup: React$1.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
205
+ declare const ContextMenuPortal: React$1.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
206
+ declare const ContextMenuSub: React$1.FC<ContextMenuPrimitive.ContextMenuSubProps>;
207
+ declare const ContextMenuRadioGroup: React$1.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
208
+ declare const ContextMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
209
+ inset?: boolean;
210
+ } & React$1.RefAttributes<HTMLDivElement>>;
211
+ declare const ContextMenuSubContent: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
212
+ declare const ContextMenuContent: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
213
+ declare const ContextMenuItem: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
214
+ inset?: boolean;
215
+ } & React$1.RefAttributes<HTMLDivElement>>;
216
+ declare const ContextMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
217
+ declare const ContextMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
218
+ declare const ContextMenuLabel: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
219
+ inset?: boolean;
220
+ } & React$1.RefAttributes<HTMLDivElement>>;
221
+ declare const ContextMenuSeparator: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
222
+ declare const ContextMenuShortcut: {
223
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
224
+ displayName: string;
225
+ };
226
+
227
+ declare const RadioGroup: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
228
+ declare const RadioGroupItem: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
229
+
230
+ declare const toggleVariants: (props?: ({
231
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
232
+ size?: "sm" | "md" | "lg" | null | undefined;
233
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
234
+ declare const Toggle: React$1.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
235
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
236
+ size?: "sm" | "md" | "lg" | null | undefined;
237
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLButtonElement>>;
238
+
239
+ declare const ToggleGroup: React$1.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React$1.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React$1.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
240
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
241
+ size?: "sm" | "md" | "lg" | null | undefined;
242
+ } & class_variance_authority_types.ClassProp) | undefined) => string>) & React$1.RefAttributes<HTMLDivElement>>;
243
+ declare const ToggleGroupItem: React$1.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
244
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
245
+ size?: "sm" | "md" | "lg" | null | undefined;
246
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLButtonElement>>;
247
+
248
+ declare const Slider: React$1.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
249
+
250
+ declare const Accordion: React$1.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React$1.RefAttributes<HTMLDivElement>>;
251
+ declare const AccordionItem: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
252
+ declare const AccordionTrigger: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
253
+ declare const AccordionContent: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
254
+
255
+ declare const Collapsible: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & React$1.RefAttributes<HTMLDivElement>>;
256
+ declare const CollapsibleTrigger: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
257
+ declare const CollapsibleContent: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & React$1.RefAttributes<HTMLDivElement>>;
258
+
259
+ declare const AlertDialog: React$1.FC<AlertDialogPrimitive.AlertDialogProps>;
260
+ declare const AlertDialogTrigger: React$1.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
261
+ declare const AlertDialogPortal: React$1.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
262
+ declare const AlertDialogOverlay: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
263
+ declare const AlertDialogContent: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
264
+ declare const AlertDialogHeader: {
265
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
266
+ displayName: string;
267
+ };
268
+ declare const AlertDialogFooter: {
269
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
270
+ displayName: string;
271
+ };
272
+ declare const AlertDialogTitle: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
273
+ declare const AlertDialogDescription: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
274
+ declare const AlertDialogAction: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
275
+ declare const AlertDialogCancel: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
276
+
277
+ declare const Progress: React$1.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
278
+
279
+ declare const HoverCard: React$1.FC<HoverCardPrimitive.HoverCardProps>;
280
+ declare const HoverCardTrigger: React$1.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & React$1.RefAttributes<HTMLAnchorElement>>;
281
+ declare const HoverCardContent: React$1.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
282
+
283
+ declare const Breadcrumb: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
284
+ separator?: React$1.ReactNode;
285
+ } & React$1.RefAttributes<HTMLElement>>;
286
+ declare const BreadcrumbList: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React$1.RefAttributes<HTMLOListElement>>;
287
+ declare const BreadcrumbItem: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
288
+ declare const BreadcrumbLink: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
289
+ asChild?: boolean;
290
+ } & React$1.RefAttributes<HTMLAnchorElement>>;
291
+ declare const BreadcrumbPage: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
292
+ declare const BreadcrumbSeparator: {
293
+ ({ children, className, ...props }: React$1.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
294
+ displayName: string;
295
+ };
296
+ declare const BreadcrumbEllipsis: {
297
+ ({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
298
+ displayName: string;
299
+ };
300
+
301
+ declare const AspectRatio: React$1.ForwardRefExoticComponent<AspectRatioPrimitive.AspectRatioProps & React$1.RefAttributes<HTMLDivElement>>;
302
+
303
+ declare const NavigationMenu: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuProps & React$1.RefAttributes<HTMLElement>, "ref"> & React$1.RefAttributes<HTMLElement>>;
304
+ declare const NavigationMenuList: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuListProps & React$1.RefAttributes<HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
305
+ declare const NavigationMenuItem: React$1.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuItemProps & React$1.RefAttributes<HTMLLIElement>>;
306
+ declare const navigationMenuTriggerStyle: (props?: class_variance_authority_types.ClassProp | undefined) => string;
307
+ declare const NavigationMenuTrigger: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
308
+ declare const NavigationMenuContent: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
309
+ declare const NavigationMenuLink: React$1.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuLinkProps & React$1.RefAttributes<HTMLAnchorElement>>;
310
+ declare const NavigationMenuViewport: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuViewportProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
311
+ declare const NavigationMenuIndicator: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuIndicatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
312
+
313
+ declare const Drawer: {
314
+ ({ shouldScaleBackground, ...props }: React$1.ComponentProps<typeof Drawer$1.Root>): react_jsx_runtime.JSX.Element;
315
+ displayName: string;
316
+ };
317
+ declare const DrawerTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
318
+ declare const DrawerPortal: typeof vaul.Portal;
319
+ declare const DrawerClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
320
+ declare const DrawerOverlay: React$1.ForwardRefExoticComponent<Omit<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
321
+ declare const DrawerContent: React$1.ForwardRefExoticComponent<Omit<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
322
+ declare const DrawerHeader: {
323
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
324
+ displayName: string;
325
+ };
326
+ declare const DrawerFooter: {
327
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
328
+ displayName: string;
329
+ };
330
+ declare const DrawerTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
331
+ declare const DrawerDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
332
+
333
+ declare const Table: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & React$1.RefAttributes<HTMLTableElement>>;
334
+ declare const TableHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
335
+ declare const TableBody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
336
+ declare const TableFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
337
+ declare const TableRow: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
338
+ declare const TableHead: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
339
+ declare const TableCell: React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
340
+ declare const TableCaption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
341
+
342
+ declare const spinnerVariants: (props?: ({
343
+ size?: "sm" | "md" | "lg" | "xl" | null | undefined;
344
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
345
+ interface SpinnerProps extends React$1.HTMLAttributes<SVGSVGElement>, VariantProps<typeof spinnerVariants> {
346
+ }
347
+ declare const Spinner: React$1.ForwardRefExoticComponent<SpinnerProps & React$1.RefAttributes<SVGSVGElement>>;
348
+
349
+ type CalendarProps = React$1.ComponentProps<typeof DayPicker>;
350
+ declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): react_jsx_runtime.JSX.Element;
351
+ declare namespace Calendar {
352
+ var displayName: string;
353
+ }
354
+
355
+ declare const Pagination: {
356
+ ({ className, ...props }: React$1.ComponentProps<"nav">): react_jsx_runtime.JSX.Element;
357
+ displayName: string;
358
+ };
359
+ declare const PaginationContent: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
360
+ declare const PaginationItem: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
361
+ type PaginationLinkProps = {
362
+ isActive?: boolean;
363
+ } & Pick<ButtonProps, "size"> & React$1.ComponentProps<"a">;
364
+ declare const PaginationLink: {
365
+ ({ className, isActive, size, ...props }: PaginationLinkProps): react_jsx_runtime.JSX.Element;
366
+ displayName: string;
367
+ };
368
+ declare const PaginationPrevious: {
369
+ ({ className, ...props }: React$1.ComponentProps<typeof PaginationLink>): react_jsx_runtime.JSX.Element;
370
+ displayName: string;
371
+ };
372
+ declare const PaginationNext: {
373
+ ({ className, ...props }: React$1.ComponentProps<typeof PaginationLink>): react_jsx_runtime.JSX.Element;
374
+ displayName: string;
375
+ };
376
+ declare const PaginationEllipsis: {
377
+ ({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
378
+ displayName: string;
379
+ };
380
+
381
+ declare const Command: React$1.ForwardRefExoticComponent<Omit<{
382
+ children?: React$1.ReactNode;
383
+ } & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React$1.HTMLAttributes<HTMLDivElement> | "key"> & {
384
+ ref?: React$1.Ref<HTMLDivElement>;
385
+ } & {
386
+ asChild?: boolean;
387
+ }, keyof React$1.HTMLAttributes<HTMLDivElement> | "asChild" | "key"> & {
388
+ label?: string;
389
+ shouldFilter?: boolean;
390
+ filter?: (value: string, search: string, keywords?: string[]) => number;
391
+ defaultValue?: string;
392
+ value?: string;
393
+ onValueChange?: (value: string) => void;
394
+ loop?: boolean;
395
+ disablePointerSelection?: boolean;
396
+ vimBindings?: boolean;
397
+ } & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
398
+ declare const CommandDialog: ({ children, ...props }: DialogProps) => react_jsx_runtime.JSX.Element;
399
+ declare const CommandInput: React$1.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React$1.InputHTMLAttributes<HTMLInputElement>> & {
400
+ ref?: React$1.Ref<HTMLInputElement>;
401
+ } & {
402
+ asChild?: boolean;
403
+ }, "asChild" | "key" | keyof React$1.InputHTMLAttributes<HTMLInputElement>>, "onChange" | "type" | "value"> & {
404
+ value?: string;
405
+ onValueChange?: (search: string) => void;
406
+ } & React$1.RefAttributes<HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
407
+ declare const CommandList: React$1.ForwardRefExoticComponent<Omit<{
408
+ children?: React$1.ReactNode;
409
+ } & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React$1.HTMLAttributes<HTMLDivElement> | "key"> & {
410
+ ref?: React$1.Ref<HTMLDivElement>;
411
+ } & {
412
+ asChild?: boolean;
413
+ }, keyof React$1.HTMLAttributes<HTMLDivElement> | "asChild" | "key"> & {
414
+ label?: string;
415
+ } & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
416
+ declare const CommandEmpty: React$1.ForwardRefExoticComponent<Omit<{
417
+ children?: React$1.ReactNode;
418
+ } & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React$1.HTMLAttributes<HTMLDivElement> | "key"> & {
419
+ ref?: React$1.Ref<HTMLDivElement>;
420
+ } & {
421
+ asChild?: boolean;
422
+ }, keyof React$1.HTMLAttributes<HTMLDivElement> | "asChild" | "key"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
423
+ declare const CommandGroup: React$1.ForwardRefExoticComponent<Omit<{
424
+ children?: React$1.ReactNode;
425
+ } & Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React$1.HTMLAttributes<HTMLDivElement> | "key"> & {
426
+ ref?: React$1.Ref<HTMLDivElement>;
427
+ } & {
428
+ asChild?: boolean;
429
+ }, keyof React$1.HTMLAttributes<HTMLDivElement> | "asChild" | "key">, "heading" | "value"> & {
430
+ heading?: React$1.ReactNode;
431
+ value?: string;
432
+ forceMount?: boolean;
433
+ } & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
434
+ declare const CommandSeparator: React$1.ForwardRefExoticComponent<Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React$1.HTMLAttributes<HTMLDivElement> | "key"> & {
435
+ ref?: React$1.Ref<HTMLDivElement>;
436
+ } & {
437
+ asChild?: boolean;
438
+ }, keyof React$1.HTMLAttributes<HTMLDivElement> | "asChild" | "key"> & {
439
+ alwaysRender?: boolean;
440
+ } & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
441
+ declare const CommandItem: React$1.ForwardRefExoticComponent<Omit<{
442
+ children?: React$1.ReactNode;
443
+ } & Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React$1.HTMLAttributes<HTMLDivElement> | "key"> & {
444
+ ref?: React$1.Ref<HTMLDivElement>;
445
+ } & {
446
+ asChild?: boolean;
447
+ }, keyof React$1.HTMLAttributes<HTMLDivElement> | "asChild" | "key">, "onSelect" | "disabled" | "value"> & {
448
+ disabled?: boolean;
449
+ onSelect?: (value: string) => void;
450
+ value?: string;
451
+ keywords?: string[];
452
+ forceMount?: boolean;
453
+ } & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
454
+ declare const CommandShortcut: {
455
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
456
+ displayName: string;
457
+ };
458
+
459
+ interface PasswordInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "type"> {
460
+ /**
461
+ * Show toggle button to reveal/hide password
462
+ * @default true
463
+ */
464
+ showToggle?: boolean;
465
+ }
466
+ declare const PasswordInput: React$1.ForwardRefExoticComponent<PasswordInputProps & React$1.RefAttributes<HTMLInputElement>>;
467
+
468
+ interface NumberInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
469
+ /**
470
+ * Show increment/decrement buttons
471
+ * @default true
472
+ */
473
+ showButtons?: boolean;
474
+ /**
475
+ * Step value for increment/decrement
476
+ * @default 1
477
+ */
478
+ step?: number;
479
+ /**
480
+ * Minimum value
481
+ */
482
+ min?: number;
483
+ /**
484
+ * Maximum value
485
+ */
486
+ max?: number;
487
+ /**
488
+ * Value of the input
489
+ */
490
+ value?: number;
491
+ /**
492
+ * Default value (uncontrolled)
493
+ */
494
+ defaultValue?: number;
495
+ /**
496
+ * Callback when value changes
497
+ */
498
+ onChange?: (value: number | undefined) => void;
499
+ }
500
+ declare const NumberInput: React$1.ForwardRefExoticComponent<NumberInputProps & React$1.RefAttributes<HTMLInputElement>>;
501
+
502
+ interface MultiSelectOption {
503
+ value: string;
504
+ label: string;
505
+ disabled?: boolean;
506
+ }
507
+ interface MultiSelectProps {
508
+ /**
509
+ * Available options
510
+ */
511
+ options: MultiSelectOption[];
512
+ /**
513
+ * Selected values
514
+ */
515
+ value?: string[];
516
+ /**
517
+ * Default selected values (uncontrolled)
518
+ */
519
+ defaultValue?: string[];
520
+ /**
521
+ * Callback when selection changes
522
+ */
523
+ onValueChange?: (value: string[]) => void;
524
+ /**
525
+ * Placeholder text when no selection
526
+ */
527
+ placeholder?: string;
528
+ /**
529
+ * Search placeholder
530
+ */
531
+ searchPlaceholder?: string;
532
+ /**
533
+ * Empty state text
534
+ */
535
+ emptyText?: string;
536
+ /**
537
+ * Maximum number of items that can be selected
538
+ */
539
+ maxItems?: number;
540
+ /**
541
+ * Show selected count badge instead of all tags
542
+ */
543
+ showCount?: boolean;
544
+ /**
545
+ * Disabled state
546
+ */
547
+ disabled?: boolean;
548
+ /**
549
+ * Additional class name
550
+ */
551
+ className?: string;
552
+ }
553
+ declare const MultiSelect: React$1.ForwardRefExoticComponent<MultiSelectProps & React$1.RefAttributes<HTMLButtonElement>>;
554
+
555
+ interface ComboboxOption {
556
+ value: string;
557
+ label: string;
558
+ disabled?: boolean;
559
+ }
560
+ interface ComboboxProps {
561
+ /**
562
+ * Available options
563
+ */
564
+ options: ComboboxOption[];
565
+ /**
566
+ * Selected value
567
+ */
568
+ value?: string;
569
+ /**
570
+ * Default selected value (uncontrolled)
571
+ */
572
+ defaultValue?: string;
573
+ /**
574
+ * Callback when selection changes
575
+ */
576
+ onValueChange?: (value: string) => void;
577
+ /**
578
+ * Placeholder text when no selection
579
+ */
580
+ placeholder?: string;
581
+ /**
582
+ * Search placeholder
583
+ */
584
+ searchPlaceholder?: string;
585
+ /**
586
+ * Empty state text
587
+ */
588
+ emptyText?: string;
589
+ /**
590
+ * Disabled state
591
+ */
592
+ disabled?: boolean;
593
+ /**
594
+ * Allow clearing the selection
595
+ */
596
+ clearable?: boolean;
597
+ /**
598
+ * Additional class name
599
+ */
600
+ className?: string;
601
+ }
602
+ declare const Combobox: React$1.ForwardRefExoticComponent<ComboboxProps & React$1.RefAttributes<HTMLButtonElement>>;
603
+
604
+ interface DatePickerProps {
605
+ /**
606
+ * Selected date
607
+ */
608
+ value?: Date;
609
+ /**
610
+ * Default date (uncontrolled)
611
+ */
612
+ defaultValue?: Date;
613
+ /**
614
+ * Callback when date changes
615
+ */
616
+ onValueChange?: (date: Date | undefined) => void;
617
+ /**
618
+ * Placeholder text
619
+ */
620
+ placeholder?: string;
621
+ /**
622
+ * Date format string (date-fns format)
623
+ * @default "PPP"
624
+ */
625
+ dateFormat?: string;
626
+ /**
627
+ * Disabled state
628
+ */
629
+ disabled?: boolean;
630
+ /**
631
+ * Minimum selectable date
632
+ */
633
+ minDate?: Date;
634
+ /**
635
+ * Maximum selectable date
636
+ */
637
+ maxDate?: Date;
638
+ /**
639
+ * Additional class name
640
+ */
641
+ className?: string;
642
+ }
643
+ declare const DatePicker: React$1.ForwardRefExoticComponent<DatePickerProps & React$1.RefAttributes<HTMLButtonElement>>;
644
+
645
+ declare const avatarGroupVariants: (props?: ({
646
+ size?: "sm" | "md" | "lg" | null | undefined;
647
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
648
+ interface AvatarGroupItem {
649
+ src?: string;
650
+ alt?: string;
651
+ fallback?: string;
652
+ }
653
+ interface AvatarGroupProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof avatarGroupVariants> {
654
+ /**
655
+ * Array of avatar items
656
+ */
657
+ items: AvatarGroupItem[];
658
+ /**
659
+ * Maximum number of avatars to display
660
+ * @default 5
661
+ */
662
+ max?: number;
663
+ /**
664
+ * Show tooltips on hover
665
+ * @default false
666
+ */
667
+ showTooltips?: boolean;
668
+ }
669
+ declare const AvatarGroup: React$1.ForwardRefExoticComponent<AvatarGroupProps & React$1.RefAttributes<HTMLDivElement>>;
670
+
671
+ declare const ratingVariants: (props?: ({
672
+ size?: "sm" | "md" | "lg" | null | undefined;
673
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
674
+ interface RatingProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof ratingVariants> {
675
+ /**
676
+ * Current rating value
677
+ */
678
+ value?: number;
679
+ /**
680
+ * Default rating value (uncontrolled)
681
+ */
682
+ defaultValue?: number;
683
+ /**
684
+ * Callback when rating changes
685
+ */
686
+ onValueChange?: (value: number) => void;
687
+ /**
688
+ * Maximum rating value
689
+ * @default 5
690
+ */
691
+ max?: number;
692
+ /**
693
+ * Icon type
694
+ * @default "star"
695
+ */
696
+ icon?: "star" | "heart";
697
+ /**
698
+ * Allow half ratings
699
+ * @default false
700
+ */
701
+ allowHalf?: boolean;
702
+ /**
703
+ * Read only mode
704
+ * @default false
705
+ */
706
+ readOnly?: boolean;
707
+ /**
708
+ * Disabled state
709
+ */
710
+ disabled?: boolean;
711
+ /**
712
+ * Color for filled icons
713
+ */
714
+ filledColor?: string;
715
+ /**
716
+ * Color for empty icons
717
+ */
718
+ emptyColor?: string;
719
+ }
720
+ declare const Rating: React$1.ForwardRefExoticComponent<RatingProps & React$1.RefAttributes<HTMLDivElement>>;
721
+
722
+ type SidebarContext = {
723
+ state: "expanded" | "collapsed";
724
+ open: boolean;
725
+ setOpen: (open: boolean) => void;
726
+ openMobile: boolean;
727
+ setOpenMobile: (open: boolean) => void;
728
+ isMobile: boolean;
729
+ toggleSidebar: () => void;
730
+ };
731
+ declare const SidebarContext: React$1.Context<SidebarContext | null>;
732
+ declare function useSidebar(): SidebarContext;
733
+ declare const SidebarProvider: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
734
+ defaultOpen?: boolean;
735
+ open?: boolean;
736
+ onOpenChange?: (open: boolean) => void;
737
+ }, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
738
+ declare const Sidebar: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
739
+ side?: "left" | "right";
740
+ variant?: "sidebar" | "floating" | "inset";
741
+ collapsible?: "offcanvas" | "icon" | "none";
742
+ }, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
743
+ declare const SidebarTrigger: React$1.ForwardRefExoticComponent<Omit<ButtonProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
744
+ declare const SidebarRail: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
745
+ declare const SidebarInset: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
746
+ declare const SidebarHeader: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
747
+ declare const SidebarFooter: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
748
+ declare const SidebarSeparator: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
749
+ declare const SidebarContent: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
750
+ declare const SidebarGroup: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
751
+ declare const SidebarGroupLabel: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
752
+ asChild?: boolean;
753
+ }, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
754
+ declare const SidebarGroupAction: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLButtonElement> & React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
755
+ asChild?: boolean;
756
+ }, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
757
+ declare const SidebarGroupContent: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
758
+ declare const SidebarMenu: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
759
+ declare const SidebarMenuItem: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
760
+ declare const sidebarMenuButtonVariants: (props?: ({
761
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
762
+ size?: "sm" | "md" | "lg" | null | undefined;
763
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
764
+ declare const SidebarMenuButton: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLButtonElement> & React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
765
+ asChild?: boolean;
766
+ isActive?: boolean;
767
+ tooltip?: string | React$1.ComponentProps<typeof TooltipContent>;
768
+ } & VariantProps<(props?: ({
769
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
770
+ size?: "sm" | "md" | "lg" | null | undefined;
771
+ } & class_variance_authority_types.ClassProp) | undefined) => string>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
772
+ declare const SidebarMenuAction: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLButtonElement> & React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
773
+ asChild?: boolean;
774
+ showOnHover?: boolean;
775
+ }, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
776
+ declare const SidebarMenuBadge: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
777
+ declare const SidebarMenuSkeleton: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
778
+ showIcon?: boolean;
779
+ }, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
780
+ declare const SidebarMenuSub: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
781
+ declare const SidebarMenuSubItem: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
782
+ declare const SidebarMenuSubButton: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLAnchorElement> & React$1.AnchorHTMLAttributes<HTMLAnchorElement> & {
783
+ asChild?: boolean;
784
+ size?: "sm" | "md";
785
+ isActive?: boolean;
786
+ }, "ref"> & React$1.RefAttributes<HTMLAnchorElement>>;
787
+
788
+ declare const chipVariants: (props?: ({
789
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
790
+ color?: "primary" | "secondary" | "success" | "warning" | "danger" | "info" | null | undefined;
791
+ size?: "sm" | "md" | "lg" | null | undefined;
792
+ clickable?: boolean | null | undefined;
793
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
794
+ interface ChipProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "color">, VariantProps<typeof chipVariants> {
795
+ /** Content to display at the start of the chip */
796
+ startContent?: React$1.ReactNode;
797
+ /** Content to display at the end of the chip (before close button) */
798
+ endContent?: React$1.ReactNode;
799
+ /** If true, shows a close button */
800
+ closable?: boolean;
801
+ /** Callback when close button is clicked */
802
+ onClose?: () => void;
803
+ /** If true, the chip is disabled */
804
+ disabled?: boolean;
805
+ /** Avatar element to display */
806
+ avatar?: React$1.ReactNode;
807
+ }
808
+ declare const Chip: React$1.ForwardRefExoticComponent<ChipProps & React$1.RefAttributes<HTMLDivElement>>;
809
+
810
+ interface ResizablePanelGroupProps extends Omit<GroupProps, "orientation"> {
811
+ direction?: "horizontal" | "vertical";
812
+ }
813
+ declare const ResizablePanelGroup: ({ className, direction, ...props }: ResizablePanelGroupProps) => react_jsx_runtime.JSX.Element;
814
+ declare const ResizablePanel: typeof Panel;
815
+ interface ResizableHandleProps extends SeparatorProps {
816
+ withHandle?: boolean;
817
+ }
818
+ declare const ResizableHandle: ({ withHandle, className, ...props }: ResizableHandleProps) => react_jsx_runtime.JSX.Element;
819
+
820
+ declare const dotsVariants: (props?: ({
821
+ size?: "sm" | "md" | "lg" | "xl" | null | undefined;
822
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
823
+ interface DotsProps extends React$1.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof dotsVariants> {
824
+ /** Number of dots to display */
825
+ count?: 3 | 4 | 5;
826
+ }
827
+ declare const Dots: React$1.ForwardRefExoticComponent<DotsProps & React$1.RefAttributes<HTMLSpanElement>>;
828
+
829
+ declare const circularProgressVariants: (props?: ({
830
+ size?: "sm" | "md" | "lg" | "xl" | null | undefined;
831
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
832
+ interface CircularProgressProps extends React$1.SVGAttributes<SVGSVGElement>, VariantProps<typeof circularProgressVariants> {
833
+ /** Progress value (0-100). If undefined, shows indeterminate spinner */
834
+ value?: number;
835
+ /** Stroke width of the progress circle */
836
+ strokeWidth?: number;
837
+ /** Whether to show the value label in the center */
838
+ showValue?: boolean;
839
+ /** Custom label to show instead of percentage */
840
+ label?: string;
841
+ }
842
+ declare const CircularProgress: React$1.ForwardRefExoticComponent<CircularProgressProps & React$1.RefAttributes<SVGSVGElement>>;
843
+
844
+ declare const inputOTPVariants: (props?: ({
845
+ size?: "sm" | "md" | "lg" | null | undefined;
846
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
847
+ interface InputOTPProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "onChange">, VariantProps<typeof inputOTPVariants> {
848
+ /** Maximum number of characters */
849
+ maxLength: number;
850
+ /** Current value */
851
+ value?: string;
852
+ /** Default value */
853
+ defaultValue?: string;
854
+ /** Callback when value changes */
855
+ onChange?: (value: string) => void;
856
+ /** Callback when OTP is complete */
857
+ onComplete?: (value: string) => void;
858
+ /** Pattern for validation (regex string) */
859
+ pattern?: string;
860
+ /** Container class name */
861
+ containerClassName?: string;
862
+ }
863
+ declare const InputOTP: React$1.ForwardRefExoticComponent<InputOTPProps & React$1.RefAttributes<HTMLInputElement>>;
864
+ declare const InputOTPGroup: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
865
+ interface InputOTPSlotProps extends React$1.HTMLAttributes<HTMLDivElement> {
866
+ /** Index of this slot */
867
+ index: number;
868
+ }
869
+ declare const InputOTPSlot: React$1.ForwardRefExoticComponent<InputOTPSlotProps & React$1.RefAttributes<HTMLDivElement>>;
870
+ declare const InputOTPSeparator: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
871
+
872
+ declare const tagVariants: (props?: ({
873
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
874
+ size?: "sm" | "md" | "lg" | null | undefined;
875
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
876
+ interface Tag {
877
+ id: string;
878
+ text: string;
879
+ }
880
+ interface TagInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "onChange" | "value">, VariantProps<typeof tagVariants> {
881
+ /** Current tags */
882
+ value?: Tag[];
883
+ /** Callback when tags change */
884
+ onChange?: (tags: Tag[]) => void;
885
+ /** Placeholder text */
886
+ placeholder?: string;
887
+ /** Maximum number of tags allowed */
888
+ maxTags?: number;
889
+ /** Minimum length for a tag */
890
+ minTagLength?: number;
891
+ /** Maximum length for a tag */
892
+ maxTagLength?: number;
893
+ /** Keys that trigger tag creation */
894
+ triggerKeys?: string[];
895
+ /** Whether to allow duplicate tags */
896
+ allowDuplicates?: boolean;
897
+ /** Whether the input is disabled */
898
+ disabled?: boolean;
899
+ /** Whether the input is read-only */
900
+ readOnly?: boolean;
901
+ /** Custom tag renderer */
902
+ renderTag?: (tag: Tag, onRemove: () => void) => React$1.ReactNode;
903
+ }
904
+ declare const TagInput: React$1.ForwardRefExoticComponent<TagInputProps & React$1.RefAttributes<HTMLInputElement>>;
905
+
906
+ declare const emptyStateVariants: (props?: ({
907
+ size?: "sm" | "md" | "lg" | null | undefined;
908
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
909
+ interface EmptyStateProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof emptyStateVariants> {
910
+ /** Icon to display */
911
+ icon?: React$1.ReactNode;
912
+ /** Title text */
913
+ title?: string;
914
+ /** Description text */
915
+ description?: string;
916
+ /** Action button or link */
917
+ action?: React$1.ReactNode;
918
+ }
919
+ declare const EmptyState: React$1.ForwardRefExoticComponent<EmptyStateProps & React$1.RefAttributes<HTMLDivElement>>;
920
+
921
+ declare const statCardVariants: (props?: ({
922
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
923
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
924
+ interface StatCardProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof statCardVariants> {
925
+ /** Label/title for the stat */
926
+ label: string;
927
+ /** The main value to display */
928
+ value: string | number;
929
+ /** Optional icon */
930
+ icon?: React$1.ReactNode;
931
+ /** Trend direction */
932
+ trend?: "up" | "down" | "neutral";
933
+ /** Trend value (e.g., "+12%" or "-5%") */
934
+ trendValue?: string;
935
+ /** Description text below the value */
936
+ description?: string;
937
+ }
938
+ declare const StatCard: React$1.ForwardRefExoticComponent<StatCardProps & React$1.RefAttributes<HTMLDivElement>>;
939
+
940
+ declare const listVariants: (props?: ({
941
+ variant?: "default" | "bordered" | "striped" | null | undefined;
942
+ size?: "sm" | "md" | "lg" | null | undefined;
943
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
944
+ interface ListProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof listVariants> {
945
+ }
946
+ declare const List: React$1.ForwardRefExoticComponent<ListProps & React$1.RefAttributes<HTMLDivElement>>;
947
+ declare const listItemVariants: (props?: ({
948
+ interactive?: boolean | null | undefined;
949
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
950
+ interface ListItemProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof listItemVariants> {
951
+ /** Leading element (icon, avatar, etc.) */
952
+ leading?: React$1.ReactNode;
953
+ /** Trailing element (action, badge, etc.) */
954
+ trailing?: React$1.ReactNode;
955
+ }
956
+ declare const ListItem: React$1.ForwardRefExoticComponent<ListItemProps & React$1.RefAttributes<HTMLDivElement>>;
957
+ interface ListItemTextProps extends React$1.HTMLAttributes<HTMLDivElement> {
958
+ /** Primary text */
959
+ primary?: React$1.ReactNode;
960
+ /** Secondary/description text */
961
+ secondary?: React$1.ReactNode;
962
+ }
963
+ declare const ListItemText: React$1.ForwardRefExoticComponent<ListItemTextProps & React$1.RefAttributes<HTMLDivElement>>;
964
+
965
+ declare const timelineVariants: (props?: ({
966
+ position?: "right" | "left" | "alternate" | null | undefined;
967
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
968
+ interface TimelineProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof timelineVariants> {
969
+ }
970
+ declare const Timeline: React$1.ForwardRefExoticComponent<TimelineProps & React$1.RefAttributes<HTMLDivElement>>;
971
+ declare const timelineItemVariants: (props?: ({
972
+ variant?: "error" | "default" | "success" | "warning" | "info" | null | undefined;
973
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
974
+ interface TimelineItemProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof timelineItemVariants> {
975
+ }
976
+ declare const TimelineItem: React$1.ForwardRefExoticComponent<TimelineItemProps & React$1.RefAttributes<HTMLDivElement>>;
977
+ interface TimelineSeparatorProps extends React$1.HTMLAttributes<HTMLDivElement> {
978
+ /** Custom dot content (icon, etc.) */
979
+ dot?: React$1.ReactNode;
980
+ /** Whether to show the connector line */
981
+ showConnector?: boolean;
982
+ }
983
+ declare const TimelineSeparator: React$1.ForwardRefExoticComponent<TimelineSeparatorProps & React$1.RefAttributes<HTMLDivElement>>;
984
+ interface TimelineContentProps extends React$1.HTMLAttributes<HTMLDivElement> {
985
+ }
986
+ declare const TimelineContent: React$1.ForwardRefExoticComponent<TimelineContentProps & React$1.RefAttributes<HTMLDivElement>>;
987
+ interface TimelineOppositeProps extends React$1.HTMLAttributes<HTMLDivElement> {
988
+ }
989
+ declare const TimelineOpposite: React$1.ForwardRefExoticComponent<TimelineOppositeProps & React$1.RefAttributes<HTMLDivElement>>;
990
+
991
+ declare const segmentedControlVariants: (props?: ({
992
+ size?: "sm" | "md" | "lg" | null | undefined;
993
+ fullWidth?: boolean | null | undefined;
994
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
995
+ declare const segmentedControlItemVariants: (props?: ({
996
+ size?: "sm" | "md" | "lg" | null | undefined;
997
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
998
+ interface SegmentedControlProps extends Omit<React$1.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Root>, "type" | "rovingFocus" | "value" | "defaultValue" | "onValueChange">, VariantProps<typeof segmentedControlVariants> {
999
+ /** Currently selected value */
1000
+ value?: string;
1001
+ /** Default selected value */
1002
+ defaultValue?: string;
1003
+ /** Callback when selection changes */
1004
+ onValueChange?: (value: string) => void;
1005
+ }
1006
+ declare const SegmentedControl: React$1.ForwardRefExoticComponent<SegmentedControlProps & React$1.RefAttributes<HTMLDivElement>>;
1007
+ interface SegmentedControlItemProps extends React$1.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Item>, Omit<VariantProps<typeof segmentedControlItemVariants>, "size"> {
1008
+ }
1009
+ declare const SegmentedControlItem: React$1.ForwardRefExoticComponent<SegmentedControlItemProps & React$1.RefAttributes<HTMLButtonElement>>;
1010
+
1011
+ declare const fileUploadVariants: (props?: ({
1012
+ variant?: "error" | "default" | "active" | null | undefined;
1013
+ size?: "sm" | "md" | "lg" | null | undefined;
1014
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1015
+ interface UploadedFile {
1016
+ file: File;
1017
+ id: string;
1018
+ progress?: number;
1019
+ error?: string;
1020
+ }
1021
+ interface FileRejection {
1022
+ file: File;
1023
+ errors: {
1024
+ code: string;
1025
+ message: string;
1026
+ }[];
1027
+ }
1028
+ interface FileUploadProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onDrop">, VariantProps<typeof fileUploadVariants> {
1029
+ /** Callback when files are dropped */
1030
+ onFilesChange?: (files: File[]) => void;
1031
+ /** Callback when file is rejected */
1032
+ onFilesRejected?: (rejections: FileRejection[]) => void;
1033
+ /** Callback when file is removed */
1034
+ onFileRemove?: (file: File) => void;
1035
+ /** Current uploaded files */
1036
+ files?: UploadedFile[];
1037
+ /** Whether to show file list */
1038
+ showFileList?: boolean;
1039
+ /** Custom dropzone content */
1040
+ children?: React$1.ReactNode;
1041
+ /** Max file size in bytes */
1042
+ maxSize?: number;
1043
+ /** Accepted file types (MIME types) */
1044
+ accept?: string[];
1045
+ /** Whether multiple files allowed */
1046
+ multiple?: boolean;
1047
+ /** Whether the upload is disabled */
1048
+ disabled?: boolean;
1049
+ }
1050
+ declare const getFileIcon: (file: File) => React$1.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & React$1.RefAttributes<SVGSVGElement>>;
1051
+ declare const formatFileSize: (bytes: number) => string;
1052
+ declare const validateFile: (file: File, maxSize?: number, accept?: string[]) => {
1053
+ code: string;
1054
+ message: string;
1055
+ }[];
1056
+ declare const FileUpload: React$1.ForwardRefExoticComponent<FileUploadProps & React$1.RefAttributes<HTMLDivElement>>;
1057
+
1058
+ interface ColorPickerProps {
1059
+ /** Current color value (hex format) */
1060
+ value?: string;
1061
+ /** Default color value */
1062
+ defaultValue?: string;
1063
+ /** Callback when color changes */
1064
+ onChange?: (color: string) => void;
1065
+ /** Whether the picker is disabled */
1066
+ disabled?: boolean;
1067
+ /** Preset colors to show */
1068
+ presets?: string[];
1069
+ /** Whether to show the input field */
1070
+ showInput?: boolean;
1071
+ /** Size of the color swatch button */
1072
+ size?: "sm" | "md" | "lg";
1073
+ /** Additional class name */
1074
+ className?: string;
1075
+ }
1076
+ declare const ColorPicker: React$1.ForwardRefExoticComponent<ColorPickerProps & React$1.RefAttributes<HTMLButtonElement>>;
1077
+
1078
+ declare const timeInputVariants: (props?: ({
1079
+ size?: "sm" | "md" | "lg" | null | undefined;
1080
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1081
+ interface TimeInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "onChange">, VariantProps<typeof timeInputVariants> {
1082
+ /** Current time value (HH:mm format) */
1083
+ value?: string;
1084
+ /** Callback when time changes */
1085
+ onChange?: (time: string) => void;
1086
+ /** Whether to show 24-hour format */
1087
+ use24Hour?: boolean;
1088
+ /** Minute step interval */
1089
+ minuteStep?: number;
1090
+ /** Whether to show picker button */
1091
+ showPicker?: boolean;
1092
+ /** Minimum time (HH:mm format) */
1093
+ minTime?: string;
1094
+ /** Maximum time (HH:mm format) */
1095
+ maxTime?: string;
1096
+ }
1097
+ declare const TimeInput: React$1.ForwardRefExoticComponent<TimeInputProps & React$1.RefAttributes<HTMLInputElement>>;
1098
+
1099
+ declare const currencyInputVariants: (props?: ({
1100
+ size?: "sm" | "md" | "lg" | null | undefined;
1101
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1102
+ interface CurrencyInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "onChange">, VariantProps<typeof currencyInputVariants> {
1103
+ /** Current numeric value */
1104
+ value?: number;
1105
+ /** Default numeric value */
1106
+ defaultValue?: number;
1107
+ /** Callback when value changes */
1108
+ onChange?: (value: number | undefined) => void;
1109
+ /** Currency code (e.g., "USD", "EUR", "TRY") */
1110
+ currency?: string;
1111
+ /** Locale for formatting (e.g., "en-US", "tr-TR") */
1112
+ locale?: string;
1113
+ /** Number of decimal places */
1114
+ decimals?: number;
1115
+ /** Minimum value */
1116
+ min?: number;
1117
+ /** Maximum value */
1118
+ max?: number;
1119
+ /** Whether to show currency symbol */
1120
+ showCurrency?: boolean;
1121
+ /** Position of currency symbol */
1122
+ currencyPosition?: "prefix" | "suffix";
1123
+ /** Custom currency symbol */
1124
+ currencySymbol?: string;
1125
+ /** Thousand separator */
1126
+ thousandSeparator?: string;
1127
+ /** Decimal separator */
1128
+ decimalSeparator?: string;
1129
+ }
1130
+ declare const formatCurrency: (value: number, decimals: number, thousandSeparator: string, decimalSeparator: string) => string;
1131
+ declare const parseFormattedValue: (value: string, thousandSeparator: string, decimalSeparator: string) => number | undefined;
1132
+ declare const CurrencyInput: React$1.ForwardRefExoticComponent<CurrencyInputProps & React$1.RefAttributes<HTMLInputElement>>;
1133
+
1134
+ declare const maskedInputVariants: (props?: ({
1135
+ size?: "sm" | "md" | "lg" | null | undefined;
1136
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1137
+ type MaskChar = "#" | "A" | "*";
1138
+ interface MaskDefinition {
1139
+ /** Mask pattern: # = digit, A = letter, * = alphanumeric */
1140
+ mask: string;
1141
+ /** Placeholder character to show for empty positions */
1142
+ placeholder?: string;
1143
+ }
1144
+ declare const MASK_PRESETS: {
1145
+ readonly creditCard: {
1146
+ readonly mask: "#### #### #### ####";
1147
+ };
1148
+ readonly creditCardAmex: {
1149
+ readonly mask: "#### ###### #####";
1150
+ };
1151
+ readonly cvv: {
1152
+ readonly mask: "###";
1153
+ };
1154
+ readonly expiry: {
1155
+ readonly mask: "##/##";
1156
+ };
1157
+ readonly date: {
1158
+ readonly mask: "##/##/####";
1159
+ };
1160
+ readonly dateISO: {
1161
+ readonly mask: "####-##-##";
1162
+ };
1163
+ readonly time: {
1164
+ readonly mask: "##:##";
1165
+ };
1166
+ readonly ip: {
1167
+ readonly mask: "###.###.###.###";
1168
+ };
1169
+ readonly mac: {
1170
+ readonly mask: "AA:AA:AA:AA:AA:AA";
1171
+ };
1172
+ readonly id11: {
1173
+ readonly mask: "###########";
1174
+ };
1175
+ readonly id9: {
1176
+ readonly mask: "#########";
1177
+ };
1178
+ readonly id10: {
1179
+ readonly mask: "##########";
1180
+ };
1181
+ readonly postal5: {
1182
+ readonly mask: "#####";
1183
+ };
1184
+ readonly postal9: {
1185
+ readonly mask: "#####-####";
1186
+ };
1187
+ };
1188
+ type MaskPreset = keyof typeof MASK_PRESETS;
1189
+ interface MaskedInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "onChange">, VariantProps<typeof maskedInputVariants> {
1190
+ /** Current masked value */
1191
+ value?: string;
1192
+ /** Default value */
1193
+ defaultValue?: string;
1194
+ /** Callback when value changes (returns unmasked value) */
1195
+ onChange?: (value: string, maskedValue: string) => void;
1196
+ /** Mask pattern or preset name */
1197
+ mask: string | MaskPreset;
1198
+ /** Placeholder character for unfilled positions */
1199
+ maskPlaceholder?: string;
1200
+ /** Whether to show mask placeholder when empty */
1201
+ showMaskPlaceholder?: boolean;
1202
+ /** Whether to include mask characters in the value */
1203
+ includeMaskChars?: boolean;
1204
+ }
1205
+ declare const applyMask: (rawValue: string, mask: string, includeMaskChars: boolean) => string;
1206
+ declare const unmask: (maskedValue: string, mask: string) => string;
1207
+ declare const getMaskPlaceholder: (mask: string, placeholder: string) => string;
1208
+ declare const MaskedInput: React$1.ForwardRefExoticComponent<MaskedInputProps & React$1.RefAttributes<HTMLInputElement>>;
1209
+
1210
+ declare const dateInputVariants: (props?: ({
1211
+ size?: "sm" | "md" | "lg" | null | undefined;
1212
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1213
+ type DateFormat = "DD/MM/YYYY" | "MM/DD/YYYY" | "YYYY-MM-DD" | "DD.MM.YYYY";
1214
+ interface DateInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "onChange" | "defaultValue">, VariantProps<typeof dateInputVariants> {
1215
+ /** Current date value */
1216
+ value?: Date | null;
1217
+ /** Default date value */
1218
+ defaultValue?: Date;
1219
+ /** Callback when date changes */
1220
+ onChange?: (date: Date | null) => void;
1221
+ /** Date format */
1222
+ format?: DateFormat;
1223
+ /** Minimum date */
1224
+ minDate?: Date;
1225
+ /** Maximum date */
1226
+ maxDate?: Date;
1227
+ /** Whether to show calendar icon */
1228
+ showIcon?: boolean;
1229
+ }
1230
+ declare const formatDate: (date: Date, format: DateFormat) => string;
1231
+ declare const parseDate: (value: string, format: DateFormat) => Date | null;
1232
+ declare const DateInput: React$1.ForwardRefExoticComponent<DateInputProps & React$1.RefAttributes<HTMLInputElement>>;
1233
+
1234
+ declare const phoneInputVariants: (props?: ({
1235
+ size?: "sm" | "md" | "lg" | null | undefined;
1236
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1237
+ interface Country {
1238
+ code: string;
1239
+ name: string;
1240
+ dialCode: string;
1241
+ flag: string;
1242
+ format: string;
1243
+ }
1244
+ declare const COUNTRIES: Country[];
1245
+ interface PhoneInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "onChange">, VariantProps<typeof phoneInputVariants> {
1246
+ /** Current phone value (just the number, without dial code) */
1247
+ value?: string;
1248
+ /** Default phone value */
1249
+ defaultValue?: string;
1250
+ /** Callback when phone changes */
1251
+ onChange?: (value: string, fullNumber: string, country: Country) => void;
1252
+ /** Selected country code (ISO 3166-1 alpha-2) */
1253
+ country?: string;
1254
+ /** Default country code */
1255
+ defaultCountry?: string;
1256
+ /** Callback when country changes */
1257
+ onCountryChange?: (country: Country) => void;
1258
+ /** Available countries (defaults to all) */
1259
+ countries?: Country[];
1260
+ /** Whether to show country selector */
1261
+ showCountrySelect?: boolean;
1262
+ /** Whether to show dial code in input */
1263
+ showDialCode?: boolean;
1264
+ }
1265
+ declare const formatPhoneNumber: (value: string, format: string) => string;
1266
+ declare const PhoneInput: React$1.ForwardRefExoticComponent<PhoneInputProps & React$1.RefAttributes<HTMLInputElement>>;
1267
+
1268
+ declare const navbarVariants: (props?: ({
1269
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
1270
+ size?: "sm" | "md" | "lg" | null | undefined;
1271
+ sticky?: boolean | null | undefined;
1272
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1273
+ interface NavbarProps extends React$1.HTMLAttributes<HTMLElement>, VariantProps<typeof navbarVariants> {
1274
+ brand?: React$1.ReactNode;
1275
+ children?: React$1.ReactNode;
1276
+ mobileBreakpoint?: "sm" | "md" | "lg";
1277
+ }
1278
+ declare const Navbar: React$1.ForwardRefExoticComponent<NavbarProps & React$1.RefAttributes<HTMLElement>>;
1279
+ declare const NavbarBrand: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
1280
+ declare const NavbarContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
1281
+ justify?: "start" | "center" | "end";
1282
+ } & React$1.RefAttributes<HTMLDivElement>>;
1283
+ declare const NavbarItem: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
1284
+ isActive?: boolean;
1285
+ } & React$1.RefAttributes<HTMLDivElement>>;
1286
+ declare const NavbarLink: React$1.ForwardRefExoticComponent<React$1.AnchorHTMLAttributes<HTMLAnchorElement> & {
1287
+ isActive?: boolean;
1288
+ } & React$1.RefAttributes<HTMLAnchorElement>>;
1289
+
1290
+ declare const linkVariants: (props?: ({
1291
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
1292
+ size?: "sm" | "md" | "lg" | null | undefined;
1293
+ underline?: "none" | "always" | "hover" | null | undefined;
1294
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1295
+ interface LinkProps extends React$1.AnchorHTMLAttributes<HTMLAnchorElement>, VariantProps<typeof linkVariants> {
1296
+ isExternal?: boolean;
1297
+ showExternalIcon?: boolean;
1298
+ isDisabled?: boolean;
1299
+ }
1300
+ declare const Link: React$1.ForwardRefExoticComponent<LinkProps & React$1.RefAttributes<HTMLAnchorElement>>;
1301
+
1302
+ declare const backTopVariants: (props?: ({
1303
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
1304
+ size?: "sm" | "md" | "lg" | null | undefined;
1305
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1306
+ interface BackTopProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof backTopVariants> {
1307
+ visibilityHeight?: number;
1308
+ smooth?: boolean;
1309
+ icon?: React$1.ReactNode;
1310
+ duration?: number;
1311
+ }
1312
+ declare const BackTop: React$1.ForwardRefExoticComponent<BackTopProps & React$1.RefAttributes<HTMLButtonElement>>;
1313
+
1314
+ declare const MenubarMenu: typeof MenubarPrimitive.Menu;
1315
+ declare const MenubarGroup: typeof MenubarPrimitive.Group;
1316
+ declare const MenubarPortal: typeof MenubarPrimitive.Portal;
1317
+ declare const MenubarSub: typeof MenubarPrimitive.Sub;
1318
+ declare const MenubarRadioGroup: typeof MenubarPrimitive.RadioGroup;
1319
+ declare const Menubar: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
1320
+ declare const MenubarTrigger: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
1321
+ declare const MenubarSubTrigger: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
1322
+ inset?: boolean;
1323
+ } & React$1.RefAttributes<HTMLDivElement>>;
1324
+ declare const MenubarSubContent: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
1325
+ declare const MenubarContent: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
1326
+ declare const MenubarItem: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
1327
+ inset?: boolean;
1328
+ } & React$1.RefAttributes<HTMLDivElement>>;
1329
+ declare const MenubarCheckboxItem: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
1330
+ declare const MenubarRadioItem: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
1331
+ declare const MenubarLabel: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
1332
+ inset?: boolean;
1333
+ } & React$1.RefAttributes<HTMLDivElement>>;
1334
+ declare const MenubarSeparator: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
1335
+ declare const MenubarShortcut: {
1336
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
1337
+ displayName: string;
1338
+ };
1339
+
1340
+ declare const stepsVariants: (props?: ({
1341
+ orientation?: "horizontal" | "vertical" | null | undefined;
1342
+ size?: "sm" | "md" | "lg" | null | undefined;
1343
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1344
+ interface StepsProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof stepsVariants> {
1345
+ currentStep?: number;
1346
+ children: React$1.ReactNode;
1347
+ }
1348
+ declare const Steps: React$1.ForwardRefExoticComponent<StepsProps & React$1.RefAttributes<HTMLDivElement>>;
1349
+ declare const stepVariants: (props?: ({
1350
+ orientation?: "horizontal" | "vertical" | null | undefined;
1351
+ size?: "sm" | "md" | "lg" | null | undefined;
1352
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1353
+ interface StepProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof stepVariants> {
1354
+ title?: string;
1355
+ description?: string;
1356
+ icon?: React$1.ReactNode;
1357
+ status?: "completed" | "current" | "upcoming";
1358
+ stepNumber?: number;
1359
+ isLast?: boolean;
1360
+ }
1361
+ declare const Step: React$1.ForwardRefExoticComponent<StepProps & React$1.RefAttributes<HTMLDivElement>>;
1362
+
1363
+ interface Column<T> {
1364
+ /** Unique column identifier */
1365
+ id: string;
1366
+ /** Column header text */
1367
+ header: string;
1368
+ /** Accessor function to get cell value */
1369
+ accessor: (row: T) => React$1.ReactNode;
1370
+ /** Whether column is sortable */
1371
+ sortable?: boolean;
1372
+ /** Column width */
1373
+ width?: string | number;
1374
+ /** Custom cell renderer */
1375
+ cell?: (row: T, index: number) => React$1.ReactNode;
1376
+ }
1377
+ type SortDirection = "asc" | "desc" | null;
1378
+ interface SortState {
1379
+ columnId: string | null;
1380
+ direction: SortDirection;
1381
+ }
1382
+ interface PaginationState {
1383
+ pageIndex: number;
1384
+ pageSize: number;
1385
+ }
1386
+ interface DataTableProps<T> extends React$1.HTMLAttributes<HTMLDivElement> {
1387
+ /** Data array */
1388
+ data: T[];
1389
+ /** Column definitions */
1390
+ columns: Column<T>[];
1391
+ /** Enable row selection */
1392
+ selectable?: boolean;
1393
+ /** Selected row keys */
1394
+ selectedKeys?: Set<string>;
1395
+ /** Callback when selection changes */
1396
+ onSelectionChange?: (keys: Set<string>) => void;
1397
+ /** Function to get unique row key */
1398
+ getRowKey?: (row: T, index: number) => string;
1399
+ /** Enable sorting */
1400
+ sortable?: boolean;
1401
+ /** Controlled sort state */
1402
+ sortState?: SortState;
1403
+ /** Callback when sort changes */
1404
+ onSortChange?: (state: SortState) => void;
1405
+ /** Enable pagination */
1406
+ paginated?: boolean;
1407
+ /** Page size options */
1408
+ pageSizeOptions?: number[];
1409
+ /** Controlled pagination state */
1410
+ paginationState?: PaginationState;
1411
+ /** Callback when pagination changes */
1412
+ onPaginationChange?: (state: PaginationState) => void;
1413
+ /** Empty state content */
1414
+ emptyContent?: React$1.ReactNode;
1415
+ /** Loading state */
1416
+ loading?: boolean;
1417
+ /** Striped rows */
1418
+ striped?: boolean;
1419
+ /** Hoverable rows */
1420
+ hoverable?: boolean;
1421
+ }
1422
+ declare const DataTable: <T>(props: DataTableProps<T> & {
1423
+ ref?: React$1.ForwardedRef<HTMLDivElement>;
1424
+ }) => React$1.ReactElement;
1425
+
1426
+ interface TreeNode {
1427
+ /** Unique node identifier */
1428
+ id: string;
1429
+ /** Display name */
1430
+ name: string;
1431
+ /** Child nodes */
1432
+ children?: TreeNode[];
1433
+ /** Custom icon */
1434
+ icon?: React$1.ReactNode;
1435
+ /** Whether node is disabled */
1436
+ disabled?: boolean;
1437
+ /** Additional data */
1438
+ data?: Record<string, unknown>;
1439
+ }
1440
+ declare const treeViewVariants: (props?: ({
1441
+ size?: "sm" | "md" | "lg" | null | undefined;
1442
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1443
+ interface TreeViewProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect">, VariantProps<typeof treeViewVariants> {
1444
+ /** Tree data */
1445
+ data: TreeNode[];
1446
+ /** Default expanded node IDs */
1447
+ defaultExpandedIds?: string[];
1448
+ /** Controlled expanded node IDs */
1449
+ expandedIds?: string[];
1450
+ /** Callback when expanded nodes change */
1451
+ onExpandedChange?: (ids: string[]) => void;
1452
+ /** Selected node ID */
1453
+ selectedId?: string;
1454
+ /** Callback when selection changes */
1455
+ onSelect?: (node: TreeNode) => void;
1456
+ /** Whether to show icons */
1457
+ showIcons?: boolean;
1458
+ /** Default icon for leaf nodes */
1459
+ leafIcon?: React$1.ReactNode;
1460
+ /** Default icon for collapsed folders */
1461
+ folderIcon?: React$1.ReactNode;
1462
+ /** Default icon for expanded folders */
1463
+ folderOpenIcon?: React$1.ReactNode;
1464
+ /** Whether to expand all by default */
1465
+ defaultExpandAll?: boolean;
1466
+ }
1467
+ declare const TreeView: React$1.ForwardRefExoticComponent<TreeViewProps & React$1.RefAttributes<HTMLDivElement>>;
1468
+
1469
+ declare const autocompleteInputVariants: (props?: ({
1470
+ size?: "sm" | "md" | "lg" | null | undefined;
1471
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1472
+ interface AutocompleteOption {
1473
+ value: string;
1474
+ label: string;
1475
+ disabled?: boolean;
1476
+ }
1477
+ interface AutocompleteProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "onChange" | "onSelect">, VariantProps<typeof autocompleteInputVariants> {
1478
+ /** Current input value */
1479
+ value?: string;
1480
+ /** Default value */
1481
+ defaultValue?: string;
1482
+ /** Callback when input value changes */
1483
+ onChange?: (value: string) => void;
1484
+ /** Callback when an option is selected */
1485
+ onSelect?: (option: AutocompleteOption) => void;
1486
+ /** Static options list */
1487
+ options?: AutocompleteOption[];
1488
+ /** Async function to fetch options */
1489
+ loadOptions?: (query: string) => Promise<AutocompleteOption[]>;
1490
+ /** Debounce delay for async loading (ms) */
1491
+ debounceMs?: number;
1492
+ /** Minimum characters before showing suggestions */
1493
+ minChars?: number;
1494
+ /** Placeholder text */
1495
+ placeholder?: string;
1496
+ /** Empty state text */
1497
+ emptyText?: string;
1498
+ /** Loading text */
1499
+ loadingText?: string;
1500
+ /** Whether to show clear button */
1501
+ clearable?: boolean;
1502
+ /** Whether free text is allowed (not just selections) */
1503
+ freeSolo?: boolean;
1504
+ /** Max height of dropdown */
1505
+ maxHeight?: number;
1506
+ /** Whether to highlight matching text */
1507
+ highlightMatch?: boolean;
1508
+ }
1509
+ declare const Autocomplete: React$1.ForwardRefExoticComponent<AutocompleteProps & React$1.RefAttributes<HTMLInputElement>>;
1510
+
1511
+ type ValidationRule = {
1512
+ validate: (value: unknown) => boolean;
1513
+ message: string;
1514
+ };
1515
+ type FieldState = {
1516
+ value: unknown;
1517
+ error: string | null;
1518
+ touched: boolean;
1519
+ dirty: boolean;
1520
+ };
1521
+ type FormState = {
1522
+ values: Record<string, unknown>;
1523
+ errors: Record<string, string | null>;
1524
+ touched: Record<string, boolean>;
1525
+ dirty: Record<string, boolean>;
1526
+ isSubmitting: boolean;
1527
+ isValid: boolean;
1528
+ };
1529
+ interface FormContextValue {
1530
+ values: Record<string, unknown>;
1531
+ errors: Record<string, string | null>;
1532
+ touched: Record<string, boolean>;
1533
+ dirty: Record<string, boolean>;
1534
+ isSubmitting: boolean;
1535
+ setValue: (name: string, value: unknown) => void;
1536
+ setError: (name: string, error: string | null) => void;
1537
+ setTouched: (name: string, touched: boolean) => void;
1538
+ validateField: (name: string) => boolean;
1539
+ validateAll: () => boolean;
1540
+ registerField: (name: string, rules: ValidationRule[]) => void;
1541
+ unregisterField: (name: string) => void;
1542
+ getFieldState: (name: string) => FieldState;
1543
+ reset: () => void;
1544
+ }
1545
+ interface FieldContextValue {
1546
+ name: string;
1547
+ id: string;
1548
+ value: unknown;
1549
+ error: string | null;
1550
+ touched: boolean;
1551
+ dirty: boolean;
1552
+ }
1553
+ declare const FormContext: React$1.Context<FormContextValue | null>;
1554
+ declare const FieldContext: React$1.Context<FieldContextValue | null>;
1555
+ declare const useFormContext: () => FormContextValue;
1556
+ declare const useFieldContext: () => FieldContextValue;
1557
+ declare const validators: {
1558
+ required: (message?: string) => ValidationRule;
1559
+ minLength: (min: number, message?: string) => ValidationRule;
1560
+ maxLength: (max: number, message?: string) => ValidationRule;
1561
+ min: (min: number, message?: string) => ValidationRule;
1562
+ max: (max: number, message?: string) => ValidationRule;
1563
+ email: (message?: string) => ValidationRule;
1564
+ pattern: (regex: RegExp, message?: string) => ValidationRule;
1565
+ custom: (validate: (value: unknown) => boolean, message: string) => ValidationRule;
1566
+ };
1567
+ interface FormProps extends Omit<React$1.FormHTMLAttributes<HTMLFormElement>, "onSubmit" | "onError"> {
1568
+ /** Initial form values */
1569
+ defaultValues?: Record<string, unknown>;
1570
+ /** Callback when form is submitted (only if valid) */
1571
+ onSubmit?: (values: Record<string, unknown>) => void | Promise<void>;
1572
+ /** Callback when validation fails */
1573
+ onError?: (errors: Record<string, string | null>) => void;
1574
+ /** Validate on blur */
1575
+ validateOnBlur?: boolean;
1576
+ /** Validate on change */
1577
+ validateOnChange?: boolean;
1578
+ }
1579
+ declare const Form: React$1.ForwardRefExoticComponent<FormProps & React$1.RefAttributes<HTMLFormElement>>;
1580
+ interface FormFieldProps {
1581
+ /** Field name (must be unique within form) */
1582
+ name: string;
1583
+ /** Validation rules */
1584
+ rules?: ValidationRule[];
1585
+ /** Default value for this field */
1586
+ defaultValue?: unknown;
1587
+ children: React$1.ReactNode;
1588
+ }
1589
+ declare const FormField: React$1.FC<FormFieldProps>;
1590
+ interface FormItemProps extends React$1.HTMLAttributes<HTMLDivElement> {
1591
+ }
1592
+ declare const FormItem: React$1.ForwardRefExoticComponent<FormItemProps & React$1.RefAttributes<HTMLDivElement>>;
1593
+ interface FormLabelProps extends React$1.ComponentPropsWithoutRef<typeof Label> {
1594
+ /** Show required indicator */
1595
+ required?: boolean;
1596
+ }
1597
+ declare const FormLabel: React$1.ForwardRefExoticComponent<FormLabelProps & React$1.RefAttributes<HTMLLabelElement>>;
1598
+ interface FormControlProps {
1599
+ children: React$1.ReactElement<{
1600
+ id?: string;
1601
+ name?: string;
1602
+ value?: unknown;
1603
+ onChange?: (e: React$1.ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => void;
1604
+ onBlur?: () => void;
1605
+ "aria-invalid"?: string;
1606
+ "aria-describedby"?: string;
1607
+ }>;
1608
+ }
1609
+ declare const FormControl: React$1.FC<FormControlProps>;
1610
+ interface FormDescriptionProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
1611
+ }
1612
+ declare const FormDescription: React$1.ForwardRefExoticComponent<FormDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>>;
1613
+ interface FormMessageProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
1614
+ /** Force show a specific message */
1615
+ message?: string;
1616
+ }
1617
+ declare const FormMessage: React$1.ForwardRefExoticComponent<FormMessageProps & React$1.RefAttributes<HTMLParagraphElement>>;
1618
+
1619
+ declare const userVariants: (props?: ({
1620
+ size?: "sm" | "md" | "lg" | null | undefined;
1621
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1622
+ interface UserProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof userVariants> {
1623
+ /** User's name */
1624
+ name: string;
1625
+ /** User's description/role/email */
1626
+ description?: string;
1627
+ /** Avatar image URL */
1628
+ avatarUrl?: string;
1629
+ /** Avatar fallback (initials) */
1630
+ avatarFallback?: string;
1631
+ /** Trailing element (badge, action, etc.) */
1632
+ trailing?: React$1.ReactNode;
1633
+ }
1634
+ declare const User: React$1.ForwardRefExoticComponent<UserProps & React$1.RefAttributes<HTMLDivElement>>;
1635
+
1636
+ declare const codeVariants: (props?: ({
1637
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
1638
+ size?: "sm" | "md" | "lg" | null | undefined;
1639
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1640
+ interface CodeProps extends React$1.HTMLAttributes<HTMLElement>, VariantProps<typeof codeVariants> {
1641
+ }
1642
+ declare const Code: React$1.ForwardRefExoticComponent<CodeProps & React$1.RefAttributes<HTMLElement>>;
1643
+
1644
+ declare const snippetVariants: (props?: ({
1645
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
1646
+ size?: "sm" | "md" | "lg" | null | undefined;
1647
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1648
+ interface SnippetProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof snippetVariants> {
1649
+ /** Code content to display */
1650
+ code: string;
1651
+ /** Whether to show copy button */
1652
+ copyable?: boolean;
1653
+ /** Custom copy button label */
1654
+ copyLabel?: string;
1655
+ /** Callback when code is copied */
1656
+ onCopy?: () => void;
1657
+ /** Symbol to show before code (e.g., "$", ">") */
1658
+ symbol?: string;
1659
+ /** Hide the symbol */
1660
+ hideSymbol?: boolean;
1661
+ }
1662
+ declare const Snippet: React$1.ForwardRefExoticComponent<SnippetProps & React$1.RefAttributes<HTMLDivElement>>;
1663
+
1664
+ declare const imageVariants: (props?: ({
1665
+ radius?: "none" | "sm" | "md" | "lg" | "full" | null | undefined;
1666
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1667
+ interface ImageProps extends Omit<React$1.ImgHTMLAttributes<HTMLImageElement>, "onLoad" | "onError">, VariantProps<typeof imageVariants> {
1668
+ /** Fallback content when image fails to load */
1669
+ fallback?: React$1.ReactNode;
1670
+ /** Whether to show skeleton while loading */
1671
+ showSkeleton?: boolean;
1672
+ /** Callback when image loads */
1673
+ onLoad?: () => void;
1674
+ /** Callback when image fails to load */
1675
+ onError?: () => void;
1676
+ /** Object fit style */
1677
+ fit?: "contain" | "cover" | "fill" | "none" | "scale-down";
1678
+ /** Aspect ratio */
1679
+ aspectRatio?: string;
1680
+ }
1681
+ declare const Image: React$1.ForwardRefExoticComponent<ImageProps & React$1.RefAttributes<HTMLImageElement>>;
1682
+
1683
+ declare const listboxVariants: (props?: ({
1684
+ size?: "sm" | "md" | "lg" | null | undefined;
1685
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1686
+ declare const listboxItemVariants: (props?: ({
1687
+ size?: "sm" | "md" | "lg" | null | undefined;
1688
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1689
+ interface ListboxOption {
1690
+ value: string;
1691
+ label: string;
1692
+ description?: string;
1693
+ disabled?: boolean;
1694
+ icon?: React$1.ReactNode;
1695
+ }
1696
+ interface ListboxProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof listboxVariants> {
1697
+ /** Current selected value(s) */
1698
+ value?: string | string[];
1699
+ /** Default value(s) */
1700
+ defaultValue?: string | string[];
1701
+ /** Callback when selection changes */
1702
+ onValueChange?: (value: string | string[]) => void;
1703
+ /** Allow multiple selection */
1704
+ multiple?: boolean;
1705
+ }
1706
+ declare const Listbox: React$1.ForwardRefExoticComponent<ListboxProps & React$1.RefAttributes<HTMLDivElement>>;
1707
+ interface ListboxItemProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "value"> {
1708
+ /** Item value */
1709
+ value: string;
1710
+ /** Whether item is disabled */
1711
+ disabled?: boolean;
1712
+ /** Leading icon */
1713
+ icon?: React$1.ReactNode;
1714
+ /** Description text */
1715
+ description?: string;
1716
+ }
1717
+ declare const ListboxItem: React$1.ForwardRefExoticComponent<ListboxItemProps & React$1.RefAttributes<HTMLDivElement>>;
1718
+
1719
+ declare const sortableListVariants: (props?: ({
1720
+ variant?: "default" | "bordered" | "cards" | null | undefined;
1721
+ size?: "sm" | "md" | "lg" | null | undefined;
1722
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1723
+ declare const sortableItemVariants: (props?: ({
1724
+ variant?: "default" | "bordered" | "cards" | null | undefined;
1725
+ size?: "sm" | "md" | "lg" | null | undefined;
1726
+ isDragging?: boolean | null | undefined;
1727
+ isDragOver?: boolean | null | undefined;
1728
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1729
+ interface SortableItem {
1730
+ id: string;
1731
+ [key: string]: unknown;
1732
+ }
1733
+ interface SortableListProps<T extends SortableItem> extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof sortableListVariants> {
1734
+ /** Items to render */
1735
+ items: T[];
1736
+ /** Callback when order changes */
1737
+ onReorder?: (items: T[]) => void;
1738
+ /** Render function for each item */
1739
+ renderItem: (item: T, index: number) => React$1.ReactNode;
1740
+ /** Whether to show drag handle */
1741
+ showHandle?: boolean;
1742
+ /** Whether sorting is disabled */
1743
+ disabled?: boolean;
1744
+ }
1745
+ declare const SortableList: <T extends SortableItem>(props: SortableListProps<T> & {
1746
+ ref?: React$1.ForwardedRef<HTMLDivElement>;
1747
+ }) => React$1.ReactElement;
1748
+
1749
+ declare const loadingOverlayVariants: (props?: ({
1750
+ variant?: "solid" | "ghost" | "soft" | null | undefined;
1751
+ visible?: boolean | null | undefined;
1752
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1753
+ interface LoadingOverlayProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof loadingOverlayVariants> {
1754
+ loading?: boolean;
1755
+ size?: "sm" | "md" | "lg";
1756
+ spinner?: React$1.ReactNode;
1757
+ text?: string;
1758
+ }
1759
+ declare const LoadingOverlay: React$1.ForwardRefExoticComponent<LoadingOverlayProps & React$1.RefAttributes<HTMLDivElement>>;
1760
+
1761
+ declare const nprogressVariants: (props?: ({
1762
+ color?: "primary" | "secondary" | "success" | "warning" | "danger" | "info" | null | undefined;
1763
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1764
+ interface NProgressProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "color">, VariantProps<typeof nprogressVariants> {
1765
+ isLoading?: boolean;
1766
+ progress?: number;
1767
+ showSpinner?: boolean;
1768
+ }
1769
+ declare const NProgress: React$1.ForwardRefExoticComponent<NProgressProps & React$1.RefAttributes<HTMLDivElement>>;
1770
+
1771
+ declare const loadingVariants: (props?: ({
1772
+ variant?: "pulse" | "spinner" | "dots" | "skeleton" | null | undefined;
1773
+ size?: "sm" | "md" | "lg" | null | undefined;
1774
+ fullScreen?: boolean | null | undefined;
1775
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1776
+ interface LoadingProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof loadingVariants> {
1777
+ text?: string;
1778
+ color?: "primary" | "secondary" | "muted";
1779
+ }
1780
+ declare const Loading: React$1.ForwardRefExoticComponent<LoadingProps & React$1.RefAttributes<HTMLDivElement>>;
1781
+
1782
+ interface ErrorBoundaryProps {
1783
+ children: React$1.ReactNode;
1784
+ fallback?: React$1.ReactNode;
1785
+ onError?: (error: Error, errorInfo: React$1.ErrorInfo) => void;
1786
+ onReset?: () => void;
1787
+ resetKeys?: unknown[];
1788
+ }
1789
+ interface ErrorBoundaryState {
1790
+ hasError: boolean;
1791
+ error: Error | null;
1792
+ }
1793
+ declare class ErrorBoundaryClass extends React$1.Component<ErrorBoundaryProps, ErrorBoundaryState> {
1794
+ constructor(props: ErrorBoundaryProps);
1795
+ static getDerivedStateFromError(error: Error): ErrorBoundaryState;
1796
+ componentDidCatch(error: Error, errorInfo: React$1.ErrorInfo): void;
1797
+ componentDidUpdate(prevProps: ErrorBoundaryProps): void;
1798
+ reset: () => void;
1799
+ render(): string | number | bigint | boolean | react_jsx_runtime.JSX.Element | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | null | undefined;
1800
+ }
1801
+ interface DefaultErrorFallbackProps {
1802
+ error: Error | null;
1803
+ onReset?: () => void;
1804
+ className?: string;
1805
+ }
1806
+ declare const DefaultErrorFallback: React$1.ForwardRefExoticComponent<DefaultErrorFallbackProps & React$1.RefAttributes<HTMLDivElement>>;
1807
+ declare const ErrorBoundary: typeof ErrorBoundaryClass;
1808
+
1809
+ interface DateRangePickerProps {
1810
+ /**
1811
+ * Selected date range
1812
+ */
1813
+ value?: DateRange;
1814
+ /**
1815
+ * Default date range (uncontrolled)
1816
+ */
1817
+ defaultValue?: DateRange;
1818
+ /**
1819
+ * Callback when date range changes
1820
+ */
1821
+ onValueChange?: (range: DateRange | undefined) => void;
1822
+ /**
1823
+ * Placeholder text
1824
+ */
1825
+ placeholder?: string;
1826
+ /**
1827
+ * Date format string (date-fns format)
1828
+ * @default "LLL dd, y"
1829
+ */
1830
+ dateFormat?: string;
1831
+ /**
1832
+ * Disabled state
1833
+ */
1834
+ disabled?: boolean;
1835
+ /**
1836
+ * Minimum selectable date
1837
+ */
1838
+ minDate?: Date;
1839
+ /**
1840
+ * Maximum selectable date
1841
+ */
1842
+ maxDate?: Date;
1843
+ /**
1844
+ * Number of months to display
1845
+ * @default 2
1846
+ */
1847
+ numberOfMonths?: number;
1848
+ /**
1849
+ * Additional class name
1850
+ */
1851
+ className?: string;
1852
+ /**
1853
+ * Alignment of the popover
1854
+ * @default "start"
1855
+ */
1856
+ align?: "start" | "center" | "end";
1857
+ }
1858
+ declare const DateRangePicker: React$1.ForwardRefExoticComponent<DateRangePickerProps & React$1.RefAttributes<HTMLButtonElement>>;
1859
+
1860
+ interface TimePickerProps {
1861
+ /**
1862
+ * Selected time value
1863
+ */
1864
+ value?: {
1865
+ hours: number;
1866
+ minutes: number;
1867
+ };
1868
+ /**
1869
+ * Callback when time changes
1870
+ */
1871
+ onValueChange?: (time: {
1872
+ hours: number;
1873
+ minutes: number;
1874
+ }) => void;
1875
+ /**
1876
+ * Placeholder text
1877
+ */
1878
+ placeholder?: string;
1879
+ /**
1880
+ * Whether to use 24-hour format
1881
+ * @default true
1882
+ */
1883
+ use24Hour?: boolean;
1884
+ /**
1885
+ * Minute interval (5, 10, 15, 30, etc.)
1886
+ * @default 1
1887
+ */
1888
+ minuteStep?: number;
1889
+ /**
1890
+ * Disabled state
1891
+ */
1892
+ disabled?: boolean;
1893
+ /**
1894
+ * Additional class name
1895
+ */
1896
+ className?: string;
1897
+ }
1898
+ declare const TimePicker: React$1.ForwardRefExoticComponent<TimePickerProps & React$1.RefAttributes<HTMLButtonElement>>;
1899
+
1900
+ declare const virtualListVariants: (props?: ({
1901
+ variant?: "default" | "bordered" | "cards" | null | undefined;
1902
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1903
+ interface VirtualListProps<T> extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children">, VariantProps<typeof virtualListVariants> {
1904
+ /** Array of items to render */
1905
+ items: T[];
1906
+ /** Height of each item in pixels */
1907
+ itemHeight: number;
1908
+ /** Height of the container in pixels */
1909
+ height: number;
1910
+ /** Number of items to render outside visible area (buffer) */
1911
+ overscan?: number;
1912
+ /** Render function for each item */
1913
+ renderItem: (item: T, index: number) => React$1.ReactNode;
1914
+ /** Key extractor function */
1915
+ getItemKey?: (item: T, index: number) => string | number;
1916
+ /** Gap between items in pixels */
1917
+ gap?: number;
1918
+ /** Callback when scroll position changes */
1919
+ onScrollChange?: (scrollTop: number) => void;
1920
+ }
1921
+ declare const VirtualList: <T>(props: VirtualListProps<T> & {
1922
+ ref?: React$1.ForwardedRef<HTMLDivElement>;
1923
+ }) => React$1.ReactElement;
1924
+
1925
+ declare const infiniteScrollVariants: (props?: ({
1926
+ variant?: "default" | "bordered" | null | undefined;
1927
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1928
+ declare const infiniteScrollLoaderVariants: (props?: ({
1929
+ size?: "sm" | "md" | "lg" | null | undefined;
1930
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1931
+ interface InfiniteScrollProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof infiniteScrollVariants>, VariantProps<typeof infiniteScrollLoaderVariants> {
1932
+ /** Callback when more items should be loaded */
1933
+ onLoadMore: () => void | Promise<void>;
1934
+ /** Whether there are more items to load */
1935
+ hasMore: boolean;
1936
+ /** Whether currently loading */
1937
+ isLoading?: boolean;
1938
+ /** Custom loader component */
1939
+ loader?: React$1.ReactNode;
1940
+ /** Threshold in pixels before end to trigger load (default: 100) */
1941
+ threshold?: number;
1942
+ /** Root margin for intersection observer */
1943
+ rootMargin?: string;
1944
+ /** Whether to use window scroll instead of container scroll */
1945
+ useWindow?: boolean;
1946
+ /** End of list message */
1947
+ endMessage?: React$1.ReactNode;
1948
+ }
1949
+ declare const InfiniteScroll: React$1.ForwardRefExoticComponent<InfiniteScrollProps & React$1.RefAttributes<HTMLDivElement>>;
1950
+
1951
+ declare const modalContentVariants: (props?: ({
1952
+ size?: "sm" | "md" | "lg" | "xl" | "full" | null | undefined;
1953
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1954
+ interface ModalProps extends VariantProps<typeof modalContentVariants> {
1955
+ open?: boolean;
1956
+ onOpenChange?: (open: boolean) => void;
1957
+ children?: React$1.ReactNode;
1958
+ trigger?: React$1.ReactNode;
1959
+ title?: React$1.ReactNode;
1960
+ description?: React$1.ReactNode;
1961
+ footer?: React$1.ReactNode;
1962
+ showCloseButton?: boolean;
1963
+ closeOnOverlayClick?: boolean;
1964
+ closeOnEscape?: boolean;
1965
+ className?: string;
1966
+ contentClassName?: string;
1967
+ }
1968
+ declare const Modal: React$1.ForwardRefExoticComponent<ModalProps & React$1.RefAttributes<HTMLDivElement>>;
1969
+ declare const ModalRoot: React$1.FC<DialogPrimitive.DialogProps>;
1970
+ declare const ModalTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
1971
+ declare const ModalPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
1972
+ declare const ModalClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
1973
+ declare const ModalOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
1974
+ declare const ModalContent: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & VariantProps<(props?: ({
1975
+ size?: "sm" | "md" | "lg" | "xl" | "full" | null | undefined;
1976
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & {
1977
+ showCloseButton?: boolean;
1978
+ } & React$1.RefAttributes<HTMLDivElement>>;
1979
+ declare const ModalHeader: {
1980
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
1981
+ displayName: string;
1982
+ };
1983
+ declare const ModalFooter: {
1984
+ ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
1985
+ displayName: string;
1986
+ };
1987
+ declare const ModalTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
1988
+ declare const ModalDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
1989
+
1990
+ declare const confirmDialogIconVariants: (props?: ({
1991
+ variant?: "default" | "success" | "warning" | "danger" | "info" | null | undefined;
1992
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
1993
+ interface ConfirmDialogProps extends VariantProps<typeof confirmDialogIconVariants> {
1994
+ open?: boolean;
1995
+ onOpenChange?: (open: boolean) => void;
1996
+ trigger?: React$1.ReactNode;
1997
+ title: React$1.ReactNode;
1998
+ description?: React$1.ReactNode;
1999
+ confirmText?: string;
2000
+ cancelText?: string;
2001
+ onConfirm?: () => void | Promise<void>;
2002
+ onCancel?: () => void;
2003
+ showIcon?: boolean;
2004
+ icon?: React$1.ReactNode;
2005
+ loading?: boolean;
2006
+ disabled?: boolean;
2007
+ className?: string;
2008
+ }
2009
+ declare const ConfirmDialog: React$1.ForwardRefExoticComponent<ConfirmDialogProps & React$1.RefAttributes<HTMLDivElement>>;
2010
+ interface UseConfirmDialogOptions {
2011
+ title: React$1.ReactNode;
2012
+ description?: React$1.ReactNode;
2013
+ confirmText?: string;
2014
+ cancelText?: string;
2015
+ variant?: "default" | "danger" | "warning" | "success" | "info";
2016
+ }
2017
+ declare function useConfirmDialog(): {
2018
+ confirm: (options: UseConfirmDialogOptions) => Promise<boolean>;
2019
+ ConfirmDialog: react_jsx_runtime.JSX.Element | null;
2020
+ };
2021
+
2022
+ interface ViewerImage {
2023
+ src: string;
2024
+ alt?: string;
2025
+ title?: string;
2026
+ description?: string;
2027
+ }
2028
+ interface ImageViewerProps {
2029
+ images: ViewerImage[] | string[];
2030
+ open?: boolean;
2031
+ onOpenChange?: (open: boolean) => void;
2032
+ initialIndex?: number;
2033
+ onIndexChange?: (index: number) => void;
2034
+ trigger?: React$1.ReactNode;
2035
+ showThumbnails?: boolean;
2036
+ showZoom?: boolean;
2037
+ showRotate?: boolean;
2038
+ showDownload?: boolean;
2039
+ showFullscreen?: boolean;
2040
+ showNavigation?: boolean;
2041
+ showCounter?: boolean;
2042
+ closeOnBackdropClick?: boolean;
2043
+ className?: string;
2044
+ }
2045
+ declare const ImageViewer: React$1.ForwardRefExoticComponent<ImageViewerProps & React$1.RefAttributes<HTMLDivElement>>;
2046
+ interface ImageViewerTriggerProps {
2047
+ children: React$1.ReactNode;
2048
+ images: ViewerImage[] | string[];
2049
+ index?: number;
2050
+ className?: string;
2051
+ }
2052
+ declare const ImageViewerTrigger: React$1.FC<ImageViewerTriggerProps>;
2053
+
2054
+ declare const closeButtonVariants: (props?: ({
2055
+ variant?: "solid" | "outline" | "ghost" | "default" | null | undefined;
2056
+ size?: "sm" | "md" | "lg" | null | undefined;
2057
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2058
+ interface CloseButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof closeButtonVariants> {
2059
+ /** Icon size in pixels */
2060
+ iconSize?: number;
2061
+ }
2062
+ declare const CloseButton: React$1.ForwardRefExoticComponent<CloseButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
2063
+
2064
+ declare const actionIconVariants: (props?: ({
2065
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
2066
+ size?: "sm" | "md" | "lg" | null | undefined;
2067
+ color?: "default" | "primary" | "secondary" | "success" | "warning" | "danger" | null | undefined;
2068
+ radius?: "none" | "sm" | "md" | "lg" | "full" | null | undefined;
2069
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2070
+ interface ActionIconProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "color">, VariantProps<typeof actionIconVariants> {
2071
+ /** Loading state */
2072
+ loading?: boolean;
2073
+ }
2074
+ declare const ActionIcon: React$1.ForwardRefExoticComponent<ActionIconProps & React$1.RefAttributes<HTMLButtonElement>>;
2075
+
2076
+ interface PortalProps {
2077
+ /** Content to render in the portal */
2078
+ children: React$1.ReactNode;
2079
+ /** Target container element or selector */
2080
+ container?: Element | string | null;
2081
+ /** Whether the portal is disabled (renders inline) */
2082
+ disabled?: boolean;
2083
+ }
2084
+ declare const Portal: React$1.FC<PortalProps>;
2085
+
2086
+ declare const indicatorVariants: (props?: ({
2087
+ color?: "default" | "primary" | "secondary" | "success" | "warning" | "danger" | null | undefined;
2088
+ size?: "sm" | "md" | "lg" | null | undefined;
2089
+ position?: "top-right" | "top-left" | "bottom-right" | "bottom-left" | null | undefined;
2090
+ ping?: boolean | null | undefined;
2091
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2092
+ interface IndicatorProps extends Omit<React$1.HTMLAttributes<HTMLSpanElement>, "color" | "content">, VariantProps<typeof indicatorVariants> {
2093
+ /** Content to show inside indicator (like a count) */
2094
+ content?: React$1.ReactNode;
2095
+ /** Whether to show the indicator */
2096
+ show?: boolean;
2097
+ /** Offset from the corner */
2098
+ offset?: number;
2099
+ }
2100
+ declare const Indicator: React$1.ForwardRefExoticComponent<IndicatorProps & React$1.RefAttributes<HTMLSpanElement>>;
2101
+ interface IndicatorWrapperProps extends React$1.HTMLAttributes<HTMLDivElement> {
2102
+ children: React$1.ReactNode;
2103
+ }
2104
+ declare const IndicatorWrapper: React$1.ForwardRefExoticComponent<IndicatorWrapperProps & React$1.RefAttributes<HTMLDivElement>>;
2105
+
2106
+ declare const scrollShadowVariants: (props?: ({
2107
+ orientation?: "both" | "horizontal" | "vertical" | null | undefined;
2108
+ size?: "sm" | "md" | "lg" | null | undefined;
2109
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2110
+ interface ScrollShadowProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof scrollShadowVariants> {
2111
+ /** Whether to hide scrollbar */
2112
+ hideScrollbar?: boolean;
2113
+ /** Shadow color (CSS value) */
2114
+ shadowColor?: string;
2115
+ }
2116
+ declare const ScrollShadow: React$1.ForwardRefExoticComponent<ScrollShadowProps & React$1.RefAttributes<HTMLDivElement>>;
2117
+
2118
+ interface VisuallyHiddenProps extends React$1.ComponentPropsWithoutRef<typeof VisuallyHiddenPrimitive.Root> {
2119
+ }
2120
+ declare const VisuallyHidden: React$1.ForwardRefExoticComponent<VisuallyHiddenProps & React$1.RefAttributes<HTMLSpanElement>>;
2121
+
2122
+ declare const kbdVariants: (props?: ({
2123
+ variant?: "outline" | "ghost" | "default" | null | undefined;
2124
+ size?: "sm" | "md" | "lg" | null | undefined;
2125
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2126
+ interface KbdProps extends React$1.HTMLAttributes<HTMLElement>, VariantProps<typeof kbdVariants> {
2127
+ /** Keyboard keys to display (can be string or array) */
2128
+ keys?: string | string[];
2129
+ }
2130
+ declare const Kbd: React$1.ForwardRefExoticComponent<KbdProps & React$1.RefAttributes<HTMLElement>>;
2131
+
2132
+ interface SpacerProps extends React$1.HTMLAttributes<HTMLDivElement> {
2133
+ /** Fixed size in pixels or CSS value */
2134
+ size?: number | string;
2135
+ /** Axis direction */
2136
+ axis?: "horizontal" | "vertical" | "both";
2137
+ }
2138
+ declare const Spacer: React$1.ForwardRefExoticComponent<SpacerProps & React$1.RefAttributes<HTMLDivElement>>;
2139
+
2140
+ declare const copyButtonVariants: (props?: ({
2141
+ variant?: "solid" | "outline" | "ghost" | "default" | null | undefined;
2142
+ size?: "sm" | "md" | "lg" | null | undefined;
2143
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2144
+ interface CopyButtonProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "children">, VariantProps<typeof copyButtonVariants> {
2145
+ /** Text to copy to clipboard */
2146
+ value: string;
2147
+ /** Duration to show success state (ms) */
2148
+ successDuration?: number;
2149
+ /** Callback when copy succeeds */
2150
+ onCopySuccess?: () => void;
2151
+ /** Callback when copy fails */
2152
+ onCopyError?: (error: Error) => void;
2153
+ /** Custom copy icon */
2154
+ copyIcon?: React$1.ReactNode;
2155
+ /** Custom success icon */
2156
+ successIcon?: React$1.ReactNode;
2157
+ }
2158
+ declare const CopyButton: React$1.ForwardRefExoticComponent<CopyButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
2159
+
2160
+ declare const fullCalendarVariants: (props?: ({
2161
+ variant?: "ghost" | "default" | "bordered" | null | undefined;
2162
+ size?: "sm" | "md" | "lg" | null | undefined;
2163
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2164
+ type CalendarView = "month" | "week" | "day";
2165
+ interface CalendarEvent {
2166
+ id: string;
2167
+ title: string;
2168
+ start: Date;
2169
+ end: Date;
2170
+ color?: string;
2171
+ allDay?: boolean;
2172
+ data?: Record<string, unknown>;
2173
+ }
2174
+ interface FullCalendarProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect">, VariantProps<typeof fullCalendarVariants> {
2175
+ /** Events to display */
2176
+ events?: CalendarEvent[];
2177
+ /** Current view mode */
2178
+ view?: CalendarView;
2179
+ /** Callback when view changes */
2180
+ onViewChange?: (view: CalendarView) => void;
2181
+ /** Current date */
2182
+ date?: Date;
2183
+ /** Callback when date changes */
2184
+ onDateChange?: (date: Date) => void;
2185
+ /** Callback when an event is clicked */
2186
+ onEventClick?: (event: CalendarEvent) => void;
2187
+ /** Callback when a date/time slot is clicked */
2188
+ onSlotClick?: (date: Date) => void;
2189
+ /** Week starts on (0 = Sunday, 1 = Monday) */
2190
+ weekStartsOn?: 0 | 1;
2191
+ /** Locale for formatting */
2192
+ locale?: string;
2193
+ }
2194
+ declare const FullCalendar: React$1.ForwardRefExoticComponent<FullCalendarProps & React$1.RefAttributes<HTMLDivElement>>;
2195
+
2196
+ declare const chartContainerVariants: (props?: ({
2197
+ size?: "sm" | "md" | "lg" | null | undefined;
2198
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2199
+ interface ChartDataPoint {
2200
+ name: string;
2201
+ value: number;
2202
+ [key: string]: string | number;
2203
+ }
2204
+ declare const DEFAULT_COLORS: string[];
2205
+ interface LineChartProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof chartContainerVariants> {
2206
+ /** Data to display */
2207
+ data: ChartDataPoint[];
2208
+ /** Data keys to plot as lines */
2209
+ dataKeys: string[];
2210
+ /** Colors for each line */
2211
+ colors?: string[];
2212
+ /** Show grid */
2213
+ showGrid?: boolean;
2214
+ /** Show legend */
2215
+ showLegend?: boolean;
2216
+ /** Show tooltip */
2217
+ showTooltip?: boolean;
2218
+ /** X-axis data key */
2219
+ xAxisKey?: string;
2220
+ /** Curve type */
2221
+ curveType?: "linear" | "monotone" | "step";
2222
+ }
2223
+ declare const LineChart: React$1.ForwardRefExoticComponent<LineChartProps & React$1.RefAttributes<HTMLDivElement>>;
2224
+ interface BarChartProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof chartContainerVariants> {
2225
+ /** Data to display */
2226
+ data: ChartDataPoint[];
2227
+ /** Data keys to plot as bars */
2228
+ dataKeys: string[];
2229
+ /** Colors for each bar group */
2230
+ colors?: string[];
2231
+ /** Show grid */
2232
+ showGrid?: boolean;
2233
+ /** Show legend */
2234
+ showLegend?: boolean;
2235
+ /** Show tooltip */
2236
+ showTooltip?: boolean;
2237
+ /** X-axis data key */
2238
+ xAxisKey?: string;
2239
+ /** Stack bars */
2240
+ stacked?: boolean;
2241
+ /** Bar layout */
2242
+ layout?: "horizontal" | "vertical";
2243
+ }
2244
+ declare const BarChart: React$1.ForwardRefExoticComponent<BarChartProps & React$1.RefAttributes<HTMLDivElement>>;
2245
+ interface PieChartProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof chartContainerVariants> {
2246
+ /** Data to display */
2247
+ data: ChartDataPoint[];
2248
+ /** Data key for values */
2249
+ dataKey?: string;
2250
+ /** Name key for labels */
2251
+ nameKey?: string;
2252
+ /** Colors for slices */
2253
+ colors?: string[];
2254
+ /** Inner radius for donut chart */
2255
+ innerRadius?: number;
2256
+ /** Outer radius */
2257
+ outerRadius?: number;
2258
+ /** Show legend */
2259
+ showLegend?: boolean;
2260
+ /** Show tooltip */
2261
+ showTooltip?: boolean;
2262
+ /** Show labels */
2263
+ showLabels?: boolean;
2264
+ }
2265
+ declare const PieChart: React$1.ForwardRefExoticComponent<PieChartProps & React$1.RefAttributes<HTMLDivElement>>;
2266
+ interface AreaChartProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof chartContainerVariants> {
2267
+ /** Data to display */
2268
+ data: ChartDataPoint[];
2269
+ /** Data keys to plot as areas */
2270
+ dataKeys: string[];
2271
+ /** Colors for each area */
2272
+ colors?: string[];
2273
+ /** Show grid */
2274
+ showGrid?: boolean;
2275
+ /** Show legend */
2276
+ showLegend?: boolean;
2277
+ /** Show tooltip */
2278
+ showTooltip?: boolean;
2279
+ /** X-axis data key */
2280
+ xAxisKey?: string;
2281
+ /** Stack areas */
2282
+ stacked?: boolean;
2283
+ /** Curve type */
2284
+ curveType?: "linear" | "monotone" | "step";
2285
+ }
2286
+ declare const AreaChart: React$1.ForwardRefExoticComponent<AreaChartProps & React$1.RefAttributes<HTMLDivElement>>;
2287
+
2288
+ declare const kanbanBoardVariants: (props?: ({
2289
+ variant?: "ghost" | "default" | "bordered" | null | undefined;
2290
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2291
+ declare const kanbanColumnVariants: (props?: ({
2292
+ variant?: "ghost" | "default" | "bordered" | null | undefined;
2293
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2294
+ declare const kanbanCardVariants: (props?: ({
2295
+ variant?: "ghost" | "default" | "bordered" | null | undefined;
2296
+ isDragging?: boolean | null | undefined;
2297
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2298
+ interface KanbanCard {
2299
+ id: string;
2300
+ title: string;
2301
+ description?: string;
2302
+ [key: string]: unknown;
2303
+ }
2304
+ interface KanbanColumn {
2305
+ id: string;
2306
+ title: string;
2307
+ cards: KanbanCard[];
2308
+ color?: string;
2309
+ }
2310
+ interface KanbanBoardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof kanbanBoardVariants> {
2311
+ /** Columns with cards */
2312
+ columns: KanbanColumn[];
2313
+ /** Callback when cards are moved */
2314
+ onCardMove?: (cardId: string, sourceColumnId: string, targetColumnId: string, targetIndex: number) => void;
2315
+ /** Callback when a card is clicked */
2316
+ onCardClick?: (card: KanbanCard, columnId: string) => void;
2317
+ /** Callback when add card button is clicked */
2318
+ onAddCard?: (columnId: string) => void;
2319
+ /** Custom card renderer */
2320
+ renderCard?: (card: KanbanCard, columnId: string) => React$1.ReactNode;
2321
+ /** Show add card button */
2322
+ showAddCard?: boolean;
2323
+ /** Max height for columns */
2324
+ columnHeight?: number | string;
2325
+ }
2326
+ declare const KanbanBoard: React$1.ForwardRefExoticComponent<KanbanBoardProps & React$1.RefAttributes<HTMLDivElement>>;
2327
+
2328
+ declare const carouselVariants: (props?: ({
2329
+ variant?: "default" | "bordered" | "cards" | null | undefined;
2330
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2331
+ type CarouselApi = UseEmblaCarouselType[1];
2332
+ type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
2333
+ type CarouselOptions = UseCarouselParameters[0];
2334
+ type CarouselPlugin = UseCarouselParameters[1];
2335
+ type CarouselContextProps = {
2336
+ carouselRef: ReturnType<typeof useEmblaCarousel>[0];
2337
+ api: CarouselApi;
2338
+ scrollPrev: () => void;
2339
+ scrollNext: () => void;
2340
+ canScrollPrev: boolean;
2341
+ canScrollNext: boolean;
2342
+ selectedIndex: number;
2343
+ scrollSnaps: number[];
2344
+ scrollTo: (index: number) => void;
2345
+ };
2346
+ declare function useCarousel(): CarouselContextProps;
2347
+ interface CarouselProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof carouselVariants> {
2348
+ /** Embla carousel options */
2349
+ opts?: CarouselOptions;
2350
+ /** Embla plugins */
2351
+ plugins?: CarouselPlugin;
2352
+ /** Orientation */
2353
+ orientation?: "horizontal" | "vertical";
2354
+ /** Show navigation arrows */
2355
+ showArrows?: boolean;
2356
+ /** Show dots indicator */
2357
+ showDots?: boolean;
2358
+ /** Set the carousel API */
2359
+ setApi?: (api: CarouselApi) => void;
2360
+ }
2361
+ declare const Carousel: React$1.ForwardRefExoticComponent<CarouselProps & React$1.RefAttributes<HTMLDivElement>>;
2362
+ declare const CarouselContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
2363
+ interface CarouselItemProps extends React$1.HTMLAttributes<HTMLDivElement> {
2364
+ /** Basis class for item width */
2365
+ basis?: string;
2366
+ }
2367
+ declare const CarouselItem: React$1.ForwardRefExoticComponent<CarouselItemProps & React$1.RefAttributes<HTMLDivElement>>;
2368
+ declare const CarouselPrevious: React$1.ForwardRefExoticComponent<Omit<ButtonProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
2369
+ declare const CarouselNext: React$1.ForwardRefExoticComponent<Omit<ButtonProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
2370
+
2371
+ declare const emojiPickerVariants: (props?: ({
2372
+ size?: "sm" | "md" | "lg" | null | undefined;
2373
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2374
+ declare const EMOJI_CATEGORIES: {
2375
+ readonly recent: {
2376
+ readonly icon: "🕐";
2377
+ readonly name: "Recent";
2378
+ };
2379
+ readonly smileys: {
2380
+ readonly icon: "😀";
2381
+ readonly name: "Smileys & Emotion";
2382
+ };
2383
+ readonly people: {
2384
+ readonly icon: "👋";
2385
+ readonly name: "People & Body";
2386
+ };
2387
+ readonly animals: {
2388
+ readonly icon: "🐻";
2389
+ readonly name: "Animals & Nature";
2390
+ };
2391
+ readonly food: {
2392
+ readonly icon: "🍔";
2393
+ readonly name: "Food & Drink";
2394
+ };
2395
+ readonly travel: {
2396
+ readonly icon: "🚗";
2397
+ readonly name: "Travel & Places";
2398
+ };
2399
+ readonly activities: {
2400
+ readonly icon: "⚽";
2401
+ readonly name: "Activities";
2402
+ };
2403
+ readonly objects: {
2404
+ readonly icon: "💡";
2405
+ readonly name: "Objects";
2406
+ };
2407
+ readonly symbols: {
2408
+ readonly icon: "❤️";
2409
+ readonly name: "Symbols";
2410
+ };
2411
+ readonly flags: {
2412
+ readonly icon: "🏳️";
2413
+ readonly name: "Flags";
2414
+ };
2415
+ };
2416
+ type EmojiCategory = keyof typeof EMOJI_CATEGORIES;
2417
+ declare const EMOJIS: Record<Exclude<EmojiCategory, "recent">, string[]>;
2418
+ interface EmojiPickerProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect">, VariantProps<typeof emojiPickerVariants> {
2419
+ /** Callback when emoji is selected */
2420
+ onEmojiSelect?: (emoji: string) => void;
2421
+ /** Recently used emojis */
2422
+ recentEmojis?: string[];
2423
+ /** Default category */
2424
+ defaultCategory?: EmojiCategory;
2425
+ /** Show search */
2426
+ showSearch?: boolean;
2427
+ /** Show category tabs */
2428
+ showCategories?: boolean;
2429
+ }
2430
+ declare const EmojiPicker: React$1.ForwardRefExoticComponent<EmojiPickerProps & React$1.RefAttributes<HTMLDivElement>>;
2431
+
2432
+ declare const richTextEditorVariants: (props?: ({
2433
+ variant?: "ghost" | "default" | "bordered" | null | undefined;
2434
+ size?: "sm" | "md" | "lg" | null | undefined;
2435
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2436
+ interface RichTextEditorProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof richTextEditorVariants> {
2437
+ /** Initial HTML content */
2438
+ value?: string;
2439
+ /** Callback when content changes */
2440
+ onChange?: (html: string) => void;
2441
+ /** Placeholder text */
2442
+ placeholder?: string;
2443
+ /** Whether editor is read-only */
2444
+ readOnly?: boolean;
2445
+ /** Show toolbar */
2446
+ showToolbar?: boolean;
2447
+ /** Min height of editor */
2448
+ minHeight?: number | string;
2449
+ /** Max height of editor */
2450
+ maxHeight?: number | string;
2451
+ /** Expose editor instance */
2452
+ onEditorReady?: (editor: Editor) => void;
2453
+ }
2454
+ declare const RichTextEditor: React$1.ForwardRefExoticComponent<RichTextEditorProps & React$1.RefAttributes<HTMLDivElement>>;
2455
+
2456
+ declare const imageCropperVariants: (props?: ({
2457
+ variant?: "ghost" | "default" | "bordered" | null | undefined;
2458
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2459
+ interface ImageCropperProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof imageCropperVariants> {
2460
+ /** Image source URL */
2461
+ src: string;
2462
+ /** Aspect ratio (e.g., 1 for square, 16/9 for widescreen) */
2463
+ aspectRatio?: number;
2464
+ /** Callback when crop changes */
2465
+ onCropChange?: (crop: Crop) => void;
2466
+ /** Callback to get cropped image blob */
2467
+ onCropComplete?: (blob: Blob | null) => void;
2468
+ /** Show zoom controls */
2469
+ showZoom?: boolean;
2470
+ /** Show rotation controls */
2471
+ showRotation?: boolean;
2472
+ /** Min zoom level */
2473
+ minZoom?: number;
2474
+ /** Max zoom level */
2475
+ maxZoom?: number;
2476
+ /** Crop shape */
2477
+ circularCrop?: boolean;
2478
+ /** Initial crop (percentage-based) */
2479
+ initialCrop?: Crop;
2480
+ }
2481
+ declare const ImageCropper: React$1.ForwardRefExoticComponent<ImageCropperProps & React$1.RefAttributes<HTMLDivElement>>;
2482
+
2483
+ declare const qrCodeVariants: (props?: ({
2484
+ variant?: "default" | "bordered" | "card" | null | undefined;
2485
+ size?: "sm" | "md" | "lg" | null | undefined;
2486
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2487
+ interface QRCodeProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title">, VariantProps<typeof qrCodeVariants> {
2488
+ /** Data to encode */
2489
+ value: string;
2490
+ /** Size of the QR code in pixels */
2491
+ qrSize?: number;
2492
+ /** Foreground color */
2493
+ fgColor?: string;
2494
+ /** Background color */
2495
+ bgColor?: string;
2496
+ /** Error correction level */
2497
+ level?: "L" | "M" | "Q" | "H";
2498
+ /** Include quiet zone */
2499
+ includeMargin?: boolean;
2500
+ /** Title for accessibility */
2501
+ title?: string;
2502
+ /** Logo/image to display in center */
2503
+ logo?: string;
2504
+ /** Logo size in pixels */
2505
+ logoSize?: number;
2506
+ /** Logo padding */
2507
+ logoPadding?: number;
2508
+ /** Logo background style */
2509
+ logoBackgroundColor?: string;
2510
+ }
2511
+ declare const QRCode: React$1.ForwardRefExoticComponent<QRCodeProps & React$1.RefAttributes<HTMLDivElement>>;
2512
+
2513
+ interface ThemeProviderProps {
2514
+ /** Child components */
2515
+ children: React$1.ReactNode;
2516
+ /** Default theme (light, dark, or system) */
2517
+ defaultTheme?: "light" | "dark" | "system";
2518
+ /** Storage key for theme preference */
2519
+ storageKey?: string;
2520
+ /** Whether to enable system theme detection */
2521
+ enableSystem?: boolean;
2522
+ /** Whether to disable transitions on theme change */
2523
+ disableTransitionOnChange?: boolean;
2524
+ /** Attribute to set on the HTML element */
2525
+ attribute?: "class" | "data-theme" | "data-mode";
2526
+ /** Force a specific theme */
2527
+ forcedTheme?: string;
2528
+ /** Themes available */
2529
+ themes?: string[];
2530
+ }
2531
+ declare const ThemeProvider: React$1.FC<ThemeProviderProps>;
2532
+
2533
+ declare const themeToggleVariants: (props?: ({
2534
+ variant?: "outline" | "ghost" | "default" | null | undefined;
2535
+ size?: "sm" | "md" | "lg" | null | undefined;
2536
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2537
+ interface ThemeToggleProps extends VariantProps<typeof themeToggleVariants> {
2538
+ /** Additional class name */
2539
+ className?: string;
2540
+ /** Show dropdown menu or cycle through themes */
2541
+ mode?: "dropdown" | "cycle";
2542
+ }
2543
+ declare const ThemeToggle: React$1.ForwardRefExoticComponent<ThemeToggleProps & React$1.RefAttributes<HTMLButtonElement>>;
2544
+
2545
+ declare const textFieldVariants: (props?: ({
2546
+ size?: "sm" | "md" | "lg" | null | undefined;
2547
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2548
+ declare const inputSizeVariants: (props?: ({
2549
+ size?: "sm" | "md" | "lg" | null | undefined;
2550
+ isInvalid?: boolean | null | undefined;
2551
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2552
+ declare const labelSizeVariants: (props?: ({
2553
+ size?: "sm" | "md" | "lg" | null | undefined;
2554
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2555
+ interface TextFieldProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof textFieldVariants> {
2556
+ label?: React$1.ReactNode;
2557
+ description?: React$1.ReactNode;
2558
+ errorMessage?: React$1.ReactNode;
2559
+ isRequired?: boolean;
2560
+ isInvalid?: boolean;
2561
+ labelClassName?: string;
2562
+ inputClassName?: string;
2563
+ descriptionClassName?: string;
2564
+ errorClassName?: string;
2565
+ startContent?: React$1.ReactNode;
2566
+ endContent?: React$1.ReactNode;
2567
+ }
2568
+ declare const TextField: React$1.ForwardRefExoticComponent<TextFieldProps & React$1.RefAttributes<HTMLInputElement>>;
2569
+
2570
+ declare const numberFieldVariants: (props?: ({
2571
+ size?: "sm" | "md" | "lg" | null | undefined;
2572
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2573
+ interface NumberFieldProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "type" | "onChange">, VariantProps<typeof numberFieldVariants> {
2574
+ label?: React$1.ReactNode;
2575
+ description?: React$1.ReactNode;
2576
+ errorMessage?: React$1.ReactNode;
2577
+ isRequired?: boolean;
2578
+ isInvalid?: boolean;
2579
+ labelClassName?: string;
2580
+ inputClassName?: string;
2581
+ descriptionClassName?: string;
2582
+ errorClassName?: string;
2583
+ min?: number;
2584
+ max?: number;
2585
+ step?: number;
2586
+ value?: number;
2587
+ defaultValue?: number;
2588
+ onChange?: (value: number | undefined) => void;
2589
+ showButtons?: boolean;
2590
+ formatOptions?: Intl.NumberFormatOptions;
2591
+ }
2592
+ declare const NumberField: React$1.ForwardRefExoticComponent<NumberFieldProps & React$1.RefAttributes<HTMLInputElement>>;
2593
+
2594
+ declare const searchFieldVariants: (props?: ({
2595
+ size?: "sm" | "md" | "lg" | null | undefined;
2596
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2597
+ interface SearchFieldProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "type" | "onChange" | "onSubmit">, VariantProps<typeof searchFieldVariants> {
2598
+ label?: React$1.ReactNode;
2599
+ description?: React$1.ReactNode;
2600
+ errorMessage?: React$1.ReactNode;
2601
+ isRequired?: boolean;
2602
+ isInvalid?: boolean;
2603
+ labelClassName?: string;
2604
+ inputClassName?: string;
2605
+ descriptionClassName?: string;
2606
+ errorClassName?: string;
2607
+ value?: string;
2608
+ defaultValue?: string;
2609
+ onChange?: (value: string) => void;
2610
+ onClear?: () => void;
2611
+ onSearch?: (value: string) => void;
2612
+ showClearButton?: boolean;
2613
+ showSearchIcon?: boolean;
2614
+ }
2615
+ declare const SearchField: React$1.ForwardRefExoticComponent<SearchFieldProps & React$1.RefAttributes<HTMLInputElement>>;
2616
+
2617
+ declare const dateFieldVariants: (props?: ({
2618
+ size?: "sm" | "md" | "lg" | null | undefined;
2619
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2620
+ interface DateFieldProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "type" | "onChange" | "value" | "defaultValue">, VariantProps<typeof dateFieldVariants> {
2621
+ label?: React$1.ReactNode;
2622
+ description?: React$1.ReactNode;
2623
+ errorMessage?: React$1.ReactNode;
2624
+ isRequired?: boolean;
2625
+ isInvalid?: boolean;
2626
+ labelClassName?: string;
2627
+ inputClassName?: string;
2628
+ descriptionClassName?: string;
2629
+ errorClassName?: string;
2630
+ value?: Date | null;
2631
+ defaultValue?: Date | null;
2632
+ onChange?: (date: Date | null) => void;
2633
+ minDate?: Date;
2634
+ maxDate?: Date;
2635
+ dateFormat?: string;
2636
+ showIcon?: boolean;
2637
+ }
2638
+ declare const DateField: React$1.ForwardRefExoticComponent<DateFieldProps & React$1.RefAttributes<HTMLInputElement>>;
2639
+
2640
+ declare const timeFieldVariants: (props?: ({
2641
+ size?: "sm" | "md" | "lg" | null | undefined;
2642
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2643
+ interface TimeValue {
2644
+ hour: number;
2645
+ minute: number;
2646
+ second?: number;
2647
+ }
2648
+ interface TimeFieldProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "type" | "onChange" | "value" | "defaultValue">, VariantProps<typeof timeFieldVariants> {
2649
+ label?: React$1.ReactNode;
2650
+ description?: React$1.ReactNode;
2651
+ errorMessage?: React$1.ReactNode;
2652
+ isRequired?: boolean;
2653
+ isInvalid?: boolean;
2654
+ labelClassName?: string;
2655
+ inputClassName?: string;
2656
+ descriptionClassName?: string;
2657
+ errorClassName?: string;
2658
+ value?: TimeValue | null;
2659
+ defaultValue?: TimeValue | null;
2660
+ onChange?: (time: TimeValue | null) => void;
2661
+ minTime?: TimeValue;
2662
+ maxTime?: TimeValue;
2663
+ showSeconds?: boolean;
2664
+ showIcon?: boolean;
2665
+ hourCycle?: 12 | 24;
2666
+ }
2667
+ declare const TimeField: React$1.ForwardRefExoticComponent<TimeFieldProps & React$1.RefAttributes<HTMLInputElement>>;
2668
+
2669
+ declare const colorFieldVariants: (props?: ({
2670
+ size?: "sm" | "md" | "lg" | null | undefined;
2671
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2672
+ interface ColorFieldProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "type" | "onChange" | "value">, VariantProps<typeof colorFieldVariants> {
2673
+ label?: React$1.ReactNode;
2674
+ description?: React$1.ReactNode;
2675
+ errorMessage?: React$1.ReactNode;
2676
+ isRequired?: boolean;
2677
+ isInvalid?: boolean;
2678
+ labelClassName?: string;
2679
+ inputClassName?: string;
2680
+ descriptionClassName?: string;
2681
+ errorClassName?: string;
2682
+ value?: string;
2683
+ defaultValue?: string;
2684
+ onChange?: (color: string) => void;
2685
+ showSwatch?: boolean;
2686
+ showPicker?: boolean;
2687
+ allowAlpha?: boolean;
2688
+ }
2689
+ declare const ColorField: React$1.ForwardRefExoticComponent<ColorFieldProps & React$1.RefAttributes<HTMLInputElement>>;
2690
+
2691
+ declare const buttonGroupVariants: (props?: ({
2692
+ variant?: "default" | "attached" | null | undefined;
2693
+ orientation?: "horizontal" | "vertical" | null | undefined;
2694
+ spacing?: "none" | "sm" | "md" | "lg" | null | undefined;
2695
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2696
+ interface ButtonGroupProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof buttonGroupVariants> {
2697
+ /** Whether buttons are disabled */
2698
+ disabled?: boolean;
2699
+ }
2700
+ declare function useButtonGroup(): {
2701
+ disabled?: boolean;
2702
+ };
2703
+ declare const ButtonGroup: React$1.ForwardRefExoticComponent<ButtonGroupProps & React$1.RefAttributes<HTMLDivElement>>;
2704
+
2705
+ declare const iconButtonVariants: (props?: ({
2706
+ variant?: "solid" | "outline" | "ghost" | "soft" | "surface" | null | undefined;
2707
+ size?: "sm" | "md" | "lg" | "xl" | null | undefined;
2708
+ radius?: "none" | "sm" | "md" | "lg" | "full" | null | undefined;
2709
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2710
+ interface IconButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof iconButtonVariants> {
2711
+ /** Accessibility label */
2712
+ "aria-label": string;
2713
+ /** Loading state */
2714
+ isLoading?: boolean;
2715
+ }
2716
+ declare const IconButton: React$1.ForwardRefExoticComponent<IconButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
2717
+
2718
+ declare const actionGroupVariants: (props?: ({
2719
+ variant?: "default" | "compact" | "attached" | null | undefined;
2720
+ orientation?: "horizontal" | "vertical" | null | undefined;
2721
+ size?: "sm" | "md" | "lg" | null | undefined;
2722
+ density?: "compact" | "regular" | "spacious" | null | undefined;
2723
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2724
+ interface ActionGroupItem {
2725
+ key: string;
2726
+ label: string;
2727
+ icon?: React$1.ReactNode;
2728
+ isDisabled?: boolean;
2729
+ onPress?: () => void;
2730
+ }
2731
+ interface ActionGroupProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children">, VariantProps<typeof actionGroupVariants> {
2732
+ /** Action items to display */
2733
+ items: ActionGroupItem[];
2734
+ /** Maximum visible items before overflow */
2735
+ maxVisibleItems?: number;
2736
+ /** Whether all items are disabled */
2737
+ isDisabled?: boolean;
2738
+ /** Called when an action is pressed */
2739
+ onAction?: (key: string) => void;
2740
+ /** Whether to show labels */
2741
+ showLabels?: boolean;
2742
+ /** Custom render for action items */
2743
+ renderItem?: (item: ActionGroupItem) => React$1.ReactNode;
2744
+ }
2745
+ declare const ActionGroup: React$1.ForwardRefExoticComponent<ActionGroupProps & React$1.RefAttributes<HTMLDivElement>>;
2746
+
2747
+ declare const statusLightVariants: (props?: ({
2748
+ variant?: "info" | "neutral" | "positive" | "notice" | "negative" | null | undefined;
2749
+ size?: "sm" | "md" | "lg" | null | undefined;
2750
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2751
+ interface StatusLightProps extends React$1.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof statusLightVariants> {
2752
+ /** Whether the light should pulse/animate */
2753
+ pulse?: boolean;
2754
+ /** Hide the label (icon only) */
2755
+ hideLabel?: boolean;
2756
+ }
2757
+ declare const StatusLight: React$1.ForwardRefExoticComponent<StatusLightProps & React$1.RefAttributes<HTMLSpanElement>>;
2758
+
2759
+ declare const illustratedMessageVariants: (props?: ({
2760
+ size?: "sm" | "md" | "lg" | null | undefined;
2761
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2762
+ interface IllustratedMessageProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof illustratedMessageVariants> {
2763
+ /** Illustration element (SVG, image, or icon) */
2764
+ illustration?: React$1.ReactNode;
2765
+ /** Heading text */
2766
+ heading?: string;
2767
+ /** Description text */
2768
+ description?: string;
2769
+ }
2770
+ declare const IllustratedMessage: React$1.ForwardRefExoticComponent<IllustratedMessageProps & React$1.RefAttributes<HTMLDivElement>>;
2771
+
2772
+ declare const inlineAlertVariants: (props?: ({
2773
+ variant?: "error" | "success" | "warning" | "info" | "neutral" | null | undefined;
2774
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2775
+ interface InlineAlertProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof inlineAlertVariants> {
2776
+ /** Title of the alert */
2777
+ title?: string;
2778
+ /** Custom icon override */
2779
+ icon?: React$1.ReactNode;
2780
+ /** Hide the icon */
2781
+ hideIcon?: boolean;
2782
+ /** Whether the alert is dismissible */
2783
+ isDismissible?: boolean;
2784
+ /** Callback when dismissed */
2785
+ onDismiss?: () => void;
2786
+ /** Action buttons/links */
2787
+ actions?: React$1.ReactNode;
2788
+ }
2789
+ declare const InlineAlert: React$1.ForwardRefExoticComponent<InlineAlertProps & React$1.RefAttributes<HTMLDivElement>>;
2790
+
2791
+ declare const actionBarVariants: (props?: ({
2792
+ position?: "top" | "bottom" | "bottom-right" | "bottom-left" | null | undefined;
2793
+ size?: "sm" | "md" | "lg" | null | undefined;
2794
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2795
+ interface ActionBarProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof actionBarVariants> {
2796
+ /** Number of selected items */
2797
+ selectedCount?: number;
2798
+ /** Whether the action bar is open */
2799
+ isOpen?: boolean;
2800
+ /** Called when close button is clicked */
2801
+ onClose?: () => void;
2802
+ /** Show close button */
2803
+ showClose?: boolean;
2804
+ /** Custom selected text */
2805
+ selectedText?: string | ((count: number) => string);
2806
+ }
2807
+ declare const ActionBar: React$1.ForwardRefExoticComponent<ActionBarProps & React$1.RefAttributes<HTMLDivElement>>;
2808
+ declare const ActionBarButton: React$1.ForwardRefExoticComponent<React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
2809
+ icon?: React$1.ReactNode;
2810
+ } & React$1.RefAttributes<HTMLButtonElement>>;
2811
+
2812
+ declare const actionMenuTriggerVariants: (props?: ({
2813
+ variant?: "outline" | "ghost" | "subtle" | null | undefined;
2814
+ size?: "sm" | "md" | "lg" | null | undefined;
2815
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2816
+ interface ActionMenuItem {
2817
+ key: string;
2818
+ label: string;
2819
+ icon?: React$1.ReactNode;
2820
+ shortcut?: string;
2821
+ isDisabled?: boolean;
2822
+ isDestructive?: boolean;
2823
+ onSelect?: () => void;
2824
+ }
2825
+ interface ActionMenuGroup {
2826
+ key: string;
2827
+ items: ActionMenuItem[];
2828
+ }
2829
+ interface ActionMenuProps extends VariantProps<typeof actionMenuTriggerVariants> {
2830
+ /** Menu items or groups */
2831
+ items: (ActionMenuItem | ActionMenuGroup)[];
2832
+ /** Menu alignment */
2833
+ align?: "start" | "center" | "end";
2834
+ /** Menu side */
2835
+ side?: "top" | "right" | "bottom" | "left";
2836
+ /** Icon orientation */
2837
+ iconOrientation?: "horizontal" | "vertical";
2838
+ /** Custom trigger */
2839
+ trigger?: React$1.ReactNode;
2840
+ /** Called when an item is selected */
2841
+ onAction?: (key: string) => void;
2842
+ /** Trigger aria-label */
2843
+ "aria-label"?: string;
2844
+ /** Additional trigger className */
2845
+ triggerClassName?: string;
2846
+ /** Disabled state */
2847
+ disabled?: boolean;
2848
+ }
2849
+ declare const ActionMenu: React$1.ForwardRefExoticComponent<ActionMenuProps & React$1.RefAttributes<HTMLButtonElement>>;
2850
+
2851
+ declare const listViewVariants: (props?: ({
2852
+ variant?: "default" | "bordered" | "cards" | null | undefined;
2853
+ size?: "sm" | "md" | "lg" | null | undefined;
2854
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2855
+ declare const listViewItemVariants: (props?: ({
2856
+ variant?: "default" | "bordered" | "cards" | null | undefined;
2857
+ size?: "sm" | "md" | "lg" | null | undefined;
2858
+ isSelected?: boolean | null | undefined;
2859
+ isDisabled?: boolean | null | undefined;
2860
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2861
+ interface ListViewItem {
2862
+ key: string;
2863
+ label: React$1.ReactNode;
2864
+ description?: React$1.ReactNode;
2865
+ icon?: React$1.ReactNode;
2866
+ isDisabled?: boolean;
2867
+ }
2868
+ interface ListViewProps<T extends ListViewItem> extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect">, VariantProps<typeof listViewVariants> {
2869
+ /** List items */
2870
+ items: T[];
2871
+ /** Selected keys */
2872
+ selectedKeys?: Set<string> | string[];
2873
+ /** Selection mode */
2874
+ selectionMode?: "none" | "single" | "multiple";
2875
+ /** Called when selection changes */
2876
+ onSelectionChange?: (keys: Set<string>) => void;
2877
+ /** Enable drag and drop */
2878
+ allowsDragging?: boolean;
2879
+ /** Called when items are reordered */
2880
+ onReorder?: (items: T[]) => void;
2881
+ /** Show selection checkboxes */
2882
+ showCheckbox?: boolean;
2883
+ /** Custom item renderer */
2884
+ renderItem?: (item: T, isSelected: boolean) => React$1.ReactNode;
2885
+ /** Empty state content */
2886
+ emptyContent?: React$1.ReactNode;
2887
+ }
2888
+ declare function ListView<T extends ListViewItem>({ className, variant, size, items, selectedKeys: controlledSelectedKeys, selectionMode, onSelectionChange, allowsDragging, onReorder, showCheckbox, renderItem, emptyContent, ...props }: ListViewProps<T>): react_jsx_runtime.JSX.Element;
2889
+ declare namespace ListView {
2890
+ var displayName: string;
2891
+ }
2892
+
2893
+ declare const rangeSliderVariants: (props?: ({
2894
+ orientation?: "horizontal" | "vertical" | null | undefined;
2895
+ size?: "sm" | "md" | "lg" | null | undefined;
2896
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2897
+ interface RangeSliderProps extends Omit<React$1.ComponentPropsWithoutRef<typeof SliderPrimitive.Root>, "value" | "defaultValue" | "onValueChange" | "orientation">, VariantProps<typeof rangeSliderVariants> {
2898
+ /** Current range value [min, max] */
2899
+ value?: [number, number];
2900
+ /** Default range value */
2901
+ defaultValue?: [number, number];
2902
+ /** Called when range changes */
2903
+ onValueChange?: (value: [number, number]) => void;
2904
+ /** Called when dragging ends */
2905
+ onValueCommit?: (value: [number, number]) => void;
2906
+ /** Show value labels */
2907
+ showLabels?: boolean;
2908
+ /** Format label value */
2909
+ formatLabel?: (value: number) => string;
2910
+ /** Track color variant */
2911
+ trackColor?: "primary" | "success" | "warning" | "danger";
2912
+ }
2913
+ declare const RangeSlider: React$1.ForwardRefExoticComponent<RangeSliderProps & React$1.RefAttributes<HTMLSpanElement>>;
2914
+
2915
+ declare const contextualHelpTriggerVariants: (props?: ({
2916
+ variant?: "help" | "warning" | "info" | null | undefined;
2917
+ size?: "sm" | "md" | "lg" | null | undefined;
2918
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2919
+ declare const contentVariants: (props?: ({
2920
+ size?: "sm" | "md" | "lg" | null | undefined;
2921
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2922
+ interface ContextualHelpProps extends VariantProps<typeof contextualHelpTriggerVariants>, VariantProps<typeof contentVariants> {
2923
+ /** Help content title */
2924
+ title?: string;
2925
+ /** Help content description */
2926
+ children: React$1.ReactNode;
2927
+ /** Custom trigger */
2928
+ trigger?: React$1.ReactNode;
2929
+ /** Popover placement */
2930
+ side?: "top" | "right" | "bottom" | "left";
2931
+ /** Popover alignment */
2932
+ align?: "start" | "center" | "end";
2933
+ /** Whether the help is open (controlled) */
2934
+ open?: boolean;
2935
+ /** Called when open state changes */
2936
+ onOpenChange?: (open: boolean) => void;
2937
+ /** Learn more link */
2938
+ learnMoreUrl?: string;
2939
+ /** Learn more link text */
2940
+ learnMoreText?: string;
2941
+ /** Additional className for trigger */
2942
+ triggerClassName?: string;
2943
+ /** Additional className for content */
2944
+ contentClassName?: string;
2945
+ }
2946
+ declare const ContextualHelp: React$1.ForwardRefExoticComponent<ContextualHelpProps & React$1.RefAttributes<HTMLButtonElement>>;
2947
+
2948
+ declare const tagGroupVariants: (props?: ({
2949
+ spacing?: "sm" | "md" | "lg" | null | undefined;
2950
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2951
+ declare const tagGroupItemVariants: (props?: ({
2952
+ variant?: "solid" | "outline" | "soft" | "surface" | null | undefined;
2953
+ size?: "sm" | "md" | "lg" | null | undefined;
2954
+ isSelected?: boolean | null | undefined;
2955
+ isDisabled?: boolean | null | undefined;
2956
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2957
+ interface TagItem {
2958
+ key: string;
2959
+ label: string;
2960
+ icon?: React$1.ReactNode;
2961
+ color?: string;
2962
+ isDisabled?: boolean;
2963
+ }
2964
+ interface TagGroupProps<T extends TagItem> extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect">, VariantProps<typeof tagGroupVariants>, VariantProps<typeof tagGroupItemVariants> {
2965
+ /** Tag items */
2966
+ items: T[];
2967
+ /** Selected keys */
2968
+ selectedKeys?: Set<string> | string[];
2969
+ /** Selection mode */
2970
+ selectionMode?: "none" | "single" | "multiple";
2971
+ /** Called when selection changes */
2972
+ onSelectionChange?: (keys: Set<string>) => void;
2973
+ /** Allow removing tags */
2974
+ allowsRemoving?: boolean;
2975
+ /** Called when a tag is removed */
2976
+ onRemove?: (key: string) => void;
2977
+ /** Label for the group */
2978
+ label?: string;
2979
+ /** Description for the group */
2980
+ description?: string;
2981
+ /** Error message */
2982
+ errorMessage?: string;
2983
+ /** Max tags to show before "+N more" */
2984
+ maxTags?: number;
2985
+ }
2986
+ declare function TagGroup<T extends TagItem>({ className, spacing, variant, size, items, selectedKeys: controlledSelectedKeys, selectionMode, onSelectionChange, allowsRemoving, onRemove, label, description, errorMessage, maxTags, ...props }: TagGroupProps<T>): react_jsx_runtime.JSX.Element;
2987
+ declare namespace TagGroup {
2988
+ var displayName: string;
2989
+ }
2990
+
2991
+ declare const gridListVariants: (props?: ({
2992
+ columns?: 1 | "auto" | 2 | 4 | 3 | 5 | 6 | null | undefined;
2993
+ gap?: "sm" | "md" | "lg" | null | undefined;
2994
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
2995
+ declare const gridListItemVariants: (props?: ({
2996
+ variant?: "default" | "card" | null | undefined;
2997
+ size?: "sm" | "md" | "lg" | null | undefined;
2998
+ isSelected?: boolean | null | undefined;
2999
+ isDisabled?: boolean | null | undefined;
3000
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3001
+ interface GridListItem {
3002
+ key: string;
3003
+ label: React$1.ReactNode;
3004
+ description?: React$1.ReactNode;
3005
+ thumbnail?: React$1.ReactNode;
3006
+ isDisabled?: boolean;
3007
+ }
3008
+ interface GridListProps<T extends GridListItem> extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect">, VariantProps<typeof gridListVariants> {
3009
+ /** Grid items */
3010
+ items: T[];
3011
+ /** Selected keys */
3012
+ selectedKeys?: Set<string> | string[];
3013
+ /** Selection mode */
3014
+ selectionMode?: "none" | "single" | "multiple";
3015
+ /** Called when selection changes */
3016
+ onSelectionChange?: (keys: Set<string>) => void;
3017
+ /** Show selection indicator */
3018
+ showSelectionIndicator?: boolean;
3019
+ /** Item variant */
3020
+ itemVariant?: "default" | "card";
3021
+ /** Item size */
3022
+ itemSize?: "sm" | "md" | "lg";
3023
+ /** Custom item renderer */
3024
+ renderItem?: (item: T, isSelected: boolean) => React$1.ReactNode;
3025
+ /** Empty state content */
3026
+ emptyContent?: React$1.ReactNode;
3027
+ }
3028
+ declare function GridList<T extends GridListItem>({ className, columns, gap, items, selectedKeys: controlledSelectedKeys, selectionMode, onSelectionChange, showSelectionIndicator, itemVariant, itemSize, renderItem, emptyContent, ...props }: GridListProps<T>): react_jsx_runtime.JSX.Element;
3029
+ declare namespace GridList {
3030
+ var displayName: string;
3031
+ }
3032
+
3033
+ declare const meterVariants: (props?: ({
3034
+ size?: "sm" | "md" | "lg" | null | undefined;
3035
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3036
+ interface MeterProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "color">, VariantProps<typeof meterVariants> {
3037
+ /** Current value */
3038
+ value: number;
3039
+ /** Minimum value */
3040
+ min?: number;
3041
+ /** Maximum value */
3042
+ max?: number;
3043
+ /** Optimum value (for auto color) */
3044
+ optimum?: number;
3045
+ /** Low threshold (for auto color) */
3046
+ low?: number;
3047
+ /** High threshold (for auto color) */
3048
+ high?: number;
3049
+ /** Label text */
3050
+ label?: string;
3051
+ /** Show value label */
3052
+ showValueLabel?: boolean;
3053
+ /** Format value label */
3054
+ formatValue?: (value: number, percentage: number) => string;
3055
+ /** Color variant */
3056
+ color?: "primary" | "success" | "warning" | "danger" | "info" | "auto";
3057
+ /** Track variant */
3058
+ trackVariant?: "default" | "subtle";
3059
+ }
3060
+ declare const Meter: React$1.ForwardRefExoticComponent<MeterProps & React$1.RefAttributes<HTMLDivElement>>;
3061
+ declare const DiskUsageMeter: React$1.ForwardRefExoticComponent<Omit<MeterProps, "color" | "high" | "low" | "optimum"> & React$1.RefAttributes<HTMLDivElement>>;
3062
+ declare const BatteryMeter: React$1.ForwardRefExoticComponent<Omit<MeterProps, "color" | "high" | "low" | "optimum"> & React$1.RefAttributes<HTMLDivElement>>;
3063
+
3064
+ declare const colorSwatchVariants: (props?: ({
3065
+ size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
3066
+ shape?: "circle" | "square" | null | undefined;
3067
+ interactive?: boolean | null | undefined;
3068
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3069
+ interface ColorSwatchProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "color" | "onSelect">, VariantProps<typeof colorSwatchVariants> {
3070
+ /** Color value (hex, rgb, hsl, etc.) */
3071
+ color: string;
3072
+ /** Whether the swatch is selected */
3073
+ isSelected?: boolean;
3074
+ /** Show checkered background for transparent colors */
3075
+ showTransparency?: boolean;
3076
+ /** Callback when swatch is clicked */
3077
+ onSelect?: (color: string) => void;
3078
+ }
3079
+ declare const ColorSwatch: React$1.ForwardRefExoticComponent<ColorSwatchProps & React$1.RefAttributes<HTMLButtonElement>>;
3080
+
3081
+ declare const colorSwatchPickerVariants: (props?: ({
3082
+ size?: "sm" | "md" | "lg" | null | undefined;
3083
+ layout?: "grid" | "wrap" | null | undefined;
3084
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3085
+ declare const defaultColors: string[];
3086
+ declare const tailwindColors: string[];
3087
+ declare const materialColors: string[];
3088
+ type ColorPalette = "default" | "tailwind" | "material" | string[];
3089
+ interface ColorSwatchPickerProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof colorSwatchPickerVariants> {
3090
+ /** Selected color value */
3091
+ value?: string;
3092
+ /** Default selected color */
3093
+ defaultValue?: string;
3094
+ /** Callback when color is selected */
3095
+ onChange?: (color: string) => void;
3096
+ /** Preset color palette or custom colors */
3097
+ colors?: ColorPalette;
3098
+ /** Custom color array (overrides colors prop) */
3099
+ customColors?: string[];
3100
+ /** Size of individual swatches */
3101
+ swatchSize?: "xs" | "sm" | "md" | "lg" | "xl";
3102
+ /** Shape of swatches */
3103
+ swatchShape?: "square" | "circle";
3104
+ /** Number of columns (for grid layout) */
3105
+ columns?: number;
3106
+ /** Whether selection is disabled */
3107
+ disabled?: boolean;
3108
+ /** Whether to show selection ring */
3109
+ showSelection?: boolean;
3110
+ }
3111
+ declare const ColorSwatchPicker: React$1.ForwardRefExoticComponent<ColorSwatchPickerProps & React$1.RefAttributes<HTMLDivElement>>;
3112
+
3113
+ declare const colorAreaVariants: (props?: ({
3114
+ size?: "sm" | "md" | "lg" | "full" | null | undefined;
3115
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3116
+ declare const hsvToRgb: (h: number, s: number, v: number) => [number, number, number];
3117
+ declare const rgbToHsv: (r: number, g: number, b: number) => [number, number, number];
3118
+ declare const hexToRgb: (hex: string) => [number, number, number] | null;
3119
+ declare const rgbToHex: (r: number, g: number, b: number) => string;
3120
+ interface ColorAreaValue {
3121
+ hue: number;
3122
+ saturation: number;
3123
+ brightness: number;
3124
+ }
3125
+ interface ColorAreaProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof colorAreaVariants> {
3126
+ /** Hue value (0-360) */
3127
+ hue?: number;
3128
+ /** Saturation value (0-1) */
3129
+ saturation?: number;
3130
+ /** Brightness/Value (0-1) */
3131
+ brightness?: number;
3132
+ /** Hex color value (alternative to hue/saturation/brightness) */
3133
+ value?: string;
3134
+ /** Default hex color */
3135
+ defaultValue?: string;
3136
+ /** Callback when color changes */
3137
+ onChange?: (value: ColorAreaValue) => void;
3138
+ /** Callback when hex color changes */
3139
+ onColorChange?: (color: string) => void;
3140
+ /** Whether the area is disabled */
3141
+ disabled?: boolean;
3142
+ /** Thumb size */
3143
+ thumbSize?: number;
3144
+ }
3145
+ declare const ColorArea: React$1.ForwardRefExoticComponent<ColorAreaProps & React$1.RefAttributes<HTMLDivElement>>;
3146
+
3147
+ declare const colorSliderVariants: (props?: ({
3148
+ orientation?: "horizontal" | "vertical" | null | undefined;
3149
+ size?: "sm" | "md" | "lg" | null | undefined;
3150
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3151
+ type ColorSliderChannel = "hue" | "alpha" | "saturation" | "brightness";
3152
+ interface ColorSliderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof colorSliderVariants> {
3153
+ /** Current value (0-360 for hue, 0-1 for others) */
3154
+ value?: number;
3155
+ /** Default value */
3156
+ defaultValue?: number;
3157
+ /** Callback when value changes */
3158
+ onChange?: (value: number) => void;
3159
+ /** Color channel type */
3160
+ channel?: ColorSliderChannel;
3161
+ /** Base color for alpha/saturation/brightness sliders (hex) */
3162
+ baseColor?: string;
3163
+ /** Whether the slider is disabled */
3164
+ disabled?: boolean;
3165
+ /** Thumb size */
3166
+ thumbSize?: number;
3167
+ /** Show track border */
3168
+ showBorder?: boolean;
3169
+ }
3170
+ declare const ColorSlider: React$1.ForwardRefExoticComponent<ColorSliderProps & React$1.RefAttributes<HTMLDivElement>>;
3171
+
3172
+ declare const colorWheelVariants: (props?: ({
3173
+ size?: "sm" | "md" | "lg" | null | undefined;
3174
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3175
+ interface ColorWheelProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof colorWheelVariants> {
3176
+ /** Hue value (0-360) */
3177
+ value?: number;
3178
+ /** Default hue value */
3179
+ defaultValue?: number;
3180
+ /** Callback when hue changes */
3181
+ onChange?: (hue: number) => void;
3182
+ /** Whether the wheel is disabled */
3183
+ disabled?: boolean;
3184
+ /** Inner radius ratio (0-1, where 1 is solid disc) */
3185
+ innerRadius?: number;
3186
+ /** Thumb size */
3187
+ thumbSize?: number;
3188
+ /** Show center dot */
3189
+ showCenter?: boolean;
3190
+ }
3191
+ declare const ColorWheel: React$1.ForwardRefExoticComponent<ColorWheelProps & React$1.RefAttributes<HTMLDivElement>>;
3192
+
3193
+ declare const flexVariants: (props?: ({
3194
+ direction?: "row" | "column" | "column-reverse" | "row-reverse" | null | undefined;
3195
+ align?: "center" | "end" | "start" | "baseline" | "stretch" | null | undefined;
3196
+ justify?: "center" | "end" | "start" | "between" | "around" | "evenly" | null | undefined;
3197
+ wrap?: "wrap" | "nowrap" | "wrap-reverse" | null | undefined;
3198
+ gap?: 0 | 1 | 2 | 4 | 3 | 5 | 6 | 10 | 12 | 8 | null | undefined;
3199
+ inline?: boolean | null | undefined;
3200
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3201
+ interface FlexProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof flexVariants> {
3202
+ /** Element to render as */
3203
+ as?: React$1.ElementType;
3204
+ }
3205
+ declare const Flex: React$1.ForwardRefExoticComponent<FlexProps & React$1.RefAttributes<HTMLDivElement>>;
3206
+ declare const HStack: React$1.ForwardRefExoticComponent<Omit<FlexProps, "direction"> & React$1.RefAttributes<HTMLDivElement>>;
3207
+ declare const VStack: React$1.ForwardRefExoticComponent<Omit<FlexProps, "direction"> & React$1.RefAttributes<HTMLDivElement>>;
3208
+ declare const Center: React$1.ForwardRefExoticComponent<Omit<FlexProps, "align" | "justify"> & React$1.RefAttributes<HTMLDivElement>>;
3209
+
3210
+ declare const gridVariants: (props?: ({
3211
+ columns?: 1 | "none" | "auto" | 2 | 4 | 3 | 5 | 6 | 7 | 10 | 12 | 8 | 9 | 11 | null | undefined;
3212
+ rows?: 1 | "none" | 2 | 4 | 3 | 5 | 6 | null | undefined;
3213
+ gap?: 0 | 1 | 2 | 4 | 3 | 5 | 6 | 10 | 12 | 8 | null | undefined;
3214
+ gapX?: 0 | 1 | 2 | 4 | 3 | 5 | 6 | 10 | 12 | 8 | null | undefined;
3215
+ gapY?: 0 | 1 | 2 | 4 | 3 | 5 | 6 | 10 | 12 | 8 | null | undefined;
3216
+ flow?: "row" | "col" | "dense" | "row-dense" | "col-dense" | null | undefined;
3217
+ align?: "center" | "end" | "start" | "baseline" | "stretch" | null | undefined;
3218
+ justify?: "center" | "end" | "start" | "stretch" | null | undefined;
3219
+ placeItems?: "center" | "end" | "start" | "stretch" | null | undefined;
3220
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3221
+ interface GridProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof gridVariants> {
3222
+ /** Element to render as */
3223
+ as?: React$1.ElementType;
3224
+ /** Min column width for auto columns */
3225
+ minChildWidth?: string;
3226
+ }
3227
+ declare const Grid: React$1.ForwardRefExoticComponent<GridProps & React$1.RefAttributes<HTMLDivElement>>;
3228
+ declare const gridItemVariants: (props?: ({
3229
+ colSpan?: 1 | 2 | 4 | 3 | 5 | "full" | 6 | 7 | 10 | 12 | 8 | 9 | 11 | null | undefined;
3230
+ rowSpan?: 1 | 2 | 4 | 3 | 5 | "full" | 6 | null | undefined;
3231
+ colStart?: 1 | "auto" | 2 | 4 | 3 | 5 | 6 | 7 | 10 | 12 | 8 | 9 | 11 | 13 | null | undefined;
3232
+ colEnd?: 1 | "auto" | 2 | 4 | 3 | 5 | 6 | 7 | 10 | 12 | 8 | 9 | 11 | 13 | null | undefined;
3233
+ rowStart?: 1 | "auto" | 2 | 4 | 3 | 5 | 6 | 7 | null | undefined;
3234
+ rowEnd?: 1 | "auto" | 2 | 4 | 3 | 5 | 6 | 7 | null | undefined;
3235
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3236
+ interface GridItemProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof gridItemVariants> {
3237
+ /** Element to render as */
3238
+ as?: React$1.ElementType;
3239
+ }
3240
+ declare const GridItem: React$1.ForwardRefExoticComponent<GridItemProps & React$1.RefAttributes<HTMLDivElement>>;
3241
+ declare const SimpleGrid: React$1.ForwardRefExoticComponent<Omit<GridProps, "columns"> & {
3242
+ columns?: number | {
3243
+ sm?: number;
3244
+ md?: number;
3245
+ lg?: number;
3246
+ xl?: number;
3247
+ };
3248
+ } & React$1.RefAttributes<HTMLDivElement>>;
3249
+
3250
+ declare const wellVariants: (props?: ({
3251
+ variant?: "outline" | "default" | "filled" | "subtle" | "sunken" | null | undefined;
3252
+ size?: "sm" | "md" | "lg" | "xl" | null | undefined;
3253
+ radius?: "none" | "sm" | "md" | "lg" | "xl" | "full" | null | undefined;
3254
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3255
+ interface WellProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof wellVariants> {
3256
+ /** Element to render as */
3257
+ as?: React$1.ElementType;
3258
+ }
3259
+ declare const Well: React$1.ForwardRefExoticComponent<WellProps & React$1.RefAttributes<HTMLDivElement>>;
3260
+
3261
+ declare const labeledValueVariants: (props?: ({
3262
+ orientation?: "horizontal" | "vertical" | null | undefined;
3263
+ size?: "sm" | "md" | "lg" | null | undefined;
3264
+ align?: "center" | "end" | "start" | null | undefined;
3265
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3266
+ interface LabeledValueProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children">, VariantProps<typeof labeledValueVariants> {
3267
+ /** Label text */
3268
+ label: React$1.ReactNode;
3269
+ /** Value content */
3270
+ value: React$1.ReactNode;
3271
+ /** Value font weight */
3272
+ valueWeight?: "normal" | "medium" | "semibold" | "bold";
3273
+ /** Use monospace font for value */
3274
+ mono?: boolean;
3275
+ /** Label width (for horizontal orientation) */
3276
+ labelWidth?: string | number;
3277
+ /** Custom label className */
3278
+ labelClassName?: string;
3279
+ /** Custom value className */
3280
+ valueClassName?: string;
3281
+ /** Show colon after label */
3282
+ showColon?: boolean;
3283
+ /** Copy value on click */
3284
+ copyable?: boolean;
3285
+ /** Callback when value is copied */
3286
+ onCopy?: () => void;
3287
+ }
3288
+ declare const LabeledValue: React$1.ForwardRefExoticComponent<LabeledValueProps & React$1.RefAttributes<HTMLDivElement>>;
3289
+ declare const labeledValueGroupVariants: (props?: ({
3290
+ orientation?: "horizontal" | "vertical" | null | undefined;
3291
+ gap?: "sm" | "md" | "lg" | null | undefined;
3292
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3293
+ interface LabeledValueGroupProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof labeledValueGroupVariants> {
3294
+ }
3295
+ declare const LabeledValueGroup: React$1.ForwardRefExoticComponent<LabeledValueGroupProps & React$1.RefAttributes<HTMLDivElement>>;
3296
+
3297
+ declare const searchBarVariants: (props?: ({
3298
+ size?: "sm" | "md" | "lg" | null | undefined;
3299
+ variant?: "ghost" | "default" | "filled" | null | undefined;
3300
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3301
+ interface SearchSuggestion {
3302
+ id: string;
3303
+ label: string;
3304
+ description?: string;
3305
+ icon?: React$1.ReactNode;
3306
+ category?: string;
3307
+ href?: string;
3308
+ }
3309
+ interface SearchBarProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size" | "onChange" | "onSelect">, VariantProps<typeof searchBarVariants> {
3310
+ /** Search value */
3311
+ value?: string;
3312
+ /** Default value */
3313
+ defaultValue?: string;
3314
+ /** Callback when value changes */
3315
+ onChange?: (value: string) => void;
3316
+ /** Callback when search is submitted */
3317
+ onSearch?: (value: string) => void;
3318
+ /** Callback when suggestion is selected */
3319
+ onSelect?: (suggestion: SearchSuggestion) => void;
3320
+ /** Search suggestions */
3321
+ suggestions?: SearchSuggestion[];
3322
+ /** Recent searches */
3323
+ recentSearches?: string[];
3324
+ /** Callback to clear recent searches */
3325
+ onClearRecentSearches?: () => void;
3326
+ /** Trending/popular searches */
3327
+ trendingSearches?: string[];
3328
+ /** Loading state for suggestions */
3329
+ isLoading?: boolean;
3330
+ /** Show clear button */
3331
+ showClear?: boolean;
3332
+ /** Show search icon */
3333
+ showIcon?: boolean;
3334
+ /** Popover width */
3335
+ popoverWidth?: number | "trigger";
3336
+ /** Empty state message */
3337
+ emptyMessage?: string;
3338
+ }
3339
+ declare const SearchBar: React$1.ForwardRefExoticComponent<SearchBarProps & React$1.RefAttributes<HTMLInputElement>>;
3340
+
3341
+ interface SpotlightItem {
3342
+ id: string;
3343
+ label: string;
3344
+ description?: string;
3345
+ icon?: React$1.ReactNode;
3346
+ category?: string;
3347
+ keywords?: string[];
3348
+ shortcut?: string[];
3349
+ onSelect?: () => void;
3350
+ href?: string;
3351
+ }
3352
+ interface SpotlightSearchProps {
3353
+ /** Whether the spotlight is open */
3354
+ open?: boolean;
3355
+ /** Callback when open state changes */
3356
+ onOpenChange?: (open: boolean) => void;
3357
+ /** Search items */
3358
+ items?: SpotlightItem[];
3359
+ /** Recent items */
3360
+ recentItems?: SpotlightItem[];
3361
+ /** Placeholder text */
3362
+ placeholder?: string;
3363
+ /** Loading state */
3364
+ isLoading?: boolean;
3365
+ /** Empty state message */
3366
+ emptyMessage?: string;
3367
+ /** Custom filter function */
3368
+ filter?: (value: string, search: string) => number;
3369
+ /** Keyboard shortcut to open (displayed in UI) */
3370
+ shortcut?: string;
3371
+ /** Callback when item is selected */
3372
+ onSelect?: (item: SpotlightItem) => void;
3373
+ /** Custom footer content */
3374
+ footer?: React$1.ReactNode;
3375
+ }
3376
+ declare const SpotlightSearch: React$1.ForwardRefExoticComponent<SpotlightSearchProps & React$1.RefAttributes<HTMLDivElement>>;
3377
+ declare function useSpotlight(shortcut?: string): {
3378
+ open: boolean;
3379
+ setOpen: React$1.Dispatch<React$1.SetStateAction<boolean>>;
3380
+ toggle: () => void;
3381
+ };
3382
+
3383
+ declare const notificationCenterVariants: (props?: ({
3384
+ size?: "sm" | "md" | "lg" | null | undefined;
3385
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3386
+ type NotificationType = "info" | "success" | "warning" | "error" | "default";
3387
+ interface Notification {
3388
+ id: string;
3389
+ title: string;
3390
+ description?: string;
3391
+ timestamp: Date | string;
3392
+ read?: boolean;
3393
+ type?: NotificationType;
3394
+ icon?: React$1.ReactNode;
3395
+ avatar?: string;
3396
+ action?: {
3397
+ label: string;
3398
+ onClick: () => void;
3399
+ };
3400
+ onDismiss?: () => void;
3401
+ }
3402
+ interface NotificationCenterProps extends VariantProps<typeof notificationCenterVariants> {
3403
+ /** Notifications list */
3404
+ notifications?: Notification[];
3405
+ /** Callback when notification is clicked */
3406
+ onNotificationClick?: (notification: Notification) => void;
3407
+ /** Callback to mark notification as read */
3408
+ onMarkAsRead?: (id: string) => void;
3409
+ /** Callback to mark all as read */
3410
+ onMarkAllAsRead?: () => void;
3411
+ /** Callback to dismiss notification */
3412
+ onDismiss?: (id: string) => void;
3413
+ /** Callback to clear all */
3414
+ onClearAll?: () => void;
3415
+ /** Show settings button */
3416
+ showSettings?: boolean;
3417
+ /** Settings click handler */
3418
+ onSettingsClick?: () => void;
3419
+ /** Custom trigger */
3420
+ trigger?: React$1.ReactNode;
3421
+ /** Popover alignment */
3422
+ align?: "start" | "center" | "end";
3423
+ /** Empty state message */
3424
+ emptyMessage?: string;
3425
+ /** Max height of notification list */
3426
+ maxHeight?: number;
3427
+ /** Custom class */
3428
+ className?: string;
3429
+ }
3430
+ declare const NotificationCenter: React$1.ForwardRefExoticComponent<NotificationCenterProps & React$1.RefAttributes<HTMLButtonElement>>;
3431
+
3432
+ declare const announcementBannerVariants: (props?: ({
3433
+ variant?: "default" | "primary" | "success" | "warning" | "danger" | "info" | "gradient" | null | undefined;
3434
+ position?: "top" | "relative" | null | undefined;
3435
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3436
+ interface AnnouncementBannerProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof announcementBannerVariants> {
3437
+ /** Banner message */
3438
+ message: React$1.ReactNode;
3439
+ /** Show icon */
3440
+ showIcon?: boolean;
3441
+ /** Custom icon */
3442
+ icon?: React$1.ReactNode;
3443
+ /** Dismissible */
3444
+ dismissible?: boolean;
3445
+ /** Callback when dismissed */
3446
+ onDismiss?: () => void;
3447
+ /** Action button */
3448
+ action?: {
3449
+ label: string;
3450
+ onClick?: () => void;
3451
+ href?: string;
3452
+ };
3453
+ /** Animate the banner */
3454
+ animate?: boolean;
3455
+ /** Auto dismiss after ms */
3456
+ autoDismiss?: number;
3457
+ /** Storage key for persistence */
3458
+ storageKey?: string;
3459
+ }
3460
+ declare const AnnouncementBanner: React$1.ForwardRefExoticComponent<AnnouncementBannerProps & React$1.RefAttributes<HTMLDivElement>>;
3461
+
3462
+ declare const fabVariants: (props?: ({
3463
+ variant?: "outline" | "ghost" | "destructive" | "default" | "secondary" | null | undefined;
3464
+ size?: "sm" | "md" | "lg" | null | undefined;
3465
+ position?: "relative" | "bottom-right" | "bottom-left" | "bottom-center" | null | undefined;
3466
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3467
+ interface FABAction {
3468
+ id: string;
3469
+ icon: React$1.ReactNode;
3470
+ label: string;
3471
+ onClick?: () => void;
3472
+ href?: string;
3473
+ variant?: "default" | "secondary" | "destructive";
3474
+ }
3475
+ interface FloatingActionButtonProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "children">, VariantProps<typeof fabVariants> {
3476
+ /** Main button icon */
3477
+ icon?: React$1.ReactNode;
3478
+ /** Label for accessibility */
3479
+ label?: string;
3480
+ /** Extended label (shows text next to icon) */
3481
+ extended?: boolean;
3482
+ /** Extended label text */
3483
+ extendedLabel?: string;
3484
+ /** Speed dial actions */
3485
+ actions?: FABAction[];
3486
+ /** Speed dial direction */
3487
+ direction?: "up" | "down" | "left" | "right";
3488
+ /** Show tooltip on hover */
3489
+ showTooltip?: boolean;
3490
+ /** Custom close icon for speed dial */
3491
+ closeIcon?: React$1.ReactNode;
3492
+ /** Animation type */
3493
+ animation?: "scale" | "rotate" | "none";
3494
+ }
3495
+ declare const FloatingActionButton: React$1.ForwardRefExoticComponent<FloatingActionButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
3496
+ declare const FAB: React$1.ForwardRefExoticComponent<FloatingActionButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
3497
+
3498
+ declare const bottomNavigationVariants: (props?: ({
3499
+ variant?: "default" | "filled" | "elevated" | null | undefined;
3500
+ size?: "sm" | "md" | "lg" | null | undefined;
3501
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3502
+ interface BottomNavigationItem {
3503
+ key: string;
3504
+ label: string;
3505
+ icon: React$1.ReactNode;
3506
+ activeIcon?: React$1.ReactNode;
3507
+ badge?: number | string;
3508
+ href?: string;
3509
+ onClick?: () => void;
3510
+ }
3511
+ interface BottomNavigationProps extends Omit<React$1.HTMLAttributes<HTMLElement>, "onChange">, VariantProps<typeof bottomNavigationVariants> {
3512
+ /** Navigation items */
3513
+ items: BottomNavigationItem[];
3514
+ /** Active item key */
3515
+ activeKey?: string;
3516
+ /** Default active key */
3517
+ defaultActiveKey?: string;
3518
+ /** Called when active item changes */
3519
+ onChange?: (key: string) => void;
3520
+ /** When to show labels */
3521
+ showLabels?: "always" | "active" | "never";
3522
+ /** Hide on scroll down */
3523
+ hideOnScroll?: boolean;
3524
+ }
3525
+ declare const BottomNavigation: React$1.ForwardRefExoticComponent<BottomNavigationProps & React$1.RefAttributes<HTMLElement>>;
3526
+
3527
+ declare const actionSheetVariants: (props?: ({
3528
+ size?: "sm" | "md" | "lg" | "full" | null | undefined;
3529
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3530
+ declare const actionSheetItemVariants: (props?: ({
3531
+ variant?: "destructive" | "default" | null | undefined;
3532
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3533
+ interface ActionSheetItem {
3534
+ key: string;
3535
+ label: string;
3536
+ icon?: React$1.ReactNode;
3537
+ description?: string;
3538
+ isDisabled?: boolean;
3539
+ isDestructive?: boolean;
3540
+ onSelect?: () => void;
3541
+ }
3542
+ interface ActionSheetProps extends VariantProps<typeof actionSheetVariants> {
3543
+ /** Whether the sheet is open */
3544
+ open?: boolean;
3545
+ /** Called when open state changes */
3546
+ onOpenChange?: (open: boolean) => void;
3547
+ /** Trigger element */
3548
+ trigger?: React$1.ReactNode;
3549
+ /** Sheet title */
3550
+ title?: string;
3551
+ /** Sheet description */
3552
+ description?: string;
3553
+ /** Action items */
3554
+ items?: ActionSheetItem[];
3555
+ /** Cancel button label */
3556
+ cancelLabel?: string;
3557
+ /** Called when cancel is clicked */
3558
+ onCancel?: () => void;
3559
+ /** Show cancel button */
3560
+ showCancel?: boolean;
3561
+ /** Custom content (instead of items) */
3562
+ children?: React$1.ReactNode;
3563
+ /** Close on item select */
3564
+ closeOnSelect?: boolean;
3565
+ /** Called when an item is selected */
3566
+ onAction?: (key: string) => void;
3567
+ }
3568
+ declare const ActionSheet: React$1.ForwardRefExoticComponent<ActionSheetProps & React$1.RefAttributes<HTMLDivElement>>;
3569
+
3570
+ declare const swipeActionsVariants: (props?: ({
3571
+ variant?: "default" | "card" | null | undefined;
3572
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3573
+ declare const swipeActionVariants: (props?: ({
3574
+ variant?: "primary" | "secondary" | "success" | "warning" | "danger" | "info" | null | undefined;
3575
+ size?: "sm" | "md" | "lg" | null | undefined;
3576
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3577
+ interface SwipeAction {
3578
+ key: string;
3579
+ label: string;
3580
+ icon?: React$1.ReactNode;
3581
+ variant?: "primary" | "secondary" | "success" | "warning" | "danger" | "info";
3582
+ onAction?: () => void;
3583
+ }
3584
+ interface SwipeActionsProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof swipeActionsVariants> {
3585
+ /** Left swipe actions (revealed when swiping right) */
3586
+ leftActions?: SwipeAction[];
3587
+ /** Right swipe actions (revealed when swiping left) */
3588
+ rightActions?: SwipeAction[];
3589
+ /** Action button size */
3590
+ actionSize?: "sm" | "md" | "lg";
3591
+ /** Threshold to trigger action (0-1) */
3592
+ threshold?: number;
3593
+ /** Called when swiped past threshold */
3594
+ onSwipeEnd?: (direction: "left" | "right", actionKey?: string) => void;
3595
+ /** Disable swipe */
3596
+ disabled?: boolean;
3597
+ /** Full swipe action (triggered when swiped completely) */
3598
+ fullSwipeAction?: "left" | "right";
3599
+ }
3600
+ declare const SwipeActions: React$1.ForwardRefExoticComponent<SwipeActionsProps & React$1.RefAttributes<HTMLDivElement>>;
3601
+
3602
+ declare const pullToRefreshVariants: (props?: ({
3603
+ variant?: "default" | "contained" | null | undefined;
3604
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3605
+ interface PullToRefreshProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof pullToRefreshVariants> {
3606
+ /** Called when pull to refresh is triggered */
3607
+ onRefresh: () => Promise<void>;
3608
+ /** Minimum distance to trigger refresh */
3609
+ pullThreshold?: number;
3610
+ /** Maximum pull distance */
3611
+ maxPullDistance?: number;
3612
+ /** Custom loading indicator */
3613
+ loadingIndicator?: React$1.ReactNode;
3614
+ /** Custom pull indicator */
3615
+ pullIndicator?: React$1.ReactNode;
3616
+ /** Indicator size */
3617
+ indicatorSize?: "sm" | "md" | "lg";
3618
+ /** Disable pull to refresh */
3619
+ disabled?: boolean;
3620
+ /** Custom pull text */
3621
+ pullText?: string;
3622
+ /** Custom release text */
3623
+ releaseText?: string;
3624
+ /** Custom refreshing text */
3625
+ refreshingText?: string;
3626
+ }
3627
+ declare const PullToRefresh: React$1.ForwardRefExoticComponent<PullToRefreshProps & React$1.RefAttributes<HTMLDivElement>>;
3628
+
3629
+ declare const appShellVariants: (props?: ({
3630
+ layout?: "sidebar" | "default" | null | undefined;
3631
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3632
+ interface AppShellProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof appShellVariants> {
3633
+ /** Fixed header that stays at top */
3634
+ header?: React$1.ReactNode;
3635
+ /** Fixed footer that stays at bottom */
3636
+ footer?: React$1.ReactNode;
3637
+ /** Sidebar content (left side) */
3638
+ sidebar?: React$1.ReactNode;
3639
+ /** Right sidebar content */
3640
+ aside?: React$1.ReactNode;
3641
+ /** Whether sidebar is collapsed */
3642
+ sidebarCollapsed?: boolean;
3643
+ /** Width of sidebar when expanded */
3644
+ sidebarWidth?: string;
3645
+ /** Width of sidebar when collapsed */
3646
+ sidebarCollapsedWidth?: string;
3647
+ /** Width of aside */
3648
+ asideWidth?: string;
3649
+ /** Whether the layout is fixed (header/footer stick) */
3650
+ fixed?: boolean;
3651
+ }
3652
+ declare const AppShell: React$1.ForwardRefExoticComponent<AppShellProps & React$1.RefAttributes<HTMLDivElement>>;
3653
+ interface AppShellHeaderProps extends React$1.HTMLAttributes<HTMLElement> {
3654
+ fixed?: boolean;
3655
+ hasSidebar?: boolean;
3656
+ }
3657
+ declare const AppShellHeader: React$1.ForwardRefExoticComponent<AppShellHeaderProps & React$1.RefAttributes<HTMLElement>>;
3658
+ interface AppShellSidebarProps extends React$1.HTMLAttributes<HTMLElement> {
3659
+ collapsed?: boolean;
3660
+ fixed?: boolean;
3661
+ }
3662
+ declare const AppShellSidebar: React$1.ForwardRefExoticComponent<AppShellSidebarProps & React$1.RefAttributes<HTMLElement>>;
3663
+ interface AppShellAsideProps extends React$1.HTMLAttributes<HTMLElement> {
3664
+ fixed?: boolean;
3665
+ }
3666
+ declare const AppShellAside: React$1.ForwardRefExoticComponent<AppShellAsideProps & React$1.RefAttributes<HTMLElement>>;
3667
+ interface AppShellFooterProps extends React$1.HTMLAttributes<HTMLElement> {
3668
+ fixed?: boolean;
3669
+ hasSidebar?: boolean;
3670
+ }
3671
+ declare const AppShellFooter: React$1.ForwardRefExoticComponent<AppShellFooterProps & React$1.RefAttributes<HTMLElement>>;
3672
+ declare const AppShellMain: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
3673
+
3674
+ declare const dashboardLayoutVariants: (props?: ({
3675
+ variant?: "default" | "filled" | "bordered" | null | undefined;
3676
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3677
+ interface DashboardLayoutProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof dashboardLayoutVariants> {
3678
+ /** Navigation items for sidebar */
3679
+ navigation?: React$1.ReactNode;
3680
+ /** Logo/brand element */
3681
+ logo?: React$1.ReactNode;
3682
+ /** User menu/profile element */
3683
+ userMenu?: React$1.ReactNode;
3684
+ /** Header actions (notifications, etc) */
3685
+ headerActions?: React$1.ReactNode;
3686
+ /** Breadcrumb element */
3687
+ breadcrumb?: React$1.ReactNode;
3688
+ /** Default collapsed state */
3689
+ defaultCollapsed?: boolean;
3690
+ /** Controlled collapsed state */
3691
+ collapsed?: boolean;
3692
+ /** Callback when collapsed state changes */
3693
+ onCollapsedChange?: (collapsed: boolean) => void;
3694
+ }
3695
+ declare const DashboardLayout: React$1.ForwardRefExoticComponent<DashboardLayoutProps & React$1.RefAttributes<HTMLDivElement>>;
3696
+ declare const DashboardPage: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
3697
+ interface DashboardPageHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
3698
+ title?: string;
3699
+ description?: string;
3700
+ actions?: React$1.ReactNode;
3701
+ }
3702
+ declare const DashboardPageHeader: React$1.ForwardRefExoticComponent<DashboardPageHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
3703
+ declare const DashboardGrid: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
3704
+ columns?: 1 | 2 | 3 | 4;
3705
+ } & React$1.RefAttributes<HTMLDivElement>>;
3706
+
3707
+ declare const authLayoutVariants: (props?: ({
3708
+ variant?: "split" | "cover" | "centered" | null | undefined;
3709
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3710
+ interface AuthLayoutProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof authLayoutVariants> {
3711
+ /** Logo element */
3712
+ logo?: React$1.ReactNode;
3713
+ /** Side panel content (for split variant) */
3714
+ sideContent?: React$1.ReactNode;
3715
+ /** Background image URL (for cover variant) */
3716
+ backgroundImage?: string;
3717
+ /** Side panel position */
3718
+ sidePosition?: "left" | "right";
3719
+ /** Footer content */
3720
+ footer?: React$1.ReactNode;
3721
+ }
3722
+ declare const AuthLayout: React$1.ForwardRefExoticComponent<AuthLayoutProps & React$1.RefAttributes<HTMLDivElement>>;
3723
+ declare const AuthForm: React$1.ForwardRefExoticComponent<React$1.FormHTMLAttributes<HTMLFormElement> & React$1.RefAttributes<HTMLFormElement>>;
3724
+ interface AuthHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
3725
+ title?: string;
3726
+ description?: string;
3727
+ }
3728
+ declare const AuthHeader: React$1.ForwardRefExoticComponent<AuthHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
3729
+ declare const AuthFooterLinks: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
3730
+ declare const AuthDivider: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
3731
+ text?: string;
3732
+ } & React$1.RefAttributes<HTMLDivElement>>;
3733
+ declare const AuthSocialButtons: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
3734
+
3735
+ declare const settingsLayoutVariants: (props?: ({
3736
+ variant?: "sidebar" | "stacked" | "tabs" | null | undefined;
3737
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
3738
+ interface SettingsLayoutProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof settingsLayoutVariants> {
3739
+ /** Navigation element (sidebar or tabs) */
3740
+ navigation?: React$1.ReactNode;
3741
+ /** Page title */
3742
+ title?: string;
3743
+ /** Page description */
3744
+ description?: string;
3745
+ }
3746
+ declare const SettingsLayout: React$1.ForwardRefExoticComponent<SettingsLayoutProps & React$1.RefAttributes<HTMLDivElement>>;
3747
+ interface SettingsHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
3748
+ title?: string;
3749
+ description?: string;
3750
+ }
3751
+ declare const SettingsHeader: React$1.ForwardRefExoticComponent<SettingsHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
3752
+ interface SettingsSectionProps extends React$1.HTMLAttributes<HTMLDivElement> {
3753
+ title?: string;
3754
+ description?: string;
3755
+ }
3756
+ declare const SettingsSection: React$1.ForwardRefExoticComponent<SettingsSectionProps & React$1.RefAttributes<HTMLDivElement>>;
3757
+ declare const SettingsCard: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
3758
+ interface SettingsRowProps extends React$1.HTMLAttributes<HTMLDivElement> {
3759
+ label?: string;
3760
+ description?: string;
3761
+ htmlFor?: string;
3762
+ }
3763
+ declare const SettingsRow: React$1.ForwardRefExoticComponent<SettingsRowProps & React$1.RefAttributes<HTMLDivElement>>;
3764
+ interface SettingsNavItemProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
3765
+ active?: boolean;
3766
+ icon?: React$1.ReactNode;
3767
+ }
3768
+ declare const SettingsNavItem: React$1.ForwardRefExoticComponent<SettingsNavItemProps & React$1.RefAttributes<HTMLButtonElement>>;
3769
+ declare const SettingsSeparator: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
3770
+
3771
+ interface TransitionProps {
3772
+ /** Whether the component is visible */
3773
+ show?: boolean;
3774
+ /** Children to animate */
3775
+ children: React$1.ReactNode;
3776
+ /** Duration in seconds */
3777
+ duration?: number;
3778
+ /** Delay in seconds */
3779
+ delay?: number;
3780
+ /** Easing function */
3781
+ ease?: Transition["ease"];
3782
+ /** Additional class names */
3783
+ className?: string;
3784
+ /** Whether to unmount when hidden */
3785
+ unmountOnExit?: boolean;
3786
+ /** Callback when animation starts */
3787
+ onAnimationStart?: () => void;
3788
+ /** Callback when animation completes */
3789
+ onAnimationComplete?: () => void;
3790
+ }
3791
+ interface FadeProps extends TransitionProps {
3792
+ /** Initial opacity */
3793
+ initialOpacity?: number;
3794
+ }
3795
+ declare const Fade: React$1.ForwardRefExoticComponent<FadeProps & React$1.RefAttributes<HTMLDivElement>>;
3796
+ type SlideDirection = "up" | "down" | "left" | "right";
3797
+ interface SlideProps extends TransitionProps {
3798
+ /** Direction to slide from */
3799
+ direction?: SlideDirection;
3800
+ /** Distance to slide (in pixels or percentage) */
3801
+ offset?: number | string;
3802
+ }
3803
+ declare const Slide: React$1.ForwardRefExoticComponent<SlideProps & React$1.RefAttributes<HTMLDivElement>>;
3804
+ type ScaleOrigin = "center" | "top" | "bottom" | "left" | "right" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
3805
+ interface ScaleProps extends TransitionProps {
3806
+ /** Initial scale */
3807
+ initialScale?: number;
3808
+ /** Transform origin */
3809
+ origin?: ScaleOrigin;
3810
+ }
3811
+ declare const Scale: React$1.ForwardRefExoticComponent<ScaleProps & React$1.RefAttributes<HTMLDivElement>>;
3812
+ interface CollapseProps extends Omit<TransitionProps, "unmountOnExit"> {
3813
+ /** Whether to animate width instead of height */
3814
+ horizontal?: boolean;
3815
+ /** Starting size (for exit animation) */
3816
+ startingSize?: number;
3817
+ /** Animate opacity along with size */
3818
+ animateOpacity?: boolean;
3819
+ }
3820
+ declare const Collapse: React$1.ForwardRefExoticComponent<CollapseProps & React$1.RefAttributes<HTMLDivElement>>;
3821
+ interface ExpandProps extends Omit<TransitionProps, "unmountOnExit"> {
3822
+ /** Initial width */
3823
+ initialWidth?: number | string;
3824
+ /** Initial height */
3825
+ initialHeight?: number | string;
3826
+ /** Animate opacity */
3827
+ animateOpacity?: boolean;
3828
+ }
3829
+ declare const Expand: React$1.ForwardRefExoticComponent<ExpandProps & React$1.RefAttributes<HTMLDivElement>>;
3830
+ interface RotateProps extends TransitionProps {
3831
+ /** Initial rotation in degrees */
3832
+ initialRotation?: number;
3833
+ /** Final rotation in degrees */
3834
+ finalRotation?: number;
3835
+ }
3836
+ declare const Rotate: React$1.ForwardRefExoticComponent<RotateProps & React$1.RefAttributes<HTMLDivElement>>;
3837
+ type FlipDirection = "horizontal" | "vertical";
3838
+ interface FlipProps extends Omit<TransitionProps, "children"> {
3839
+ /** Front content */
3840
+ front: React$1.ReactNode;
3841
+ /** Back content */
3842
+ back: React$1.ReactNode;
3843
+ /** Flip direction */
3844
+ direction?: FlipDirection;
3845
+ /** Whether to show back (flipped state) */
3846
+ flipped?: boolean;
3847
+ }
3848
+ declare const Flip: React$1.ForwardRefExoticComponent<FlipProps & React$1.RefAttributes<HTMLDivElement>>;
3849
+
3850
+ interface RippleProps {
3851
+ /** Color of ripple */
3852
+ color?: string;
3853
+ /** Duration of ripple animation */
3854
+ duration?: number;
3855
+ /** Children to wrap */
3856
+ children: React$1.ReactNode;
3857
+ /** Additional class names */
3858
+ className?: string;
3859
+ /** Disable ripple */
3860
+ disabled?: boolean;
3861
+ }
3862
+ declare const Ripple: React$1.ForwardRefExoticComponent<RippleProps & React$1.RefAttributes<HTMLDivElement>>;
3863
+ interface BounceProps {
3864
+ /** Children to animate */
3865
+ children: React$1.ReactNode;
3866
+ /** Whether to animate */
3867
+ animate?: boolean;
3868
+ /** Bounce height in pixels */
3869
+ height?: number;
3870
+ /** Duration of one bounce cycle */
3871
+ duration?: number;
3872
+ /** Number of bounces (0 = infinite) */
3873
+ count?: number;
3874
+ /** Additional class names */
3875
+ className?: string;
3876
+ /** Trigger on hover */
3877
+ triggerOnHover?: boolean;
3878
+ }
3879
+ declare const Bounce: React$1.ForwardRefExoticComponent<BounceProps & React$1.RefAttributes<HTMLDivElement>>;
3880
+ type ShakeIntensity = "subtle" | "normal" | "strong";
3881
+ interface ShakeProps {
3882
+ /** Children to animate */
3883
+ children: React$1.ReactNode;
3884
+ /** Whether to shake */
3885
+ animate?: boolean;
3886
+ /** Shake intensity */
3887
+ intensity?: ShakeIntensity;
3888
+ /** Duration of shake animation */
3889
+ duration?: number;
3890
+ /** Number of shakes */
3891
+ count?: number;
3892
+ /** Additional class names */
3893
+ className?: string;
3894
+ /** Trigger on hover */
3895
+ triggerOnHover?: boolean;
3896
+ }
3897
+ declare const Shake: React$1.ForwardRefExoticComponent<ShakeProps & React$1.RefAttributes<HTMLDivElement>>;
3898
+ type PulseSpeed = "slow" | "normal" | "fast";
3899
+ interface PulseProps {
3900
+ /** Children to animate */
3901
+ children: React$1.ReactNode;
3902
+ /** Whether to pulse */
3903
+ animate?: boolean;
3904
+ /** Pulse speed */
3905
+ speed?: PulseSpeed;
3906
+ /** Additional class names */
3907
+ className?: string;
3908
+ }
3909
+ declare const Pulse: React$1.ForwardRefExoticComponent<PulseProps & React$1.RefAttributes<HTMLDivElement>>;
3910
+ interface WiggleProps {
3911
+ /** Children to animate */
3912
+ children: React$1.ReactNode;
3913
+ /** Whether to wiggle */
3914
+ animate?: boolean;
3915
+ /** Rotation angle in degrees */
3916
+ angle?: number;
3917
+ /** Duration of wiggle */
3918
+ duration?: number;
3919
+ /** Number of wiggles (0 = infinite) */
3920
+ count?: number;
3921
+ /** Additional class names */
3922
+ className?: string;
3923
+ /** Trigger on hover */
3924
+ triggerOnHover?: boolean;
3925
+ }
3926
+ declare const Wiggle: React$1.ForwardRefExoticComponent<WiggleProps & React$1.RefAttributes<HTMLDivElement>>;
3927
+ interface PopProps {
3928
+ /** Children to animate */
3929
+ children: React$1.ReactNode;
3930
+ /** Whether to animate */
3931
+ animate?: boolean;
3932
+ /** Scale factor for pop */
3933
+ scale?: number;
3934
+ /** Duration of pop */
3935
+ duration?: number;
3936
+ /** Additional class names */
3937
+ className?: string;
3938
+ /** Trigger on hover */
3939
+ triggerOnHover?: boolean;
3940
+ /** Trigger on click */
3941
+ triggerOnClick?: boolean;
3942
+ }
3943
+ declare const Pop: React$1.ForwardRefExoticComponent<PopProps & React$1.RefAttributes<HTMLDivElement>>;
3944
+
3945
+ interface CounterProps {
3946
+ /** Target value to count to */
3947
+ value: number;
3948
+ /** Starting value */
3949
+ from?: number;
3950
+ /** Duration in seconds */
3951
+ duration?: number;
3952
+ /** Number of decimal places */
3953
+ decimals?: number;
3954
+ /** Prefix (e.g., "$") */
3955
+ prefix?: string;
3956
+ /** Suffix (e.g., "%") */
3957
+ suffix?: string;
3958
+ /** Thousand separator */
3959
+ separator?: string;
3960
+ /** Decimal separator */
3961
+ decimalSeparator?: string;
3962
+ /** Start animation when in view */
3963
+ animateOnView?: boolean;
3964
+ /** Delay before animation starts */
3965
+ delay?: number;
3966
+ /** Additional class names */
3967
+ className?: string;
3968
+ /** Callback when animation completes */
3969
+ onComplete?: () => void;
3970
+ }
3971
+ declare const Counter: React$1.ForwardRefExoticComponent<CounterProps & React$1.RefAttributes<HTMLSpanElement>>;
3972
+ interface TypewriterProps {
3973
+ /** Text to type */
3974
+ text: string | string[];
3975
+ /** Typing speed (ms per character) */
3976
+ speed?: number;
3977
+ /** Delay before starting */
3978
+ delay?: number;
3979
+ /** Delay between texts (if array) */
3980
+ pauseBetween?: number;
3981
+ /** Show cursor */
3982
+ cursor?: boolean;
3983
+ /** Cursor character */
3984
+ cursorChar?: string;
3985
+ /** Loop animation */
3986
+ loop?: boolean;
3987
+ /** Delete text after typing (for loop) */
3988
+ deleteSpeed?: number;
3989
+ /** Start animation when in view */
3990
+ animateOnView?: boolean;
3991
+ /** Additional class names */
3992
+ className?: string;
3993
+ /** Cursor class names */
3994
+ cursorClassName?: string;
3995
+ /** Callback when typing completes */
3996
+ onComplete?: () => void;
3997
+ }
3998
+ declare const Typewriter: React$1.ForwardRefExoticComponent<TypewriterProps & React$1.RefAttributes<HTMLSpanElement>>;
3999
+ type TextRevealDirection = "up" | "down" | "left" | "right";
4000
+ interface TextRevealProps {
4001
+ /** Text or children to reveal */
4002
+ children: React$1.ReactNode;
4003
+ /** Animation direction */
4004
+ direction?: TextRevealDirection;
4005
+ /** Stagger delay between characters/words */
4006
+ stagger?: number;
4007
+ /** Animation duration */
4008
+ duration?: number;
4009
+ /** Initial delay */
4010
+ delay?: number;
4011
+ /** Split by word or character */
4012
+ splitBy?: "word" | "character";
4013
+ /** Start animation when in view */
4014
+ animateOnView?: boolean;
4015
+ /** Additional class names */
4016
+ className?: string;
4017
+ }
4018
+ declare const TextReveal: React$1.ForwardRefExoticComponent<TextRevealProps & React$1.RefAttributes<HTMLDivElement>>;
4019
+ interface WordRotateProps {
4020
+ /** Words to rotate through */
4021
+ words: string[];
4022
+ /** Duration each word is shown */
4023
+ duration?: number;
4024
+ /** Animation type */
4025
+ animation?: "fade" | "slide" | "scale" | "blur";
4026
+ /** Animation duration */
4027
+ animationDuration?: number;
4028
+ /** Additional class names */
4029
+ className?: string;
4030
+ /** Loop animation */
4031
+ loop?: boolean;
4032
+ }
4033
+ declare const WordRotate: React$1.ForwardRefExoticComponent<WordRotateProps & React$1.RefAttributes<HTMLSpanElement>>;
4034
+
4035
+ type ScrollRevealDirection = "up" | "down" | "left" | "right" | "none";
4036
+ interface ScrollRevealProps {
4037
+ /** Children to reveal */
4038
+ children: React$1.ReactNode;
4039
+ /** Direction to animate from */
4040
+ direction?: ScrollRevealDirection;
4041
+ /** Distance to animate */
4042
+ distance?: number;
4043
+ /** Animation duration */
4044
+ duration?: number;
4045
+ /** Animation delay */
4046
+ delay?: number;
4047
+ /** Animate once or every time in view */
4048
+ once?: boolean;
4049
+ /** Amount of element visible to trigger (0-1) */
4050
+ threshold?: number;
4051
+ /** Additional class names */
4052
+ className?: string;
4053
+ /** Scale animation */
4054
+ scale?: number;
4055
+ /** Rotate animation (degrees) */
4056
+ rotate?: number;
4057
+ /** Blur animation */
4058
+ blur?: number;
4059
+ /** Custom easing */
4060
+ ease?: readonly [number, number, number, number];
4061
+ }
4062
+ declare const ScrollReveal: React$1.ForwardRefExoticComponent<ScrollRevealProps & React$1.RefAttributes<HTMLDivElement>>;
4063
+ type ScrollProgressPosition = "top" | "bottom" | "left" | "right";
4064
+ interface ScrollProgressProps {
4065
+ /** Position of progress bar */
4066
+ position?: ScrollProgressPosition;
4067
+ /** Height/width of progress bar */
4068
+ size?: number;
4069
+ /** Color of progress bar */
4070
+ color?: string;
4071
+ /** Background color */
4072
+ backgroundColor?: string;
4073
+ /** Z-index */
4074
+ zIndex?: number;
4075
+ /** Additional class names */
4076
+ className?: string;
4077
+ /** Container to track (default: window) */
4078
+ container?: React$1.RefObject<HTMLElement | null>;
4079
+ /** Show percentage text */
4080
+ showPercentage?: boolean;
4081
+ /** Use spring animation */
4082
+ useSpring?: boolean;
4083
+ }
4084
+ declare const ScrollProgress: React$1.ForwardRefExoticComponent<ScrollProgressProps & React$1.RefAttributes<HTMLDivElement>>;
4085
+ interface ParallaxProps {
4086
+ /** Children to apply parallax effect */
4087
+ children: React$1.ReactNode;
4088
+ /** Speed multiplier (negative = opposite direction) */
4089
+ speed?: number;
4090
+ /** Direction of parallax */
4091
+ direction?: "vertical" | "horizontal";
4092
+ /** Additional class names */
4093
+ className?: string;
4094
+ /** Container ref for scroll tracking */
4095
+ container?: React$1.RefObject<HTMLElement | null>;
4096
+ }
4097
+ declare const Parallax: React$1.ForwardRefExoticComponent<ParallaxProps & React$1.RefAttributes<HTMLDivElement>>;
4098
+
4099
+ type ShimmerDirection = "left" | "right" | "top" | "bottom";
4100
+ interface ShimmerProps {
4101
+ /** Children to apply shimmer effect */
4102
+ children?: React$1.ReactNode;
4103
+ /** Width of shimmer */
4104
+ width?: string | number;
4105
+ /** Height of shimmer */
4106
+ height?: string | number;
4107
+ /** Shimmer duration */
4108
+ duration?: number;
4109
+ /** Shimmer direction */
4110
+ direction?: ShimmerDirection;
4111
+ /** Base color */
4112
+ baseColor?: string;
4113
+ /** Highlight color */
4114
+ highlightColor?: string;
4115
+ /** Border radius */
4116
+ borderRadius?: string | number;
4117
+ /** Additional class names */
4118
+ className?: string;
4119
+ /** Whether shimmer is active */
4120
+ active?: boolean;
4121
+ }
4122
+ declare const Shimmer: React$1.ForwardRefExoticComponent<ShimmerProps & React$1.RefAttributes<HTMLDivElement>>;
4123
+ type CheckmarkSize = "sm" | "md" | "lg" | "xl";
4124
+ type CheckmarkVariant = "default" | "success" | "primary" | "outline";
4125
+ interface CheckmarkProps {
4126
+ /** Whether to show/animate the checkmark */
4127
+ show?: boolean;
4128
+ /** Size of checkmark */
4129
+ size?: CheckmarkSize;
4130
+ /** Variant style */
4131
+ variant?: CheckmarkVariant;
4132
+ /** Stroke width */
4133
+ strokeWidth?: number;
4134
+ /** Animation duration */
4135
+ duration?: number;
4136
+ /** Delay before animation */
4137
+ delay?: number;
4138
+ /** Additional class names */
4139
+ className?: string;
4140
+ /** Callback when animation completes */
4141
+ onComplete?: () => void;
4142
+ }
4143
+ declare const Checkmark: React$1.ForwardRefExoticComponent<CheckmarkProps & React$1.RefAttributes<SVGSVGElement>>;
4144
+ interface ConfettiOptions {
4145
+ /** Number of confetti particles */
4146
+ particleCount?: number;
4147
+ /** Spread angle */
4148
+ spread?: number;
4149
+ /** Starting velocity */
4150
+ startVelocity?: number;
4151
+ /** Decay rate */
4152
+ decay?: number;
4153
+ /** Gravity */
4154
+ gravity?: number;
4155
+ /** Particle colors */
4156
+ colors?: string[];
4157
+ /** Origin point { x: 0-1, y: 0-1 } */
4158
+ origin?: {
4159
+ x: number;
4160
+ y: number;
4161
+ };
4162
+ /** Confetti shapes */
4163
+ shapes?: ("square" | "circle")[];
4164
+ /** Scalar for size */
4165
+ scalar?: number;
4166
+ /** Drift */
4167
+ drift?: number;
4168
+ /** Ticks (lifetime) */
4169
+ ticks?: number;
4170
+ }
4171
+ interface ConfettiProps {
4172
+ /** Auto-trigger on mount */
4173
+ autoTrigger?: boolean;
4174
+ /** Trigger delay (ms) */
4175
+ delay?: number;
4176
+ /** Confetti options */
4177
+ options?: ConfettiOptions;
4178
+ /** Children (optional, renders button if provided) */
4179
+ children?: React$1.ReactNode;
4180
+ /** Callback on trigger */
4181
+ onTrigger?: () => void;
4182
+ }
4183
+ declare const Confetti: React$1.ForwardRefExoticComponent<ConfettiProps & React$1.RefAttributes<HTMLButtonElement>>;
4184
+ declare const useConfetti: () => {
4185
+ fire: (options?: ConfettiOptions) => void;
4186
+ fireworks: () => void;
4187
+ cannon: (side?: "left" | "right" | "both") => void;
4188
+ };
4189
+ interface GlowProps {
4190
+ /** Children to wrap */
4191
+ children: React$1.ReactNode;
4192
+ /** Glow color */
4193
+ color?: string;
4194
+ /** Glow intensity (blur radius) */
4195
+ intensity?: number;
4196
+ /** Glow spread */
4197
+ spread?: number;
4198
+ /** Animate glow */
4199
+ animate?: boolean;
4200
+ /** Animation duration */
4201
+ duration?: number;
4202
+ /** Additional class names */
4203
+ className?: string;
4204
+ }
4205
+ declare const Glow: React$1.ForwardRefExoticComponent<GlowProps & React$1.RefAttributes<HTMLDivElement>>;
4206
+ interface SparklesProps {
4207
+ /** Children to wrap */
4208
+ children?: React$1.ReactNode;
4209
+ /** Number of sparkles */
4210
+ count?: number;
4211
+ /** Sparkle color */
4212
+ color?: string;
4213
+ /** Min sparkle size */
4214
+ minSize?: number;
4215
+ /** Max sparkle size */
4216
+ maxSize?: number;
4217
+ /** Animation duration */
4218
+ duration?: number;
4219
+ /** Additional class names */
4220
+ className?: string;
4221
+ }
4222
+ declare const Sparkles: React$1.ForwardRefExoticComponent<SparklesProps & React$1.RefAttributes<HTMLDivElement>>;
4223
+
4224
+ /**
4225
+ * Combines class names with Tailwind CSS class merging
4226
+ * @example cn("px-2 py-1", "px-4") => "py-1 px-4"
4227
+ */
4228
+ declare function cn(...inputs: ClassValue[]): string;
4229
+
4230
+ export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, ActionBar, ActionBarButton, type ActionBarProps, ActionGroup, type ActionGroupItem, type ActionGroupProps, ActionIcon, type ActionIconProps, ActionMenu, type ActionMenuGroup, type ActionMenuItem, type ActionMenuProps, ActionSheet, type ActionSheetItem, type ActionSheetProps, Alert, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AlertTitle, AnnouncementBanner, type AnnouncementBannerProps, AppShell, AppShellAside, AppShellFooter, AppShellHeader, AppShellMain, type AppShellProps, AppShellSidebar, AreaChart, type AreaChartProps, AspectRatio, AuthDivider, AuthFooterLinks, AuthForm, AuthHeader, AuthLayout, type AuthLayoutProps, AuthSocialButtons, Autocomplete, type AutocompleteOption, type AutocompleteProps, Avatar, AvatarFallback, AvatarGroup, type AvatarGroupItem, type AvatarGroupProps, AvatarImage, BackTop, type BackTopProps, Badge, type BadgeProps, BarChart, type BarChartProps, BatteryMeter, BottomNavigation, type BottomNavigationItem, type BottomNavigationProps, Bounce, type BounceProps, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, COUNTRIES, Calendar, type CalendarEvent, type CalendarProps, type CalendarView, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Carousel, type CarouselApi, CarouselContent, CarouselItem, type CarouselItemProps, CarouselNext, CarouselPrevious, type CarouselProps, Center, type ChartDataPoint, Checkbox, Checkmark, type CheckmarkProps, type CheckmarkSize, type CheckmarkVariant, Chip, type ChipProps, CircularProgress, CloseButton, type CloseButtonProps, Code, Collapse, type CollapseProps, Collapsible, CollapsibleContent, CollapsibleTrigger, ColorArea, type ColorAreaProps, type ColorAreaValue, ColorField, type ColorFieldProps, type ColorPalette, ColorPicker, type ColorPickerProps, ColorSlider, type ColorSliderChannel, type ColorSliderProps, ColorSwatch, ColorSwatchPicker, type ColorSwatchPickerProps, type ColorSwatchProps, ColorWheel, type ColorWheelProps, type Column, Combobox, type ComboboxOption, type ComboboxProps, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, Confetti, type ConfettiOptions, type ConfettiProps, ConfirmDialog, type ConfirmDialogProps, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, ContextualHelp, type ContextualHelpProps, CopyButton, type CopyButtonProps, Counter, type CounterProps, type Country, CurrencyInput, type CurrencyInputProps, DEFAULT_COLORS, DashboardGrid, DashboardLayout, type DashboardLayoutProps, DashboardPage, DashboardPageHeader, DataTable, type DataTableProps, DateField, type DateFieldProps, type DateFormat, DateInput, type DateInputProps, DatePicker, type DatePickerProps, DateRangePicker, type DateRangePickerProps, DefaultErrorFallback, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DiskUsageMeter, Dots, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EMOJIS, EMOJI_CATEGORIES, EmojiPicker, type EmojiPickerProps, EmptyState, ErrorBoundary, type ErrorBoundaryProps, Expand, type ExpandProps, FAB, type FABAction, Fade, type FadeProps, FieldContext, type FieldContextValue, type FieldState, type FileRejection, FileUpload, type FileUploadProps, Flex, type FlexProps, Flip, type FlipDirection, type FlipProps, FloatingActionButton, type FloatingActionButtonProps, Form, FormContext, type FormContextValue, FormControl, type FormControlProps, FormDescription, type FormDescriptionProps, FormField, type FormFieldProps, FormItem, type FormItemProps, FormLabel, type FormLabelProps, FormMessage, type FormMessageProps, type FormProps, type FormState, FullCalendar, type FullCalendarProps, Glow, type GlowProps, Grid, GridItem, type GridItemProps, GridList, type GridListItem, type GridListProps, type GridProps, HStack, HoverCard, HoverCardContent, HoverCardTrigger, IconButton, type IconButtonProps, IllustratedMessage, type IllustratedMessageProps, Image, ImageCropper, type ImageCropperProps, ImageViewer, type ImageViewerProps, ImageViewerTrigger, type ImageViewerTriggerProps, Indicator, type IndicatorProps, IndicatorWrapper, type IndicatorWrapperProps, InfiniteScroll, type InfiniteScrollProps, InlineAlert, type InlineAlertProps, Input, InputOTP, InputOTPGroup, type InputOTPProps, InputOTPSeparator, InputOTPSlot, type InputOTPSlotProps, type InputProps, KanbanBoard, type KanbanBoardProps, type KanbanCard, type KanbanColumn, Kbd, type KbdProps, Label, LabeledValue, LabeledValueGroup, type LabeledValueGroupProps, type LabeledValueProps, LineChart, type LineChartProps, Link, type LinkProps, List, ListItem, ListItemText, ListView, type ListViewItem, type ListViewProps, Listbox, ListboxItem, type ListboxOption, Loading, LoadingOverlay, type LoadingOverlayProps, type LoadingProps, MASK_PRESETS, type MaskChar, type MaskDefinition, type MaskPreset, MaskedInput, type MaskedInputProps, Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, MenubarPortal, MenubarRadioGroup, MenubarRadioItem, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger, Meter, type MeterProps, Modal, ModalClose, ModalContent, ModalDescription, ModalFooter, ModalHeader, ModalOverlay, ModalPortal, type ModalProps, ModalRoot, ModalTitle, ModalTrigger, MultiSelect, type MultiSelectOption, type MultiSelectProps, NProgress, type NProgressProps, Navbar, NavbarBrand, NavbarContent, NavbarItem, NavbarLink, type NavbarProps, NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, NavigationMenuViewport, type Notification, NotificationCenter, type NotificationCenterProps, type NotificationType, NumberField, type NumberFieldProps, NumberInput, type NumberInputProps, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, type PaginationState, Parallax, type ParallaxProps, PasswordInput, type PasswordInputProps, PhoneInput, type PhoneInputProps, PieChart, type PieChartProps, Pop, type PopProps, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, Portal, type PortalProps, Progress, PullToRefresh, type PullToRefreshProps, Pulse, type PulseProps, type PulseSpeed, QRCode, type QRCodeProps, RadioGroup, RadioGroupItem, RangeSlider, type RangeSliderProps, Rating, type RatingProps, ResizableHandle, type ResizableHandleProps, ResizablePanel, ResizablePanelGroup, type ResizablePanelGroupProps, RichTextEditor, type RichTextEditorProps, Ripple, type RippleProps, Rotate, type RotateProps, Scale, type ScaleOrigin, type ScaleProps, ScrollArea, ScrollBar, ScrollProgress, type ScrollProgressPosition, type ScrollProgressProps, ScrollReveal, type ScrollRevealDirection, type ScrollRevealProps, ScrollShadow, type ScrollShadowProps, SearchBar, type SearchBarProps, SearchField, type SearchFieldProps, type SearchSuggestion, SegmentedControl, SegmentedControlItem, type SegmentedControlItemProps, type SegmentedControlProps, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, Separator, SettingsCard, SettingsHeader, SettingsLayout, type SettingsLayoutProps, SettingsNavItem, SettingsRow, SettingsSection, SettingsSeparator, Shake, type ShakeIntensity, type ShakeProps, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Shimmer, type ShimmerDirection, type ShimmerProps, Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, SimpleGrid, Skeleton, Slide, type SlideDirection, type SlideProps, Slider, Snippet, type SortDirection, type SortState, type SortableItem, SortableList, Spacer, type SpacerProps, Sparkles, type SparklesProps, Spinner, type SpotlightItem, SpotlightSearch, type SpotlightSearchProps, StatCard, StatusLight, type StatusLightProps, Step, type StepProps, Steps, type StepsProps, type SwipeAction, SwipeActions, type SwipeActionsProps, Switch, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, type Tag, TagGroup, type TagGroupProps, TagInput, type TagInputProps, type TagItem, TextField, type TextFieldProps, TextReveal, type TextRevealDirection, type TextRevealProps, Textarea, type TextareaProps, ThemeProvider, type ThemeProviderProps, ThemeToggle, type ThemeToggleProps, TimeField, type TimeFieldProps, TimeInput, type TimeInputProps, TimePicker, type TimePickerProps, type TimeValue, Timeline, TimelineContent, TimelineItem, TimelineOpposite, TimelineSeparator, Toaster, Toggle, ToggleGroup, ToggleGroupItem, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type TransitionProps, type TreeNode, TreeView, type TreeViewProps, Typewriter, type TypewriterProps, type UploadedFile, User, VStack, type ValidationRule, type ViewerImage, VirtualList, type VirtualListProps, VisuallyHidden, type VisuallyHiddenProps, Well, type WellProps, Wiggle, type WiggleProps, WordRotate, type WordRotateProps, actionBarVariants, actionGroupVariants, actionIconVariants, actionMenuTriggerVariants, actionSheetItemVariants, actionSheetVariants, announcementBannerVariants, appShellVariants, applyMask, authLayoutVariants, autocompleteInputVariants, avatarGroupVariants, backTopVariants, badgeVariants, bottomNavigationVariants, buttonGroupVariants, buttonVariants, carouselVariants, chartContainerVariants, chipVariants, circularProgressVariants, closeButtonVariants, cn, codeVariants, colorAreaVariants, colorFieldVariants, colorSliderVariants, colorSwatchPickerVariants, colorSwatchVariants, colorWheelVariants, confirmDialogIconVariants, contextualHelpTriggerVariants, copyButtonVariants, currencyInputVariants, dashboardLayoutVariants, dateFieldVariants, dateInputVariants, defaultColors, dotsVariants, emojiPickerVariants, emptyStateVariants, fabVariants, fileUploadVariants, flexVariants, formatCurrency, formatDate, formatFileSize, formatPhoneNumber, fullCalendarVariants, getFileIcon, getMaskPlaceholder, gridItemVariants, gridListItemVariants, gridListVariants, gridVariants, hexToRgb, hsvToRgb, iconButtonVariants, illustratedMessageVariants, imageCropperVariants, imageVariants, indicatorVariants, infiniteScrollLoaderVariants, infiniteScrollVariants, inlineAlertVariants, inputOTPVariants, inputSizeVariants, kanbanBoardVariants, kanbanCardVariants, kanbanColumnVariants, kbdVariants, labelSizeVariants, labeledValueGroupVariants, labeledValueVariants, linkVariants, listItemVariants, listVariants, listViewItemVariants, listViewVariants, listboxItemVariants, listboxVariants, loadingOverlayVariants, loadingVariants, maskedInputVariants, materialColors, meterVariants, modalContentVariants, navbarVariants, navigationMenuTriggerStyle, notificationCenterVariants, nprogressVariants, numberFieldVariants, parseDate, parseFormattedValue, phoneInputVariants, pullToRefreshVariants, qrCodeVariants, rangeSliderVariants, ratingVariants, rgbToHex, rgbToHsv, richTextEditorVariants, scrollShadowVariants, searchBarVariants, searchFieldVariants, segmentedControlItemVariants, segmentedControlVariants, settingsLayoutVariants, sheetVariants, sidebarMenuButtonVariants, skeletonVariants, snippetVariants, sortableItemVariants, sortableListVariants, spinnerVariants, statCardVariants, statusLightVariants, stepVariants, stepsVariants, swipeActionVariants, swipeActionsVariants, tagGroupItemVariants, tagGroupVariants, tagVariants, tailwindColors, textFieldVariants, themeToggleVariants, timeFieldVariants, timeInputVariants, timelineItemVariants, timelineVariants, toggleVariants, treeViewVariants, unmask, useButtonGroup, useCarousel, useConfetti, useConfirmDialog, useFieldContext, useFormContext, useSidebar, useSpotlight, userVariants, validateFile, validators, virtualListVariants, wellVariants };