@calimero-network/mero-design 0.0.0-bootstrap.0 → 1.0.0-rc.32

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.
@@ -0,0 +1,2065 @@
1
+ import React from 'react';
2
+
3
+ interface CardProps {
4
+ /** Optional CSS class name */
5
+ className?: string;
6
+ /** Card content - can be any React node */
7
+ children?: React.ReactNode;
8
+ /** Tooltip text to show on the info icon */
9
+ tooltip?: string;
10
+ /** Custom icon component for the tooltip trigger */
11
+ tooltipIcon?: React.ComponentType<{
12
+ size?: number | string;
13
+ color?: string;
14
+ strokeWidth?: number | string;
15
+ }>;
16
+ /** Border color - defaults to neutral-600 */
17
+ color?: string;
18
+ /** Remove border entirely */
19
+ noBorder?: boolean;
20
+ /** Border radius variant */
21
+ variant?: "rounded" | "rectangle";
22
+ /** Inline styles */
23
+ style?: React.CSSProperties;
24
+ /** Convenience prop: card title */
25
+ title?: React.ReactNode;
26
+ /** Convenience prop: icon to display with title */
27
+ icon?: React.ReactNode;
28
+ /** Convenience prop: description text below title */
29
+ description?: React.ReactNode;
30
+ /** Convenience prop: action buttons or elements in header */
31
+ actions?: React.ReactNode;
32
+ /** Make card clickable - adds pointer cursor and click handler */
33
+ onClick?: () => void;
34
+ }
35
+ /**
36
+ * Card component - a flexible container with optional header, content, and actions.
37
+ *
38
+ * Supports both composition pattern (using CardHeader, CardTitle, CardContent)
39
+ * and convenience props (title, icon, description, actions).
40
+ */
41
+ declare function Card({ className, children, tooltip, tooltipIcon: TooltipIcon, color, noBorder, variant, style, title, icon, description, actions, onClick, }: CardProps): React.JSX.Element;
42
+ /**
43
+ * CardHeader - horizontal container for title and actions
44
+ */
45
+ interface CardHeaderProps {
46
+ children: React.ReactNode;
47
+ className?: string;
48
+ style?: React.CSSProperties;
49
+ }
50
+ declare function CardHeader({ children, className, style, }: CardHeaderProps): React.JSX.Element;
51
+ /**
52
+ * CardTitle - styled title text with truncation
53
+ */
54
+ interface CardTitleProps {
55
+ children: React.ReactNode;
56
+ className?: string;
57
+ style?: React.CSSProperties;
58
+ color?: string;
59
+ }
60
+ declare function CardTitle({ children, className, style, color, }: CardTitleProps): React.JSX.Element;
61
+ /**
62
+ * CardContent - content area with proper spacing
63
+ */
64
+ interface CardContentProps {
65
+ children: React.ReactNode;
66
+ className?: string;
67
+ style?: React.CSSProperties;
68
+ color?: string;
69
+ }
70
+ declare function CardContent({ children, className, style, color, }: CardContentProps): React.JSX.Element;
71
+
72
+ /**
73
+ * Button size variants
74
+ * @public
75
+ */
76
+ type ButtonSize = "sm" | "md" | "lg" | "xl";
77
+ /**
78
+ * Button style variants
79
+ * @public
80
+ */
81
+ type ButtonVariant = "primary" | "secondary" | "success" | "warning" | "error" | "info" | "outline" | "ghost" | "destructive";
82
+ /**
83
+ * Button component props
84
+ * @public
85
+ */
86
+ interface ButtonProps extends React.PropsWithChildren {
87
+ /** Render as a different element or component (polymorphic) */
88
+ as?: React.ElementType;
89
+ /** Click handler function */
90
+ onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
91
+ /** Whether the button is disabled */
92
+ disabled?: boolean;
93
+ /** Additional CSS class name */
94
+ className?: string;
95
+ /** Inline styles */
96
+ style?: React.CSSProperties;
97
+ /** HTML button type (only applies when as="button") */
98
+ type?: "button" | "submit" | "reset";
99
+ /** Visual variant/style of the button */
100
+ variant?: ButtonVariant;
101
+ /** Size of the button */
102
+ size?: ButtonSize;
103
+ /** Icon to display on the left side of the button text */
104
+ leftIcon?: React.ReactNode;
105
+ /** Icon to display on the right side of the button text */
106
+ rightIcon?: React.ReactNode;
107
+ /** Make button span full width of container */
108
+ fullWidth?: boolean;
109
+ /** Whether button has rounded corners (default: true, 12px radius). When false, uses 0px (sharp corners) */
110
+ rounded?: boolean;
111
+ /** Accessibility: aria-label for screen readers */
112
+ "aria-label"?: string;
113
+ /** Accessibility: aria-current attribute */
114
+ "aria-current"?: "page" | "step" | "location" | "date" | "time" | "true" | "false";
115
+ /** HTML title attribute for tooltip */
116
+ title?: string;
117
+ }
118
+ /**
119
+ * Button Component
120
+ *
121
+ * A versatile, accessible button component with multiple variants, sizes, and states.
122
+ * Supports icons, full-width layout, and border radius control.
123
+ * For loading states, compose with <Spinner /> in children and use disabled + aria-busy.
124
+ *
125
+ * @example
126
+ * ```tsx
127
+ * import { Button, Spinner } from '@calimero-network/mero-design';
128
+ *
129
+ * // Basic usage
130
+ * <Button onClick={() => console.log('clicked')}>
131
+ * Click me
132
+ * </Button>
133
+ *
134
+ * // With variant and size
135
+ * <Button variant="secondary" size="lg">
136
+ * Large Secondary Button
137
+ * </Button>
138
+ *
139
+ * // With loading state (composed pattern)
140
+ * <Button disabled aria-busy>
141
+ * <Spinner size="xs" color="current" thickness="thin" style={{ marginRight: 8 }} />
142
+ * Processing...
143
+ * </Button>
144
+ *
145
+ * // With icons
146
+ * <Button leftIcon={<Icon />} rightIcon={<Arrow />}>
147
+ * With Icons
148
+ * </Button>
149
+ *
150
+ * // Full width
151
+ * <Button fullWidth>Full Width Button</Button>
152
+ *
153
+ * // Sharp corners (not rounded)
154
+ * <Button rounded={false}>Sharp Button</Button>
155
+ * ```
156
+ *
157
+ * @public
158
+ */
159
+ declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLElement>>;
160
+
161
+ type InputProps = {
162
+ value?: string;
163
+ defaultValue?: string;
164
+ onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
165
+ placeholder?: string;
166
+ disabled?: boolean;
167
+ className?: string;
168
+ style?: React.CSSProperties;
169
+ type?: "text" | "password" | "email" | "number" | "search";
170
+ name?: string;
171
+ id?: string;
172
+ autoComplete?: string;
173
+ /** Turn off for secrets (recovery phrases, keys): the browser may send spellchecked text to a cloud service. */
174
+ spellCheck?: boolean;
175
+ autoFocus?: boolean;
176
+ maxLength?: number;
177
+ min?: number | string;
178
+ max?: number | string;
179
+ step?: number | string;
180
+ };
181
+ declare function Input({ value, defaultValue, onChange, placeholder, disabled, className, style, type, name, id, autoComplete, spellCheck, autoFocus, maxLength, min, max, step, }: InputProps): React.JSX.Element;
182
+
183
+ type ListItem = {
184
+ id: string | number;
185
+ content: React.ReactNode;
186
+ icon?: React.ReactNode;
187
+ hint?: React.ReactNode;
188
+ };
189
+ type ListProps = {
190
+ items: ListItem[];
191
+ variant?: "solid" | "ghost";
192
+ divider?: boolean;
193
+ className?: string;
194
+ style?: React.CSSProperties;
195
+ };
196
+ declare function List({ items, variant, divider, className, style, }: ListProps): React.JSX.Element;
197
+
198
+ type SelectOption = {
199
+ value: string;
200
+ label: string;
201
+ disabled?: boolean;
202
+ };
203
+ type SelectProps = {
204
+ value?: string;
205
+ defaultValue?: string;
206
+ onChange?: (value: string) => void;
207
+ options: SelectOption[];
208
+ placeholder?: string;
209
+ disabled?: boolean;
210
+ className?: string;
211
+ style?: React.CSSProperties;
212
+ name?: string;
213
+ required?: boolean;
214
+ error?: string;
215
+ label?: string;
216
+ description?: string;
217
+ };
218
+ declare function Select({ value, defaultValue, onChange, options, placeholder, disabled, className, style, name, required, error, label, description, }: SelectProps): React.JSX.Element;
219
+
220
+ type TableColumn<T> = {
221
+ key: keyof T;
222
+ title: string;
223
+ width?: number | string;
224
+ align?: "left" | "center" | "right";
225
+ render?: (value: any, row: T, rowIndex: number, isEditing?: boolean) => React.ReactNode;
226
+ sortable?: boolean;
227
+ filterable?: boolean;
228
+ fixed?: "left" | "right";
229
+ editable?: boolean;
230
+ type?: "text" | "number" | "select" | "textarea" | "date" | "email" | "url";
231
+ options?: SelectOption[];
232
+ placeholder?: string;
233
+ required?: boolean;
234
+ min?: number;
235
+ max?: number;
236
+ step?: number;
237
+ precision?: number;
238
+ rows?: number;
239
+ validate?: (value: any, row: T) => string | null;
240
+ };
241
+ type TableMode = "display" | "data" | "editable";
242
+ interface BaseTableProps<T extends Record<string, any>> {
243
+ data: T[];
244
+ columns: TableColumn<T>[];
245
+ mode?: TableMode;
246
+ className?: string;
247
+ style?: React.CSSProperties;
248
+ zebra?: boolean;
249
+ compact?: boolean;
250
+ stickyHeader?: boolean;
251
+ bordered?: boolean;
252
+ striped?: boolean;
253
+ hoverable?: boolean;
254
+ size?: "small" | "medium" | "large";
255
+ rowKey?: keyof T | ((row: T, index: number) => string);
256
+ emptyStateText?: string;
257
+ disabled?: boolean;
258
+ loading?: boolean;
259
+ }
260
+ interface DisplayTableProps<T extends Record<string, any>> extends BaseTableProps<T> {
261
+ mode?: "display";
262
+ }
263
+ interface DataTableProps<T extends Record<string, any>> extends BaseTableProps<T> {
264
+ mode: "data";
265
+ searchable?: boolean;
266
+ searchPlaceholder?: string;
267
+ sortable?: boolean;
268
+ filterable?: boolean;
269
+ selectable?: boolean;
270
+ selectedRowKeys?: string[];
271
+ onSelectionChange?: (selectedKeys: string[], selectedRows: T[]) => void;
272
+ onRowClick?: (record: T, index: number) => void;
273
+ onSort?: (column: string, direction: "asc" | "desc") => void;
274
+ onFilter?: (filters: Record<string, any>) => void;
275
+ pagination?: {
276
+ pageSize?: number;
277
+ showSizeChanger?: boolean;
278
+ showQuickJumper?: boolean;
279
+ showTotal?: (total: number, range: [number, number]) => string;
280
+ };
281
+ }
282
+ interface EditableTableProps<T extends Record<string, any>> extends BaseTableProps<T> {
283
+ mode: "editable";
284
+ onDataChange?: (newData: T[]) => void;
285
+ onRowAdd?: (newRow: T) => void;
286
+ onRowDelete?: (rowIndex: number, row: T) => void;
287
+ onRowUpdate?: (rowIndex: number, updatedRow: T) => void;
288
+ showAddButton?: boolean;
289
+ showDeleteButton?: boolean;
290
+ addButtonText?: string;
291
+ deleteButtonText?: string;
292
+ }
293
+ type TableProps<T extends Record<string, any>> = DisplayTableProps<T> | DataTableProps<T> | EditableTableProps<T>;
294
+ declare function Table<T extends Record<string, any>>(props: TableProps<T>): React.JSX.Element;
295
+
296
+ declare const DataTable: <T extends Record<string, any>>(props: Omit<DataTableProps<T>, "mode">) => React.JSX.Element;
297
+ declare const EditableTable: <T extends Record<string, any>>(props: Omit<EditableTableProps<T>, "mode">) => React.JSX.Element;
298
+
299
+ type GridProps = React.PropsWithChildren<{
300
+ /** Number of columns at the base breakpoint */
301
+ columns?: number;
302
+ /** Gap between grid items, e.g., 8, 12, 16 (px) */
303
+ gap?: number;
304
+ /** Max width of the grid container, e.g., 1200 (px) */
305
+ maxWidth?: number | string;
306
+ /** Horizontal alignment of content */
307
+ justify?: React.CSSProperties["justifyContent"];
308
+ /** Vertical alignment of content */
309
+ align?: React.CSSProperties["alignItems"];
310
+ /** Custom inline styles */
311
+ style?: React.CSSProperties;
312
+ /** Optional className passthrough */
313
+ className?: string;
314
+ }>;
315
+ declare function Grid({ children, columns, gap, maxWidth, justify, align, style, className, }: GridProps): React.JSX.Element;
316
+
317
+ type GridItemProps = React.PropsWithChildren<{
318
+ /** Column span at base breakpoint */
319
+ colSpan?: number;
320
+ /** Column start line (1-based). If provided, overrides flow positioning */
321
+ colStart?: number;
322
+ /** Row span at base breakpoint */
323
+ rowSpan?: number;
324
+ /** Row start line (1-based) */
325
+ rowStart?: number;
326
+ /** Optional className passthrough */
327
+ className?: string;
328
+ /** Custom inline styles */
329
+ style?: React.CSSProperties;
330
+ }>;
331
+ declare function GridItem({ children, colSpan, colStart, rowSpan, rowStart, className, style, }: GridItemProps): React.JSX.Element;
332
+
333
+ type MenuProps = React.PropsWithChildren<{
334
+ /** Optional className passthrough */
335
+ className?: string;
336
+ /** Custom inline styles */
337
+ style?: React.CSSProperties;
338
+ /** Menu variant */
339
+ variant?: "default" | "compact";
340
+ /** Menu size */
341
+ size?: "sm" | "md" | "lg";
342
+ }>;
343
+ declare function Menu({ children, className, style, variant, size, }: MenuProps): React.JSX.Element;
344
+ type MenuItemProps = React.PropsWithChildren<{
345
+ /** Whether the menu item is disabled */
346
+ disabled?: boolean;
347
+ /** Whether the menu item is selected */
348
+ selected?: boolean;
349
+ /** Click handler */
350
+ onClick?: () => void;
351
+ /** Optional className passthrough */
352
+ className?: string;
353
+ /** Custom inline styles */
354
+ style?: React.CSSProperties;
355
+ /** Icon to display before the content */
356
+ icon?: React.ReactNode;
357
+ /** Icon to display after the content */
358
+ endIcon?: React.ReactNode;
359
+ }>;
360
+ declare function MenuItem({ children, disabled, selected, onClick, className, style, icon, endIcon, }: MenuItemProps): React.JSX.Element;
361
+ type MenuGroupProps = React.PropsWithChildren<{
362
+ /** Group label */
363
+ label?: string;
364
+ /** Optional className passthrough */
365
+ className?: string;
366
+ /** Custom inline styles */
367
+ style?: React.CSSProperties;
368
+ }>;
369
+ declare function MenuGroup({ children, label, className, style, }: MenuGroupProps): React.JSX.Element;
370
+ type MenuDividerProps = {
371
+ /** Optional className passthrough */
372
+ className?: string;
373
+ /** Custom inline styles */
374
+ style?: React.CSSProperties;
375
+ };
376
+ declare function MenuDivider({ className, style }: MenuDividerProps): React.JSX.Element;
377
+
378
+ type NavbarProps = React.PropsWithChildren<{
379
+ /** Optional className passthrough */
380
+ className?: string;
381
+ /** Custom inline styles */
382
+ style?: React.CSSProperties;
383
+ /** Navbar variant */
384
+ variant?: "default" | "minimal" | "elevated";
385
+ /** Navbar size */
386
+ size?: "sm" | "md" | "lg";
387
+ /** Whether the navbar is fixed */
388
+ fixed?: boolean;
389
+ /** Position when fixed */
390
+ position?: "top" | "bottom";
391
+ }>;
392
+ declare function Navbar({ children, className, style, variant, size, fixed, position, }: NavbarProps): React.JSX.Element;
393
+ type NavbarBrandProps = React.PropsWithChildren<{
394
+ /** Brand logo/icon */
395
+ logo?: React.ReactNode;
396
+ /** Brand text */
397
+ text?: string;
398
+ /** Click handler for brand */
399
+ onClick?: () => void;
400
+ /** Optional className passthrough */
401
+ className?: string;
402
+ /** Custom inline styles */
403
+ style?: React.CSSProperties;
404
+ }>;
405
+ declare function NavbarBrand({ children, logo, text, onClick, className, style, }: NavbarBrandProps): React.JSX.Element;
406
+ type NavbarItemProps = React.PropsWithChildren<{
407
+ /** Whether the item is active */
408
+ active?: boolean;
409
+ /** Click handler */
410
+ onClick?: () => void;
411
+ /** Optional className passthrough */
412
+ className?: string;
413
+ /** Custom inline styles */
414
+ style?: React.CSSProperties;
415
+ /** Icon to display before the content */
416
+ icon?: React.ReactNode;
417
+ /** Whether the item is disabled */
418
+ disabled?: boolean;
419
+ }>;
420
+ declare function NavbarItem({ children, active, onClick, className, style, icon, disabled, }: NavbarItemProps): React.JSX.Element;
421
+ type NavbarMenuProps = React.PropsWithChildren<{
422
+ /** Menu alignment */
423
+ align?: "left" | "center" | "right";
424
+ /** Optional className passthrough */
425
+ className?: string;
426
+ /** Custom inline styles */
427
+ style?: React.CSSProperties;
428
+ }>;
429
+ declare function NavbarMenu({ children, align, className, style, }: NavbarMenuProps): React.JSX.Element;
430
+ type NavbarToggleProps = {
431
+ /** Whether the menu is open */
432
+ isOpen?: boolean;
433
+ /** Toggle handler */
434
+ onToggle?: () => void;
435
+ /** Optional className passthrough */
436
+ className?: string;
437
+ /** Custom inline styles */
438
+ style?: React.CSSProperties;
439
+ };
440
+ declare function NavbarToggle({ isOpen, onToggle, className, style, }: NavbarToggleProps): React.JSX.Element;
441
+
442
+ interface SidebarItem {
443
+ id: string;
444
+ label: string;
445
+ icon?: string;
446
+ href?: string;
447
+ onClick?: () => void;
448
+ disabled?: boolean;
449
+ badge?: string | number;
450
+ children?: SidebarItem[];
451
+ external?: boolean;
452
+ }
453
+ interface SidebarGroup {
454
+ id: string;
455
+ label?: string;
456
+ items: SidebarItem[];
457
+ collapsible?: boolean;
458
+ defaultCollapsed?: boolean;
459
+ }
460
+ interface SidebarProps {
461
+ /** Navigation groups */
462
+ groups: SidebarGroup[];
463
+ /** Currently active item ID */
464
+ activeItemId?: string;
465
+ /** Callback when item is clicked */
466
+ onItemClick?: (item: SidebarItem) => void;
467
+ /** Sidebar variant */
468
+ variant?: "default" | "minimal" | "compact";
469
+ /** Sidebar size */
470
+ size?: "sm" | "md" | "lg";
471
+ /** Whether sidebar is collapsed */
472
+ collapsed?: boolean;
473
+ /** Whether sidebar can be toggled */
474
+ collapsible?: boolean;
475
+ /** Callback when collapse state changes */
476
+ onCollapseChange?: (collapsed: boolean) => void;
477
+ /** Sidebar position */
478
+ position?: "left" | "right";
479
+ /** Whether sidebar is fixed */
480
+ fixed?: boolean;
481
+ /** Custom header content */
482
+ header?: React.ReactNode;
483
+ /** Custom footer content */
484
+ footer?: React.ReactNode;
485
+ /** Custom className */
486
+ className?: string;
487
+ /** Custom styles */
488
+ style?: React.CSSProperties;
489
+ /** Whether to show group labels when collapsed */
490
+ showGroupLabelsWhenCollapsed?: boolean;
491
+ /** Whether to show tooltips when collapsed */
492
+ showTooltipsWhenCollapsed?: boolean;
493
+ }
494
+ declare const Sidebar: React.FC<SidebarProps>;
495
+ declare const SidebarHeader: React.FC<{
496
+ children: React.ReactNode;
497
+ className?: string;
498
+ style?: React.CSSProperties;
499
+ }>;
500
+ declare const SidebarFooter: React.FC<{
501
+ children: React.ReactNode;
502
+ className?: string;
503
+ style?: React.CSSProperties;
504
+ }>;
505
+ declare const SidebarBrand: React.FC<{
506
+ children: React.ReactNode;
507
+ className?: string;
508
+ style?: React.CSSProperties;
509
+ }>;
510
+ declare const SidebarUser: React.FC<{
511
+ name: string;
512
+ email?: string;
513
+ avatar?: string;
514
+ className?: string;
515
+ style?: React.CSSProperties;
516
+ }>;
517
+
518
+ type BannerVariant = "info" | "success" | "warning" | "error" | "announcement" | "promotion";
519
+ type BannerSize = "sm" | "md" | "lg";
520
+ type BannerPosition = "top" | "bottom" | "inline";
521
+ interface BannerAction {
522
+ label: string;
523
+ onClick: () => void;
524
+ variant?: "primary" | "secondary" | "success" | "warning" | "error" | "info";
525
+ disabled?: boolean;
526
+ }
527
+ interface BannerProps {
528
+ /** Banner variant */
529
+ variant?: BannerVariant;
530
+ /** Banner size */
531
+ size?: BannerSize;
532
+ /** Banner position */
533
+ position?: BannerPosition;
534
+ /** Banner title */
535
+ title?: string;
536
+ /** Banner description */
537
+ description?: string;
538
+ /** Custom icon */
539
+ icon?: React.ReactNode;
540
+ /** Show close button */
541
+ dismissible?: boolean;
542
+ /** Close handler */
543
+ onClose?: () => void;
544
+ /** Auto dismiss after delay (in milliseconds) */
545
+ autoDismiss?: number;
546
+ /** Action buttons */
547
+ actions?: BannerAction[];
548
+ /** Whether banner is visible */
549
+ visible?: boolean;
550
+ /** Custom content */
551
+ children?: React.ReactNode;
552
+ /** Additional CSS class */
553
+ className?: string;
554
+ /** Custom styles */
555
+ style?: React.CSSProperties;
556
+ /** Whether to show as sticky */
557
+ sticky?: boolean;
558
+ /** Whether to show with animation */
559
+ animated?: boolean;
560
+ /** Custom background color */
561
+ backgroundColor?: string;
562
+ /** Custom text color */
563
+ textColor?: string;
564
+ /** Custom border color */
565
+ borderColor?: string;
566
+ }
567
+ declare const Banner: React.FC<BannerProps>;
568
+ declare const InfoBanner: React.FC<Omit<BannerProps, "variant">>;
569
+ declare const SuccessBanner: React.FC<Omit<BannerProps, "variant">>;
570
+ declare const WarningBanner: React.FC<Omit<BannerProps, "variant">>;
571
+ declare const ErrorBanner: React.FC<Omit<BannerProps, "variant">>;
572
+ declare const AnnouncementBanner: React.FC<Omit<BannerProps, "variant">>;
573
+ declare const PromotionBanner: React.FC<Omit<BannerProps, "variant">>;
574
+
575
+ type NotificationVariant = "info" | "success" | "warning" | "error" | "announcement" | "promotion";
576
+ type NotificationPriority = "low" | "medium" | "high" | "urgent";
577
+ type NotificationStatus = "unread" | "read" | "archived";
578
+ type NotificationCategory = "system" | "user" | "security" | "feature" | "marketing" | "maintenance";
579
+ interface Notification {
580
+ id: string;
581
+ title: string;
582
+ description?: string;
583
+ variant?: NotificationVariant;
584
+ priority?: NotificationPriority;
585
+ status?: NotificationStatus;
586
+ category?: NotificationCategory;
587
+ timestamp: Date;
588
+ readAt?: Date;
589
+ archivedAt?: Date;
590
+ icon?: React.ReactNode;
591
+ image?: string;
592
+ actions?: NotificationAction[];
593
+ metadata?: Record<string, any>;
594
+ expiresAt?: Date;
595
+ persistent?: boolean;
596
+ }
597
+ interface NotificationAction {
598
+ label: string;
599
+ onClick: (notification: Notification) => void;
600
+ variant?: "primary" | "secondary" | "success" | "warning" | "error" | "info";
601
+ disabled?: boolean;
602
+ }
603
+ interface NotificationCenterProps {
604
+ /** Notifications to display */
605
+ notifications: Notification[];
606
+ /** Whether the center is open */
607
+ open?: boolean;
608
+ /** Open/close handler */
609
+ onToggle?: (open: boolean) => void;
610
+ /** Notification click handler */
611
+ onNotificationClick?: (notification: Notification) => void;
612
+ /** Mark as read handler */
613
+ onMarkAsRead?: (notificationId: string) => void;
614
+ /** Mark all as read handler */
615
+ onMarkAllAsRead?: () => void;
616
+ /** Archive notification handler */
617
+ onArchive?: (notificationId: string) => void;
618
+ /** Archive all notifications handler */
619
+ onArchiveAll?: () => void;
620
+ /** Delete notification handler */
621
+ onDelete?: (notificationId: string) => void;
622
+ /** Clear all notifications handler */
623
+ onClearAll?: () => void;
624
+ /** Filter by status */
625
+ statusFilter?: NotificationStatus | "all";
626
+ /** Filter by category */
627
+ categoryFilter?: NotificationCategory | "all";
628
+ /** Filter by priority */
629
+ priorityFilter?: NotificationPriority | "all";
630
+ /** Maximum number of notifications to show */
631
+ maxNotifications?: number;
632
+ /** Whether to show unread count badge */
633
+ showUnreadCount?: boolean;
634
+ /** Whether to group notifications by date */
635
+ groupByDate?: boolean;
636
+ /** Whether to show notification timestamps */
637
+ showTimestamps?: boolean;
638
+ /** Whether to show notification categories */
639
+ showCategories?: boolean;
640
+ /** Whether to show notification priorities */
641
+ showPriorities?: boolean;
642
+ /** Custom empty state message */
643
+ emptyMessage?: string;
644
+ /** Custom empty state icon */
645
+ emptyIcon?: React.ReactNode;
646
+ /** Position of the notification center */
647
+ position?: "top-right" | "top-left" | "bottom-right" | "bottom-left";
648
+ /** Size of the notification center */
649
+ size?: "sm" | "md" | "lg";
650
+ /** Whether to show the center as a dropdown */
651
+ dropdown?: boolean;
652
+ /** Custom trigger element */
653
+ trigger?: React.ReactNode;
654
+ /** Additional CSS class */
655
+ className?: string;
656
+ /** Custom styles */
657
+ style?: React.CSSProperties;
658
+ }
659
+ declare const NotificationCenter: React.FC<NotificationCenterProps>;
660
+ declare const useNotifications: () => {
661
+ notifications: Notification[];
662
+ addNotification: (notification: Omit<Notification, "id" | "timestamp">) => string;
663
+ markAsRead: (id: string) => void;
664
+ markAllAsRead: () => void;
665
+ archive: (id: string) => void;
666
+ archiveAll: () => void;
667
+ deleteNotification: (id: string) => void;
668
+ clearAll: () => void;
669
+ };
670
+
671
+ type AlertVariant = "info" | "success" | "warning" | "error";
672
+ type AlertProps = {
673
+ variant?: AlertVariant;
674
+ title?: string;
675
+ description?: string;
676
+ icon?: React.ReactNode;
677
+ dismissible?: boolean;
678
+ onClose?: () => void;
679
+ className?: string;
680
+ style?: React.CSSProperties;
681
+ children?: React.ReactNode;
682
+ };
683
+ declare function Alert({ variant, title, description, icon, dismissible, onClose, className, style, children, }: AlertProps): React.JSX.Element;
684
+
685
+ type BadgeVariant = "default" | "success" | "warning" | "error" | "info" | "outline" | "neutral";
686
+ type BadgeProps = {
687
+ children?: React.ReactNode;
688
+ variant?: BadgeVariant;
689
+ dot?: boolean;
690
+ icon?: string;
691
+ size?: "sm" | "md" | "lg";
692
+ className?: string;
693
+ style?: React.CSSProperties;
694
+ };
695
+ type StatusBadgeProps = {
696
+ status: "active" | "inactive" | "pending" | "error" | "success" | "warning" | "info";
697
+ text?: string;
698
+ size?: "sm" | "md" | "lg";
699
+ showIcon?: boolean;
700
+ className?: string;
701
+ style?: React.CSSProperties;
702
+ };
703
+ declare function Badge({ children, variant, dot, icon, size, className, style, }: BadgeProps): React.JSX.Element;
704
+ declare function StatusBadge({ status, text, size, showIcon, className, style, }: StatusBadgeProps): React.JSX.Element;
705
+
706
+ type BreadcrumbItem = {
707
+ label: string;
708
+ href?: string;
709
+ onClick?: (event: React.MouseEvent<HTMLAnchorElement | HTMLSpanElement>) => void;
710
+ };
711
+ type BreadcrumbsProps = {
712
+ items: BreadcrumbItem[];
713
+ separator?: React.ReactNode;
714
+ className?: string;
715
+ style?: React.CSSProperties;
716
+ };
717
+ declare function Breadcrumbs({ items, separator, className, style, }: BreadcrumbsProps): React.JSX.Element;
718
+
719
+ type TabItem = {
720
+ id: string;
721
+ label: string;
722
+ disabled?: boolean;
723
+ };
724
+ type TabsProps = {
725
+ tabs: TabItem[];
726
+ value?: string;
727
+ defaultValue?: string;
728
+ onValueChange?: (id: string) => void;
729
+ className?: string;
730
+ style?: React.CSSProperties;
731
+ children?: React.ReactNode;
732
+ };
733
+ declare function Tabs({ tabs, value, defaultValue, onValueChange, className, style, children, }: TabsProps): React.JSX.Element;
734
+ type TabPanelProps = {
735
+ when: string;
736
+ active?: string;
737
+ className?: string;
738
+ style?: React.CSSProperties;
739
+ children?: React.ReactNode;
740
+ };
741
+ declare function TabPanel({ when, active, className, style, children, }: TabPanelProps): React.JSX.Element;
742
+
743
+ type ModalProps = {
744
+ open: boolean;
745
+ onClose: () => void;
746
+ title?: string;
747
+ children?: React.ReactNode;
748
+ className?: string;
749
+ style?: React.CSSProperties;
750
+ closeOnOverlay?: boolean;
751
+ };
752
+ declare function Modal({ open, onClose, title, children, className, style, closeOnOverlay, }: ModalProps): React.JSX.Element | null;
753
+
754
+ type CheckboxProps = {
755
+ checked?: boolean;
756
+ defaultChecked?: boolean;
757
+ onChange?: (checked: boolean) => void;
758
+ disabled?: boolean;
759
+ label?: string;
760
+ description?: string;
761
+ className?: string;
762
+ style?: React.CSSProperties;
763
+ name?: string;
764
+ value?: string;
765
+ };
766
+ declare function Checkbox({ checked, defaultChecked, onChange, disabled, label, description, className, style, name, value, }: CheckboxProps): React.JSX.Element;
767
+
768
+ type RadioProps = {
769
+ checked?: boolean;
770
+ defaultChecked?: boolean;
771
+ onChange?: (checked: boolean) => void;
772
+ disabled?: boolean;
773
+ label?: string;
774
+ description?: string;
775
+ className?: string;
776
+ style?: React.CSSProperties;
777
+ name?: string;
778
+ value?: string;
779
+ };
780
+ declare function Radio({ checked, defaultChecked, onChange, disabled, label, description, className, style, name, value, }: RadioProps): React.JSX.Element;
781
+ type RadioGroupProps = {
782
+ value?: string;
783
+ defaultValue?: string;
784
+ onChange?: (value: string) => void;
785
+ disabled?: boolean;
786
+ className?: string;
787
+ style?: React.CSSProperties;
788
+ children: React.ReactNode;
789
+ name?: string;
790
+ };
791
+ declare function RadioGroup({ value, defaultValue, onChange, disabled, className, style, children, name, }: RadioGroupProps): React.JSX.Element;
792
+
793
+ type SwitchProps = {
794
+ checked?: boolean;
795
+ defaultChecked?: boolean;
796
+ onChange?: (checked: boolean) => void;
797
+ disabled?: boolean;
798
+ label?: string;
799
+ description?: string;
800
+ className?: string;
801
+ style?: React.CSSProperties;
802
+ name?: string;
803
+ value?: string;
804
+ size?: "small" | "medium" | "large";
805
+ };
806
+ declare function Switch({ checked, defaultChecked, onChange, disabled, label, description, className, style, name, value, size, }: SwitchProps): React.JSX.Element;
807
+
808
+ type PaginationProps = {
809
+ currentPage: number;
810
+ totalPages: number;
811
+ onPageChange: (page: number) => void;
812
+ showFirstLast?: boolean;
813
+ showPrevNext?: boolean;
814
+ maxVisiblePages?: number;
815
+ className?: string;
816
+ style?: React.CSSProperties;
817
+ disabled?: boolean;
818
+ };
819
+ declare function Pagination({ currentPage, totalPages, onPageChange, showFirstLast, showPrevNext, maxVisiblePages, className, style, disabled, }: PaginationProps): React.JSX.Element | null;
820
+
821
+ type ToastVariant = "default" | "success" | "warning" | "error" | "info";
822
+ type Toast = {
823
+ id: string;
824
+ title?: string;
825
+ description?: string;
826
+ variant?: ToastVariant;
827
+ durationMs?: number;
828
+ };
829
+ type ToastContextValue = {
830
+ toasts: Toast[];
831
+ show: (toast: Omit<Toast, "id">) => string;
832
+ dismiss: (id: string) => void;
833
+ clear: () => void;
834
+ };
835
+ declare function useToast(): ToastContextValue;
836
+ declare function ToastProvider({ children }: {
837
+ children: React.ReactNode;
838
+ }): React.JSX.Element;
839
+
840
+ type LayoutProps = React.PropsWithChildren<{
841
+ className?: string;
842
+ style?: React.CSSProperties;
843
+ maxWidth?: string | number;
844
+ padding?: string | number;
845
+ centered?: boolean;
846
+ variant?: "auth" | "default";
847
+ }>;
848
+ declare function Layout({ children, className, style, maxWidth, padding, centered, variant, }: LayoutProps): React.JSX.Element;
849
+ declare function AuthLayout({ children, className, style, maxWidth, padding, ...props }: Omit<LayoutProps, "variant" | "centered">): React.JSX.Element;
850
+ declare function Container({ children, className, style, maxWidth, padding, ...props }: Omit<LayoutProps, "variant" | "centered">): React.JSX.Element;
851
+
852
+ type LoaderProps = {
853
+ size?: "small" | "medium" | "large";
854
+ variant?: "spinner" | "dots" | "pulse";
855
+ color?: string;
856
+ className?: string;
857
+ style?: React.CSSProperties;
858
+ fullScreen?: boolean;
859
+ overlay?: boolean;
860
+ message?: string;
861
+ };
862
+ declare function Loader({ size, variant, color, className, style, fullScreen, overlay, message, }: LoaderProps): React.JSX.Element;
863
+ declare function InlineLoader({ size, variant, color, className, style, }: Omit<LoaderProps, "fullScreen" | "overlay" | "message">): React.JSX.Element;
864
+ declare function FullScreenLoader({ message, variant, color, className, style, }: Omit<LoaderProps, "fullScreen" | "overlay" | "size">): React.JSX.Element;
865
+ declare function PageLoader({ message, variant, color, className, style, }: Omit<LoaderProps, "fullScreen" | "overlay" | "size">): React.JSX.Element;
866
+
867
+ interface TextProps {
868
+ children: React.ReactNode;
869
+ size?: "xs" | "sm" | "md" | "lg" | "xl";
870
+ weight?: "normal" | "medium" | "semibold" | "bold";
871
+ color?: "primary" | "secondary" | "muted" | "success" | "warning" | "error";
872
+ align?: "left" | "center" | "right" | "justify";
873
+ as?: "p" | "span" | "div" | "label";
874
+ className?: string;
875
+ style?: React.CSSProperties;
876
+ }
877
+ declare const Text: React.FC<TextProps>;
878
+ interface HeadingProps {
879
+ children: React.ReactNode;
880
+ level?: 1 | 2 | 3 | 4 | 5 | 6;
881
+ size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "4xl";
882
+ weight?: "normal" | "medium" | "semibold" | "bold";
883
+ color?: "primary" | "secondary" | "muted" | "success" | "warning" | "error";
884
+ align?: "left" | "center" | "right" | "justify";
885
+ className?: string;
886
+ style?: React.CSSProperties;
887
+ }
888
+ declare const Heading: React.FC<HeadingProps>;
889
+ interface CodeProps {
890
+ children: React.ReactNode;
891
+ variant?: "inline" | "block";
892
+ language?: string;
893
+ className?: string;
894
+ style?: React.CSSProperties;
895
+ }
896
+ declare const Code: React.FC<CodeProps>;
897
+ interface LinkProps {
898
+ children: React.ReactNode;
899
+ href?: string;
900
+ onClick?: () => void;
901
+ variant?: "default" | "subtle" | "underline";
902
+ color?: "primary" | "secondary" | "success" | "warning" | "error";
903
+ disabled?: boolean;
904
+ external?: boolean;
905
+ className?: string;
906
+ style?: React.CSSProperties;
907
+ }
908
+ declare const Link: React.FC<LinkProps>;
909
+
910
+ interface AvatarProps {
911
+ src?: string;
912
+ alt?: string;
913
+ name?: string;
914
+ size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl";
915
+ shape?: "circle" | "square";
916
+ fallback?: React.ReactNode;
917
+ className?: string;
918
+ style?: React.CSSProperties;
919
+ }
920
+ declare const Avatar: React.FC<AvatarProps>;
921
+
922
+ interface ImageProps {
923
+ src: string;
924
+ alt: string;
925
+ width?: number | string;
926
+ height?: number | string;
927
+ fit?: "cover" | "contain" | "fill" | "none" | "scale-down";
928
+ radius?: "none" | "sm" | "md" | "lg" | "full";
929
+ fallback?: React.ReactNode;
930
+ loading?: "lazy" | "eager";
931
+ className?: string;
932
+ style?: React.CSSProperties;
933
+ onLoad?: () => void;
934
+ onError?: () => void;
935
+ }
936
+ declare const Image: React.FC<ImageProps>;
937
+
938
+ interface IconProps {
939
+ name: string;
940
+ size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl";
941
+ color?: "primary" | "secondary" | "muted" | "success" | "warning" | "error" | "current";
942
+ className?: string;
943
+ style?: React.CSSProperties;
944
+ onClick?: () => void;
945
+ }
946
+ declare const Icon: React.FC<IconProps>;
947
+
948
+ interface DividerProps {
949
+ orientation?: "horizontal" | "vertical";
950
+ variant?: "solid" | "dashed" | "dotted";
951
+ color?: "default" | "muted" | "subtle";
952
+ thickness?: "thin" | "medium" | "thick";
953
+ spacing?: "none" | "sm" | "md" | "lg";
954
+ label?: string;
955
+ labelPosition?: "left" | "center" | "right";
956
+ className?: string;
957
+ style?: React.CSSProperties;
958
+ }
959
+ declare const Divider: React.FC<DividerProps>;
960
+
961
+ interface TextareaProps {
962
+ value?: string;
963
+ defaultValue?: string;
964
+ placeholder?: string;
965
+ disabled?: boolean;
966
+ readOnly?: boolean;
967
+ required?: boolean;
968
+ rows?: number;
969
+ cols?: number;
970
+ resize?: "none" | "both" | "horizontal" | "vertical";
971
+ size?: "sm" | "md" | "lg";
972
+ variant?: "default" | "filled" | "outlined";
973
+ error?: boolean;
974
+ helperText?: string;
975
+ label?: string;
976
+ className?: string;
977
+ style?: React.CSSProperties;
978
+ onChange?: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
979
+ onFocus?: (event: React.FocusEvent<HTMLTextAreaElement>) => void;
980
+ onBlur?: (event: React.FocusEvent<HTMLTextAreaElement>) => void;
981
+ name?: string;
982
+ id?: string;
983
+ autoComplete?: string;
984
+ /** Turn off for secrets (recovery phrases, keys): the browser may send spellchecked text to a cloud service. */
985
+ spellCheck?: boolean;
986
+ }
987
+ declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
988
+
989
+ interface NumberInputProps {
990
+ value?: number;
991
+ defaultValue?: number;
992
+ min?: number;
993
+ max?: number;
994
+ step?: number;
995
+ precision?: number;
996
+ disabled?: boolean;
997
+ readOnly?: boolean;
998
+ required?: boolean;
999
+ placeholder?: string;
1000
+ size?: "sm" | "md" | "lg";
1001
+ variant?: "default" | "filled" | "outlined";
1002
+ error?: boolean;
1003
+ helperText?: string;
1004
+ label?: string;
1005
+ showButtons?: boolean;
1006
+ className?: string;
1007
+ style?: React.CSSProperties;
1008
+ onChange?: (value: number | undefined) => void;
1009
+ onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
1010
+ onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
1011
+ }
1012
+ declare const NumberInput: React.ForwardRefExoticComponent<NumberInputProps & React.RefAttributes<HTMLInputElement>>;
1013
+
1014
+ interface BoxProps {
1015
+ children?: React.ReactNode;
1016
+ as?: keyof React.JSX.IntrinsicElements;
1017
+ padding?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
1018
+ margin?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
1019
+ backgroundColor?: "primary" | "secondary" | "muted" | "subtle" | "transparent";
1020
+ borderRadius?: "none" | "sm" | "md" | "lg" | "full";
1021
+ border?: "none" | "thin" | "medium" | "thick";
1022
+ borderColor?: "default" | "muted" | "subtle" | "primary" | "success" | "warning" | "error";
1023
+ shadow?: "none" | "sm" | "md" | "lg" | "xl";
1024
+ width?: number | string;
1025
+ height?: number | string;
1026
+ minWidth?: number | string;
1027
+ minHeight?: number | string;
1028
+ maxWidth?: number | string;
1029
+ maxHeight?: number | string;
1030
+ display?: "block" | "inline" | "inline-block" | "flex" | "inline-flex" | "grid" | "none";
1031
+ flexDirection?: "row" | "column" | "row-reverse" | "column-reverse";
1032
+ alignItems?: "flex-start" | "flex-end" | "center" | "baseline" | "stretch";
1033
+ justifyContent?: "flex-start" | "flex-end" | "center" | "space-between" | "space-around" | "space-evenly";
1034
+ gap?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
1035
+ position?: "static" | "relative" | "absolute" | "fixed" | "sticky";
1036
+ top?: number | string;
1037
+ right?: number | string;
1038
+ bottom?: number | string;
1039
+ left?: number | string;
1040
+ zIndex?: number;
1041
+ overflow?: "visible" | "hidden" | "scroll" | "auto";
1042
+ className?: string;
1043
+ style?: React.CSSProperties;
1044
+ onClick?: () => void;
1045
+ }
1046
+ declare const Box: React.FC<BoxProps>;
1047
+
1048
+ interface FlexProps extends Omit<BoxProps, "display"> {
1049
+ direction?: "row" | "column" | "row-reverse" | "column-reverse";
1050
+ wrap?: "nowrap" | "wrap" | "wrap-reverse";
1051
+ align?: "flex-start" | "flex-end" | "center" | "baseline" | "stretch";
1052
+ justify?: "flex-start" | "flex-end" | "center" | "space-between" | "space-around" | "space-evenly";
1053
+ gap?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
1054
+ grow?: number;
1055
+ shrink?: number;
1056
+ basis?: number | string;
1057
+ }
1058
+ declare const Flex: React.FC<FlexProps>;
1059
+
1060
+ interface StackProps extends Omit<FlexProps, "direction" | "justify" | "align"> {
1061
+ direction?: "vertical" | "horizontal";
1062
+ spacing?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
1063
+ align?: "start" | "center" | "end" | "stretch";
1064
+ justify?: "start" | "center" | "end" | "space-between" | "space-around" | "space-evenly";
1065
+ divider?: React.ReactNode;
1066
+ }
1067
+ declare const Stack: React.FC<StackProps>;
1068
+
1069
+ interface CenterProps extends Omit<BoxProps, "display" | "alignItems" | "justifyContent"> {
1070
+ inline?: boolean;
1071
+ }
1072
+ declare const Center: React.FC<CenterProps>;
1073
+
1074
+ interface SpacerProps extends Omit<BoxProps, "children"> {
1075
+ size?: "xs" | "sm" | "md" | "lg" | "xl";
1076
+ axis?: "horizontal" | "vertical" | "both";
1077
+ }
1078
+ declare const Spacer: React.FC<SpacerProps>;
1079
+
1080
+ interface TooltipProps {
1081
+ children: React.ReactNode;
1082
+ content: React.ReactNode;
1083
+ placement?: "top" | "bottom" | "left" | "right";
1084
+ trigger?: "hover" | "click" | "focus";
1085
+ delay?: number;
1086
+ disabled?: boolean;
1087
+ className?: string;
1088
+ style?: React.CSSProperties;
1089
+ }
1090
+ declare const Tooltip: React.FC<TooltipProps>;
1091
+
1092
+ interface ProgressProps {
1093
+ value: number;
1094
+ max?: number;
1095
+ size?: "sm" | "md" | "lg";
1096
+ variant?: "default" | "success" | "warning" | "error";
1097
+ showValue?: boolean;
1098
+ label?: string;
1099
+ className?: string;
1100
+ style?: React.CSSProperties;
1101
+ }
1102
+ declare const Progress: React.FC<ProgressProps>;
1103
+ interface CircularProgressProps {
1104
+ value: number;
1105
+ max?: number;
1106
+ size?: "sm" | "md" | "lg" | "xl";
1107
+ variant?: "default" | "success" | "warning" | "error";
1108
+ showValue?: boolean;
1109
+ label?: string;
1110
+ className?: string;
1111
+ style?: React.CSSProperties;
1112
+ }
1113
+ declare const CircularProgress: React.FC<CircularProgressProps>;
1114
+
1115
+ interface SpinnerProps {
1116
+ size?: "xs" | "sm" | "md" | "lg" | "xl";
1117
+ color?: "primary" | "secondary" | "muted" | "success" | "warning" | "error" | "current";
1118
+ thickness?: "thin" | "medium" | "thick";
1119
+ className?: string;
1120
+ style?: React.CSSProperties;
1121
+ }
1122
+ declare const Spinner: React.FC<SpinnerProps>;
1123
+
1124
+ interface FormProps extends React.FormHTMLAttributes<HTMLFormElement> {
1125
+ initialValues?: Record<string, any>;
1126
+ onSubmit?: (values: Record<string, any>) => void | Promise<void>;
1127
+ validationSchema?: Record<string, (value: any) => string | undefined>;
1128
+ children: React.ReactNode;
1129
+ className?: string;
1130
+ style?: React.CSSProperties;
1131
+ }
1132
+ declare const Form: React.FC<FormProps>;
1133
+ interface FieldsetProps extends React.FieldsetHTMLAttributes<HTMLFieldSetElement> {
1134
+ legend?: string;
1135
+ children: React.ReactNode;
1136
+ className?: string;
1137
+ style?: React.CSSProperties;
1138
+ }
1139
+ declare const Fieldset: React.FC<FieldsetProps>;
1140
+ interface FormFieldProps {
1141
+ name: string;
1142
+ label?: string;
1143
+ required?: boolean;
1144
+ children: React.ReactNode;
1145
+ className?: string;
1146
+ style?: React.CSSProperties;
1147
+ }
1148
+ declare const FormField: React.FC<FormFieldProps>;
1149
+ interface FormGroupProps extends React.HTMLAttributes<HTMLDivElement> {
1150
+ children: React.ReactNode;
1151
+ direction?: "row" | "column";
1152
+ gap?: "sm" | "md" | "lg";
1153
+ className?: string;
1154
+ style?: React.CSSProperties;
1155
+ }
1156
+ declare const FormGroup: React.FC<FormGroupProps>;
1157
+
1158
+ interface PopoverProps {
1159
+ children: React.ReactNode;
1160
+ content: React.ReactNode;
1161
+ isOpen?: boolean;
1162
+ onOpenChange?: (isOpen: boolean) => void;
1163
+ placement?: "top" | "bottom" | "left" | "right" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
1164
+ trigger?: "click" | "hover" | "focus";
1165
+ disabled?: boolean;
1166
+ closeOnClickOutside?: boolean;
1167
+ closeOnEscape?: boolean;
1168
+ className?: string;
1169
+ style?: React.CSSProperties;
1170
+ }
1171
+ declare const Popover: React.FC<PopoverProps>;
1172
+
1173
+ interface DropdownItem {
1174
+ value: string;
1175
+ label: string;
1176
+ disabled?: boolean;
1177
+ icon?: React.ReactNode;
1178
+ onClick?: () => void;
1179
+ }
1180
+ interface DropdownProps {
1181
+ items: DropdownItem[];
1182
+ value?: string;
1183
+ placeholder?: string;
1184
+ disabled?: boolean;
1185
+ size?: "sm" | "md" | "lg";
1186
+ variant?: "default" | "filled" | "outlined";
1187
+ onSelect?: (value: string, item: DropdownItem) => void;
1188
+ className?: string;
1189
+ style?: React.CSSProperties;
1190
+ }
1191
+ declare const Dropdown: React.FC<DropdownProps>;
1192
+
1193
+ interface CalendarProps {
1194
+ value?: Date;
1195
+ onChange?: (date: Date) => void;
1196
+ minDate?: Date;
1197
+ maxDate?: Date;
1198
+ disabled?: boolean;
1199
+ size?: "sm" | "md" | "lg";
1200
+ variant?: "default" | "filled" | "outlined";
1201
+ showWeekNumbers?: boolean;
1202
+ className?: string;
1203
+ style?: React.CSSProperties;
1204
+ }
1205
+ declare const Calendar: React.FC<CalendarProps>;
1206
+
1207
+ interface TimelineItem {
1208
+ id: string;
1209
+ title: string;
1210
+ description?: string;
1211
+ timestamp?: string;
1212
+ status?: "completed" | "current" | "pending" | "error";
1213
+ icon?: React.ReactNode;
1214
+ color?: "primary" | "success" | "warning" | "error" | "neutral";
1215
+ }
1216
+ interface TimelineProps {
1217
+ items: TimelineItem[];
1218
+ orientation?: "vertical" | "horizontal";
1219
+ size?: "sm" | "md" | "lg";
1220
+ variant?: "default" | "minimal" | "detailed";
1221
+ className?: string;
1222
+ style?: React.CSSProperties;
1223
+ }
1224
+ declare const Timeline: React.FC<TimelineProps>;
1225
+
1226
+ interface TreeNode$1 {
1227
+ id: string;
1228
+ label: string;
1229
+ children?: TreeNode$1[];
1230
+ icon?: React.ReactNode;
1231
+ disabled?: boolean;
1232
+ selected?: boolean;
1233
+ expanded?: boolean;
1234
+ data?: any;
1235
+ }
1236
+ interface TreeProps {
1237
+ data: TreeNode$1[];
1238
+ onNodeSelect?: (node: TreeNode$1) => void;
1239
+ onNodeToggle?: (node: TreeNode$1, expanded: boolean) => void;
1240
+ selectable?: boolean;
1241
+ expandable?: boolean;
1242
+ size?: "sm" | "md" | "lg";
1243
+ variant?: "default" | "minimal" | "detailed";
1244
+ className?: string;
1245
+ style?: React.CSSProperties;
1246
+ }
1247
+ declare const Tree: React.FC<TreeProps>;
1248
+
1249
+ interface StatCardProps {
1250
+ title: string;
1251
+ value: string | number;
1252
+ subtitle?: string;
1253
+ trend?: {
1254
+ value: number;
1255
+ direction: "up" | "down" | "neutral";
1256
+ period?: string;
1257
+ };
1258
+ icon?: React.ReactNode;
1259
+ color?: "primary" | "success" | "warning" | "error" | "info" | "neutral";
1260
+ size?: "small" | "medium" | "large";
1261
+ loading?: boolean;
1262
+ className?: string;
1263
+ style?: React.CSSProperties;
1264
+ onClick?: () => void;
1265
+ }
1266
+ declare function StatCard({ title, value, subtitle, trend, icon, color, size, loading, className, style, onClick, }: StatCardProps): React.JSX.Element;
1267
+
1268
+ interface TreeNode<T = any> {
1269
+ id: string;
1270
+ data: T;
1271
+ children?: TreeNode<T>[];
1272
+ expanded?: boolean;
1273
+ level?: number;
1274
+ parent?: TreeNode<T>;
1275
+ }
1276
+ interface TreeTableColumn<T = any> {
1277
+ key: string;
1278
+ title: string;
1279
+ dataIndex?: keyof T;
1280
+ render?: (value: any, node: TreeNode<T>, level: number) => React.ReactNode;
1281
+ width?: string | number;
1282
+ align?: "left" | "center" | "right";
1283
+ sortable?: boolean;
1284
+ filterable?: boolean;
1285
+ }
1286
+ interface TreeTableProps<T = any> {
1287
+ data: TreeNode<T>[];
1288
+ columns: TreeTableColumn<T>[];
1289
+ loading?: boolean;
1290
+ searchable?: boolean;
1291
+ searchPlaceholder?: string;
1292
+ sortable?: boolean;
1293
+ filterable?: boolean;
1294
+ selectable?: boolean;
1295
+ selectedKeys?: string[];
1296
+ onSelectionChange?: (selectedKeys: string[], selectedNodes: TreeNode<T>[]) => void;
1297
+ onNodeClick?: (node: TreeNode<T>, level: number) => void;
1298
+ onNodeToggle?: (node: TreeNode<T>, expanded: boolean) => void;
1299
+ onSort?: (column: string, direction: "asc" | "desc") => void;
1300
+ onFilter?: (filters: Record<string, any>) => void;
1301
+ className?: string;
1302
+ style?: React.CSSProperties;
1303
+ size?: "small" | "medium" | "large";
1304
+ bordered?: boolean;
1305
+ striped?: boolean;
1306
+ hoverable?: boolean;
1307
+ expandIcon?: React.ReactNode;
1308
+ collapseIcon?: React.ReactNode;
1309
+ indentSize?: number;
1310
+ showExpandAll?: boolean;
1311
+ defaultExpandAll?: boolean;
1312
+ }
1313
+ declare function TreeTable<T = any>({ data, columns, loading, searchable, searchPlaceholder, sortable, filterable, selectable, selectedKeys, onSelectionChange, onNodeClick, onNodeToggle, onSort, onFilter, className, style, size, bordered, striped, hoverable, expandIcon, collapseIcon, indentSize, showExpandAll, defaultExpandAll, }: TreeTableProps<T>): React.JSX.Element;
1314
+
1315
+ interface SparklineData {
1316
+ value: number;
1317
+ timestamp: string | number;
1318
+ }
1319
+ interface MetricCardProps {
1320
+ title: string;
1321
+ value: string | number;
1322
+ subtitle?: string;
1323
+ sparkline?: SparklineData[];
1324
+ trend?: {
1325
+ value: number;
1326
+ direction: "up" | "down" | "neutral";
1327
+ period?: string;
1328
+ };
1329
+ icon?: React.ReactNode;
1330
+ color?: "primary" | "success" | "warning" | "error" | "info" | "neutral";
1331
+ size?: "small" | "medium" | "large";
1332
+ loading?: boolean;
1333
+ className?: string;
1334
+ style?: React.CSSProperties;
1335
+ onClick?: () => void;
1336
+ showSparkline?: boolean;
1337
+ sparklineHeight?: number;
1338
+ sparklineColor?: string;
1339
+ threshold?: {
1340
+ value: number;
1341
+ type: "above" | "below" | "between";
1342
+ color?: string;
1343
+ };
1344
+ }
1345
+ declare function MetricCard({ title, value, subtitle, sparkline, trend, icon, color, size, loading, className, style, onClick, showSparkline, sparklineHeight, sparklineColor, threshold, }: MetricCardProps): React.JSX.Element;
1346
+
1347
+ interface DatePickerProps {
1348
+ value?: Date | null;
1349
+ onChange?: (date: Date | null) => void;
1350
+ placeholder?: string;
1351
+ disabled?: boolean;
1352
+ format?: string;
1353
+ minDate?: Date;
1354
+ maxDate?: Date;
1355
+ showTime?: boolean;
1356
+ timeFormat?: "12h" | "24h";
1357
+ className?: string;
1358
+ style?: React.CSSProperties;
1359
+ error?: boolean;
1360
+ errorMessage?: string;
1361
+ label?: string;
1362
+ required?: boolean;
1363
+ size?: "small" | "medium" | "large";
1364
+ }
1365
+ declare function DatePicker({ value, onChange, placeholder, disabled, format, minDate, maxDate, showTime, timeFormat, className, style, error, errorMessage, label, required, size, }: DatePickerProps): React.JSX.Element;
1366
+
1367
+ interface TimePickerProps {
1368
+ value?: Date | null;
1369
+ onChange?: (date: Date | null) => void;
1370
+ placeholder?: string;
1371
+ disabled?: boolean;
1372
+ format?: "12h" | "24h";
1373
+ minTime?: string;
1374
+ maxTime?: string;
1375
+ step?: number;
1376
+ className?: string;
1377
+ style?: React.CSSProperties;
1378
+ error?: boolean;
1379
+ errorMessage?: string;
1380
+ label?: string;
1381
+ required?: boolean;
1382
+ size?: "small" | "medium" | "large";
1383
+ showSeconds?: boolean;
1384
+ use12Hours?: boolean;
1385
+ }
1386
+ declare function TimePicker({ value, onChange, placeholder, disabled, format, minTime, maxTime, step, className, style, error, errorMessage, label, required, size, showSeconds, use12Hours, }: TimePickerProps): React.JSX.Element;
1387
+
1388
+ interface FileUploadProps {
1389
+ accept?: string;
1390
+ multiple?: boolean;
1391
+ maxSize?: number;
1392
+ maxFiles?: number;
1393
+ onUpload?: (files: File[]) => void;
1394
+ onRemove?: (file: File) => void;
1395
+ disabled?: boolean;
1396
+ className?: string;
1397
+ style?: React.CSSProperties;
1398
+ variant?: "default" | "compact" | "minimal";
1399
+ showPreview?: boolean;
1400
+ showProgress?: boolean;
1401
+ placeholder?: string;
1402
+ error?: boolean;
1403
+ errorMessage?: string;
1404
+ label?: string;
1405
+ required?: boolean;
1406
+ }
1407
+ declare function FileUpload({ accept, multiple, maxSize, // 10MB default
1408
+ maxFiles, onUpload, onRemove, disabled, className, style, variant, showPreview, showProgress, placeholder, error, errorMessage, label, required, }: FileUploadProps): React.JSX.Element;
1409
+
1410
+ interface SearchSuggestion {
1411
+ id: string;
1412
+ text: string;
1413
+ description?: string;
1414
+ icon?: React.ReactNode;
1415
+ category?: string;
1416
+ value?: any;
1417
+ }
1418
+ interface SearchInputProps {
1419
+ value?: string;
1420
+ onChange?: (value: string) => void;
1421
+ onSearch?: (query: string) => void;
1422
+ onSelect?: (suggestion: SearchSuggestion) => void;
1423
+ suggestions?: SearchSuggestion[];
1424
+ placeholder?: string;
1425
+ disabled?: boolean;
1426
+ loading?: boolean;
1427
+ clearable?: boolean;
1428
+ showSuggestions?: boolean;
1429
+ maxSuggestions?: number;
1430
+ minLength?: number;
1431
+ debounceMs?: number;
1432
+ className?: string;
1433
+ style?: React.CSSProperties;
1434
+ error?: boolean;
1435
+ errorMessage?: string;
1436
+ label?: string;
1437
+ required?: boolean;
1438
+ size?: "small" | "medium" | "large";
1439
+ showCategories?: boolean;
1440
+ emptyMessage?: string;
1441
+ hotkey?: string;
1442
+ }
1443
+ declare function SearchInput({ value, onChange, onSearch, onSelect, suggestions, placeholder, disabled, loading, clearable, showSuggestions, maxSuggestions, minLength, debounceMs, className, style, error, errorMessage, label, required, size, showCategories, emptyMessage, hotkey, }: SearchInputProps): React.JSX.Element;
1444
+
1445
+ interface Tag$1 {
1446
+ id: string;
1447
+ label: string;
1448
+ value: any;
1449
+ color?: string;
1450
+ removable?: boolean;
1451
+ }
1452
+ interface TagInputProps {
1453
+ value?: Tag$1[];
1454
+ onChange?: (tags: Tag$1[]) => void;
1455
+ onAdd?: (tag: Tag$1) => void;
1456
+ onRemove?: (tag: Tag$1) => void;
1457
+ suggestions?: string[];
1458
+ placeholder?: string;
1459
+ disabled?: boolean;
1460
+ maxTags?: number;
1461
+ allowDuplicates?: boolean;
1462
+ validateTag?: (tag: string) => boolean | string;
1463
+ className?: string;
1464
+ style?: React.CSSProperties;
1465
+ error?: boolean;
1466
+ errorMessage?: string;
1467
+ label?: string;
1468
+ required?: boolean;
1469
+ size?: "small" | "medium" | "large";
1470
+ variant?: "default" | "outlined" | "filled";
1471
+ showSuggestions?: boolean;
1472
+ maxSuggestions?: number;
1473
+ createTagOnEnter?: boolean;
1474
+ createTagOnComma?: boolean;
1475
+ createTagOnSpace?: boolean;
1476
+ separator?: string;
1477
+ caseSensitive?: boolean;
1478
+ }
1479
+ declare function TagInput({ value, onChange, onAdd, onRemove, suggestions, placeholder, disabled, maxTags, allowDuplicates, validateTag, className, style, error, errorMessage, label, required, size, variant, showSuggestions, maxSuggestions, createTagOnEnter, createTagOnComma, createTagOnSpace, separator, caseSensitive, }: TagInputProps): React.JSX.Element;
1480
+
1481
+ interface RichTextEditorProps {
1482
+ value?: string;
1483
+ defaultValue?: string;
1484
+ placeholder?: string;
1485
+ disabled?: boolean;
1486
+ readOnly?: boolean;
1487
+ required?: boolean;
1488
+ error?: boolean;
1489
+ helperText?: string;
1490
+ label?: string;
1491
+ className?: string;
1492
+ style?: React.CSSProperties;
1493
+ size?: "sm" | "md" | "lg";
1494
+ variant?: "default" | "filled" | "outlined";
1495
+ minHeight?: number;
1496
+ maxHeight?: number;
1497
+ onChange?: (html: string) => void;
1498
+ onSend?: (html: string) => void;
1499
+ sendOnEnter?: boolean;
1500
+ clearOnSend?: boolean;
1501
+ onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
1502
+ onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
1503
+ onSelectionChange?: (selection: Selection | null) => void;
1504
+ toolbar?: boolean;
1505
+ customToolbar?: React.ReactNode;
1506
+ }
1507
+ interface RichTextEditorRef {
1508
+ insertContent: (content: string) => void;
1509
+ focus: () => void;
1510
+ getHTML: () => string;
1511
+ }
1512
+ /**
1513
+ * Cuts HTML down to what `RichTextEditor` can produce: its nodes and marks,
1514
+ * links with an allowed scheme (no `javascript:`, `data:`, ...), and only a
1515
+ * valid text colour and alignment as style. Scripts, event handlers, images,
1516
+ * frames and every other element or attribute are dropped.
1517
+ *
1518
+ * Rich text from another member is attacker-controlled. Render it with
1519
+ * `dangerouslySetInnerHTML={{ __html: sanitizeRichTextHtml(html) }}`, never the
1520
+ * raw string. Needs a DOM (`window.DOMParser`).
1521
+ */
1522
+ declare function sanitizeRichTextHtml(html: string): string;
1523
+ declare const RichTextEditor: React.ForwardRefExoticComponent<RichTextEditorProps & React.RefAttributes<RichTextEditorRef>>;
1524
+
1525
+ interface WizardStep {
1526
+ id: string;
1527
+ title: string;
1528
+ description?: string;
1529
+ icon?: string;
1530
+ component: React.ComponentType<WizardStepProps>;
1531
+ validation?: (data: any) => boolean | Promise<boolean>;
1532
+ isOptional?: boolean;
1533
+ isDisabled?: boolean;
1534
+ }
1535
+ interface WizardStepProps {
1536
+ data: any;
1537
+ updateData: (data: any) => void;
1538
+ goToStep: (stepId: string) => void;
1539
+ isFirstStep: boolean;
1540
+ isLastStep: boolean;
1541
+ stepIndex: number;
1542
+ totalSteps: number;
1543
+ }
1544
+ interface BuildWizardProps {
1545
+ steps: WizardStep[];
1546
+ initialData?: any;
1547
+ onComplete: (data: any) => void;
1548
+ onCancel?: () => void;
1549
+ onStepChange?: (stepId: string, stepIndex: number) => void;
1550
+ showProgress?: boolean;
1551
+ showStepNumbers?: boolean;
1552
+ allowSkip?: boolean;
1553
+ className?: string;
1554
+ style?: React.CSSProperties;
1555
+ }
1556
+ declare function BuildWizard({ steps, initialData, onComplete, onCancel, onStepChange, showProgress, showStepNumbers, allowSkip, className, style, }: BuildWizardProps): React.JSX.Element;
1557
+ interface TextInputStepProps extends WizardStepProps {
1558
+ label: string;
1559
+ placeholder?: string;
1560
+ required?: boolean;
1561
+ multiline?: boolean;
1562
+ rows?: number;
1563
+ }
1564
+ declare function TextInputStep({ data, updateData, label, placeholder, required, multiline, rows, }: TextInputStepProps): React.JSX.Element;
1565
+ interface SelectStepProps extends WizardStepProps {
1566
+ label: string;
1567
+ options: Array<{
1568
+ value: string;
1569
+ label: string;
1570
+ disabled?: boolean;
1571
+ }>;
1572
+ required?: boolean;
1573
+ multiple?: boolean;
1574
+ }
1575
+ declare function SelectStep({ data, updateData, label, options, required, multiple, }: SelectStepProps): React.JSX.Element;
1576
+ interface CheckboxStepProps extends WizardStepProps {
1577
+ label: string;
1578
+ options: Array<{
1579
+ value: string;
1580
+ label: string;
1581
+ description?: string;
1582
+ }>;
1583
+ required?: boolean;
1584
+ }
1585
+ declare function CheckboxStep({ data, updateData, label, options, required, }: CheckboxStepProps): React.JSX.Element;
1586
+
1587
+ interface SkeletonProps {
1588
+ width?: string | number;
1589
+ height?: string | number;
1590
+ variant?: "text" | "rectangular" | "circular" | "rounded";
1591
+ animation?: "pulse" | "wave" | "none";
1592
+ lines?: number;
1593
+ className?: string;
1594
+ style?: React.CSSProperties;
1595
+ }
1596
+ declare function Skeleton({ width, height, variant, animation, lines, className, style, }: SkeletonProps): React.JSX.Element;
1597
+ declare function SkeletonText({ lines, ...props }: Omit<SkeletonProps, "variant" | "height">): React.JSX.Element;
1598
+ declare function SkeletonTitle({ ...props }: Omit<SkeletonProps, "variant" | "height">): React.JSX.Element;
1599
+ declare function SkeletonAvatar({ size, ...props }: Omit<SkeletonProps, "variant" | "width" | "height"> & {
1600
+ size?: number;
1601
+ }): React.JSX.Element;
1602
+ declare function SkeletonButton({ ...props }: Omit<SkeletonProps, "variant" | "height">): React.JSX.Element;
1603
+ declare function SkeletonCard({ ...props }: Omit<SkeletonProps, "variant" | "height" | "width">): React.JSX.Element;
1604
+ declare function SkeletonTable({ rows, columns, ...props }: Omit<SkeletonProps, "variant" | "height" | "width" | "lines"> & {
1605
+ rows?: number;
1606
+ columns?: number;
1607
+ }): React.JSX.Element;
1608
+
1609
+ interface AccordionItemProps {
1610
+ title: React.ReactNode;
1611
+ children: React.ReactNode;
1612
+ disabled?: boolean;
1613
+ defaultOpen?: boolean;
1614
+ icon?: React.ReactNode;
1615
+ className?: string;
1616
+ style?: React.CSSProperties;
1617
+ }
1618
+ interface AccordionProps {
1619
+ items: AccordionItemProps[];
1620
+ allowMultiple?: boolean;
1621
+ variant?: "default" | "bordered" | "filled";
1622
+ size?: "small" | "medium" | "large";
1623
+ className?: string;
1624
+ style?: React.CSSProperties;
1625
+ }
1626
+ declare function AccordionItem({ title, children, disabled, defaultOpen, icon, className, style, }: AccordionItemProps): React.JSX.Element;
1627
+ declare function Accordion({ items, allowMultiple, variant, size, className, style, }: AccordionProps): React.JSX.Element;
1628
+ declare function AccordionItemControlled({ title, children, isOpen, onToggle, disabled, icon, className, style, }: AccordionItemProps & {
1629
+ isOpen: boolean;
1630
+ onToggle: () => void;
1631
+ }): React.JSX.Element;
1632
+
1633
+ interface CommandItem {
1634
+ id: string;
1635
+ title: string;
1636
+ description?: string;
1637
+ icon?: React.ReactNode;
1638
+ keywords?: string[];
1639
+ category?: string;
1640
+ action: () => void;
1641
+ disabled?: boolean;
1642
+ }
1643
+ interface CommandPaletteProps {
1644
+ items: CommandItem[];
1645
+ placeholder?: string;
1646
+ emptyMessage?: string;
1647
+ maxHeight?: number;
1648
+ onOpen?: () => void;
1649
+ onClose?: () => void;
1650
+ onSelect?: (item: CommandItem) => void;
1651
+ className?: string;
1652
+ style?: React.CSSProperties;
1653
+ hotkey?: string;
1654
+ showCategories?: boolean;
1655
+ searchThreshold?: number;
1656
+ }
1657
+ declare function CommandPalette({ items, placeholder, emptyMessage, maxHeight, onOpen, onClose, onSelect, className, style, hotkey, showCategories, searchThreshold, }: CommandPaletteProps): React.JSX.Element;
1658
+
1659
+ interface CopyToClipboardProps {
1660
+ text: string;
1661
+ children?: React.ReactNode;
1662
+ onCopy?: (text: string) => void;
1663
+ onError?: (error: Error) => void;
1664
+ successMessage?: string;
1665
+ errorMessage?: string;
1666
+ showToast?: boolean;
1667
+ variant?: "button" | "icon" | "text" | "custom";
1668
+ size?: "small" | "medium" | "large";
1669
+ disabled?: boolean;
1670
+ className?: string;
1671
+ style?: React.CSSProperties;
1672
+ copyIcon?: React.ReactNode;
1673
+ successIcon?: React.ReactNode;
1674
+ errorIcon?: React.ReactNode;
1675
+ showFeedback?: boolean;
1676
+ feedbackDuration?: number;
1677
+ }
1678
+ declare function CopyToClipboard({ text, children, onCopy, onError, successMessage, errorMessage, showToast, variant, size, disabled, className, style, copyIcon, successIcon, errorIcon, showFeedback, feedbackDuration, }: CopyToClipboardProps): React.JSX.Element;
1679
+ declare function useCopyToClipboard(): {
1680
+ copy: (text: string) => Promise<boolean>;
1681
+ status: "error" | "success" | "idle";
1682
+ };
1683
+
1684
+ interface TrendIndicatorProps {
1685
+ value: number;
1686
+ direction: "up" | "down" | "neutral";
1687
+ period?: string;
1688
+ color?: "success" | "error" | "neutral" | "primary";
1689
+ size?: "sm" | "md" | "lg";
1690
+ showIcon?: boolean;
1691
+ className?: string;
1692
+ style?: React.CSSProperties;
1693
+ }
1694
+ declare function TrendIndicator({ value, direction, period, color, size, showIcon, className, style, }: TrendIndicatorProps): React.JSX.Element;
1695
+
1696
+ interface EmptyStateProps {
1697
+ icon?: React.ReactNode;
1698
+ title: string;
1699
+ description?: string;
1700
+ action?: React.ReactNode;
1701
+ size?: "sm" | "md" | "lg";
1702
+ variant?: "default" | "minimal" | "card";
1703
+ type?: "empty" | "error" | "not-found" | "loading";
1704
+ className?: string;
1705
+ style?: React.CSSProperties;
1706
+ }
1707
+ interface ErrorViewProps {
1708
+ title?: string;
1709
+ message?: string;
1710
+ actionLabel?: string;
1711
+ onAction?: () => void;
1712
+ variant?: "error" | "empty" | "not-found";
1713
+ icon?: React.ReactNode;
1714
+ className?: string;
1715
+ style?: React.CSSProperties;
1716
+ showAction?: boolean;
1717
+ }
1718
+ declare function EmptyState({ icon, title, description, action, size, variant, type, className, style, }: EmptyStateProps): React.JSX.Element;
1719
+ declare function EmptySearchState({ searchTerm, onClear, ...props }: Omit<EmptyStateProps, "icon" | "title" | "description"> & {
1720
+ searchTerm?: string;
1721
+ onClear?: () => void;
1722
+ }): React.JSX.Element;
1723
+ declare function EmptyDataState({ onRefresh, ...props }: Omit<EmptyStateProps, "icon" | "title" | "description"> & {
1724
+ onRefresh?: () => void;
1725
+ }): React.JSX.Element;
1726
+ declare function ErrorView({ title, message, actionLabel, onAction, variant, icon, className, style, showAction, }: ErrorViewProps): React.JSX.Element;
1727
+ declare function EmptyView(props: Omit<ErrorViewProps, "variant">): React.JSX.Element;
1728
+ declare function NotFoundView(props: Omit<ErrorViewProps, "variant">): React.JSX.Element;
1729
+
1730
+ interface TagProps {
1731
+ children: string;
1732
+ onRemove?: () => void;
1733
+ variant?: "default" | "success" | "warning" | "error" | "info" | "neutral";
1734
+ size?: "sm" | "md" | "lg";
1735
+ disabled?: boolean;
1736
+ className?: string;
1737
+ style?: React.CSSProperties;
1738
+ }
1739
+ declare function Tag({ children, onRemove, variant, size, disabled, className, style, }: TagProps): React.JSX.Element;
1740
+
1741
+ interface FilePreviewProps {
1742
+ file: File;
1743
+ onRemove?: () => void;
1744
+ showSize?: boolean;
1745
+ variant?: "compact" | "detailed";
1746
+ size?: "sm" | "md" | "lg";
1747
+ className?: string;
1748
+ style?: React.CSSProperties;
1749
+ }
1750
+ declare function FilePreview({ file, onRemove, showSize, variant, size, className, style, }: FilePreviewProps): React.JSX.Element;
1751
+
1752
+ interface SearchHighlightProps {
1753
+ text: string;
1754
+ searchTerm: string;
1755
+ highlightColor?: string;
1756
+ caseSensitive?: boolean;
1757
+ className?: string;
1758
+ style?: React.CSSProperties;
1759
+ }
1760
+ declare function SearchHighlight({ text, searchTerm, highlightColor, caseSensitive, className, style, }: SearchHighlightProps): React.JSX.Element;
1761
+
1762
+ var color = {
1763
+ neutral: {
1764
+ "200": {
1765
+ value: "#C8C8C8",
1766
+ comment: "Very light gray"
1767
+ },
1768
+ "300": {
1769
+ value: "#A0A0A0",
1770
+ comment: "Light gray"
1771
+ },
1772
+ "400": {
1773
+ value: "#8E8E8E",
1774
+ comment: "Medium gray"
1775
+ },
1776
+ "600": {
1777
+ value: "#404040",
1778
+ comment: "Medium dark gray"
1779
+ },
1780
+ "700": {
1781
+ value: "#282828",
1782
+ comment: "Slightly lighter dark gray"
1783
+ },
1784
+ "800": {
1785
+ value: "#222222",
1786
+ comment: "Dark gray"
1787
+ },
1788
+ "900": {
1789
+ value: "#131215",
1790
+ comment: "Very dark gray, almost black"
1791
+ }
1792
+ },
1793
+ brand: {
1794
+ "100": {
1795
+ value: "#ECFC91",
1796
+ comment: "Very pale, almost white, yellow-green"
1797
+ },
1798
+ "600": {
1799
+ value: "#A5FF11",
1800
+ comment: "Bright, vibrant lime green"
1801
+ },
1802
+ "700": {
1803
+ value: "#73B30C",
1804
+ comment: "Medium lime green"
1805
+ },
1806
+ "800": {
1807
+ value: "#8AA200",
1808
+ comment: "Darker lime green"
1809
+ },
1810
+ "900": {
1811
+ value: "#2D381B",
1812
+ comment: "Very dark olive green"
1813
+ }
1814
+ },
1815
+ transparent: {
1816
+ brand: {
1817
+ value: "rgba(72, 72, 72, 0.05)",
1818
+ comment: "Brand transparent - 5% opacity"
1819
+ },
1820
+ "black-50": {
1821
+ value: "rgba(0, 0, 0, 0.5)",
1822
+ comment: "Transparent black - 50% opacity"
1823
+ },
1824
+ "green-20": {
1825
+ value: "rgba(112, 237, 206, 0.2)",
1826
+ comment: "Transparent green - 20% opacity"
1827
+ },
1828
+ "green-10": {
1829
+ value: "rgba(109, 234, 173, 0.1)",
1830
+ comment: "Transparent green - 10% opacity"
1831
+ }
1832
+ },
1833
+ background: {
1834
+ primary: {
1835
+ value: "#1A1A1A",
1836
+ comment: "Primary background - dark gray"
1837
+ },
1838
+ secondary: {
1839
+ value: "#2A2A2A",
1840
+ comment: "Secondary background - medium dark gray"
1841
+ },
1842
+ tertiary: {
1843
+ value: "#3A3A3A",
1844
+ comment: "Tertiary background - lighter dark gray"
1845
+ },
1846
+ brand: {
1847
+ value: "#1F2A15",
1848
+ comment: "Brand background - dark greenish gray"
1849
+ }
1850
+ },
1851
+ semantic: {
1852
+ success: {
1853
+ value: "#16a34a",
1854
+ comment: "Green for success states"
1855
+ },
1856
+ warning: {
1857
+ value: "#f59e0b",
1858
+ comment: "Orange for warning states"
1859
+ },
1860
+ error: {
1861
+ value: "#ef4444",
1862
+ comment: "Red for error states"
1863
+ },
1864
+ info: {
1865
+ value: "#3b82f6",
1866
+ comment: "Blue for info states"
1867
+ }
1868
+ }
1869
+ };
1870
+ var radius$1 = {
1871
+ sm: {
1872
+ value: "8px"
1873
+ },
1874
+ md: {
1875
+ value: "12px"
1876
+ },
1877
+ lg: {
1878
+ value: "16px"
1879
+ }
1880
+ };
1881
+ var space = {
1882
+ "2": {
1883
+ value: "0.5rem"
1884
+ },
1885
+ "3": {
1886
+ value: "0.75rem"
1887
+ },
1888
+ "4": {
1889
+ value: "1rem"
1890
+ },
1891
+ "6": {
1892
+ value: "1.5rem"
1893
+ }
1894
+ };
1895
+ var font = {
1896
+ body: {
1897
+ value: "Power Grotesk, Inter, system-ui, sans-serif",
1898
+ comment: "Main typeface for Calimero brand cohesion"
1899
+ },
1900
+ heading: {
1901
+ value: "Power Grotesk, Inter, system-ui, sans-serif",
1902
+ comment: "Heading typeface"
1903
+ },
1904
+ secondary: {
1905
+ value: "Inter, system-ui, sans-serif",
1906
+ comment: "Secondary typeface for tools and diagrams"
1907
+ }
1908
+ };
1909
+ var tokens = {
1910
+ color: color,
1911
+ radius: radius$1,
1912
+ space: space,
1913
+ font: font
1914
+ };
1915
+
1916
+ declare const colors: {
1917
+ neutral: {
1918
+ "900": {
1919
+ value: string;
1920
+ comment: string;
1921
+ };
1922
+ "800": {
1923
+ value: string;
1924
+ comment: string;
1925
+ };
1926
+ "700": {
1927
+ value: string;
1928
+ comment: string;
1929
+ };
1930
+ "600": {
1931
+ value: string;
1932
+ comment: string;
1933
+ };
1934
+ "400": {
1935
+ value: string;
1936
+ comment: string;
1937
+ };
1938
+ "300": {
1939
+ value: string;
1940
+ comment: string;
1941
+ };
1942
+ "200": {
1943
+ value: string;
1944
+ comment: string;
1945
+ };
1946
+ };
1947
+ brand: {
1948
+ "900": {
1949
+ value: string;
1950
+ comment: string;
1951
+ };
1952
+ "800": {
1953
+ value: string;
1954
+ comment: string;
1955
+ };
1956
+ "700": {
1957
+ value: string;
1958
+ comment: string;
1959
+ };
1960
+ "600": {
1961
+ value: string;
1962
+ comment: string;
1963
+ };
1964
+ "100": {
1965
+ value: string;
1966
+ comment: string;
1967
+ };
1968
+ };
1969
+ transparent: {
1970
+ brand: {
1971
+ value: string;
1972
+ comment: string;
1973
+ };
1974
+ "black-50": {
1975
+ value: string;
1976
+ comment: string;
1977
+ };
1978
+ "green-20": {
1979
+ value: string;
1980
+ comment: string;
1981
+ };
1982
+ "green-10": {
1983
+ value: string;
1984
+ comment: string;
1985
+ };
1986
+ };
1987
+ background: {
1988
+ primary: {
1989
+ value: string;
1990
+ comment: string;
1991
+ };
1992
+ secondary: {
1993
+ value: string;
1994
+ comment: string;
1995
+ };
1996
+ tertiary: {
1997
+ value: string;
1998
+ comment: string;
1999
+ };
2000
+ brand: {
2001
+ value: string;
2002
+ comment: string;
2003
+ };
2004
+ };
2005
+ semantic: {
2006
+ success: {
2007
+ value: string;
2008
+ comment: string;
2009
+ };
2010
+ warning: {
2011
+ value: string;
2012
+ comment: string;
2013
+ };
2014
+ error: {
2015
+ value: string;
2016
+ comment: string;
2017
+ };
2018
+ info: {
2019
+ value: string;
2020
+ comment: string;
2021
+ };
2022
+ };
2023
+ };
2024
+ declare const spacing: {
2025
+ "2": {
2026
+ value: string;
2027
+ };
2028
+ "3": {
2029
+ value: string;
2030
+ };
2031
+ "4": {
2032
+ value: string;
2033
+ };
2034
+ "6": {
2035
+ value: string;
2036
+ };
2037
+ };
2038
+ declare const radius: {
2039
+ sm: {
2040
+ value: string;
2041
+ };
2042
+ md: {
2043
+ value: string;
2044
+ };
2045
+ lg: {
2046
+ value: string;
2047
+ };
2048
+ };
2049
+ declare const fonts: {
2050
+ body: {
2051
+ value: string;
2052
+ comment: string;
2053
+ };
2054
+ heading: {
2055
+ value: string;
2056
+ comment: string;
2057
+ };
2058
+ secondary: {
2059
+ value: string;
2060
+ comment: string;
2061
+ };
2062
+ };
2063
+ declare const cssVariables: string;
2064
+
2065
+ export { Accordion, AccordionItem, AccordionItemControlled, Alert, AnnouncementBanner, AuthLayout, Avatar, Badge, Banner, type BannerAction, type BannerPosition, type BannerProps, type BannerSize, type BannerVariant, Box, Breadcrumbs, BuildWizard, Button, type ButtonProps, type ButtonSize, type ButtonVariant, Calendar, Card, CardContent, type CardContentProps, CardHeader, type CardHeaderProps, type CardProps, CardTitle, type CardTitleProps, Center, Checkbox, CheckboxStep, CircularProgress, Code, CommandPalette, Container, CopyToClipboard, DataTable, DatePicker, Divider, Dropdown, EditableTable, EmptyDataState, EmptySearchState, EmptyState, EmptyView, ErrorBanner, ErrorView, Fieldset, FilePreview, FileUpload, Flex, Form, FormField, FormGroup, FullScreenLoader, Grid, GridItem, Heading, Icon, Image, InfoBanner, InlineLoader, Input, Layout, Link, List, Loader, Menu, MenuDivider, MenuGroup, MenuItem, MetricCard, Modal, Navbar, NavbarBrand, NavbarItem, NavbarMenu, NavbarToggle, NotFoundView, type Notification, type NotificationAction, type NotificationCategory, NotificationCenter, type NotificationCenterProps, type NotificationPriority, type NotificationStatus, type NotificationVariant, NumberInput, PageLoader, Pagination, Popover, Progress, PromotionBanner, Radio, RadioGroup, RichTextEditor, type RichTextEditorProps, SearchHighlight, SearchInput, Select, SelectStep, Sidebar, SidebarBrand, SidebarFooter, SidebarHeader, SidebarUser, Skeleton, SkeletonAvatar, SkeletonButton, SkeletonCard, SkeletonTable, SkeletonText, SkeletonTitle, Spacer, Spinner, Stack, StatCard, StatusBadge, SuccessBanner, Switch, TabPanel, Table, Tabs, Tag, TagInput, Text, TextInputStep, Textarea, TimePicker, Timeline, ToastProvider, Tooltip, Tree, TreeTable, TrendIndicator, WarningBanner, colors, cssVariables, fonts, radius, sanitizeRichTextHtml, spacing, tokens, useCopyToClipboard, useNotifications, useToast };