@unifiedsoftware/react-ui 2.0.0-alpha.2 → 2.0.0-alpha.20

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/index.d.ts +538 -307
  2. package/dist/index.js +1 -1
  3. package/package.json +1 -1
package/dist/index.d.ts CHANGED
@@ -3,21 +3,39 @@ import react__default, { Dispatch, SetStateAction } from 'react';
3
3
  import * as react_jsx_runtime from 'react/jsx-runtime';
4
4
  import { VirtualizerOptions as VirtualizerOptions$1, Virtualizer as Virtualizer$1, ListItemProps as ListItemProps$1, ResultProps as ResultProps$1 } from '@unifiedsoftware/react-ui';
5
5
 
6
- interface Props$D {
6
+ interface Props$J {
7
7
  }
8
- type NativeAttrs$D = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$D>;
9
- type DividerProps = Props$D & NativeAttrs$D;
10
- declare const Divider: react.ForwardRefExoticComponent<Props$D & NativeAttrs$D & react.RefAttributes<HTMLDivElement>>;
8
+ type NativeAttrs$L = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$J>;
9
+ type DividerProps = Props$J & NativeAttrs$L;
10
+ declare const Divider: react.ForwardRefExoticComponent<Props$J & NativeAttrs$L & react.RefAttributes<HTMLDivElement>>;
11
+
12
+ type BoxShadow = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
13
+ type BorderRadius = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
14
+ type TransitionDuration = 0 | 100 | 200 | 300;
15
+ type TransitionProperty = 'none' | 'all' | 'shadow';
16
+ type BoxState = 'base' | 'hover' | 'active';
17
+ type BoxProperties = {
18
+ shadow?: BoxShadow;
19
+ rounded?: BorderRadius;
20
+ transitionProperty?: TransitionProperty;
21
+ transitionDuration?: TransitionDuration;
22
+ };
23
+ type BoxApplyState<T> = T | {
24
+ [K in BoxState]?: T;
25
+ };
26
+ type BoxCSS = {
27
+ [K in keyof BoxProperties]: BoxApplyState<BoxProperties[K]>;
28
+ };
11
29
 
12
30
  type AccordionSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
13
31
  type AccordionVariant = 'plain' | 'flat' | 'tonal' | 'filled';
14
- type AccordionColor = 'primary' | 'secondary';
32
+ type AccordionColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
15
33
  interface AccordionArrow {
16
34
  isVisible?: boolean;
17
35
  position?: 'start' | 'end';
18
36
  }
19
37
 
20
- interface Props$C {
38
+ interface Props$I {
21
39
  value?: any[];
22
40
  defaultValue?: any[];
23
41
  expandMode?: 'single' | 'multiple';
@@ -27,39 +45,46 @@ interface Props$C {
27
45
  color?: AccordionColor;
28
46
  splitted?: boolean;
29
47
  bordered?: boolean;
30
- shadow?: boolean;
31
- headerProps?: {
32
- variant?: AccordionVariant;
33
- color?: AccordionColor;
34
- };
48
+ centered?: boolean;
49
+ css?: BoxCSS;
50
+ indicator?: ({ isOpen }: {
51
+ isOpen: boolean;
52
+ }) => React.ReactNode;
35
53
  onChange?: (value: any[]) => void;
36
54
  }
37
- type NativeAttrs$C = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$C>;
38
- type AccordionProps = Props$C & NativeAttrs$C;
39
- declare const Accordion: react.ForwardRefExoticComponent<Props$C & NativeAttrs$C & react.RefAttributes<HTMLDivElement>>;
55
+ type NativeAttrs$K = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$I>;
56
+ type AccordionProps = Props$I & NativeAttrs$K;
57
+ declare const Accordion: react.ForwardRefExoticComponent<Props$I & NativeAttrs$K & react.RefAttributes<HTMLDivElement>>;
40
58
 
41
59
  interface AccordionItemContextValue {
42
60
  value: string;
61
+ indicator?: ({ isOpen }: {
62
+ isOpen: boolean;
63
+ }) => React.ReactNode;
43
64
  }
44
65
  declare const useAccordionItem: () => AccordionItemContextValue;
45
- interface Props$B {
66
+ interface Props$H {
46
67
  value?: any;
68
+ variant?: AccordionVariant;
69
+ color?: AccordionColor;
70
+ indicator?: ({ isOpen }: {
71
+ isOpen: boolean;
72
+ }) => React.ReactNode;
47
73
  }
48
- type NativeAttrs$B = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$B>;
49
- type AccordionItemProps = Props$B & NativeAttrs$B;
50
- declare const AccordionItem: react.ForwardRefExoticComponent<Props$B & NativeAttrs$B & react.RefAttributes<HTMLDivElement>>;
74
+ type NativeAttrs$J = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$H>;
75
+ type AccordionItemProps = Props$H & NativeAttrs$J;
76
+ declare const AccordionItem: react.ForwardRefExoticComponent<Props$H & NativeAttrs$J & react.RefAttributes<HTMLDivElement>>;
51
77
 
52
- interface Props$A {
78
+ interface Props$G {
53
79
  as?: React.ElementType;
54
80
  title?: React.ReactNode;
55
81
  subtitle?: React.ReactNode;
56
82
  startContent?: React.ReactNode;
57
83
  endContent?: React.ReactNode;
58
84
  bordered?: boolean;
85
+ centered?: boolean;
59
86
  collapsible?: boolean;
60
87
  arrow?: AccordionArrow;
61
- variant?: AccordionVariant;
62
- color?: AccordionColor;
63
88
  slotProps?: {
64
89
  startContent?: React.HTMLAttributes<HTMLDivElement>;
65
90
  content?: React.HTMLAttributes<HTMLDivElement>;
@@ -68,9 +93,9 @@ interface Props$A {
68
93
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
69
94
  };
70
95
  }
71
- type NativeAttrs$A = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$A>;
72
- type AccordionHeaderProps = Props$A & NativeAttrs$A;
73
- declare const AccordionHeader: react.ForwardRefExoticComponent<Props$A & NativeAttrs$A & react.RefAttributes<HTMLDivElement>>;
96
+ type NativeAttrs$I = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$G>;
97
+ type AccordionHeaderProps = Props$G & NativeAttrs$I;
98
+ declare const AccordionHeader: react.ForwardRefExoticComponent<Props$G & NativeAttrs$I & react.RefAttributes<HTMLDivElement>>;
74
99
 
75
100
  type AccordionBodyProps = React.HTMLAttributes<HTMLDivElement>;
76
101
  declare const AccordionBody: react.ForwardRefExoticComponent<AccordionBodyProps & react.RefAttributes<HTMLDivElement>>;
@@ -89,10 +114,12 @@ interface AccordionContextValue {
89
114
  arrow: AccordionArrow;
90
115
  variant: AccordionVariant;
91
116
  color: AccordionColor;
92
- headerProps: {
93
- variant: AccordionVariant;
94
- color: AccordionColor;
95
- };
117
+ splitted?: boolean;
118
+ centered?: boolean;
119
+ css?: BoxCSS;
120
+ indicator?: ({ isOpen }: {
121
+ isOpen: boolean;
122
+ }) => React.ReactNode;
96
123
  onChange: (value: any[]) => void;
97
124
  }
98
125
  declare const AccordionContext: react.Context<AccordionContextValue | null>;
@@ -330,13 +357,32 @@ type SetValueAction<S> = (prev: S) => Generator<any, void, unknown>;
330
357
  declare function useValueEffect<S>(defaultValue: S | (() => S)): [S, Dispatch<SetValueAction<S>>];
331
358
 
332
359
  declare const defaultBreakpoints: {
333
- xs: number;
334
- sm: number;
335
- md: number;
336
- lg: number;
337
- xl: number;
338
- xxl: number;
360
+ readonly xs: 0;
361
+ readonly sm: 576;
362
+ readonly md: 768;
363
+ readonly lg: 992;
364
+ readonly xl: 1200;
365
+ readonly '2xl': 1400;
339
366
  };
367
+ declare const breakpointsMap: readonly [{
368
+ readonly key: "2xl";
369
+ readonly mq: (typeof ContainerMediaQuery)["2XL"];
370
+ }, {
371
+ readonly key: "xl";
372
+ readonly mq: ContainerMediaQuery.XL;
373
+ }, {
374
+ readonly key: "lg";
375
+ readonly mq: ContainerMediaQuery.LG;
376
+ }, {
377
+ readonly key: "md";
378
+ readonly mq: ContainerMediaQuery.MD;
379
+ }, {
380
+ readonly key: "sm";
381
+ readonly mq: ContainerMediaQuery.SM;
382
+ }, {
383
+ readonly key: "xs";
384
+ readonly mq: ContainerMediaQuery.XS;
385
+ }];
340
386
 
341
387
  declare enum ContainerMediaQuery {
342
388
  XS = 0,
@@ -344,7 +390,7 @@ declare enum ContainerMediaQuery {
344
390
  MD = 2,
345
391
  LG = 3,
346
392
  XL = 4,
347
- XXL = 5
393
+ '2XL' = 5
348
394
  }
349
395
  type ContainerBreakpoints = typeof defaultBreakpoints;
350
396
 
@@ -354,10 +400,102 @@ interface UseContainerMediaQueryOptions<TElement extends HTMLElement = HTMLEleme
354
400
  }
355
401
  declare function useContainerMediaQuery<TElement extends HTMLElement = HTMLElement>(options: UseContainerMediaQueryOptions<TElement>): ContainerMediaQuery | undefined;
356
402
 
403
+ interface FormatStringOptions {
404
+ type?: 'string';
405
+ value?: string | null;
406
+ }
407
+ interface FormatNumberOptions {
408
+ type: 'number';
409
+ value?: number | string | null;
410
+ }
411
+ interface FormatDateOptions {
412
+ type: 'date';
413
+ value?: Date | string | number | null;
414
+ format?: 'datetime' | 'short datetime' | 'date' | 'time';
415
+ locales?: Intl.LocalesArgument;
416
+ options?: Intl.DateTimeFormatOptions;
417
+ }
418
+ interface FormatBooleanOptions {
419
+ type: 'boolean';
420
+ value?: boolean | null;
421
+ labels?: {
422
+ true?: string;
423
+ false?: string;
424
+ };
425
+ }
426
+ interface FormatCurrencyOptions {
427
+ type: 'currency';
428
+ value?: number | bigint | Intl.StringNumericLiteral | null;
429
+ currency?: string;
430
+ locales?: Intl.LocalesArgument;
431
+ options?: Intl.NumberFormatOptions;
432
+ }
433
+ interface FormatPercentOptions {
434
+ type: 'percent';
435
+ value?: number | string | null;
436
+ decimals?: number;
437
+ locales?: Intl.LocalesArgument;
438
+ options?: Intl.NumberFormatOptions;
439
+ }
440
+ type FormatOptions = FormatStringOptions | FormatNumberOptions | FormatDateOptions | FormatBooleanOptions | FormatCurrencyOptions | FormatPercentOptions;
441
+
442
+ declare function useFormat(options: FormatOptions): {
443
+ value: string | undefined;
444
+ getValue: (value: any) => string | undefined;
445
+ };
446
+
447
+ type ColorScheme = 'default' | 'light' | 'dark';
448
+
449
+ type MediaQuery = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
450
+ type Responsive<T> = T | {
451
+ /**
452
+ * Minimum captured size: 0px
453
+ */
454
+ xs?: T;
455
+ /**
456
+ * Minimum captured size: 576px
457
+ */
458
+ sm?: T;
459
+ /**
460
+ * Minimum captured size: 768px
461
+ */
462
+ md?: T;
463
+ /**
464
+ * Minimum captured size: 992px
465
+ */
466
+ lg?: T;
467
+ /**
468
+ * Minimum captured size: 1200px
469
+ */
470
+ xl?: T;
471
+ /**
472
+ * Minimum captured size: 1400px
473
+ */
474
+ '2xl'?: T;
475
+ };
476
+
477
+ type SelectionValue<TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = TMultiple extends true ? TClearable extends true ? TItem[TKeyField][] | null : TItem[TKeyField][] : TClearable extends true ? TItem[TKeyField] | null : TItem[TKeyField];
478
+ type SelectionItem<TData extends Record<string, any>, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> = TMultiple extends true ? TClearable extends true ? TData[] | null : TData[] : TClearable extends true ? TData | null : TData;
479
+ type SelectionOnChange<TData extends Record<string, any>, TKeyField extends keyof TData, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> = (value: SelectionValue<TData, TKeyField, TMultiple, TClearable>, item: SelectionItem<TData, TMultiple, TClearable>) => void;
480
+ interface SelectionProps<TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> {
481
+ data: TItem[];
482
+ isMultiple?: TMultiple;
483
+ clearable?: TClearable;
484
+ keyField?: TKeyField;
485
+ value?: SelectionValue<TItem, TKeyField, TMultiple, TClearable>;
486
+ onChange?: SelectionOnChange<TItem, TKeyField, TMultiple, TClearable>;
487
+ }
488
+
357
489
  type InputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
358
- type InputColor = 'light' | 'dark' | 'inherit';
490
+ type InputColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
359
491
  type InputVariant = 'filled' | 'outlined' | 'flat' | 'text';
360
492
 
493
+ interface Props$F {
494
+ }
495
+ type NativeAttrs$H = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$F>;
496
+ type InputGroupProps = Props$F & NativeAttrs$H;
497
+ declare const InputGroup: react.ForwardRefExoticComponent<Props$F & NativeAttrs$H & react.RefAttributes<HTMLDivElement>>;
498
+
361
499
  type ListSize = 'sm' | 'md' | 'lg';
362
500
 
363
501
  interface ListProps extends React.HTMLAttributes<HTMLDivElement> {
@@ -366,7 +504,7 @@ interface ListProps extends React.HTMLAttributes<HTMLDivElement> {
366
504
  }
367
505
  declare const List: react.ForwardRefExoticComponent<ListProps & react.RefAttributes<HTMLDivElement>>;
368
506
 
369
- interface Props$z {
507
+ interface Props$E {
370
508
  as?: react__default.ElementType;
371
509
  title?: react__default.ReactNode;
372
510
  subtitle?: react__default.ReactNode;
@@ -384,11 +522,11 @@ interface Props$z {
384
522
  subtitle?: react__default.HTMLAttributes<HTMLDivElement>;
385
523
  };
386
524
  }
387
- type NativeAttrs$z = Omit<react__default.HTMLAttributes<HTMLDivElement>, keyof Props$z>;
388
- type ListItemProps = Props$z & NativeAttrs$z;
389
- declare const ListItem: react__default.ForwardRefExoticComponent<Props$z & NativeAttrs$z & react__default.RefAttributes<HTMLDivElement>>;
525
+ type NativeAttrs$G = Omit<react__default.HTMLAttributes<HTMLDivElement>, keyof Props$E>;
526
+ type ListItemProps = Props$E & NativeAttrs$G;
527
+ declare const ListItem: react__default.ForwardRefExoticComponent<Props$E & NativeAttrs$G & react__default.RefAttributes<HTMLDivElement>>;
390
528
 
391
- interface Props$y {
529
+ interface Props$D {
392
530
  expandVisible?: boolean;
393
531
  expandPosition?: 'start' | 'end';
394
532
  isOpen?: boolean;
@@ -396,9 +534,9 @@ interface Props$y {
396
534
  onClose?: () => void;
397
535
  onToggle?: () => void;
398
536
  }
399
- type NativeAttrs$y = Omit<ListItemProps, keyof Props$y>;
400
- type ListGroupProps = Props$y & NativeAttrs$y;
401
- declare const ListGroup: react.ForwardRefExoticComponent<Props$y & NativeAttrs$y & react.RefAttributes<HTMLDivElement>>;
537
+ type NativeAttrs$F = Omit<ListItemProps, keyof Props$D>;
538
+ type ListGroupProps = Props$D & NativeAttrs$F;
539
+ declare const ListGroup: react.ForwardRefExoticComponent<Props$D & NativeAttrs$F & react.RefAttributes<HTMLDivElement>>;
402
540
 
403
541
  interface ListSubheaderProps extends React.HTMLAttributes<HTMLDivElement> {
404
542
  as?: React.ElementType;
@@ -426,30 +564,14 @@ interface ResultProps extends React.HTMLAttributes<HTMLDivElement> {
426
564
  }
427
565
  declare const Result: React.FC<ResultProps>;
428
566
 
429
- type AutocompleteItem = Record<string, any>;
430
- type AutocompleteKeyField<TAutocompleteItem> = keyof TAutocompleteItem;
431
- interface AutocompleteSingleProps<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> {
432
- isMultiple?: false;
433
- value: TAutocompleteItem[TAutocompleteKeyField] | null;
434
- onChange?: (value: TAutocompleteItem | null) => void;
435
- onValueChange?: (value: TAutocompleteItem[TAutocompleteKeyField] | null) => void;
436
- }
437
- interface AutocompleteMultipleProps<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> {
438
- isMultiple: true;
439
- value: TAutocompleteItem[TAutocompleteKeyField][];
440
- onChange?: (value: TAutocompleteItem[]) => void;
441
- onValueChange?: (value: TAutocompleteItem[TAutocompleteKeyField][]) => void;
442
- }
443
- type NativeAttrs$x<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$x<TAutocompleteItem, TAutocompleteKeyField>>;
444
- type Props$x<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> = {
445
- data: TAutocompleteItem[];
446
- keyField?: TAutocompleteKeyField;
447
- textField?: keyof TAutocompleteItem;
567
+ type NativeAttrs$E<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$C<TItem, TKeyField>>;
568
+ type BaseProps$1<TItem extends Record<string, any>> = {
569
+ textField?: keyof TItem;
448
570
  placeholder?: string;
449
571
  filter?: string;
450
572
  loading?: boolean;
451
573
  disabled?: boolean;
452
- clearable?: boolean;
574
+ readOnly?: boolean;
453
575
  disclosure?: Disclosure;
454
576
  virtual?: Omit<VirtualizerOptions, 'parentRef'>;
455
577
  color?: InputColor;
@@ -457,19 +579,36 @@ type Props$x<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField e
457
579
  size?: InputSize;
458
580
  startContent?: React.ReactNode;
459
581
  endContent?: React.ReactNode;
460
- onItemSelect?: (item: TAutocompleteItem) => void;
582
+ onItemSelect?: (item: TItem) => void;
461
583
  onFilterChange?: (value: string) => void;
462
- renderItem?: (item: TAutocompleteItem, props: ListItemProps) => React.ReactNode;
584
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
463
585
  renderNoData?: (props: ResultProps) => React.ReactNode;
464
- } & (AutocompleteSingleProps<TAutocompleteItem, TAutocompleteKeyField> | AutocompleteMultipleProps<TAutocompleteItem, TAutocompleteKeyField>);
465
- type AutocompleteProps<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> = Props$x<TAutocompleteItem, TAutocompleteKeyField> & NativeAttrs$x<TAutocompleteItem, TAutocompleteKeyField>;
586
+ };
587
+ type Props$C<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = BaseProps$1<TItem> & SelectionProps<TItem, TKeyField, TMultiple, TClearable>;
588
+ type AutocompleteProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$C<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$E<TItem, TKeyField>;
589
+
590
+ declare const Autocomplete: <TItem extends Record<string, any>, TKeyField extends keyof TItem = "key", TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = true>(props: AutocompleteProps<TItem, TKeyField, TMultiple, TClearable>) => react_jsx_runtime.JSX.Element;
466
591
 
467
- declare const Autocomplete: <TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = "key">(props: AutocompleteProps<TAutocompleteItem, TAutocompleteKeyField>) => react_jsx_runtime.JSX.Element;
592
+ type AutocompleteContextValue<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = {
593
+ data: TItem[];
594
+ values: TItem[TKeyField][];
595
+ keyField: TKeyField;
596
+ textField: keyof TItem;
597
+ isMultiple: boolean;
598
+ virtual?: Omit<VirtualizerOptions, 'parentRef'>;
599
+ onChange: (value: TItem[]) => void;
600
+ onItemSelect: (item: TItem) => void;
601
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
602
+ offset: number;
603
+ setOffset: React.Dispatch<React.SetStateAction<number>>;
604
+ };
605
+ declare const AutocompleteContext: react.Context<AutocompleteContextValue<Record<string, any>, string> | null>;
606
+ declare const useAutocomplete: () => AutocompleteContextValue<Record<string, any>, string>;
468
607
 
469
608
  type BackdropPlacement = 'top' | 'left' | 'center' | 'right' | 'bottom';
470
609
  type BackdropVariant = 'opaque' | 'blur' | 'transparent';
471
610
 
472
- interface Props$w {
611
+ interface Props$B {
473
612
  isOpen: boolean;
474
613
  closable?: boolean;
475
614
  placement?: BackdropPlacement;
@@ -478,14 +617,14 @@ interface Props$w {
478
617
  scrollArea?: boolean;
479
618
  onClose(): void;
480
619
  }
481
- type NativeAttrs$w = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$w>;
482
- type BackdropProps = Props$w & NativeAttrs$w;
483
- declare const Backdrop: react.ForwardRefExoticComponent<Props$w & NativeAttrs$w & react.RefAttributes<HTMLDivElement>>;
620
+ type NativeAttrs$D = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$B>;
621
+ type BackdropProps = Props$B & NativeAttrs$D;
622
+ declare const Backdrop: react.ForwardRefExoticComponent<Props$B & NativeAttrs$D & react.RefAttributes<HTMLDivElement>>;
484
623
 
485
624
  type BadgeColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
486
625
  type BadgePlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
487
626
 
488
- interface Props$v {
627
+ interface Props$A {
489
628
  /**
490
629
  * The placement of the badge relative to its content.
491
630
  */
@@ -503,8 +642,8 @@ interface Props$v {
503
642
  wrapper?: React.HTMLAttributes<HTMLDivElement>;
504
643
  };
505
644
  }
506
- type NativeAttrs$v = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$v>;
507
- type BadgeProps = Props$v & NativeAttrs$v;
645
+ type NativeAttrs$C = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$A>;
646
+ type BadgeProps = Props$A & NativeAttrs$C;
508
647
  declare const Badge: React.FC<BadgeProps>;
509
648
 
510
649
  type DataListItem = Record<string, any>;
@@ -521,7 +660,7 @@ interface DataListMultipleProps<TDataListItem extends DataListItem, TDataListKey
521
660
  onChange?: (value: TDataListItem[]) => void;
522
661
  onValueChange?: (value: TDataListItem[TDataListKeyField][]) => void;
523
662
  }
524
- type Props$u<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
663
+ type Props$z<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
525
664
  data: TDataListItem[];
526
665
  keyField?: TDataListKeyField;
527
666
  textField?: keyof DataListItem;
@@ -536,17 +675,17 @@ type Props$u<TDataListItem extends DataListItem, TDataListKeyField extends DataL
536
675
  renderItem?: (item: TDataListItem, props: ListItemProps$1) => React.ReactNode;
537
676
  renderNoData?: (props: ResultProps$1) => React.ReactNode;
538
677
  } & (DataListSingleProps<TDataListItem, TDataListKeyField> | DataListMultipleProps<TDataListItem, TDataListKeyField>);
539
- type NativeAttrs$u<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$u<TDataListItem, TDataListKeyField>>;
540
- type DataListProps<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Props$u<TDataListItem, TDataListKeyField> & NativeAttrs$u<TDataListItem, TDataListKeyField>;
678
+ type NativeAttrs$B<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$z<TDataListItem, TDataListKeyField>>;
679
+ type DataListProps<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Props$z<TDataListItem, TDataListKeyField> & NativeAttrs$B<TDataListItem, TDataListKeyField>;
541
680
 
542
681
  declare const DataList: <TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = "key">(props: DataListProps<TDataListItem, TDataListKeyField>) => react_jsx_runtime.JSX.Element;
543
682
 
544
- type ButtonVariant = 'filled' | 'outlined' | 'flat' | 'text';
545
- type ButtonColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'inherit';
546
- type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
683
+ type ButtonVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'bordered';
684
+ type ButtonColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
685
+ type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
547
686
  type ButtonGroupDirection = 'row' | 'col';
548
687
 
549
- interface Props$t {
688
+ interface Props$y {
550
689
  /**
551
690
  * The HTML element type or React component to render as the button.
552
691
  */
@@ -591,20 +730,20 @@ interface Props$t {
591
730
  fontStyle?: React.CSSProperties['fontStyle'];
592
731
  };
593
732
  }
594
- type NativeAttrs$t = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$t>;
595
- type ButtonProps = Props$t & NativeAttrs$t;
596
- declare const Button: react.ForwardRefExoticComponent<Props$t & NativeAttrs$t & react.RefAttributes<HTMLButtonElement>>;
733
+ type NativeAttrs$A = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$y>;
734
+ type ButtonProps = Props$y & NativeAttrs$A;
735
+ declare const Button: react.ForwardRefExoticComponent<Props$y & NativeAttrs$A & react.RefAttributes<HTMLButtonElement>>;
597
736
 
598
- interface Props$s {
737
+ interface Props$x {
599
738
  direction?: ButtonGroupDirection;
600
739
  variant?: ButtonVariant;
601
740
  color?: ButtonColor;
602
741
  size?: ButtonSize;
603
742
  disabled?: boolean;
604
743
  }
605
- type NativeAttrs$s = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$s>;
606
- type ButtonGroupProps = Props$s & NativeAttrs$s;
607
- declare const ButtonGroup: react.ForwardRefExoticComponent<Props$s & NativeAttrs$s & react.RefAttributes<HTMLDivElement>>;
744
+ type NativeAttrs$z = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$x>;
745
+ type ButtonGroupProps = Props$x & NativeAttrs$z;
746
+ declare const ButtonGroup: react.ForwardRefExoticComponent<Props$x & NativeAttrs$z & react.RefAttributes<HTMLDivElement>>;
608
747
 
609
748
  interface ButtonGroupContextValue {
610
749
  direction: ButtonGroupDirection;
@@ -616,44 +755,26 @@ interface ButtonGroupContextValue {
616
755
  declare const ButtonGroupContext: react.Context<ButtonGroupContextValue | null>;
617
756
  declare const useButtonGroup: () => ButtonGroupContextValue | null;
618
757
 
619
- type BoxShadow = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
620
- type BorderRadius = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
621
- type TransitionDuration = 0 | 100 | 200 | 300;
622
- type TransitionProperty = 'none' | 'all' | 'shadow';
623
- type BoxState = 'base' | 'hover' | 'active';
624
- type BoxProperties = {
625
- shadow?: BoxShadow;
626
- rounded?: BorderRadius;
627
- transitionProperty?: TransitionProperty;
628
- transitionDuration?: TransitionDuration;
629
- };
630
- type BoxApplyState<T> = T | {
631
- [K in BoxState]?: T;
632
- };
633
- type BoxCSS = {
634
- [K in keyof BoxProperties]: BoxApplyState<BoxProperties[K]>;
635
- };
636
-
637
- type CardSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
758
+ type CardSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
638
759
 
639
- interface Props$r {
760
+ interface Props$w {
640
761
  as?: React.ElementType;
641
762
  size?: CardSize;
642
763
  hoverable?: boolean;
643
764
  selected?: boolean;
644
765
  disabled?: boolean;
645
766
  bordered?: boolean;
646
- underlined?: boolean;
767
+ divider?: boolean;
647
768
  css?: BoxCSS;
648
769
  }
649
- type NativeAttrs$r = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$r>;
650
- type CardProps = Props$r & NativeAttrs$r;
651
- declare const Card: react.ForwardRefExoticComponent<Props$r & NativeAttrs$r & react.RefAttributes<HTMLDivElement>>;
770
+ type NativeAttrs$y = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$w>;
771
+ type CardProps = Props$w & NativeAttrs$y;
772
+ declare const Card: react.ForwardRefExoticComponent<Props$w & NativeAttrs$y & react.RefAttributes<HTMLDivElement>>;
652
773
 
653
774
  type CardBodyProps = React.HTMLAttributes<HTMLDivElement>;
654
775
  declare const CardBody: react.ForwardRefExoticComponent<CardBodyProps & react.RefAttributes<HTMLDivElement>>;
655
776
 
656
- interface Props$q {
777
+ interface Props$v {
657
778
  as?: React.ElementType;
658
779
  title?: React.ReactNode;
659
780
  subtitle?: React.ReactNode;
@@ -663,6 +784,9 @@ interface Props$q {
663
784
  * @deprecated Use `underlined` instead
664
785
  */
665
786
  bordered?: boolean;
787
+ /**
788
+ * @deprecated Use `divider` in instead in Card
789
+ */
666
790
  underlined?: boolean;
667
791
  centered?: boolean;
668
792
  slotProps?: {
@@ -676,11 +800,11 @@ interface Props$q {
676
800
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
677
801
  };
678
802
  }
679
- type NativeAttrs$q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$q>;
680
- type CardHeaderProps = Props$q & NativeAttrs$q;
681
- declare const CardHeader: react.ForwardRefExoticComponent<Props$q & NativeAttrs$q & react.RefAttributes<HTMLDivElement>>;
803
+ type NativeAttrs$x = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$v>;
804
+ type CardHeaderProps = Props$v & NativeAttrs$x;
805
+ declare const CardHeader: react.ForwardRefExoticComponent<Props$v & NativeAttrs$x & react.RefAttributes<HTMLDivElement>>;
682
806
 
683
- interface Props$p {
807
+ interface Props$u {
684
808
  as?: React.ElementType;
685
809
  /**
686
810
  * @deprecated Use `underlined` instead
@@ -688,9 +812,9 @@ interface Props$p {
688
812
  bordered?: boolean;
689
813
  underlined?: boolean;
690
814
  }
691
- type NativeAttrs$p = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$p>;
692
- type CardFooterProps = Props$p & NativeAttrs$p;
693
- declare const CardFooter: react.ForwardRefExoticComponent<Props$p & NativeAttrs$p & react.RefAttributes<HTMLDivElement>>;
815
+ type NativeAttrs$w = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$u>;
816
+ type CardFooterProps = Props$u & NativeAttrs$w;
817
+ declare const CardFooter: react.ForwardRefExoticComponent<Props$u & NativeAttrs$w & react.RefAttributes<HTMLDivElement>>;
694
818
 
695
819
  type CardMediaProps = React.HTMLAttributes<HTMLDivElement> & {
696
820
  topLeftContent?: React.ReactNode;
@@ -701,28 +825,28 @@ declare const CardMedia: react.ForwardRefExoticComponent<react.HTMLAttributes<HT
701
825
  topRightContent?: React.ReactNode;
702
826
  } & react.RefAttributes<HTMLDivElement>>;
703
827
 
704
- interface Props$o {
828
+ interface Props$t {
705
829
  as?: React.ElementType;
706
830
  centered?: boolean;
707
831
  css?: BoxCSS;
708
832
  }
709
- type NativeAttrs$o = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$o>;
710
- type CardTitleProps = Props$o & NativeAttrs$o;
711
- declare const CardTitle: react.ForwardRefExoticComponent<Props$o & NativeAttrs$o & react.RefAttributes<HTMLDivElement>>;
833
+ type NativeAttrs$v = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$t>;
834
+ type CardTitleProps = Props$t & NativeAttrs$v;
835
+ declare const CardTitle: react.ForwardRefExoticComponent<Props$t & NativeAttrs$v & react.RefAttributes<HTMLDivElement>>;
712
836
 
713
- interface Props$n {
837
+ interface Props$s {
714
838
  as?: React.ElementType;
715
839
  css?: BoxCSS;
716
840
  }
717
- type NativeAttrs$n = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$n>;
718
- type CardSubtitleProps = Props$n & NativeAttrs$n;
719
- declare const CardSubtitle: react.ForwardRefExoticComponent<Props$n & NativeAttrs$n & react.RefAttributes<HTMLDivElement>>;
841
+ type NativeAttrs$u = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$s>;
842
+ type CardSubtitleProps = Props$s & NativeAttrs$u;
843
+ declare const CardSubtitle: react.ForwardRefExoticComponent<Props$s & NativeAttrs$u & react.RefAttributes<HTMLDivElement>>;
720
844
 
721
- type ChipVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain';
845
+ type ChipVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain' | 'bordered';
722
846
  type ChipColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
723
847
  type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
724
848
 
725
- interface Props$m {
849
+ interface Props$r {
726
850
  /**
727
851
  * The HTML element type or React component to render as the chip.
728
852
  */
@@ -760,9 +884,9 @@ interface Props$m {
760
884
  };
761
885
  onClose?: () => void;
762
886
  }
763
- type NativeAttrs$m = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$m>;
764
- type ChipProps = Props$m & NativeAttrs$m;
765
- declare const Chip: react.ForwardRefExoticComponent<Props$m & NativeAttrs$m & react.RefAttributes<HTMLDivElement>>;
887
+ type NativeAttrs$t = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$r>;
888
+ type ChipProps = Props$r & NativeAttrs$t;
889
+ declare const Chip: react.ForwardRefExoticComponent<Props$r & NativeAttrs$t & react.RefAttributes<HTMLDivElement>>;
766
890
 
767
891
  interface CollapseProps {
768
892
  children: React.ReactNode;
@@ -806,7 +930,7 @@ interface DrawerClose {
806
930
  }
807
931
  type DrawerBackdrop = BackdropVariant;
808
932
 
809
- interface Props$l {
933
+ interface Props$q {
810
934
  isOpen: boolean;
811
935
  size?: DrawerSize;
812
936
  backdrop?: DrawerBackdrop;
@@ -823,11 +947,11 @@ interface Props$l {
823
947
  onClose: () => void;
824
948
  onAfterClose?: () => void;
825
949
  }
826
- type NativeAttrs$l = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$l>;
827
- type DrawerProps = Props$l & NativeAttrs$l;
828
- declare const Drawer: react.ForwardRefExoticComponent<Props$l & NativeAttrs$l & react.RefAttributes<HTMLDivElement>>;
950
+ type NativeAttrs$s = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$q>;
951
+ type DrawerProps = Props$q & NativeAttrs$s;
952
+ declare const Drawer: react.ForwardRefExoticComponent<Props$q & NativeAttrs$s & react.RefAttributes<HTMLDivElement>>;
829
953
 
830
- interface Props$k {
954
+ interface Props$p {
831
955
  as?: React.ElementType;
832
956
  title?: React.ReactNode;
833
957
  subtitle?: React.ReactNode;
@@ -843,20 +967,20 @@ interface Props$k {
843
967
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
844
968
  };
845
969
  }
846
- type NativeAttrs$k = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$k>;
847
- type DrawerHeaderProps = Props$k & NativeAttrs$k;
848
- declare const DrawerHeader: react.ForwardRefExoticComponent<Props$k & NativeAttrs$k & react.RefAttributes<HTMLDivElement>>;
970
+ type NativeAttrs$r = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$p>;
971
+ type DrawerHeaderProps = Props$p & NativeAttrs$r;
972
+ declare const DrawerHeader: react.ForwardRefExoticComponent<Props$p & NativeAttrs$r & react.RefAttributes<HTMLDivElement>>;
849
973
 
850
974
  type DrawerBodyProps = React.HTMLAttributes<HTMLDivElement>;
851
975
  declare const DrawerBody: react.ForwardRefExoticComponent<DrawerBodyProps & react.RefAttributes<HTMLDivElement>>;
852
976
 
853
- interface Props$j {
977
+ interface Props$o {
854
978
  as?: React.ElementType;
855
979
  bordered?: boolean;
856
980
  }
857
- type NativeAttrs$j = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$j>;
858
- type DrawerFooterProps = Props$j & NativeAttrs$j;
859
- declare const DrawerFooter: react.ForwardRefExoticComponent<Props$j & NativeAttrs$j & react.RefAttributes<HTMLDivElement>>;
981
+ type NativeAttrs$q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$o>;
982
+ type DrawerFooterProps = Props$o & NativeAttrs$q;
983
+ declare const DrawerFooter: react.ForwardRefExoticComponent<Props$o & NativeAttrs$q & react.RefAttributes<HTMLDivElement>>;
860
984
 
861
985
  interface DrawerContextValue {
862
986
  isOpen: boolean;
@@ -880,7 +1004,7 @@ interface IconProps {
880
1004
  }
881
1005
  declare const Icon: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<unknown>>;
882
1006
 
883
- interface Props$i {
1007
+ interface Props$n {
884
1008
  /**
885
1009
  * The HTML element type or React component to render as the menu item.
886
1010
  */
@@ -906,9 +1030,9 @@ interface Props$i {
906
1030
  */
907
1031
  disabled?: boolean;
908
1032
  }
909
- type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$i | 'items'>;
910
- type MenuItemProps = Props$i & NativeAttrs$i;
911
- declare const MenuItem: react.ForwardRefExoticComponent<Props$i & NativeAttrs$i & react.RefAttributes<HTMLDivElement>>;
1033
+ type NativeAttrs$p = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$n | 'items'>;
1034
+ type MenuItemProps = Props$n & NativeAttrs$p;
1035
+ declare const MenuItem: react.ForwardRefExoticComponent<Props$n & NativeAttrs$p & react.RefAttributes<HTMLDivElement>>;
912
1036
 
913
1037
  type MenuSubmenuProps = Omit<MenuItemProps, 'items'> & {
914
1038
  items?: MenuItemType[];
@@ -932,7 +1056,7 @@ type MenuItemType = (MenuGroupProps & {
932
1056
  }) | (MenuItemProps & {
933
1057
  type?: 'item';
934
1058
  });
935
- interface Props$h {
1059
+ interface Props$m {
936
1060
  /**
937
1061
  * The currently selected value of the menu.
938
1062
  */
@@ -968,8 +1092,8 @@ interface Props$h {
968
1092
  */
969
1093
  onItemSelect?: (props: MenuItemProps) => void;
970
1094
  }
971
- type NativeAttrs$h = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$h | 'items'>;
972
- type MenuProps = Props$h & NativeAttrs$h & {
1095
+ type NativeAttrs$o = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$m | 'items'>;
1096
+ type MenuProps = Props$m & NativeAttrs$o & {
973
1097
  items?: MenuItemType[];
974
1098
  };
975
1099
  declare const Menu: React.FC<MenuProps>;
@@ -1044,27 +1168,13 @@ declare const ScrollArea: react.ForwardRefExoticComponent<ScrollAreaProps & reac
1044
1168
 
1045
1169
  type SelectItem = Record<string, any>;
1046
1170
  type SelectKeyField<TSelectItem> = keyof TSelectItem;
1047
- interface SelectSingleProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> {
1048
- isMultiple?: false;
1049
- value: TSelectItem[TSelectKeyField] | null;
1050
- onChange?: (value: TSelectItem | null) => void;
1051
- onValueChange?: (value: TSelectItem[TSelectKeyField] | null) => void;
1052
- }
1053
- interface SelectMultipleProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> {
1054
- isMultiple: true;
1055
- value: TSelectItem[TSelectKeyField][];
1056
- onChange?: (value: TSelectItem[]) => void;
1057
- onValueChange?: (value: TSelectItem[TSelectKeyField][]) => void;
1058
- }
1059
- type NativeAttrs$g<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g<TSelectItem, TSelectKeyField>>;
1060
- type Props$g<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = {
1061
- data: TSelectItem[];
1062
- keyField?: TSelectKeyField;
1063
- textField?: keyof TSelectItem;
1171
+ type NativeAttrs$n<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$l<TSelectItem, TSelectKeyField>>;
1172
+ type BaseProps<TItem extends Record<string, any>> = {
1173
+ textField?: keyof TItem;
1064
1174
  placeholder?: string;
1065
1175
  loading?: boolean;
1066
- clearable?: boolean;
1067
1176
  disabled?: boolean;
1177
+ readOnly?: boolean;
1068
1178
  disclosure?: Disclosure;
1069
1179
  virtual?: Omit<VirtualizerOptions, 'parentRef'>;
1070
1180
  color?: InputColor;
@@ -1072,33 +1182,49 @@ type Props$g<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyFi
1072
1182
  size?: InputSize;
1073
1183
  startContent?: React.ReactNode;
1074
1184
  endContent?: React.ReactNode;
1075
- onItemSelect?: (item: TSelectItem) => void;
1076
- renderItem?: (item: TSelectItem, props: ListItemProps) => React.ReactNode;
1185
+ onItemSelect?: (item: TItem) => void;
1186
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
1077
1187
  renderNoData?: (props: ResultProps) => React.ReactNode;
1078
- } & (SelectSingleProps<TSelectItem, TSelectKeyField> | SelectMultipleProps<TSelectItem, TSelectKeyField>);
1079
- type SelectProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = Props$g<TSelectItem, TSelectKeyField> & NativeAttrs$g<TSelectItem, TSelectKeyField>;
1188
+ };
1189
+ type Props$l<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = BaseProps<TItem> & SelectionProps<TItem, TKeyField, TMultiple, TClearable>;
1190
+ type SelectProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$l<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$n<TItem, TKeyField>;
1080
1191
 
1081
- declare const Select: <TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = "key">(props: SelectProps<TSelectItem, TSelectKeyField>) => react_jsx_runtime.JSX.Element;
1192
+ declare const Select: <TItem extends Record<string, any>, TKeyField extends keyof TItem = "key", TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false>(props: SelectProps<TItem, TKeyField, TMultiple, TClearable>) => react_jsx_runtime.JSX.Element;
1082
1193
 
1083
- type ColorScheme = 'default' | 'light' | 'dark';
1194
+ type SelectContextValue<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = {
1195
+ data: TItem[];
1196
+ values: TItem[TKeyField][];
1197
+ keyField: TKeyField;
1198
+ textField: keyof TItem;
1199
+ isMultiple: boolean;
1200
+ virtual?: Omit<VirtualizerOptions, 'parentRef'>;
1201
+ onChange: (value: TItem[]) => void;
1202
+ onItemSelect: (item: TItem) => void;
1203
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
1204
+ offset: number;
1205
+ setOffset: React.Dispatch<React.SetStateAction<number>>;
1206
+ };
1207
+ declare const SelectContext: react.Context<SelectContextValue<SelectItem, string> | null>;
1208
+ declare const useSelect: () => SelectContextValue<SelectItem, string>;
1084
1209
 
1085
- type SwitchSize = 'sm' | 'md' | 'lg';
1210
+ type SwitchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1086
1211
  type SwitchLabelPlacement = 'before' | 'after';
1212
+ type SwitchColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1087
1213
 
1088
- interface Props$f {
1214
+ interface Props$k {
1089
1215
  size?: SwitchSize;
1090
1216
  labelPlacement?: SwitchLabelPlacement;
1091
- colorScheme?: ColorScheme;
1217
+ color?: SwitchColor;
1092
1218
  }
1093
- type NativeAttrs$f = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$f | 'value' | 'defaultValue'>;
1094
- type SwitchProps = Props$f & NativeAttrs$f;
1095
- declare const Switch: react.ForwardRefExoticComponent<Props$f & NativeAttrs$f & react.RefAttributes<HTMLInputElement>>;
1219
+ type NativeAttrs$m = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$k | 'value' | 'defaultValue'>;
1220
+ type SwitchProps = Props$k & NativeAttrs$m;
1221
+ declare const Switch: react.ForwardRefExoticComponent<Props$k & NativeAttrs$m & react.RefAttributes<HTMLInputElement>>;
1096
1222
 
1097
1223
  type TabsVariant = 'underlined' | 'outlined' | 'pills';
1098
1224
  type TabValue = string | number | symbol;
1099
1225
  type TabsAlignment = 'start' | 'center' | 'end' | 'stretch';
1100
1226
 
1101
- interface Props$e<TTabValue extends TabValue = TabValue> {
1227
+ interface Props$j<TTabValue extends TabValue = TabValue> {
1102
1228
  /**
1103
1229
  * The HTML element type or React component to render as the tab.
1104
1230
  */
@@ -1124,11 +1250,11 @@ interface Props$e<TTabValue extends TabValue = TabValue> {
1124
1250
  */
1125
1251
  endContent?: React.ReactNode;
1126
1252
  }
1127
- type NativeAttrs$e = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$e>;
1128
- type TabProps<TTabValue extends TabValue = TabValue> = Props$e<TTabValue> & NativeAttrs$e;
1129
- declare const Tab: react.ForwardRefExoticComponent<Props$e<TabValue> & NativeAttrs$e & react.RefAttributes<HTMLDivElement>>;
1253
+ type NativeAttrs$l = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$j>;
1254
+ type TabProps<TTabValue extends TabValue = TabValue> = Props$j<TTabValue> & NativeAttrs$l;
1255
+ declare const Tab: react.ForwardRefExoticComponent<Props$j<TabValue> & NativeAttrs$l & react.RefAttributes<HTMLDivElement>>;
1130
1256
 
1131
- interface Props$d<TTabValue extends TabValue = TabValue> {
1257
+ interface Props$i<TTabValue extends TabValue = TabValue> {
1132
1258
  /**
1133
1259
  * The currently selected value of the tabs.
1134
1260
  */
@@ -1151,11 +1277,11 @@ interface Props$d<TTabValue extends TabValue = TabValue> {
1151
1277
  */
1152
1278
  onClose?: (value: TTabValue) => void;
1153
1279
  }
1154
- type NativeAttrs$d = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$d>;
1155
- type TabsProps<TTabValue extends TabValue = TabValue> = Props$d<TTabValue> & NativeAttrs$d;
1156
- declare const Tabs: <TTabValue extends TabValue = TabValue>(props: Props$d<TTabValue> & NativeAttrs$d & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1280
+ type NativeAttrs$k = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$i>;
1281
+ type TabsProps<TTabValue extends TabValue = TabValue> = Props$i<TTabValue> & NativeAttrs$k;
1282
+ declare const Tabs: <TTabValue extends TabValue = TabValue>(props: Props$i<TTabValue> & NativeAttrs$k & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1157
1283
 
1158
- interface Props$c {
1284
+ interface Props$h {
1159
1285
  inputRef?: React.RefObject<HTMLInputElement>;
1160
1286
  variant?: InputVariant;
1161
1287
  color?: InputColor;
@@ -1164,13 +1290,13 @@ interface Props$c {
1164
1290
  endContent?: React.ReactNode;
1165
1291
  css?: BoxCSS;
1166
1292
  }
1167
- type NativeAttrs$c = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$c>;
1168
- type TextInputProps = Props$c & NativeAttrs$c;
1169
- declare const TextInput: react.ForwardRefExoticComponent<Props$c & NativeAttrs$c & react.RefAttributes<HTMLInputElement>>;
1293
+ type NativeAttrs$j = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$h>;
1294
+ type TextInputProps = Props$h & NativeAttrs$j;
1295
+ declare const TextInput: react.ForwardRefExoticComponent<Props$h & NativeAttrs$j & react.RefAttributes<HTMLInputElement>>;
1170
1296
 
1171
1297
  type ToolbarSize = 'auto' | 'sm' | 'md' | 'lg';
1172
1298
 
1173
- interface Props$b {
1299
+ interface Props$g {
1174
1300
  size?: ToolbarSize;
1175
1301
  title?: React.ReactNode;
1176
1302
  subtitle?: React.ReactNode;
@@ -1192,8 +1318,8 @@ interface Props$b {
1192
1318
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
1193
1319
  };
1194
1320
  }
1195
- type NativeAttrs$b = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$b>;
1196
- type ToolbarProps = Props$b & NativeAttrs$b;
1321
+ type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g>;
1322
+ type ToolbarProps = Props$g & NativeAttrs$i;
1197
1323
  declare const Toolbar: React.FC<ToolbarProps>;
1198
1324
 
1199
1325
  interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
@@ -1206,24 +1332,24 @@ interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
1206
1332
  unmountOnExit?: boolean;
1207
1333
  onExited?: () => void;
1208
1334
  }
1209
- declare const Transition: react.ForwardRefExoticComponent<TransitionProps & react.RefAttributes<HTMLElement>>;
1335
+ declare const Transition: React.FC<TransitionProps>;
1210
1336
 
1211
- interface Props$a {
1337
+ interface Props$f {
1212
1338
  /**
1213
1339
  * The HTML element type or React component to render as the tab.
1214
1340
  */
1215
1341
  as?: React.ElementType;
1216
1342
  width?: number;
1217
1343
  }
1218
- type NativeAttrs$a = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$a>;
1219
- type SwipeItemProps = Props$a & NativeAttrs$a;
1220
- declare const SwipeItem: react.ForwardRefExoticComponent<Props$a & NativeAttrs$a & {
1344
+ type NativeAttrs$h = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$f>;
1345
+ type SwipeItemProps = Props$f & NativeAttrs$h;
1346
+ declare const SwipeItem: react.ForwardRefExoticComponent<Props$f & NativeAttrs$h & {
1221
1347
  children?: react.ReactNode | undefined;
1222
1348
  } & react.RefAttributes<HTMLDivElement>>;
1223
1349
 
1224
1350
  type SwiperAlignmet = 'start' | 'center' | 'end';
1225
1351
 
1226
- interface Props$9 {
1352
+ interface Props$e {
1227
1353
  gap?: number;
1228
1354
  alignment?: SwiperAlignmet;
1229
1355
  autoHide?: boolean;
@@ -1233,8 +1359,8 @@ interface Props$9 {
1233
1359
  arrowRightButton?: ButtonProps;
1234
1360
  };
1235
1361
  }
1236
- type NativeAttrs$9 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9>;
1237
- type SwipeProps = Props$9 & NativeAttrs$9;
1362
+ type NativeAttrs$g = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$e>;
1363
+ type SwipeProps = Props$e & NativeAttrs$g;
1238
1364
  declare const Swipe: React.FC<SwipeProps>;
1239
1365
 
1240
1366
  type ModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
@@ -1246,7 +1372,7 @@ interface ModalClose {
1246
1372
  type ModalScrollBehavior = 'inside' | 'outside';
1247
1373
  type ModalBackdrop = BackdropVariant;
1248
1374
 
1249
- interface Props$8 {
1375
+ interface Props$d {
1250
1376
  isOpen: boolean;
1251
1377
  size?: ModalSize;
1252
1378
  backdrop?: ModalBackdrop;
@@ -1261,9 +1387,9 @@ interface Props$8 {
1261
1387
  onClose: () => void;
1262
1388
  onAfterClose?: () => void;
1263
1389
  }
1264
- type NativeAttrs$8 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$8>;
1265
- type ModalProps = Props$8 & NativeAttrs$8;
1266
- declare const Modal: react.ForwardRefExoticComponent<Props$8 & NativeAttrs$8 & react.RefAttributes<HTMLDivElement>>;
1390
+ type NativeAttrs$f = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$d>;
1391
+ type ModalProps = Props$d & NativeAttrs$f;
1392
+ declare const Modal: react.ForwardRefExoticComponent<Props$d & NativeAttrs$f & react.RefAttributes<HTMLDivElement>>;
1267
1393
 
1268
1394
  type ModalBodyProps = React.HTMLAttributes<HTMLDivElement>;
1269
1395
  declare const ModalBody: React.FC<ModalBodyProps>;
@@ -1272,27 +1398,28 @@ interface ModalContextValue {
1272
1398
  isOpen: boolean;
1273
1399
  scrollBehavior: ModalScrollBehavior;
1274
1400
  scrollArea: boolean;
1401
+ closable: boolean;
1275
1402
  onClose(): void;
1276
1403
  onAfterClose(): void;
1277
1404
  }
1278
1405
  declare function useModal(): ModalContextValue;
1279
1406
 
1280
- interface Props$7 {
1407
+ interface Props$c {
1281
1408
  as?: React.ElementType;
1282
1409
  bordered?: boolean;
1283
1410
  }
1284
- type NativeAttrs$7 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7>;
1285
- type ModalFooterProps = Props$7 & NativeAttrs$7;
1286
- declare const ModalFooter: react.ForwardRefExoticComponent<Props$7 & NativeAttrs$7 & react.RefAttributes<HTMLDivElement>>;
1411
+ type NativeAttrs$e = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$c>;
1412
+ type ModalFooterProps = Props$c & NativeAttrs$e;
1413
+ declare const ModalFooter: react.ForwardRefExoticComponent<Props$c & NativeAttrs$e & react.RefAttributes<HTMLDivElement>>;
1287
1414
 
1288
- interface Props$6 {
1415
+ interface Props$b {
1289
1416
  as?: React.ElementType;
1290
1417
  title?: React.ReactNode;
1291
1418
  subtitle?: React.ReactNode;
1292
1419
  startContent?: React.ReactNode;
1293
1420
  endContent?: React.ReactNode;
1294
1421
  bordered?: boolean;
1295
- close?: ModalClose;
1422
+ close?: ModalClose | boolean;
1296
1423
  slotProps?: {
1297
1424
  startContent?: React.HTMLAttributes<HTMLDivElement>;
1298
1425
  content?: React.HTMLAttributes<HTMLDivElement>;
@@ -1301,27 +1428,28 @@ interface Props$6 {
1301
1428
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
1302
1429
  };
1303
1430
  }
1304
- type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
1305
- type ModalHeaderProps = Props$6 & NativeAttrs$6;
1306
- declare const ModalHeader: react.ForwardRefExoticComponent<Props$6 & NativeAttrs$6 & react.RefAttributes<HTMLDivElement>>;
1431
+ type NativeAttrs$d = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$b>;
1432
+ type ModalHeaderProps = Props$b & NativeAttrs$d;
1433
+ declare const ModalHeader: react.ForwardRefExoticComponent<Props$b & NativeAttrs$d & react.RefAttributes<HTMLDivElement>>;
1307
1434
 
1308
1435
  type CheckboxValue = string | number | symbol;
1309
- type CheckboxSize = 'sm' | 'md' | 'lg';
1436
+ type CheckboxSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1310
1437
  type CheckboxLabelPlacement = 'before' | 'after';
1311
1438
  type CheckboxGroupDirection = 'row' | 'col';
1312
1439
  type CheckboxGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
1440
+ type CheckboxColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1313
1441
 
1314
- interface Props$5<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1442
+ interface Props$a<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1315
1443
  value?: TCheckboxValue;
1316
1444
  size?: CheckboxSize;
1317
1445
  labelPlacement?: CheckboxLabelPlacement;
1318
- colorScheme?: ColorScheme;
1446
+ color?: CheckboxColor;
1319
1447
  }
1320
- type NativeAttrs$5 = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$5 | 'defaultValue'>;
1321
- type CheckboxProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$5<TCheckboxValue> & NativeAttrs$5;
1322
- declare const Checkbox: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$5<TCheckboxValue> & NativeAttrs$5 & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1448
+ type NativeAttrs$c = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$a | 'defaultValue'>;
1449
+ type CheckboxProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$a<TCheckboxValue> & NativeAttrs$c;
1450
+ declare const Checkbox: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$a<TCheckboxValue> & NativeAttrs$c & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1323
1451
 
1324
- interface Props$4<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1452
+ interface Props$9<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1325
1453
  value?: TCheckboxValue[];
1326
1454
  defaultValue?: TCheckboxValue[];
1327
1455
  disabled?: boolean;
@@ -1330,12 +1458,12 @@ interface Props$4<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1330
1458
  alignment?: CheckboxGroupAlignment;
1331
1459
  size?: CheckboxSize;
1332
1460
  labelPlacement?: CheckboxLabelPlacement;
1333
- colorScheme?: ColorScheme;
1461
+ color?: CheckboxColor;
1334
1462
  onChange?: (value: TCheckboxValue[]) => void;
1335
1463
  }
1336
- type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
1337
- type CheckboxGroupProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$4<TCheckboxValue> & NativeAttrs$4;
1338
- declare const CheckboxGroup: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$4<TCheckboxValue> & NativeAttrs$4 & react.RefAttributes<HTMLTableElement>) => ReturnType<React.FunctionComponent>;
1464
+ type NativeAttrs$b = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9>;
1465
+ type CheckboxGroupProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$9<TCheckboxValue> & NativeAttrs$b;
1466
+ declare const CheckboxGroup: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$9<TCheckboxValue> & NativeAttrs$b & react.RefAttributes<HTMLTableElement>) => ReturnType<React.FunctionComponent>;
1339
1467
 
1340
1468
  interface CheckboxGroupContextValue<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1341
1469
  value: TCheckboxValue[];
@@ -1344,18 +1472,20 @@ interface CheckboxGroupContextValue<TCheckboxValue extends CheckboxValue = Check
1344
1472
  direction?: CheckboxGroupDirection;
1345
1473
  size: CheckboxSize;
1346
1474
  labelPlacement: CheckboxLabelPlacement;
1347
- colorScheme: ColorScheme;
1475
+ color: CheckboxColor;
1348
1476
  onChange: (value: TCheckboxValue[]) => void;
1349
1477
  }
1478
+ declare const CheckboxGroupContext: react.Context<CheckboxGroupContextValue<CheckboxValue> | null>;
1350
1479
  declare const useCheckboxGroup: () => CheckboxGroupContextValue<CheckboxValue> | null;
1351
1480
 
1352
1481
  type RadioValue = string | number | symbol;
1353
- type RadioSize = 'sm' | 'md' | 'lg';
1482
+ type RadioSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1354
1483
  type RadioLabelPlacement = 'before' | 'after';
1355
1484
  type RadioGroupDirection = 'row' | 'col';
1356
1485
  type RadioGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
1486
+ type RadioColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1357
1487
 
1358
- interface Props$3<TRadioValue extends RadioValue = RadioValue> {
1488
+ interface Props$8<TRadioValue extends RadioValue = RadioValue> {
1359
1489
  value?: TRadioValue;
1360
1490
  disabled?: boolean;
1361
1491
  readOnly?: boolean;
@@ -1363,11 +1493,11 @@ interface Props$3<TRadioValue extends RadioValue = RadioValue> {
1363
1493
  labelPlacement?: RadioLabelPlacement;
1364
1494
  colorScheme?: ColorScheme;
1365
1495
  }
1366
- type NativeAttrs$3 = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$3 | 'defaultValue' | 'checked' | 'defaultChecked' | 'onChange'>;
1367
- type RadioProps<TRadioValue extends RadioValue = RadioValue> = Props$3<TRadioValue> & NativeAttrs$3;
1368
- declare const Radio: <TRadioValue extends RadioValue = RadioValue>(props: Props$3<TRadioValue> & NativeAttrs$3 & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1496
+ type NativeAttrs$a = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$8 | 'defaultValue' | 'checked' | 'defaultChecked' | 'onChange'>;
1497
+ type RadioProps<TRadioValue extends RadioValue = RadioValue> = Props$8<TRadioValue> & NativeAttrs$a;
1498
+ declare const Radio: <TRadioValue extends RadioValue = RadioValue>(props: Props$8<TRadioValue> & NativeAttrs$a & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1369
1499
 
1370
- interface Props$2<TRadioValue extends RadioValue = RadioValue> {
1500
+ interface Props$7<TRadioValue extends RadioValue = RadioValue> {
1371
1501
  name?: string;
1372
1502
  value?: TRadioValue;
1373
1503
  defaultValue?: TRadioValue;
@@ -1377,12 +1507,12 @@ interface Props$2<TRadioValue extends RadioValue = RadioValue> {
1377
1507
  alignment?: RadioGroupAlignment;
1378
1508
  size?: RadioSize;
1379
1509
  labelPlacement?: RadioLabelPlacement;
1380
- colorScheme?: ColorScheme;
1510
+ color?: RadioColor;
1381
1511
  onChange?: (value: TRadioValue) => void;
1382
1512
  }
1383
- type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2>;
1384
- type RadioGroupProps<TRadioValue extends RadioValue = RadioValue> = Props$2<TRadioValue> & NativeAttrs$2;
1385
- declare const RadioGroup: <TRadioValue extends RadioValue = RadioValue>(props: Props$2<TRadioValue> & NativeAttrs$2 & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1513
+ type NativeAttrs$9 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7>;
1514
+ type RadioGroupProps<TRadioValue extends RadioValue = RadioValue> = Props$7<TRadioValue> & NativeAttrs$9;
1515
+ declare const RadioGroup: <TRadioValue extends RadioValue = RadioValue>(props: Props$7<TRadioValue> & NativeAttrs$9 & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1386
1516
 
1387
1517
  interface RadioGroupContextValue {
1388
1518
  name: string;
@@ -1392,92 +1522,188 @@ interface RadioGroupContextValue {
1392
1522
  direction: RadioGroupDirection;
1393
1523
  size: RadioSize;
1394
1524
  labelPlacement: RadioLabelPlacement;
1395
- colorScheme: ColorScheme;
1525
+ color: RadioColor;
1396
1526
  onChange: (value: RadioValue) => void;
1397
1527
  }
1528
+ declare const RadioGroupContext: react.Context<RadioGroupContextValue | null>;
1398
1529
  declare const useRadioGroup: () => RadioGroupContextValue;
1399
1530
 
1400
1531
  type NavRailPlacement = 'left' | 'right';
1401
1532
 
1402
- interface Props$1 {
1533
+ interface Props$6 {
1403
1534
  startContent?: React.ReactNode;
1404
1535
  endContent?: React.ReactNode;
1405
1536
  placement?: NavRailPlacement;
1406
1537
  }
1407
- type NativeAttrs$1 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$1>;
1408
- type NavRailProps = Props$1 & NativeAttrs$1;
1538
+ type NativeAttrs$8 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
1539
+ type NavRailProps = Props$6 & NativeAttrs$8;
1409
1540
  declare const NavRail: React.FC<NavRailProps>;
1410
1541
 
1411
- interface Props {
1542
+ interface Props$5 {
1412
1543
  as?: React.ElementType;
1413
1544
  icon?: React.ReactNode;
1414
1545
  media?: React.ReactNode;
1415
1546
  label?: React.ReactNode;
1416
1547
  selected?: boolean;
1417
1548
  }
1549
+ type NativeAttrs$7 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5>;
1550
+ type NavRailItemProps = Props$5 & NativeAttrs$7;
1551
+ declare const NavRailItem: react.ForwardRefExoticComponent<Props$5 & NativeAttrs$7 & react.RefAttributes<HTMLDivElement>>;
1552
+
1553
+ type Props$4 = {
1554
+ as?: React.ElementType;
1555
+ label: React.ReactNode;
1556
+ span?: Responsive<number>;
1557
+ order?: Responsive<number>;
1558
+ labelStartContent?: React.ReactNode;
1559
+ labelEndContent?: React.ReactNode;
1560
+ valueStartContent?: React.ReactNode;
1561
+ valueEndContent?: React.ReactNode;
1562
+ hoverable?: boolean;
1563
+ render?: (options: {
1564
+ content: React.ReactNode;
1565
+ isEmpty: boolean;
1566
+ mq: ContainerMediaQuery;
1567
+ }) => React.ReactNode;
1568
+ } & FormatOptions;
1569
+ type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4 | 'children'>;
1570
+ type DescriptionProps = Props$4 & NativeAttrs$6;
1571
+ declare const Description: react.ForwardRefExoticComponent<DescriptionProps & react.RefAttributes<HTMLDivElement>>;
1572
+
1573
+ type NativeAttrs$5 = React.HTMLAttributes<HTMLDivElement>;
1574
+ type DescriptionEmptyProps = NativeAttrs$5;
1575
+ declare const DescriptionEmpty: react.ForwardRefExoticComponent<NativeAttrs$5 & react.RefAttributes<HTMLDivElement>>;
1576
+
1577
+ type DescriptionsLayout = 'row' | 'col';
1578
+ type DescriptionsSize = 'sm' | 'md' | 'lg';
1579
+ type DescriptionsAlign = React.CSSProperties['textAlign'];
1580
+ type DescriptionsMode = 'container' | 'screen' | 'css';
1581
+
1582
+ interface Props$3 {
1583
+ as?: React.ElementType;
1584
+ mode?: DescriptionsMode;
1585
+ items?: DescriptionProps[];
1586
+ layout?: Responsive<DescriptionsLayout>;
1587
+ size?: Responsive<DescriptionsSize>;
1588
+ cols?: Responsive<number>;
1589
+ align?: Responsive<DescriptionsAlign>;
1590
+ labelAlign?: Responsive<DescriptionsAlign>;
1591
+ contentAlign?: Responsive<DescriptionsAlign>;
1592
+ }
1593
+ type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3 | 'children'>;
1594
+ type DescriptionsProps = Props$3 & NativeAttrs$4;
1595
+ declare const Descriptions: react.ForwardRefExoticComponent<Props$3 & NativeAttrs$4 & react.RefAttributes<HTMLDivElement>>;
1596
+
1597
+ interface DescriptionsContextValue {
1598
+ mq: ContainerMediaQuery;
1599
+ layout: DescriptionsLayout;
1600
+ size: DescriptionsSize;
1601
+ cols: number;
1602
+ labelAlign?: DescriptionsAlign;
1603
+ contentAlign?: DescriptionsAlign;
1604
+ }
1605
+ declare const DescriptionsContext: react.Context<DescriptionsContextValue | null>;
1606
+ declare const useDescriptionsContext: () => DescriptionsContextValue;
1607
+
1608
+ type NativeAttrs$3 = React.HTMLAttributes<HTMLDivElement>;
1609
+ type DescriptionTextProps = NativeAttrs$3;
1610
+ declare const DescriptionText: react.ForwardRefExoticComponent<NativeAttrs$3 & react.RefAttributes<HTMLDivElement>>;
1611
+
1612
+ declare function reactNodeToText(node: React.ReactNode): string;
1613
+
1614
+ interface ResponsiveProps$2 {
1615
+ span?: Responsive<number>;
1616
+ order?: Responsive<number>;
1617
+ p?: Responsive<React.CSSProperties['padding']>;
1618
+ py?: Responsive<React.CSSProperties['paddingBlock']>;
1619
+ px?: Responsive<React.CSSProperties['paddingInline']>;
1620
+ pt?: Responsive<React.CSSProperties['paddingTop']>;
1621
+ pb?: Responsive<React.CSSProperties['paddingBottom']>;
1622
+ pr?: Responsive<React.CSSProperties['paddingRight']>;
1623
+ pl?: Responsive<React.CSSProperties['paddingLeft']>;
1624
+ g?: Responsive<React.CSSProperties['gap']>;
1625
+ gy?: Responsive<React.CSSProperties['rowGap']>;
1626
+ gx?: Responsive<React.CSSProperties['columnGap']>;
1627
+ justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1628
+ alignItems?: Responsive<React.CSSProperties['alignItems']>;
1629
+ }
1630
+ type Props$2 = {
1631
+ as?: React.ElementType;
1632
+ } & ResponsiveProps$2;
1633
+ type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2>;
1634
+ type GridItemProps = Props$2 & NativeAttrs$2;
1635
+ declare const GridItem: react.ForwardRefExoticComponent<{
1636
+ as?: React.ElementType;
1637
+ } & ResponsiveProps$2 & NativeAttrs$2 & react.RefAttributes<HTMLDivElement>>;
1638
+
1639
+ interface ResponsiveProps$1 {
1640
+ cols?: Responsive<number>;
1641
+ span?: Responsive<number>;
1642
+ p?: Responsive<React.CSSProperties['padding']>;
1643
+ py?: Responsive<React.CSSProperties['paddingBlock']>;
1644
+ px?: Responsive<React.CSSProperties['paddingInline']>;
1645
+ pt?: Responsive<React.CSSProperties['paddingTop']>;
1646
+ pb?: Responsive<React.CSSProperties['paddingBottom']>;
1647
+ pr?: Responsive<React.CSSProperties['paddingRight']>;
1648
+ pl?: Responsive<React.CSSProperties['paddingLeft']>;
1649
+ g?: Responsive<React.CSSProperties['gap']>;
1650
+ gy?: Responsive<React.CSSProperties['rowGap']>;
1651
+ gx?: Responsive<React.CSSProperties['columnGap']>;
1652
+ justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1653
+ alignItems?: Responsive<React.CSSProperties['alignItems']>;
1654
+ }
1655
+ type Props$1 = {
1656
+ items?: GridItemProps[];
1657
+ } & ResponsiveProps$1;
1658
+ type NativeAttrs$1 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$1>;
1659
+ type GridSubProps = Props$1 & NativeAttrs$1;
1660
+ declare const GridSub: react.ForwardRefExoticComponent<{
1661
+ items?: GridItemProps[];
1662
+ } & ResponsiveProps$1 & NativeAttrs$1 & react.RefAttributes<HTMLDivElement>>;
1663
+
1664
+ type GridMode = 'container' | 'screen' | 'css';
1665
+
1666
+ interface ResponsiveProps {
1667
+ cols?: Responsive<number>;
1668
+ p?: Responsive<React.CSSProperties['padding']>;
1669
+ py?: Responsive<React.CSSProperties['paddingBlock']>;
1670
+ px?: Responsive<React.CSSProperties['paddingInline']>;
1671
+ pt?: Responsive<React.CSSProperties['paddingTop']>;
1672
+ pb?: Responsive<React.CSSProperties['paddingBottom']>;
1673
+ pr?: Responsive<React.CSSProperties['paddingRight']>;
1674
+ pl?: Responsive<React.CSSProperties['paddingLeft']>;
1675
+ g?: Responsive<React.CSSProperties['gap']>;
1676
+ gy?: Responsive<React.CSSProperties['rowGap']>;
1677
+ gx?: Responsive<React.CSSProperties['columnGap']>;
1678
+ justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1679
+ alignItems?: Responsive<React.CSSProperties['alignItems']>;
1680
+ }
1681
+ type Props = {
1682
+ mode?: GridMode;
1683
+ items?: (GridItemProps | GridSubProps)[];
1684
+ } & ResponsiveProps;
1418
1685
  type NativeAttrs = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props>;
1419
- type NavRailItemProps = Props & NativeAttrs;
1420
- declare const NavRailItem: react.ForwardRefExoticComponent<Props & NativeAttrs & react.RefAttributes<HTMLDivElement>>;
1421
-
1422
- type DescriptionSpan = {
1423
- xs?: number;
1424
- sm?: number;
1425
- md?: number;
1426
- lg?: number;
1427
- xl?: number;
1428
- xxl?: number;
1429
- };
1430
- interface DescriptionItemString {
1431
- type: 'string';
1432
- value?: string;
1433
- }
1434
- interface DescriptionItemNumber {
1435
- type: 'number';
1436
- value?: number | string;
1437
- }
1438
- interface DescriptionItemDate {
1439
- type: 'date';
1440
- value?: Date | string | number;
1441
- format?: 'date' | 'datetime' | 'time';
1442
- locales?: Intl.LocalesArgument;
1443
- options?: Intl.DateTimeFormatOptions;
1444
- }
1445
- interface DescriptionItemBoolean {
1446
- type: 'boolean';
1447
- value?: boolean;
1448
- labels?: {
1449
- true?: string;
1450
- false?: string;
1451
- };
1452
- }
1453
- interface DescriptionItemCurrency {
1454
- type: 'currency';
1455
- value?: number | bigint | Intl.StringNumericLiteral;
1456
- currency?: string;
1457
- locales?: Intl.LocalesArgument;
1458
- options?: Intl.NumberFormatOptions;
1459
- }
1460
- interface DescriptionItemPercent {
1461
- type: 'percent';
1462
- value?: number | string;
1463
- decimals?: number;
1464
- locales?: Intl.LocalesArgument;
1465
- options?: Intl.NumberFormatOptions;
1686
+ type GridProps = Props & NativeAttrs;
1687
+ declare const Grid: react.ForwardRefExoticComponent<{
1688
+ mode?: GridMode;
1689
+ items?: (GridItemProps | GridSubProps)[];
1690
+ } & ResponsiveProps & NativeAttrs & react.RefAttributes<HTMLDivElement>>;
1691
+
1692
+ interface GridContextValue {
1693
+ mq: ContainerMediaQuery;
1466
1694
  }
1467
- type DescriptionItem = {
1468
- name: React.ReactNode;
1469
- span?: number | DescriptionSpan;
1470
- } & (DescriptionItemString | DescriptionItemNumber | DescriptionItemDate | DescriptionItemBoolean | DescriptionItemCurrency | DescriptionItemPercent);
1695
+ declare const GridContext: react.Context<GridContextValue | null>;
1696
+ declare const useGridContext: () => GridContextValue;
1471
1697
 
1472
- interface DescriptionsProps {
1473
- items: DescriptionItem[];
1698
+ interface IframeProps extends React.IframeHTMLAttributes<HTMLIFrameElement> {
1699
+ anchorTarget?: React.HTMLAttributeAnchorTarget;
1700
+ anchorPreventDefault?: boolean;
1474
1701
  }
1475
- declare const Descriptions: React.FC<DescriptionsProps>;
1702
+ declare const Iframe: React.FC<IframeProps>;
1476
1703
 
1477
- interface DescriptionProps {
1478
- item: DescriptionItem;
1704
+ interface HtmlProps extends IframeProps {
1479
1705
  }
1480
- declare const Description: React.FC<DescriptionProps>;
1706
+ declare const Html: React.FC<HtmlProps>;
1481
1707
 
1482
1708
  declare const scrollToItem: (parentElement: Element, currentElement: Element) => void;
1483
1709
 
@@ -1490,11 +1716,16 @@ type ReactRef<T> = React.RefCallback<T> | React.MutableRefObject<T>;
1490
1716
  declare function assignRef<T = any>(ref: ReactRef<T> | null | undefined, value: T): void;
1491
1717
  declare function mergeRefs<T>(...refs: (ReactRef<T> | null | undefined)[]): (node: T | null) => void;
1492
1718
 
1719
+ declare function dateFormat(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1493
1720
  declare function formatDate(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1494
- declare function formatFullDataTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1721
+ declare function formatDateTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1495
1722
  declare function formatShortDateTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1496
- declare function formatShortDate(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1723
+ declare function formatTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1497
1724
  declare function formatCurrency(value: number | bigint | Intl.StringNumericLiteral, currency?: string, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
1498
1725
  declare function formatPercent(value: any, decimals?: number, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
1726
+ declare function format(options: FormatOptions): string | undefined;
1727
+
1728
+ declare const valueToValues: <TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false>(value?: SelectionValue<TItem, TKeyField, TMultiple, TClearable>) => TItem[TKeyField][];
1729
+ declare const valuesToValue: <TItem extends Record<string, any>, TKeyField extends keyof TItem>(values: TItem[TKeyField][]) => TItem[TKeyField] | null;
1499
1730
 
1500
- export { Accordion, type AccordionArrow, AccordionBody, type AccordionBodyProps, type AccordionColor, AccordionContent, type AccordionContentProps, AccordionContext, AccordionHeader, type AccordionHeaderProps, AccordionItem, type AccordionItemProps, type AccordionProps, type AccordionSize, AccordionTrigger, type AccordionTriggerProps, type AccordionVariant, Autocomplete, type AutocompleteItem, type AutocompleteKeyField, type AutocompleteMultipleProps, type AutocompleteProps, type AutocompleteSingleProps, Backdrop, type BackdropPlacement, type BackdropProps, type BackdropVariant, Badge, type BadgeProps, Button, type ButtonColor, ButtonGroup, ButtonGroupContext, type ButtonGroupContextValue, type ButtonGroupDirection, type ButtonGroupProps, type ButtonProps, type ButtonSize, type ButtonVariant, Card, CardBody, type CardBodyProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, CardMedia, type CardMediaProps, type CardProps, CardSubtitle, type CardSubtitleProps, CardTitle, type CardTitleProps, Checkbox, CheckboxGroup, type CheckboxGroupAlignment, type CheckboxGroupContextValue, type CheckboxGroupDirection, type CheckboxGroupProps, type CheckboxLabelPlacement, type CheckboxProps, type CheckboxSize, type CheckboxValue, Chip, type ChipProps, Collapse, CollapseContent, type CollapseContentProps, CollapseContext, type CollapseContextValue, type CollapseProps, CollapseTrigger, type CollapseTriggerProps, type ColorScheme, type ContainerBreakpoints, ContainerMediaQuery, DataList, type DataListItem, type DataListKeyField, type DataListMultipleProps, type DataListProps, type DataListSingleProps, Description, type DescriptionItem, type DescriptionProps, type DescriptionSpan, Descriptions, type DescriptionsProps, type Disclosure, Divider, type DividerProps, Drawer, type DrawerBackdrop, DrawerBody, type DrawerBodyProps, type DrawerClose, DrawerContext, type DrawerContextValue, DrawerFooter, type DrawerFooterProps, DrawerHeader, type DrawerHeaderProps, type DrawerPlacement, type DrawerPosition, type DrawerProps, type DrawerSize, Field, type FieldProps, Icon, type IconColor, type IconProps, type IconSize, type InfiniteData, type InfiniteQueryFunction, type InfiniteQueryOptions, type InfiniteQueryRefetchOptions, type InputColor, type InputSize, type InputVariant, List, ListGroup, type ListGroupProps, ListItem, type ListItemProps, type ListProps, type ListSize, ListSubheader, type ListSubheaderProps, Menu, MenuContext, type MenuContextValue, MenuGroup, type MenuGroupItemType, type MenuGroupProps, MenuItem, type MenuItemProps, type MenuItemType, type MenuProps, MenuSubmenu, type MenuSubmenuProps, MenuValueContext, Modal, type ModalBackdrop, ModalBody, type ModalBodyProps, type ModalClose, ModalFooter, type ModalFooterProps, ModalHeader, type ModalHeaderProps, type ModalPlacement, type ModalProps, type ModalScrollBehavior, type ModalSize, type MutationError, type MutationFunction, type MutationOK, type MutationResult, MutationStatus, NavRail, NavRailItem, type NavRailItemProps, type NavRailPlacement, type NavRailProps, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type PopoverTriggerProps, Portal, type PortalProps, type QueryFunction, QueryStatus, Radio, RadioGroup, type RadioGroupAlignment, type RadioGroupContextValue, type RadioGroupDirection, type RadioGroupProps, type RadioProps, type RadioSize, type RadioValue, type ReactRef, type Resize, Result, type ResultProps, type ResultStatus, type ScrollAlignment, ScrollArea, type ScrollAreaProps, type ScrollBehavior, type ScrollToOptions, Select, type SelectItem, type SelectKeyField, type SelectMultipleProps, type SelectProps, type SelectSingleProps, Swipe, SwipeItem, type SwipeItemProps, type SwipeProps, Switch, type SwitchProps, type SwitchSize, Tab, type TabProps, Tabs, type TabsAlignment, type TabsProps, type TabsVariant, TextInput, type TextInputProps, Toolbar, type ToolbarProps, type ToolbarSize, Transition, type TransitionProps, type UseContainerMediaQueryOptions, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, type UseResizeObserverOptions, type VirtualItem, type Virtualizer, type VirtualizerOptions, assignRef, clsx, formatCurrency, formatDate, formatFullDataTime, formatPercent, formatShortDate, formatShortDateTime, getOpenValuesByPathname, hasResizeObserver, mergeRefs, scrollToItem, useAccordion, useAccordionItem, useButtonGroup, useCheckboxGroup, useCollapse, useContainerMediaQuery, useDebounce, useDisclosure, useDrawer, useEffectEvent, useElementSize, useInfiniteQuery, useLocalStorage, useMediaQuery, useMenu, useMenuItemValue, useModal, useMutation, useOnClickOutside, usePopover, usePrevious, useQuery, useRadioGroup, useResizeObserver, useStep, useValueEffect, useVirtualizer };
1731
+ export { Accordion, type AccordionArrow, AccordionBody, type AccordionBodyProps, type AccordionColor, AccordionContent, type AccordionContentProps, AccordionContext, AccordionHeader, type AccordionHeaderProps, AccordionItem, type AccordionItemProps, type AccordionProps, type AccordionSize, AccordionTrigger, type AccordionTriggerProps, type AccordionVariant, Autocomplete, AutocompleteContext, type AutocompleteContextValue, type AutocompleteProps, Backdrop, type BackdropPlacement, type BackdropProps, type BackdropVariant, Badge, type BadgeProps, Button, type ButtonColor, ButtonGroup, ButtonGroupContext, type ButtonGroupContextValue, type ButtonGroupDirection, type ButtonGroupProps, type ButtonProps, type ButtonSize, type ButtonVariant, Card, CardBody, type CardBodyProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, CardMedia, type CardMediaProps, type CardProps, CardSubtitle, type CardSubtitleProps, CardTitle, type CardTitleProps, Checkbox, type CheckboxColor, CheckboxGroup, type CheckboxGroupAlignment, CheckboxGroupContext, type CheckboxGroupContextValue, type CheckboxGroupDirection, type CheckboxGroupProps, type CheckboxLabelPlacement, type CheckboxProps, type CheckboxSize, type CheckboxValue, Chip, type ChipProps, Collapse, CollapseContent, type CollapseContentProps, CollapseContext, type CollapseContextValue, type CollapseProps, CollapseTrigger, type CollapseTriggerProps, type ColorScheme, type ContainerBreakpoints, ContainerMediaQuery, DataList, type DataListItem, type DataListKeyField, type DataListMultipleProps, type DataListProps, type DataListSingleProps, Description, DescriptionEmpty, type DescriptionEmptyProps, type DescriptionProps, DescriptionText, type DescriptionTextProps, Descriptions, type DescriptionsAlign, DescriptionsContext, type DescriptionsContextValue, type DescriptionsLayout, type DescriptionsMode, type DescriptionsProps, type DescriptionsSize, type Disclosure, Divider, type DividerProps, Drawer, type DrawerBackdrop, DrawerBody, type DrawerBodyProps, type DrawerClose, DrawerContext, type DrawerContextValue, DrawerFooter, type DrawerFooterProps, DrawerHeader, type DrawerHeaderProps, type DrawerPlacement, type DrawerPosition, type DrawerProps, type DrawerSize, Field, type FieldProps, type FormatBooleanOptions, type FormatCurrencyOptions, type FormatDateOptions, type FormatNumberOptions, type FormatOptions, type FormatPercentOptions, type FormatStringOptions, Grid, GridContext, type GridContextValue, GridItem, type GridItemProps, type GridMode, type GridProps, GridSub, type GridSubProps, Html, type HtmlProps, Icon, type IconColor, type IconProps, type IconSize, Iframe, type IframeProps, type InfiniteData, type InfiniteQueryFunction, type InfiniteQueryOptions, type InfiniteQueryRefetchOptions, type InputColor, InputGroup, type InputGroupProps, type InputSize, type InputVariant, List, ListGroup, type ListGroupProps, ListItem, type ListItemProps, type ListProps, type ListSize, ListSubheader, type ListSubheaderProps, type MediaQuery, Menu, MenuContext, type MenuContextValue, MenuGroup, type MenuGroupItemType, type MenuGroupProps, MenuItem, type MenuItemProps, type MenuItemType, type MenuProps, MenuSubmenu, type MenuSubmenuProps, MenuValueContext, Modal, type ModalBackdrop, ModalBody, type ModalBodyProps, type ModalClose, ModalFooter, type ModalFooterProps, ModalHeader, type ModalHeaderProps, type ModalPlacement, type ModalProps, type ModalScrollBehavior, type ModalSize, type MutationError, type MutationFunction, type MutationOK, type MutationResult, MutationStatus, NavRail, NavRailItem, type NavRailItemProps, type NavRailPlacement, type NavRailProps, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type PopoverTriggerProps, Portal, type PortalProps, type QueryFunction, QueryStatus, Radio, type RadioColor, RadioGroup, type RadioGroupAlignment, RadioGroupContext, type RadioGroupContextValue, type RadioGroupDirection, type RadioGroupProps, type RadioLabelPlacement, type RadioProps, type RadioSize, type RadioValue, type ReactRef, type Resize, type Responsive, Result, type ResultProps, type ResultStatus, type ScrollAlignment, ScrollArea, type ScrollAreaProps, type ScrollBehavior, type ScrollToOptions, Select, SelectContext, type SelectContextValue, type SelectItem, type SelectKeyField, type SelectProps, type SelectionItem, type SelectionOnChange, type SelectionProps, type SelectionValue, Swipe, SwipeItem, type SwipeItemProps, type SwipeProps, Switch, type SwitchColor, type SwitchLabelPlacement, type SwitchProps, type SwitchSize, Tab, type TabProps, Tabs, type TabsAlignment, type TabsProps, type TabsVariant, TextInput, type TextInputProps, Toolbar, type ToolbarProps, type ToolbarSize, Transition, type TransitionProps, type UseContainerMediaQueryOptions, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, type UseResizeObserverOptions, type VirtualItem, type Virtualizer, type VirtualizerOptions, assignRef, breakpointsMap, clsx, dateFormat, defaultBreakpoints, format, formatCurrency, formatDate, formatDateTime, formatPercent, formatShortDateTime, formatTime, getOpenValuesByPathname, hasResizeObserver, mergeRefs, reactNodeToText, scrollToItem, useAccordion, useAccordionItem, useAutocomplete, useButtonGroup, useCheckboxGroup, useCollapse, useContainerMediaQuery, useDebounce, useDescriptionsContext, useDisclosure, useDrawer, useEffectEvent, useElementSize, useFormat, useGridContext, useInfiniteQuery, useLocalStorage, useMediaQuery, useMenu, useMenuItemValue, useModal, useMutation, useOnClickOutside, usePopover, usePrevious, useQuery, useRadioGroup, useResizeObserver, useSelect, useStep, useValueEffect, useVirtualizer, valueToValues, valuesToValue };