@humu-tech/ui 0.1.6

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,1637 @@
1
+ import { ClassValue } from 'clsx';
2
+ import * as react from 'react';
3
+ import { ReactNode, HTMLAttributes, ComponentPropsWithoutRef, InputHTMLAttributes, ButtonHTMLAttributes, TextareaHTMLAttributes, ForwardedRef } from 'react';
4
+ import * as class_variance_authority_types from 'class-variance-authority/types';
5
+ import * as class_variance_authority from 'class-variance-authority';
6
+ import { VariantProps } from 'class-variance-authority';
7
+ import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
8
+ import { ptBR } from 'date-fns/locale';
9
+ import { DayPickerSingleProps } from 'react-day-picker';
10
+ import * as DialogPrimitive from '@radix-ui/react-dialog';
11
+ import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
12
+ import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
13
+ import * as PopoverPrimitive from '@radix-ui/react-popover';
14
+ import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
15
+ import * as SeparatorPrimitive from '@radix-ui/react-separator';
16
+ import * as SwitchPrimitive from '@radix-ui/react-switch';
17
+ import * as TabsPrimitive from '@radix-ui/react-tabs';
18
+ import * as TooltipPrimitive from '@radix-ui/react-tooltip';
19
+ import * as ToastPrimitive from '@radix-ui/react-toast';
20
+ import * as AccordionPrimitive from '@radix-ui/react-accordion';
21
+
22
+ declare function cn(...args: ClassValue[]): string;
23
+
24
+ type DsLinkComponent = React.ComponentType<{
25
+ to: string;
26
+ className?: string;
27
+ children?: ReactNode;
28
+ }>;
29
+ declare const DefaultLink: DsLinkComponent;
30
+
31
+ type DsV2Theme = 'light' | 'dark';
32
+ declare function useDsV2Theme(): DsV2Theme;
33
+
34
+ type SuspenseSkeletonProps = {
35
+ label?: string;
36
+ };
37
+ declare function SuspenseSkeleton({ label, }: SuspenseSkeletonProps): react.JSX.Element;
38
+
39
+ declare function isMacOS(): boolean;
40
+ declare function getShortcutLabel(key: string): string;
41
+ declare function getShortcutKeys(key: string): string[];
42
+
43
+ type AvatarTone = 'auto' | 'blue' | 'orange' | 'green' | 'lime' | 'red';
44
+ type AvatarSize = 'sm' | 'md' | 'lg';
45
+ type AvatarProps = Omit<HTMLAttributes<HTMLSpanElement>, 'children'> & {
46
+ name: string;
47
+ size?: AvatarSize;
48
+ tone?: AvatarTone;
49
+ src?: string;
50
+ };
51
+
52
+ declare const Avatar: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLSpanElement>, "children"> & {
53
+ name: string;
54
+ size?: AvatarSize;
55
+ tone?: AvatarTone;
56
+ src?: string;
57
+ } & react.RefAttributes<HTMLSpanElement>>;
58
+
59
+ declare const badgeStyles: (props?: ({
60
+ variant?: "default" | "success" | "warning" | "danger" | "info" | "solid" | null | undefined;
61
+ size?: "sm" | "md" | "lg" | null | undefined;
62
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
63
+ type BadgeProps = ComponentPropsWithoutRef<'span'> & VariantProps<typeof badgeStyles>;
64
+ declare const Badge: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & VariantProps<(props?: ({
65
+ variant?: "default" | "success" | "warning" | "danger" | "info" | "solid" | null | undefined;
66
+ size?: "sm" | "md" | "lg" | null | undefined;
67
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & react.RefAttributes<HTMLSpanElement>>;
68
+
69
+ type BreadcrumbItem = {
70
+ label: string;
71
+ to?: string;
72
+ };
73
+ type BreadcrumbProps = {
74
+ items: BreadcrumbItem[];
75
+ className?: string;
76
+ linkComponent?: DsLinkComponent;
77
+ };
78
+
79
+ declare function Breadcrumb({ items, className, linkComponent, }: BreadcrumbProps): react.JSX.Element;
80
+
81
+ declare const Button: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & class_variance_authority.VariantProps<(props?: ({
82
+ variant?: "primary" | "secondary" | "ghost" | "destructive" | null | undefined;
83
+ size?: "sm" | "md" | "lg" | null | undefined;
84
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & {
85
+ leftIcon?: react.ReactNode;
86
+ rightIcon?: react.ReactNode;
87
+ loading?: boolean;
88
+ asChild?: boolean;
89
+ } & react.RefAttributes<HTMLButtonElement>>;
90
+
91
+ declare const buttonStyles: (props?: ({
92
+ variant?: "primary" | "secondary" | "ghost" | "destructive" | null | undefined;
93
+ size?: "sm" | "md" | "lg" | null | undefined;
94
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
95
+
96
+ type ButtonProps = ComponentPropsWithoutRef<'button'> & VariantProps<typeof buttonStyles> & {
97
+ leftIcon?: ReactNode;
98
+ rightIcon?: ReactNode;
99
+ loading?: boolean;
100
+ asChild?: boolean;
101
+ };
102
+
103
+ declare const cardStyles: (props?: ({
104
+ variant?: "default" | "elevated" | "interactive" | null | undefined;
105
+ padding?: "none" | "sm" | "md" | "lg" | null | undefined;
106
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
107
+
108
+ type CardProps = ComponentPropsWithoutRef<'div'> & VariantProps<typeof cardStyles> & {
109
+ asChild?: boolean;
110
+ };
111
+ declare const Card: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & VariantProps<(props?: ({
112
+ variant?: "default" | "elevated" | "interactive" | null | undefined;
113
+ padding?: "none" | "sm" | "md" | "lg" | null | undefined;
114
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & {
115
+ asChild?: boolean;
116
+ } & react.RefAttributes<HTMLDivElement>> & {
117
+ Header: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
118
+ Title: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & react.RefAttributes<HTMLHeadingElement>>;
119
+ Description: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
120
+ Body: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
121
+ Footer: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
122
+ };
123
+
124
+ declare const MaskedInput: react.ForwardRefExoticComponent<Omit<react.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value"> & {
125
+ mask: string | string[];
126
+ value?: string;
127
+ onValueChange?: (formatted: string, raw: string) => void;
128
+ label?: string;
129
+ helper?: string;
130
+ error?: string;
131
+ floating?: boolean;
132
+ surface?: "light" | "dark";
133
+ normalizeRaw?: (raw: string) => string;
134
+ } & react.RefAttributes<HTMLInputElement>>;
135
+
136
+ type MaskedInputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange'> & {
137
+ mask: string | string[];
138
+ value?: string;
139
+ onValueChange?: (formatted: string, raw: string) => void;
140
+ label?: string;
141
+ helper?: string;
142
+ error?: string;
143
+ floating?: boolean;
144
+ surface?: 'light' | 'dark';
145
+ normalizeRaw?: (raw: string) => string;
146
+ };
147
+
148
+ type CepInputProps = Omit<MaskedInputProps, 'mask'>;
149
+ declare function CepInput(props: CepInputProps): react.JSX.Element;
150
+
151
+ type CheckboxProps = ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root> & {
152
+ label?: ReactNode;
153
+ helper?: string;
154
+ error?: string;
155
+ };
156
+ declare const Checkbox: react.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & react.RefAttributes<HTMLButtonElement>, "ref"> & {
157
+ label?: ReactNode;
158
+ helper?: string;
159
+ error?: string;
160
+ } & react.RefAttributes<HTMLButtonElement>>;
161
+
162
+ type ColorPickerProps = {
163
+ value?: string | null;
164
+ defaultValue?: string;
165
+ onValueChange?: (color: string) => void;
166
+ label?: ReactNode;
167
+ helper?: ReactNode;
168
+ error?: string;
169
+ required?: boolean;
170
+ disabled?: boolean;
171
+ placeholder?: string;
172
+ id?: string;
173
+ className?: string;
174
+ };
175
+
176
+ declare const ColorPicker: react.ForwardRefExoticComponent<ColorPickerProps & react.RefAttributes<HTMLInputElement>>;
177
+
178
+ type ComboboxItem = {
179
+ value: string;
180
+ label: string;
181
+ description?: string;
182
+ disabled?: boolean;
183
+ };
184
+ type ComboboxProps = Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'onChange'> & {
185
+ items: ComboboxItem[];
186
+ value?: string;
187
+ defaultValue?: string;
188
+ onValueChange?: (value: string) => void;
189
+ placeholder?: string;
190
+ searchPlaceholder?: string;
191
+ label?: string;
192
+ helper?: string;
193
+ error?: string;
194
+ required?: boolean;
195
+ disabled?: boolean;
196
+ loading?: boolean;
197
+ emptyMessage?: string;
198
+ allowClear?: boolean;
199
+ };
200
+
201
+ declare const Combobox: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLDivElement>, "children" | "onChange"> & {
202
+ items: ComboboxItem[];
203
+ value?: string;
204
+ defaultValue?: string;
205
+ onValueChange?: (value: string) => void;
206
+ placeholder?: string;
207
+ searchPlaceholder?: string;
208
+ label?: string;
209
+ helper?: string;
210
+ error?: string;
211
+ required?: boolean;
212
+ disabled?: boolean;
213
+ loading?: boolean;
214
+ emptyMessage?: string;
215
+ allowClear?: boolean;
216
+ } & react.RefAttributes<HTMLButtonElement>>;
217
+
218
+ type ConfirmDialogVariant = 'danger' | 'warn' | 'info';
219
+ type ConfirmDialogProps = {
220
+ trigger: ReactNode;
221
+ title: string;
222
+ description?: ReactNode;
223
+ confirmLabel?: string;
224
+ cancelLabel?: string;
225
+ variant?: ConfirmDialogVariant;
226
+ onConfirm: () => void | Promise<void>;
227
+ disabled?: boolean;
228
+ };
229
+ declare function ConfirmDialog({ trigger, title, description, confirmLabel, cancelLabel, variant, onConfirm, disabled, }: ConfirmDialogProps): react.JSX.Element;
230
+
231
+ type DateInputProps = Omit<ComponentPropsWithoutRef<'button'>, 'value' | 'defaultValue' | 'onChange' | 'size'> & {
232
+ value?: Date;
233
+ defaultValue?: Date;
234
+ onValueChange?: (value: Date | undefined) => void;
235
+ label?: ReactNode;
236
+ helper?: string;
237
+ error?: string;
238
+ required?: boolean;
239
+ placeholder?: string;
240
+ fromDate?: Date;
241
+ toDate?: Date;
242
+ disabledDates?: DayPickerSingleProps['disabled'];
243
+ leftIcon?: ReactNode;
244
+ formatPattern?: string;
245
+ locale?: typeof ptBR;
246
+ closeLabel?: string;
247
+ };
248
+ declare const DateInput: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "size" | "defaultValue" | "onChange" | "value"> & {
249
+ value?: Date;
250
+ defaultValue?: Date;
251
+ onValueChange?: (value: Date | undefined) => void;
252
+ label?: ReactNode;
253
+ helper?: string;
254
+ error?: string;
255
+ required?: boolean;
256
+ placeholder?: string;
257
+ fromDate?: Date;
258
+ toDate?: Date;
259
+ disabledDates?: DayPickerSingleProps["disabled"];
260
+ leftIcon?: ReactNode;
261
+ formatPattern?: string;
262
+ locale?: typeof ptBR;
263
+ closeLabel?: string;
264
+ } & react.RefAttributes<HTMLButtonElement>>;
265
+
266
+ type DateRange = {
267
+ from?: string;
268
+ to?: string;
269
+ };
270
+ type DateRangeInputProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'value' | 'onChange' | 'defaultValue'> & {
271
+ value?: DateRange;
272
+ defaultValue?: DateRange;
273
+ onChange?: (range: DateRange) => void;
274
+ label?: string;
275
+ helper?: string;
276
+ error?: string;
277
+ required?: boolean;
278
+ fromLabel?: string;
279
+ toLabel?: string;
280
+ closeLabel?: string;
281
+ };
282
+
283
+ declare const DateRangeInput: react.ForwardRefExoticComponent<Omit<react.ButtonHTMLAttributes<HTMLButtonElement>, "defaultValue" | "onChange" | "value"> & {
284
+ value?: DateRange;
285
+ defaultValue?: DateRange;
286
+ onChange?: (range: DateRange) => void;
287
+ label?: string;
288
+ helper?: string;
289
+ error?: string;
290
+ required?: boolean;
291
+ fromLabel?: string;
292
+ toLabel?: string;
293
+ closeLabel?: string;
294
+ } & react.RefAttributes<HTMLButtonElement>>;
295
+
296
+ declare const dialogContentStyles: (props?: ({
297
+ size?: "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "4xl" | "full" | null | undefined;
298
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
299
+
300
+ type DialogProps = ComponentPropsWithoutRef<typeof DialogPrimitive.Root> & {
301
+ children?: ReactNode;
302
+ };
303
+ type DialogContentProps = ComponentPropsWithoutRef<typeof DialogPrimitive.Content> & VariantProps<typeof dialogContentStyles> & {
304
+ hideCloseButton?: boolean;
305
+ };
306
+ declare function DialogRootBase({ children, ...props }: DialogProps): react.JSX.Element;
307
+ declare namespace DialogRootBase {
308
+ var displayName: string;
309
+ }
310
+ declare const DialogRoot: typeof DialogRootBase & {
311
+ Trigger: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
312
+ Close: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogCloseProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
313
+ Content: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & VariantProps<(props?: ({
314
+ size?: "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "4xl" | "full" | null | undefined;
315
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & {
316
+ hideCloseButton?: boolean;
317
+ } & react.RefAttributes<HTMLDivElement>>;
318
+ Header: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
319
+ Body: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
320
+ Footer: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
321
+ Title: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & react.RefAttributes<HTMLHeadingElement>, "ref"> & react.RefAttributes<HTMLHeadingElement>>;
322
+ Description: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & react.RefAttributes<HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
323
+ };
324
+
325
+ type DocumentInputProps = Omit<MaskedInputProps, 'mask'>;
326
+ declare function DocumentInput(props: DocumentInputProps): react.JSX.Element;
327
+
328
+ type DrawerSide = 'right' | 'left' | 'bottom';
329
+ type DrawerSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
330
+ type DrawerProps = ComponentPropsWithoutRef<typeof DialogPrimitive.Root> & {
331
+ children?: ReactNode;
332
+ };
333
+ type DrawerContentProps = ComponentPropsWithoutRef<typeof DialogPrimitive.Content> & {
334
+ side?: DrawerSide;
335
+ size?: DrawerSize;
336
+ hideCloseButton?: boolean;
337
+ };
338
+
339
+ declare function DrawerRootBase({ children, ...props }: DrawerProps): react.JSX.Element;
340
+ declare namespace DrawerRootBase {
341
+ var displayName: string;
342
+ }
343
+ declare const DrawerRoot: typeof DrawerRootBase & {
344
+ Trigger: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
345
+ Close: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogCloseProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
346
+ Content: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
347
+ side?: DrawerSide;
348
+ size?: DrawerSize;
349
+ hideCloseButton?: boolean;
350
+ } & react.RefAttributes<HTMLDivElement>>;
351
+ Header: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
352
+ Body: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
353
+ Footer: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
354
+ Title: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & react.RefAttributes<HTMLHeadingElement>, "ref"> & react.RefAttributes<HTMLHeadingElement>>;
355
+ Description: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & react.RefAttributes<HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
356
+ };
357
+
358
+ declare const dropdownItemStyles: (props?: ({
359
+ variant?: "default" | "danger" | null | undefined;
360
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
361
+
362
+ type DropdownProps = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Root> & {
363
+ children?: ReactNode;
364
+ };
365
+ type DropdownContentProps = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content>;
366
+ type DropdownItemProps = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> & VariantProps<typeof dropdownItemStyles>;
367
+ declare function DropdownRoot({ children, ...props }: DropdownProps): react.JSX.Element;
368
+ declare namespace DropdownRoot {
369
+ var displayName: string;
370
+ }
371
+ declare const Dropdown: typeof DropdownRoot & {
372
+ Trigger: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
373
+ Content: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
374
+ Item: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & VariantProps<(props?: ({
375
+ variant?: "default" | "danger" | null | undefined;
376
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & react.RefAttributes<HTMLDivElement>>;
377
+ Label: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
378
+ Separator: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
379
+ Group: react.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & react.RefAttributes<HTMLDivElement>>;
380
+ };
381
+
382
+ declare const contextMenuItemStyles: (props?: ({
383
+ variant?: "default" | "danger" | null | undefined;
384
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
385
+
386
+ type ContextMenuProps = ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Root> & {
387
+ children?: ReactNode;
388
+ };
389
+ type ContextMenuContentProps = ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Content>;
390
+ type ContextMenuItemProps = ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Item> & VariantProps<typeof contextMenuItemStyles>;
391
+ declare function ContextMenuRoot({ children, ...props }: ContextMenuProps): react.JSX.Element;
392
+ declare namespace ContextMenuRoot {
393
+ var displayName: string;
394
+ }
395
+ declare const ContextMenu: typeof ContextMenuRoot & {
396
+ Trigger: react.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuTriggerProps & react.RefAttributes<HTMLSpanElement>, "ref"> & react.RefAttributes<HTMLSpanElement>>;
397
+ Content: react.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
398
+ Item: react.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & VariantProps<(props?: ({
399
+ variant?: "default" | "danger" | null | undefined;
400
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & react.RefAttributes<HTMLDivElement>>;
401
+ Label: react.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
402
+ Separator: react.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
403
+ Group: react.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & react.RefAttributes<HTMLDivElement>>;
404
+ };
405
+
406
+ type CopyButtonProps = Omit<ComponentPropsWithoutRef<'button'>, 'children'> & {
407
+ textToCopy: string;
408
+ children?: ReactNode;
409
+ unstyled?: boolean;
410
+ };
411
+ declare const CopyButton: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "children"> & {
412
+ textToCopy: string;
413
+ children?: ReactNode;
414
+ unstyled?: boolean;
415
+ } & react.RefAttributes<HTMLButtonElement>>;
416
+
417
+ declare const FileUpload: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLDivElement>, "children" | "onChange" | "onDrop"> & {
418
+ onFilesSelected: (files: File[]) => void;
419
+ accept?: string;
420
+ maxSize?: number;
421
+ maxFiles?: number;
422
+ disabled?: boolean;
423
+ multiple?: boolean;
424
+ label?: string;
425
+ helper?: string;
426
+ error?: string;
427
+ files?: File[];
428
+ onFileRemove?: (file: File, index: number) => void;
429
+ dropzonePlaceholder?: react.ReactNode;
430
+ } & react.RefAttributes<HTMLDivElement>>;
431
+
432
+ type FileUploadProps = Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'children' | 'onDrop'> & {
433
+ onFilesSelected: (files: File[]) => void;
434
+ accept?: string;
435
+ maxSize?: number;
436
+ maxFiles?: number;
437
+ disabled?: boolean;
438
+ multiple?: boolean;
439
+ label?: string;
440
+ helper?: string;
441
+ error?: string;
442
+ files?: File[];
443
+ onFileRemove?: (file: File, index: number) => void;
444
+ dropzonePlaceholder?: ReactNode;
445
+ };
446
+
447
+ declare const formAlertStyles: (props?: ({
448
+ variant?: "success" | "warning" | "danger" | "info" | null | undefined;
449
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
450
+ type FormAlertProps = ComponentPropsWithoutRef<'div'> & VariantProps<typeof formAlertStyles> & {
451
+ title?: ReactNode;
452
+ icon?: ReactNode;
453
+ hideIcon?: boolean;
454
+ };
455
+ declare const FormAlert: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & VariantProps<(props?: ({
456
+ variant?: "success" | "warning" | "danger" | "info" | null | undefined;
457
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & {
458
+ title?: ReactNode;
459
+ icon?: ReactNode;
460
+ hideIcon?: boolean;
461
+ } & react.RefAttributes<HTMLDivElement>>;
462
+
463
+ declare const headingStyles: (props?: ({
464
+ size?: "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "xs" | null | undefined;
465
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
466
+ type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
467
+ type HeadingProps = ComponentPropsWithoutRef<'h1'> & VariantProps<typeof headingStyles> & {
468
+ level?: HeadingLevel;
469
+ };
470
+ declare const Heading: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & VariantProps<(props?: ({
471
+ size?: "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "xs" | null | undefined;
472
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & {
473
+ level?: HeadingLevel;
474
+ } & react.RefAttributes<HTMLHeadingElement>>;
475
+
476
+ type HelpHintSize = 'sm' | 'md';
477
+ type HelpHintProps = {
478
+ description: ReactNode;
479
+ title?: ReactNode;
480
+ videoUrl?: string;
481
+ docHref?: string;
482
+ docLabel?: string;
483
+ size?: HelpHintSize;
484
+ ariaLabel?: string;
485
+ align?: 'start' | 'center' | 'end';
486
+ className?: string;
487
+ };
488
+
489
+ declare const HelpHint: react.ForwardRefExoticComponent<HelpHintProps & react.RefAttributes<HTMLButtonElement>>;
490
+
491
+ type ImageUploadPreviewBg = 'panel' | 'light' | 'dark';
492
+ type ImageUploadProps = {
493
+ value?: string | null;
494
+ onValueChange: (base64: string | null) => void;
495
+ label?: ReactNode;
496
+ helper?: ReactNode;
497
+ error?: string;
498
+ accept?: string;
499
+ maxSize?: number;
500
+ previewBg?: ImageUploadPreviewBg;
501
+ disabled?: boolean;
502
+ required?: boolean;
503
+ selectLabel?: string;
504
+ changeLabel?: string;
505
+ removeConfirmTitle?: string;
506
+ removeConfirmDescription?: string;
507
+ removeConfirmLabel?: string;
508
+ id?: string;
509
+ className?: string;
510
+ };
511
+
512
+ declare const ImageUpload: react.ForwardRefExoticComponent<ImageUploadProps & react.RefAttributes<HTMLInputElement>>;
513
+
514
+ declare const inputContainerStyles: (props?: ({
515
+ size?: "sm" | "md" | "lg" | null | undefined;
516
+ hasError?: boolean | null | undefined;
517
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
518
+
519
+ type InputProps = Omit<ComponentPropsWithoutRef<'input'>, 'size'> & Pick<VariantProps<typeof inputContainerStyles>, 'size'> & {
520
+ label?: string;
521
+ helper?: string;
522
+ error?: string;
523
+ leftIcon?: ReactNode;
524
+ rightIcon?: ReactNode;
525
+ required?: boolean;
526
+ floating?: boolean;
527
+ surface?: 'light' | 'dark';
528
+ };
529
+ declare const Input: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref">, "size"> & Pick<VariantProps<(props?: ({
530
+ size?: "sm" | "md" | "lg" | null | undefined;
531
+ hasError?: boolean | null | undefined;
532
+ } & class_variance_authority_types.ClassProp) | undefined) => string>, "size"> & {
533
+ label?: string;
534
+ helper?: string;
535
+ error?: string;
536
+ leftIcon?: ReactNode;
537
+ rightIcon?: ReactNode;
538
+ required?: boolean;
539
+ floating?: boolean;
540
+ surface?: "light" | "dark";
541
+ } & react.RefAttributes<HTMLInputElement>>;
542
+
543
+ type LabelProps = ComponentPropsWithoutRef<'label'> & {
544
+ required?: boolean;
545
+ };
546
+ declare const Label: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
547
+ required?: boolean;
548
+ } & react.RefAttributes<HTMLLabelElement>>;
549
+
550
+ type MoneyInputProps = Omit<InputProps, 'value' | 'onChange'> & {
551
+ value?: string;
552
+ onValueChange?: (formatted: string, raw: string) => void;
553
+ };
554
+ declare function MoneyInput({ value, onValueChange, ...props }: MoneyInputProps): react.JSX.Element;
555
+
556
+ type MultiComboboxItem = {
557
+ value: string;
558
+ label: string;
559
+ description?: string;
560
+ disabled?: boolean;
561
+ };
562
+ type MultiComboboxProps = Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'onChange'> & {
563
+ items: MultiComboboxItem[];
564
+ value?: string[];
565
+ defaultValue?: string[];
566
+ onValueChange?: (value: string[]) => void;
567
+ placeholder?: string;
568
+ searchPlaceholder?: string;
569
+ label?: string;
570
+ helper?: string;
571
+ error?: string;
572
+ required?: boolean;
573
+ disabled?: boolean;
574
+ loading?: boolean;
575
+ emptyMessage?: string;
576
+ maxChipsVisible?: number;
577
+ contentClassName?: string;
578
+ };
579
+
580
+ declare const MultiCombobox: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLDivElement>, "children" | "onChange"> & {
581
+ items: MultiComboboxItem[];
582
+ value?: string[];
583
+ defaultValue?: string[];
584
+ onValueChange?: (value: string[]) => void;
585
+ placeholder?: string;
586
+ searchPlaceholder?: string;
587
+ label?: string;
588
+ helper?: string;
589
+ error?: string;
590
+ required?: boolean;
591
+ disabled?: boolean;
592
+ loading?: boolean;
593
+ emptyMessage?: string;
594
+ maxChipsVisible?: number;
595
+ contentClassName?: string;
596
+ } & react.RefAttributes<HTMLButtonElement>>;
597
+
598
+ type OtpInputProps = {
599
+ value?: string;
600
+ onChange?: (value: string) => void;
601
+ onComplete?: (value: string) => void;
602
+ onBlur?: React.FocusEventHandler<HTMLInputElement>;
603
+ name?: string;
604
+ length?: number;
605
+ surface?: 'light' | 'dark';
606
+ error?: string;
607
+ disabled?: boolean;
608
+ autoFocus?: boolean;
609
+ className?: string;
610
+ };
611
+ declare const OtpInput: react.ForwardRefExoticComponent<OtpInputProps & react.RefAttributes<HTMLInputElement>>;
612
+
613
+ type PasswordInputProps = Omit<InputProps, 'type' | 'rightIcon'>;
614
+ declare const PasswordInput: react.ForwardRefExoticComponent<PasswordInputProps & react.RefAttributes<HTMLInputElement>>;
615
+
616
+ type PercentInputProps = Omit<InputProps, 'value' | 'onChange'> & {
617
+ value?: string;
618
+ onValueChange?: (formatted: string, raw: string) => void;
619
+ };
620
+ declare function PercentInput({ value, onValueChange, ...props }: PercentInputProps): react.JSX.Element;
621
+
622
+ type PhoneInputProps = Omit<MaskedInputProps, 'mask'>;
623
+ declare function PhoneInput(props: PhoneInputProps): react.JSX.Element;
624
+
625
+ declare const popoverContentStyles: (props?: ({
626
+ size?: "auto" | "sm" | "md" | "lg" | null | undefined;
627
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
628
+
629
+ type PopoverProps = ComponentPropsWithoutRef<typeof PopoverPrimitive.Root> & {
630
+ children?: ReactNode;
631
+ };
632
+ type PopoverContentProps = ComponentPropsWithoutRef<typeof PopoverPrimitive.Content> & VariantProps<typeof popoverContentStyles>;
633
+ declare function PopoverRoot({ children, ...props }: PopoverProps): react.JSX.Element;
634
+ declare namespace PopoverRoot {
635
+ var displayName: string;
636
+ }
637
+ declare const Popover: typeof PopoverRoot & {
638
+ Trigger: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
639
+ Anchor: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverAnchorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
640
+ Close: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverCloseProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
641
+ Content: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & VariantProps<(props?: ({
642
+ size?: "auto" | "sm" | "md" | "lg" | null | undefined;
643
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & react.RefAttributes<HTMLDivElement>>;
644
+ };
645
+
646
+ type RadioItem = {
647
+ value: string;
648
+ label: ReactNode;
649
+ disabled?: boolean;
650
+ };
651
+ type RadioGroupProps = ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root> & {
652
+ items: RadioItem[];
653
+ label?: ReactNode;
654
+ helper?: string;
655
+ error?: string;
656
+ required?: boolean;
657
+ orientation?: 'horizontal' | 'vertical';
658
+ };
659
+ declare const RadioGroup: react.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
660
+ items: RadioItem[];
661
+ label?: ReactNode;
662
+ helper?: string;
663
+ error?: string;
664
+ required?: boolean;
665
+ orientation?: "horizontal" | "vertical";
666
+ } & react.RefAttributes<HTMLDivElement>>;
667
+
668
+ type SeparatorProps = ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root>;
669
+ declare const Separator: react.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
670
+
671
+ type StepState = 'completed' | 'active' | 'pending' | 'blocked' | 'error';
672
+ type StepperStep = {
673
+ id: string;
674
+ label: string;
675
+ description?: string;
676
+ state: StepState;
677
+ optional?: boolean;
678
+ };
679
+ type StepperProps = Omit<HTMLAttributes<HTMLOListElement>, 'children'> & {
680
+ steps: StepperStep[];
681
+ orientation?: 'horizontal' | 'vertical';
682
+ };
683
+
684
+ declare const Stepper: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLOListElement>, "children"> & {
685
+ steps: StepperStep[];
686
+ orientation?: "horizontal" | "vertical";
687
+ } & react.RefAttributes<HTMLOListElement>>;
688
+
689
+ declare const skeletonStyles: (props?: ({
690
+ shape?: "text" | "circle" | "rect" | null | undefined;
691
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
692
+ type SkeletonProps = ComponentPropsWithoutRef<'div'> & VariantProps<typeof skeletonStyles> & {
693
+ loading?: boolean;
694
+ };
695
+ declare const Skeleton: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & VariantProps<(props?: ({
696
+ shape?: "text" | "circle" | "rect" | null | undefined;
697
+ } & class_variance_authority_types.ClassProp) | undefined) => string> & {
698
+ loading?: boolean;
699
+ } & react.RefAttributes<HTMLDivElement>>;
700
+
701
+ declare const spinnerStyles: (props?: ({
702
+ size?: "sm" | "md" | "lg" | null | undefined;
703
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
704
+ type SpinnerProps = VariantProps<typeof spinnerStyles> & {
705
+ label?: string;
706
+ decorative?: boolean;
707
+ className?: string;
708
+ };
709
+ declare function Spinner({ size, label, decorative, className, }: SpinnerProps): react.JSX.Element;
710
+
711
+ type SparklineProps = {
712
+ values: number[];
713
+ color?: string;
714
+ height?: number;
715
+ width?: number | string;
716
+ variant?: 'line' | 'area';
717
+ ariaLabel?: string;
718
+ className?: string;
719
+ };
720
+
721
+ declare function Sparkline({ values, color, height, width, variant, ariaLabel, className, }: SparklineProps): react.JSX.Element | null;
722
+
723
+ type SparklineBadgeDirection = 'up' | 'down' | 'flat';
724
+ type SparklineBadgeTone = 'auto' | 'success' | 'danger' | 'muted' | 'warning' | 'info';
725
+ type SparklineBadgeProps = Omit<HTMLAttributes<HTMLSpanElement>, 'children'> & {
726
+ value: string;
727
+ direction: SparklineBadgeDirection;
728
+ tone?: SparklineBadgeTone;
729
+ size?: 'sm' | 'md';
730
+ };
731
+
732
+ declare const SparklineBadge: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLSpanElement>, "children"> & {
733
+ value: string;
734
+ direction: SparklineBadgeDirection;
735
+ tone?: SparklineBadgeTone;
736
+ size?: "sm" | "md";
737
+ } & react.RefAttributes<HTMLSpanElement>>;
738
+
739
+ type SwitchProps = ComponentPropsWithoutRef<typeof SwitchPrimitive.Root> & {
740
+ label?: ReactNode;
741
+ helper?: string;
742
+ error?: string;
743
+ };
744
+ declare const Switch: react.ForwardRefExoticComponent<Omit<SwitchPrimitive.SwitchProps & react.RefAttributes<HTMLButtonElement>, "ref"> & {
745
+ label?: ReactNode;
746
+ helper?: string;
747
+ error?: string;
748
+ } & react.RefAttributes<HTMLButtonElement>>;
749
+
750
+ type TabsVariant = 'pill' | 'underline';
751
+ type TabsProps = ComponentPropsWithoutRef<typeof TabsPrimitive.Root> & {
752
+ children?: ReactNode;
753
+ };
754
+ declare function TabsRoot({ children, className, ...props }: TabsProps): react.JSX.Element;
755
+ declare namespace TabsRoot {
756
+ var displayName: string;
757
+ }
758
+ declare const Tabs: typeof TabsRoot & {
759
+ List: react.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
760
+ variant?: TabsVariant;
761
+ } & react.RefAttributes<HTMLDivElement>>;
762
+ Trigger: react.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
763
+ Content: react.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
764
+ };
765
+
766
+ declare const ThemeToggle: react.ForwardRefExoticComponent<Omit<react.ButtonHTMLAttributes<HTMLButtonElement>, "children"> & {
767
+ size?: "sm" | "md" | "lg";
768
+ ariaLabelLight?: string;
769
+ ariaLabelDark?: string;
770
+ storageKey?: string;
771
+ } & react.RefAttributes<HTMLButtonElement>>;
772
+
773
+ type ThemeMode = 'light' | 'dark';
774
+ type ThemeToggleProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> & {
775
+ size?: 'sm' | 'md' | 'lg';
776
+ ariaLabelLight?: string;
777
+ ariaLabelDark?: string;
778
+ storageKey?: string;
779
+ };
780
+
781
+ declare const textStyles: (props?: ({
782
+ size?: "sm" | "lg" | "base" | "xs" | null | undefined;
783
+ color?: "default" | "danger" | "muted" | "subtle" | null | undefined;
784
+ weight?: "bold" | "normal" | "medium" | "semibold" | null | undefined;
785
+ } & class_variance_authority_types.ClassProp) | undefined) => string;
786
+ type TextProps = (ComponentPropsWithoutRef<'p'> & VariantProps<typeof textStyles> & {
787
+ tag?: 'p';
788
+ }) | (ComponentPropsWithoutRef<'span'> & VariantProps<typeof textStyles> & {
789
+ tag: 'span';
790
+ });
791
+ declare const Text: react.ForwardRefExoticComponent<TextProps & react.RefAttributes<HTMLSpanElement | HTMLParagraphElement>>;
792
+
793
+ declare const TextArea: react.ForwardRefExoticComponent<react.TextareaHTMLAttributes<HTMLTextAreaElement> & {
794
+ label?: string;
795
+ helper?: string;
796
+ error?: string;
797
+ showCount?: boolean;
798
+ required?: boolean;
799
+ } & react.RefAttributes<HTMLTextAreaElement>>;
800
+
801
+ type TextAreaProps = TextareaHTMLAttributes<HTMLTextAreaElement> & {
802
+ label?: string;
803
+ helper?: string;
804
+ error?: string;
805
+ showCount?: boolean;
806
+ required?: boolean;
807
+ };
808
+
809
+ type TooltipProps = {
810
+ content: ReactNode;
811
+ children: ReactNode;
812
+ side?: ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>['side'];
813
+ align?: ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>['align'];
814
+ sideOffset?: number;
815
+ delayDuration?: number;
816
+ open?: boolean;
817
+ defaultOpen?: boolean;
818
+ onOpenChange?: (open: boolean) => void;
819
+ contentClassName?: string;
820
+ disableHoverableContent?: boolean;
821
+ };
822
+ declare const Tooltip: react.ForwardRefExoticComponent<TooltipProps & Omit<Omit<TooltipPrimitive.TooltipTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref">, keyof TooltipProps> & react.RefAttributes<HTMLButtonElement>> & {
823
+ Provider: react.FC<TooltipPrimitive.TooltipProviderProps>;
824
+ Root: react.FC<TooltipPrimitive.TooltipProps>;
825
+ Trigger: react.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
826
+ Content: react.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
827
+ };
828
+
829
+ type ToasterProps = {
830
+ duration?: number;
831
+ swipeDirection?: ComponentPropsWithoutRef<typeof ToastPrimitive.Provider>['swipeDirection'];
832
+ viewportClassName?: string;
833
+ };
834
+ declare function Toaster({ duration, swipeDirection, viewportClassName, }: ToasterProps): react.JSX.Element;
835
+
836
+ type ToastVariant = 'default' | 'success' | 'warning' | 'danger' | 'info';
837
+ type ToastOptions = {
838
+ title?: ReactNode;
839
+ description?: ReactNode;
840
+ variant?: ToastVariant;
841
+ duration?: number;
842
+ action?: ReactNode;
843
+ };
844
+ type ToastRecord = ToastOptions & {
845
+ id: string;
846
+ open: boolean;
847
+ };
848
+ declare function dismissToast(id: string): void;
849
+ type ToastFn = {
850
+ (input: string | ToastOptions): string;
851
+ success: (input: string | ToastOptions) => string;
852
+ warning: (input: string | ToastOptions) => string;
853
+ danger: (input: string | ToastOptions) => string;
854
+ info: (input: string | ToastOptions) => string;
855
+ };
856
+ declare const toast: ToastFn;
857
+ declare function useToast(): {
858
+ toasts: ToastRecord[];
859
+ toast: ToastFn;
860
+ dismiss: (id: string) => void;
861
+ };
862
+
863
+ type SidebarItem = {
864
+ id: string;
865
+ label: string;
866
+ icon: ReactNode;
867
+ to: string;
868
+ badge?: number | string;
869
+ external?: boolean;
870
+ };
871
+ type SidebarGroup = {
872
+ label: string | null;
873
+ items: SidebarItem[];
874
+ pin?: 'bottom';
875
+ };
876
+ type SidebarProps = Omit<HTMLAttributes<HTMLElement>, 'children'> & {
877
+ groups: SidebarGroup[];
878
+ collapsed?: boolean;
879
+ defaultCollapsed?: boolean;
880
+ onCollapseChange?: (next: boolean) => void;
881
+ currentPath?: string;
882
+ renderLink?: (item: SidebarItem, children: ReactNode) => ReactNode;
883
+ linkComponent?: DsLinkComponent;
884
+ headerSlot?: ReactNode;
885
+ ariaLabel?: string;
886
+ collapsedWidth?: string;
887
+ expandedWidth?: string;
888
+ enableShortcut?: boolean;
889
+ };
890
+
891
+ declare const Sidebar: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLElement>, "children"> & {
892
+ groups: SidebarGroup[];
893
+ collapsed?: boolean;
894
+ defaultCollapsed?: boolean;
895
+ onCollapseChange?: (next: boolean) => void;
896
+ currentPath?: string;
897
+ renderLink?: (item: SidebarItem, children: ReactNode) => ReactNode;
898
+ linkComponent?: DsLinkComponent;
899
+ headerSlot?: ReactNode;
900
+ ariaLabel?: string;
901
+ collapsedWidth?: string;
902
+ expandedWidth?: string;
903
+ enableShortcut?: boolean;
904
+ } & react.RefAttributes<HTMLElement>>;
905
+
906
+ type AppShellProps = {
907
+ children: ReactNode;
908
+ sidebarGroups?: SidebarGroup[];
909
+ currentPath?: string;
910
+ linkComponent?: DsLinkComponent;
911
+ pageTitle?: ReactNode;
912
+ searchTrigger?: ReactNode;
913
+ notificationCenter?: ReactNode;
914
+ themeToggle?: ReactNode;
915
+ userMenu?: ReactNode;
916
+ headerSlot?: ReactNode;
917
+ defaultSidebarCollapsed?: boolean;
918
+ };
919
+ declare function AppShell({ children, sidebarGroups, currentPath, linkComponent, pageTitle, searchTrigger, notificationCenter, themeToggle, userMenu, headerSlot, defaultSidebarCollapsed, }: AppShellProps): react.JSX.Element;
920
+ declare namespace AppShell {
921
+ var displayName: string;
922
+ }
923
+
924
+ type KpiHeroTone = 'brand' | 'info' | 'warn' | 'danger' | 'success';
925
+ type KpiHeroTrendDirection = 'up' | 'down' | 'flat';
926
+ type KpiHeroTrend = {
927
+ direction: KpiHeroTrendDirection;
928
+ value: string;
929
+ };
930
+ type KpiHeroProps = {
931
+ label: string;
932
+ value: ReactNode;
933
+ sub?: ReactNode;
934
+ trend?: KpiHeroTrend;
935
+ icon: ReactNode;
936
+ tone: KpiHeroTone;
937
+ sparkline?: number[];
938
+ to?: string;
939
+ cta?: string;
940
+ linkComponent?: DsLinkComponent;
941
+ };
942
+
943
+ declare function KpiHero({ label, value, sub, trend, icon, tone, sparkline, to, cta, linkComponent, }: KpiHeroProps): react.JSX.Element;
944
+
945
+ type DashboardReason = 'permission_denied' | 'not_applicable_for_scope' | 'source_data_missing' | 'not_implemented' | 'invalid_period';
946
+ type DashboardBlockData = {
947
+ available: boolean;
948
+ reason: DashboardReason | null;
949
+ };
950
+ type DashboardBlockProps = DashboardBlockData & {
951
+ loading?: boolean;
952
+ isEmpty?: boolean;
953
+ emptyLabel?: string;
954
+ onRetry?: () => void;
955
+ children: ReactNode;
956
+ };
957
+
958
+ declare function DashboardBlock({ available, reason, loading, isEmpty, emptyLabel, onRetry, children, }: DashboardBlockProps): react.JSX.Element | null;
959
+
960
+ type LegalDocumentContent = {
961
+ content: string;
962
+ lastUpdated: string;
963
+ };
964
+ type LegalDocumentRendererProps = {
965
+ document?: LegalDocumentContent;
966
+ isLoading?: boolean;
967
+ error?: Error | null;
968
+ title?: string;
969
+ loadingState?: ReactNode;
970
+ errorState?: ReactNode;
971
+ lastUpdatedLabel?: string;
972
+ className?: string;
973
+ };
974
+
975
+ declare function LegalDocumentRenderer({ document, isLoading, error, title, loadingState, errorState, lastUpdatedLabel, className, }: LegalDocumentRendererProps): react.JSX.Element;
976
+ declare namespace LegalDocumentRenderer {
977
+ var displayName: string;
978
+ }
979
+
980
+ type DataTableSortDirection = 'asc' | 'desc';
981
+ type DataTableColumn<T> = {
982
+ key: string;
983
+ label: ReactNode;
984
+ sortable?: boolean;
985
+ width?: string;
986
+ align?: 'left' | 'right' | 'center';
987
+ render?: (row: T, index: number) => ReactNode;
988
+ accessor?: (row: T) => ReactNode;
989
+ };
990
+ type DataTableDensity = 'compact' | 'comfortable';
991
+ type DataTableProps<T> = Omit<HTMLAttributes<HTMLTableElement>, 'children'> & {
992
+ columns: DataTableColumn<T>[];
993
+ rows: T[];
994
+ rowKey: (row: T) => string;
995
+ density?: DataTableDensity;
996
+ zebra?: boolean;
997
+ stickyHeader?: boolean;
998
+ sortKey?: string;
999
+ sortDir?: DataTableSortDirection;
1000
+ onSortChange?: (key: string, dir: DataTableSortDirection) => void;
1001
+ loading?: boolean;
1002
+ loadingRowCount?: number;
1003
+ emptyState?: ReactNode;
1004
+ rowClassName?: (row: T, index: number) => string | undefined;
1005
+ ariaLabel?: string;
1006
+ };
1007
+
1008
+ type DataTableComponent = <T>(props: DataTableProps<T> & {
1009
+ ref?: ForwardedRef<HTMLTableElement>;
1010
+ }) => ReactNode;
1011
+ declare const DataTable: DataTableComponent;
1012
+
1013
+ declare const DataTablePagination: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLElement>, "children"> & {
1014
+ page: number;
1015
+ perPage: number;
1016
+ total: number;
1017
+ perPageOptions?: number[];
1018
+ onPageChange: (next: number) => void;
1019
+ onPerPageChange?: (next: number) => void;
1020
+ siblingCount?: number;
1021
+ showingLabel?: string;
1022
+ ofLabel?: string;
1023
+ perPageLabel?: string;
1024
+ prevAriaLabel?: string;
1025
+ nextAriaLabel?: string;
1026
+ } & react.RefAttributes<HTMLElement>>;
1027
+
1028
+ type DataTablePaginationProps = Omit<HTMLAttributes<HTMLElement>, 'children'> & {
1029
+ page: number;
1030
+ perPage: number;
1031
+ total: number;
1032
+ perPageOptions?: number[];
1033
+ onPageChange: (next: number) => void;
1034
+ onPerPageChange?: (next: number) => void;
1035
+ siblingCount?: number;
1036
+ showingLabel?: string;
1037
+ ofLabel?: string;
1038
+ perPageLabel?: string;
1039
+ prevAriaLabel?: string;
1040
+ nextAriaLabel?: string;
1041
+ };
1042
+
1043
+ type BadgeVariant = NonNullable<BadgeProps['variant']>;
1044
+ type SortDirection$1 = 'asc' | 'desc';
1045
+ type ReadOnlyColumn<T> = {
1046
+ type: 'text';
1047
+ key: keyof T & string;
1048
+ label: string;
1049
+ sortable?: boolean;
1050
+ align?: 'left' | 'right' | 'center';
1051
+ mono?: boolean;
1052
+ } | {
1053
+ type: 'badge';
1054
+ key: keyof T & string;
1055
+ label: string;
1056
+ sortable?: boolean;
1057
+ variantMap: Record<string, BadgeVariant>;
1058
+ labelMap?: Record<string, string>;
1059
+ } | {
1060
+ type: 'date';
1061
+ key: keyof T & string;
1062
+ label: string;
1063
+ format?: 'short' | 'long';
1064
+ sortable?: boolean;
1065
+ } | {
1066
+ type: 'currency';
1067
+ key: keyof T & string;
1068
+ label: string;
1069
+ sortable?: boolean;
1070
+ currency?: string;
1071
+ locale?: string;
1072
+ } | {
1073
+ type: 'action';
1074
+ key: string;
1075
+ label: string;
1076
+ render: (row: T) => ReactNode;
1077
+ align?: 'left' | 'right' | 'center';
1078
+ };
1079
+ type DetailsDialog<TList, TDetails> = {
1080
+ triggerColumn: keyof TList & string;
1081
+ title: string;
1082
+ fetchDetails: (row: TList) => Promise<TDetails> | TDetails;
1083
+ renderDetails: (details: TDetails) => ReactNode;
1084
+ size?: 'sm' | 'md' | 'lg' | 'xl';
1085
+ };
1086
+ type ReadOnlyDataViewProps<TList, TDetails> = {
1087
+ list: TList[];
1088
+ columns: ReadOnlyColumn<TList>[];
1089
+ detailsDialogs?: Array<DetailsDialog<TList, TDetails>>;
1090
+ emptyState?: ReactNode;
1091
+ loading?: boolean;
1092
+ loadingRows?: number;
1093
+ caption?: string;
1094
+ sortValue?: {
1095
+ column: keyof TList & string;
1096
+ direction: SortDirection$1;
1097
+ };
1098
+ onSortChange?: (column: keyof TList & string, direction: SortDirection$1) => void;
1099
+ rowKey: (row: TList, index: number) => string | number;
1100
+ density?: 'compact' | 'normal';
1101
+ className?: string;
1102
+ };
1103
+
1104
+ declare function ReadOnlyDataView<TList, TDetails = unknown>({ list, columns, detailsDialogs, emptyState, loading, loadingRows, caption, sortValue, onSortChange, rowKey, density, className, }: ReadOnlyDataViewProps<TList, TDetails>): react.JSX.Element;
1105
+ declare namespace ReadOnlyDataView {
1106
+ var displayName: string;
1107
+ }
1108
+
1109
+ type NotificationSeverity = 'info' | 'success' | 'warning' | 'danger';
1110
+ type Notification = {
1111
+ id: string;
1112
+ title: string;
1113
+ description?: string;
1114
+ timestamp: string;
1115
+ read: boolean;
1116
+ severity: NotificationSeverity;
1117
+ actionUrl?: string;
1118
+ };
1119
+ type NotificationCenterProps = {
1120
+ notifications: Notification[];
1121
+ unreadCount: number;
1122
+ onMarkAllRead?: () => void;
1123
+ onItemClick?: (notification: Notification) => void;
1124
+ emptyMessage?: string;
1125
+ triggerAriaLabel?: string;
1126
+ relativeTime?: (iso: string) => string;
1127
+ };
1128
+
1129
+ declare const NotificationCenter: react.ForwardRefExoticComponent<NotificationCenterProps & react.RefAttributes<HTMLButtonElement>>;
1130
+
1131
+ declare const NavigatorTile: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "title"> & {
1132
+ icon?: react.ReactNode;
1133
+ title: string;
1134
+ description?: string;
1135
+ badge?: react.ReactNode;
1136
+ showChevron?: boolean;
1137
+ asChild?: boolean;
1138
+ disabled?: boolean;
1139
+ } & react.RefAttributes<HTMLDivElement>>;
1140
+ declare const NavigatorTileGrid: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
1141
+ columns?: 1 | 2 | 3 | 4;
1142
+ emptyState?: react.ReactNode;
1143
+ isEmpty?: boolean;
1144
+ } & react.RefAttributes<HTMLDivElement>>;
1145
+
1146
+ type NavigatorTileProps = Omit<ComponentPropsWithoutRef<'div'>, 'title'> & {
1147
+ icon?: ReactNode;
1148
+ title: string;
1149
+ description?: string;
1150
+ badge?: ReactNode;
1151
+ showChevron?: boolean;
1152
+ asChild?: boolean;
1153
+ disabled?: boolean;
1154
+ };
1155
+ type NavigatorTileGridProps = ComponentPropsWithoutRef<'div'> & {
1156
+ columns?: 1 | 2 | 3 | 4;
1157
+ emptyState?: ReactNode;
1158
+ isEmpty?: boolean;
1159
+ };
1160
+
1161
+ type SortDirection = 'asc' | 'desc' | 'none';
1162
+ type SortableColumnHeaderProps = Omit<ComponentPropsWithoutRef<'button'>, 'children' | 'onChange'> & {
1163
+ label: ReactNode;
1164
+ direction: SortDirection;
1165
+ onDirectionChange: (next: SortDirection) => void;
1166
+ cycleMode?: 'tri-state' | 'asc-desc';
1167
+ align?: 'left' | 'right' | 'center';
1168
+ };
1169
+
1170
+ declare const SortableColumnHeader: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "children" | "onChange"> & {
1171
+ label: react.ReactNode;
1172
+ direction: SortDirection;
1173
+ onDirectionChange: (next: SortDirection) => void;
1174
+ cycleMode?: "tri-state" | "asc-desc";
1175
+ align?: "left" | "right" | "center";
1176
+ } & react.RefAttributes<HTMLButtonElement>>;
1177
+
1178
+ declare const PublicPageLayout: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
1179
+ header?: react.ReactNode;
1180
+ footer?: react.ReactNode;
1181
+ maxWidth?: "sm" | "md" | "lg" | "xl" | "2xl" | "full";
1182
+ skipToMainLabel?: string;
1183
+ mainId?: string;
1184
+ } & react.RefAttributes<HTMLDivElement>>;
1185
+
1186
+ type PublicPageLayoutProps = ComponentPropsWithoutRef<'div'> & {
1187
+ header?: ReactNode;
1188
+ footer?: ReactNode;
1189
+ maxWidth?: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
1190
+ skipToMainLabel?: string;
1191
+ mainId?: string;
1192
+ };
1193
+
1194
+ declare const ErrorPageLayout: react.ForwardRefExoticComponent<Omit<PublicPageLayoutProps, "children"> & {
1195
+ code?: string;
1196
+ title: string;
1197
+ description?: react.ReactNode;
1198
+ primaryAction?: {
1199
+ label: string;
1200
+ onClick: () => void;
1201
+ } | {
1202
+ label: string;
1203
+ href: string;
1204
+ };
1205
+ illustration?: react.ReactNode;
1206
+ } & react.RefAttributes<HTMLDivElement>>;
1207
+
1208
+ type ErrorPageLayoutProps = Omit<PublicPageLayoutProps, 'children'> & {
1209
+ code?: string;
1210
+ title: string;
1211
+ description?: ReactNode;
1212
+ primaryAction?: {
1213
+ label: string;
1214
+ onClick: () => void;
1215
+ } | {
1216
+ label: string;
1217
+ href: string;
1218
+ };
1219
+ illustration?: ReactNode;
1220
+ };
1221
+
1222
+ declare const Topbar: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLElement>, "children"> & {
1223
+ pageTitle?: react.ReactNode;
1224
+ searchTrigger?: react.ReactNode;
1225
+ notificationCenter?: react.ReactNode;
1226
+ themeToggle?: react.ReactNode;
1227
+ userMenu?: react.ReactNode;
1228
+ ariaLabel?: string;
1229
+ } & react.RefAttributes<HTMLElement>>;
1230
+
1231
+ type TopbarProps = Omit<HTMLAttributes<HTMLElement>, 'children'> & {
1232
+ pageTitle?: ReactNode;
1233
+ searchTrigger?: ReactNode;
1234
+ notificationCenter?: ReactNode;
1235
+ themeToggle?: ReactNode;
1236
+ userMenu?: ReactNode;
1237
+ ariaLabel?: string;
1238
+ };
1239
+
1240
+ declare const TutorialCard: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "title"> & {
1241
+ title: string;
1242
+ description?: string;
1243
+ media?: react.ReactNode;
1244
+ duration?: string;
1245
+ category?: string;
1246
+ asChild?: boolean;
1247
+ } & react.RefAttributes<HTMLDivElement>>;
1248
+
1249
+ type TutorialCardProps = Omit<ComponentPropsWithoutRef<'div'>, 'title'> & {
1250
+ title: string;
1251
+ description?: string;
1252
+ media?: ReactNode;
1253
+ duration?: string;
1254
+ category?: string;
1255
+ asChild?: boolean;
1256
+ };
1257
+
1258
+ type KpiCardVariant = 'neutral' | 'success' | 'warning' | 'danger' | 'info';
1259
+ type KpiCardProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & {
1260
+ label: string;
1261
+ value: string;
1262
+ sublabel?: string;
1263
+ variant?: KpiCardVariant;
1264
+ icon?: ReactNode;
1265
+ };
1266
+
1267
+ declare const KpiCard: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLDivElement>, "children"> & {
1268
+ label: string;
1269
+ value: string;
1270
+ sublabel?: string;
1271
+ variant?: KpiCardVariant;
1272
+ icon?: react.ReactNode;
1273
+ } & react.RefAttributes<HTMLDivElement>>;
1274
+
1275
+ type CommandItem = {
1276
+ id: string;
1277
+ label: string;
1278
+ description?: string;
1279
+ meta?: ReactNode;
1280
+ shortcut?: string;
1281
+ to?: string;
1282
+ onSelect?: () => void;
1283
+ disabled?: boolean;
1284
+ };
1285
+ type CommandGroup = {
1286
+ id: string;
1287
+ label?: string;
1288
+ items: CommandItem[];
1289
+ loading?: boolean;
1290
+ emptyMessage?: string;
1291
+ };
1292
+ type CommandPaletteProps = {
1293
+ open: boolean;
1294
+ onOpenChange: (next: boolean) => void;
1295
+ groups: CommandGroup[];
1296
+ query?: string;
1297
+ onQueryChange?: (next: string) => void;
1298
+ placeholder?: string;
1299
+ enableShortcut?: boolean;
1300
+ renderItem?: (item: CommandItem, isHighlighted: boolean) => ReactNode;
1301
+ onItemSelect?: (item: CommandItem) => void;
1302
+ emptyMessage?: string;
1303
+ ariaLabel?: string;
1304
+ };
1305
+
1306
+ declare function CommandPalette({ open, onOpenChange, groups, query, onQueryChange, placeholder, enableShortcut, renderItem, onItemSelect, emptyMessage, ariaLabel, }: CommandPaletteProps): react.ReactPortal | null;
1307
+
1308
+ type ChartTimeSeriesPoint = {
1309
+ label: string;
1310
+ value: number;
1311
+ };
1312
+ type ChartTimeSeriesProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & {
1313
+ title: ReactNode;
1314
+ subtitle?: ReactNode;
1315
+ data: ChartTimeSeriesPoint[];
1316
+ ranges?: readonly string[];
1317
+ defaultRange?: string;
1318
+ range?: string;
1319
+ onRangeChange?: (next: string) => void;
1320
+ emptyMessage?: string;
1321
+ };
1322
+
1323
+ declare const ChartTimeSeries: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLDivElement>, "children"> & {
1324
+ title: react.ReactNode;
1325
+ subtitle?: react.ReactNode;
1326
+ data: ChartTimeSeriesPoint[];
1327
+ ranges?: readonly string[];
1328
+ defaultRange?: string;
1329
+ range?: string;
1330
+ onRangeChange?: (next: string) => void;
1331
+ emptyMessage?: string;
1332
+ } & react.RefAttributes<HTMLDivElement>>;
1333
+
1334
+ type DonutChartSlice = {
1335
+ label: string;
1336
+ value: number;
1337
+ color?: string;
1338
+ secondaryValue?: number;
1339
+ };
1340
+ type DonutChartProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & {
1341
+ title: ReactNode;
1342
+ data: DonutChartSlice[];
1343
+ total?: number;
1344
+ centerValue?: string | number;
1345
+ centerLabel?: string;
1346
+ topN?: number;
1347
+ emptyMessage?: string;
1348
+ defaultColors?: readonly string[];
1349
+ othersLabel?: string;
1350
+ valueFormatter?: (value: number) => string;
1351
+ secondaryFormatter?: (value: number) => string;
1352
+ };
1353
+
1354
+ declare const DonutChart: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLDivElement>, "children"> & {
1355
+ title: react.ReactNode;
1356
+ data: DonutChartSlice[];
1357
+ total?: number;
1358
+ centerValue?: string | number;
1359
+ centerLabel?: string;
1360
+ topN?: number;
1361
+ emptyMessage?: string;
1362
+ defaultColors?: readonly string[];
1363
+ othersLabel?: string;
1364
+ valueFormatter?: (value: number) => string;
1365
+ secondaryFormatter?: (value: number) => string;
1366
+ } & react.RefAttributes<HTMLDivElement>>;
1367
+
1368
+ type EmptyStateVariant = 'no-data' | 'no-results' | 'error';
1369
+ type EmptyStateProps = Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'title'> & {
1370
+ variant?: EmptyStateVariant;
1371
+ icon?: ReactNode;
1372
+ title: ReactNode;
1373
+ description?: ReactNode;
1374
+ action?: ReactNode;
1375
+ };
1376
+
1377
+ declare const EmptyState: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLDivElement>, "children" | "title"> & {
1378
+ variant?: EmptyStateVariant;
1379
+ icon?: react.ReactNode;
1380
+ title: react.ReactNode;
1381
+ description?: react.ReactNode;
1382
+ action?: react.ReactNode;
1383
+ } & react.RefAttributes<HTMLDivElement>>;
1384
+
1385
+ type WizardShellStep = {
1386
+ id: string;
1387
+ label: string;
1388
+ description?: string;
1389
+ state: StepState;
1390
+ optional?: boolean;
1391
+ };
1392
+ type WizardShellProps = {
1393
+ steps: WizardShellStep[];
1394
+ currentStepId: string;
1395
+ onStepChange?: (stepId: string) => void;
1396
+ title: string;
1397
+ subtitle?: string;
1398
+ children: ReactNode;
1399
+ aside?: ReactNode;
1400
+ footer?: ReactNode;
1401
+ className?: string;
1402
+ };
1403
+
1404
+ declare function WizardShell(props: WizardShellProps): react.JSX.Element;
1405
+ declare namespace WizardShell {
1406
+ var displayName: string;
1407
+ }
1408
+
1409
+ type TriggerProps = ComponentPropsWithoutRef<typeof AccordionPrimitive.Trigger> & {
1410
+ icon?: ReactNode;
1411
+ meta?: ReactNode;
1412
+ };
1413
+ declare const DSAccordion: react.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & react.RefAttributes<HTMLDivElement>> & {
1414
+ Item: react.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
1415
+ Trigger: react.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & {
1416
+ icon?: ReactNode;
1417
+ meta?: ReactNode;
1418
+ } & react.RefAttributes<HTMLButtonElement>>;
1419
+ Content: react.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
1420
+ };
1421
+ type DSAccordionRootProps = ComponentPropsWithoutRef<typeof AccordionPrimitive.Root>;
1422
+ type DSAccordionTriggerProps = TriggerProps;
1423
+
1424
+ type DataFieldProps = {
1425
+ label: string;
1426
+ value: ReactNode;
1427
+ icon?: ReactNode;
1428
+ hint?: ReactNode;
1429
+ className?: string;
1430
+ };
1431
+ declare function DataField({ label, value, icon, hint, className, }: DataFieldProps): react.JSX.Element;
1432
+
1433
+ type FilterFieldBase = {
1434
+ name: string;
1435
+ label: string;
1436
+ placeholder?: string;
1437
+ helper?: string;
1438
+ };
1439
+ type TextFilterField = FilterFieldBase & {
1440
+ type: 'text';
1441
+ };
1442
+ type MaskFilterField = FilterFieldBase & {
1443
+ type: 'mask';
1444
+ mask: 'cpf' | 'cnpj' | 'both';
1445
+ };
1446
+ type SelectFilterField = FilterFieldBase & {
1447
+ type: 'select';
1448
+ options: ComboboxItem[];
1449
+ };
1450
+ type MultiSelectFilterField = FilterFieldBase & {
1451
+ type: 'multiSelect';
1452
+ options: ComboboxItem[];
1453
+ };
1454
+ type DateRangeFilterField = FilterFieldBase & {
1455
+ type: 'dateRange';
1456
+ fromLabel?: string;
1457
+ toLabel?: string;
1458
+ };
1459
+ type NumberRangeFilterField = FilterFieldBase & {
1460
+ type: 'numberRange';
1461
+ format?: 'decimal' | 'money' | 'percent';
1462
+ minLabel?: string;
1463
+ maxLabel?: string;
1464
+ };
1465
+ type FilterField = TextFilterField | MaskFilterField | SelectFilterField | MultiSelectFilterField | DateRangeFilterField | NumberRangeFilterField;
1466
+ type FilterFormValues = Record<string, unknown>;
1467
+ type FilterBarV2Props = {
1468
+ fields: FilterField[];
1469
+ values?: FilterFormValues;
1470
+ defaultValues?: FilterFormValues;
1471
+ activeCount?: number;
1472
+ onApply: (values: FilterFormValues) => void;
1473
+ onClear: () => void;
1474
+ title?: ReactNode;
1475
+ applyLabel?: string;
1476
+ clearLabel?: string;
1477
+ className?: string;
1478
+ defaultOpen?: boolean;
1479
+ hideTrigger?: boolean;
1480
+ open?: boolean;
1481
+ onOpenChange?: (open: boolean) => void;
1482
+ };
1483
+
1484
+ declare function FilterBarV2({ fields, values: controlledValues, defaultValues, activeCount, onApply, onClear, title, applyLabel, clearLabel, className, defaultOpen, hideTrigger, open: controlledOpen, onOpenChange, }: FilterBarV2Props): react.JSX.Element;
1485
+
1486
+ type FormSectionProps = {
1487
+ id: string;
1488
+ icon: ReactNode;
1489
+ title: string;
1490
+ description: string;
1491
+ meta?: ReactNode;
1492
+ children: ReactNode;
1493
+ ariaLabel?: string;
1494
+ };
1495
+ declare function FormSection({ id, icon, title, description, meta, children, ariaLabel, }: FormSectionProps): react.JSX.Element;
1496
+
1497
+ type FormAsideSection = {
1498
+ id: string;
1499
+ label: string;
1500
+ percent?: number;
1501
+ pendingCount?: number;
1502
+ };
1503
+ type FormWithAsideProps = {
1504
+ sections: FormAsideSection[];
1505
+ children: ReactNode;
1506
+ title?: string;
1507
+ emptyMessage?: string;
1508
+ overallPercent?: number;
1509
+ asideExtra?: ReactNode;
1510
+ };
1511
+
1512
+ declare function FormWithAside({ sections, children, title, overallPercent, asideExtra, }: FormWithAsideProps): react.JSX.Element;
1513
+
1514
+ type HorizontalBarItem = {
1515
+ label: string;
1516
+ value: number;
1517
+ color?: string;
1518
+ secondaryValue?: number;
1519
+ secondaryLabel?: string;
1520
+ };
1521
+ type HorizontalBarChartProps = {
1522
+ ariaLabel: string;
1523
+ items: HorizontalBarItem[];
1524
+ className?: string;
1525
+ valueFormatter?: (value: number) => string;
1526
+ secondaryFormatter?: (value: number) => string;
1527
+ showSecondary?: boolean;
1528
+ };
1529
+
1530
+ declare function HorizontalBarChart({ ariaLabel, items, className, valueFormatter, secondaryFormatter, showSecondary, }: HorizontalBarChartProps): react.JSX.Element;
1531
+
1532
+ type LineSeries = {
1533
+ name: string;
1534
+ color: string;
1535
+ values: number[];
1536
+ };
1537
+ type LineChartProps = {
1538
+ ariaLabel: string;
1539
+ labels: string[];
1540
+ series: LineSeries[];
1541
+ height?: number;
1542
+ className?: string;
1543
+ formatValue?: (value: number) => string;
1544
+ formatLabel?: (label: string) => string;
1545
+ variant?: 'line' | 'area';
1546
+ };
1547
+
1548
+ declare function LineChart({ ariaLabel, labels, series, height, className, formatValue, formatLabel, variant, }: LineChartProps): react.JSX.Element;
1549
+
1550
+ type PanelCardProps = Omit<HTMLAttributes<HTMLDivElement>, 'title'> & {
1551
+ icon?: ReactNode;
1552
+ title?: ReactNode;
1553
+ subtitle?: ReactNode;
1554
+ actions?: ReactNode;
1555
+ footer?: ReactNode;
1556
+ bodyClassName?: string;
1557
+ headerClassName?: string;
1558
+ density?: 'comfortable' | 'compact';
1559
+ bare?: boolean;
1560
+ };
1561
+ declare const PanelCard: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "title"> & {
1562
+ icon?: ReactNode;
1563
+ title?: ReactNode;
1564
+ subtitle?: ReactNode;
1565
+ actions?: ReactNode;
1566
+ footer?: ReactNode;
1567
+ bodyClassName?: string;
1568
+ headerClassName?: string;
1569
+ density?: "comfortable" | "compact";
1570
+ bare?: boolean;
1571
+ } & react.RefAttributes<HTMLDivElement>>;
1572
+
1573
+ type SectionCardProps = {
1574
+ title: string;
1575
+ icon?: ReactNode;
1576
+ action?: ReactNode;
1577
+ children: ReactNode;
1578
+ id?: string;
1579
+ highlight?: boolean;
1580
+ className?: string;
1581
+ };
1582
+ declare function SectionCard({ title, icon, action, children, id, highlight, className, }: SectionCardProps): react.JSX.Element;
1583
+
1584
+ type StackSeries = {
1585
+ name: string;
1586
+ color: string;
1587
+ values: number[];
1588
+ };
1589
+ type StackedBarChartProps = {
1590
+ ariaLabel: string;
1591
+ labels: string[];
1592
+ stacks: StackSeries[];
1593
+ height?: number;
1594
+ className?: string;
1595
+ formatValue?: (value: number) => string;
1596
+ formatLabel?: (label: string) => string;
1597
+ };
1598
+
1599
+ declare function StackedBarChart({ ariaLabel, labels, stacks, height, className, formatValue, formatLabel, }: StackedBarChartProps): react.JSX.Element;
1600
+
1601
+ type WorkflowNodeKind = 'automatic' | 'manual' | 'system';
1602
+ type WorkflowNodeRuleType = 'required_role' | 'required_signature' | 'required_doc' | 'min_amount' | 'max_amount';
1603
+ type WorkflowNodeRule = {
1604
+ type: WorkflowNodeRuleType;
1605
+ value: string;
1606
+ };
1607
+ type WorkflowNodeActionType = 'trigger_webhook' | 'send_email' | 'send_notification' | 'change_status';
1608
+ type WorkflowNodeAction = {
1609
+ type: WorkflowNodeActionType;
1610
+ event: string;
1611
+ };
1612
+ type WorkflowNode = {
1613
+ id: string;
1614
+ label: string;
1615
+ kind: WorkflowNodeKind;
1616
+ phase: string;
1617
+ rules?: WorkflowNodeRule[];
1618
+ actions?: WorkflowNodeAction[];
1619
+ };
1620
+ type WorkflowEdgeTrigger = 'automatic' | 'manual';
1621
+ type WorkflowEdge = {
1622
+ from: string;
1623
+ to: string;
1624
+ trigger?: WorkflowEdgeTrigger;
1625
+ };
1626
+ type WorkflowDesignerProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & {
1627
+ phases: string[];
1628
+ nodes: WorkflowNode[];
1629
+ edges: WorkflowEdge[];
1630
+ selectedNodeId?: string;
1631
+ onNodeSelect?: (id: string | null) => void;
1632
+ showSidePanel?: boolean;
1633
+ };
1634
+
1635
+ declare function WorkflowDesigner({ phases, nodes, edges, selectedNodeId, onNodeSelect, showSidePanel, className, ...props }: WorkflowDesignerProps): react.JSX.Element;
1636
+
1637
+ export { AppShell, type AppShellProps, Avatar, type AvatarProps, type AvatarSize, type AvatarTone, Badge, type BadgeProps, type BadgeVariant, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, Button, type ButtonProps, Card, type CardProps, CepInput, type CepInputProps, ChartTimeSeries, type ChartTimeSeriesPoint, type ChartTimeSeriesProps, Checkbox, type CheckboxProps, ColorPicker, type ColorPickerProps, Combobox, type ComboboxItem, type ComboboxProps, type CommandGroup, type CommandItem, CommandPalette, type CommandPaletteProps, ConfirmDialog, type ConfirmDialogProps, type ConfirmDialogVariant, ContextMenu, type ContextMenuContentProps, type ContextMenuItemProps, type ContextMenuProps, CopyButton, type CopyButtonProps, DSAccordion, type DSAccordionRootProps, type DSAccordionTriggerProps, DashboardBlock, type DashboardBlockData, type DashboardBlockProps, type DashboardReason, DataField, type DataFieldProps, DataTable, type DataTableColumn, type DataTableDensity, DataTablePagination, type DataTablePaginationProps, type DataTableProps, type DataTableSortDirection, DateInput, type DateInputProps, type DateRange, type DateRangeFilterField, DateRangeInput, type DateRangeInputProps, DefaultLink, type DetailsDialog, DialogRoot as Dialog, type DialogContentProps, type DialogProps, DocumentInput, type DocumentInputProps, DonutChart, type DonutChartProps, type DonutChartSlice, DrawerRoot as Drawer, type DrawerContentProps, type DrawerProps, type DrawerSide, type DrawerSize, Dropdown, type DropdownContentProps, type DropdownItemProps, type DropdownProps, type DsLinkComponent, type DsV2Theme, EmptyState, type EmptyStateProps, type EmptyStateVariant, ErrorPageLayout, type ErrorPageLayoutProps, FileUpload, type FileUploadProps, FilterBarV2, type FilterBarV2Props, type FilterField, type FilterFormValues, FormAlert, type FormAlertProps, type FormAsideSection, FormSection, type FormSectionProps, FormWithAside, type FormWithAsideProps, Heading, type HeadingProps, HelpHint, type HelpHintProps, type HelpHintSize, HorizontalBarChart, type HorizontalBarChartProps, type HorizontalBarItem, ImageUpload, type ImageUploadPreviewBg, type ImageUploadProps, Input, type InputProps, KpiCard, type KpiCardProps, type KpiCardVariant, KpiHero, type KpiHeroProps, type KpiHeroTone, type KpiHeroTrend, type KpiHeroTrendDirection, Label, type LabelProps, type LegalDocumentContent, LegalDocumentRenderer, type LegalDocumentRendererProps, LineChart, type LineChartProps, type LineSeries, type MaskFilterField, MaskedInput, type MaskedInputProps, MoneyInput, type MoneyInputProps, MultiCombobox, type MultiComboboxItem, type MultiComboboxProps, type MultiSelectFilterField, NavigatorTile, NavigatorTileGrid, type NavigatorTileGridProps, type NavigatorTileProps, type Notification, NotificationCenter, type NotificationCenterProps, type NotificationSeverity, type NumberRangeFilterField, OtpInput, type OtpInputProps, PanelCard, type PanelCardProps, PasswordInput, type PasswordInputProps, PercentInput, type PercentInputProps, PhoneInput, type PhoneInputProps, Popover, type PopoverContentProps, type PopoverProps, PublicPageLayout, type PublicPageLayoutProps, RadioGroup, type RadioGroupProps, type ReadOnlyColumn, ReadOnlyDataView, type ReadOnlyDataViewProps, SectionCard, type SectionCardProps, type SelectFilterField, Separator, type SeparatorProps, Sidebar, type SidebarGroup, type SidebarItem, type SidebarProps, Skeleton, type SkeletonProps, type SortDirection$1 as SortDirection, SortableColumnHeader, type SortableColumnHeaderProps, Sparkline, SparklineBadge, type SparklineBadgeDirection, type SparklineBadgeProps, type SparklineBadgeTone, type SparklineProps, Spinner, type SpinnerProps, type StackSeries, StackedBarChart, type StackedBarChartProps, type StepState, Stepper, type StepperProps, type StepperStep, SuspenseSkeleton, Switch, type SwitchProps, Tabs, type TabsProps, Text, TextArea, type TextAreaProps, type TextFilterField, type TextProps, type ThemeMode, ThemeToggle, type ThemeToggleProps, type ToastOptions, type ToastRecord, type ToastVariant, Toaster, type ToasterProps, Tooltip, type TooltipProps, Topbar, type TopbarProps, TutorialCard, type TutorialCardProps, WizardShell, type WizardShellProps, type WizardShellStep, WorkflowDesigner, type WorkflowDesignerProps, type WorkflowEdge, type WorkflowEdgeTrigger, type WorkflowNode, type WorkflowNodeAction, type WorkflowNodeKind, type WorkflowNodeRule, cn, dismissToast, getShortcutKeys, getShortcutLabel, isMacOS, toast, useDsV2Theme, useToast };