@unifiedsoftware/react-ui 2.0.0-alpha.9 → 2.0.0-beta.10

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 +496 -270
  2. package/dist/index.js +1 -1
  3. package/package.json +2 -1
package/dist/index.d.ts CHANGED
@@ -2,12 +2,13 @@ import * as react from 'react';
2
2
  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
+ import { FloatingRootContext } from '@floating-ui/react';
5
6
 
6
- interface Props$J {
7
+ interface Props$O {
7
8
  }
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>>;
9
+ type NativeAttrs$Q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$O>;
10
+ type DividerProps = Props$O & NativeAttrs$Q;
11
+ declare const Divider: react.ForwardRefExoticComponent<Props$O & NativeAttrs$Q & react.RefAttributes<HTMLDivElement>>;
11
12
 
12
13
  type BoxShadow = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
13
14
  type BorderRadius = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
@@ -35,7 +36,7 @@ interface AccordionArrow {
35
36
  position?: 'start' | 'end';
36
37
  }
37
38
 
38
- interface Props$I {
39
+ interface Props$N {
39
40
  value?: any[];
40
41
  defaultValue?: any[];
41
42
  expandMode?: 'single' | 'multiple';
@@ -52,9 +53,9 @@ interface Props$I {
52
53
  }) => React.ReactNode;
53
54
  onChange?: (value: any[]) => void;
54
55
  }
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>>;
56
+ type NativeAttrs$P = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$N>;
57
+ type AccordionProps = Props$N & NativeAttrs$P;
58
+ declare const Accordion: react.ForwardRefExoticComponent<Props$N & NativeAttrs$P & react.RefAttributes<HTMLDivElement>>;
58
59
 
59
60
  interface AccordionItemContextValue {
60
61
  value: string;
@@ -63,7 +64,7 @@ interface AccordionItemContextValue {
63
64
  }) => React.ReactNode;
64
65
  }
65
66
  declare const useAccordionItem: () => AccordionItemContextValue;
66
- interface Props$H {
67
+ interface Props$M {
67
68
  value?: any;
68
69
  variant?: AccordionVariant;
69
70
  color?: AccordionColor;
@@ -71,11 +72,11 @@ interface Props$H {
71
72
  isOpen: boolean;
72
73
  }) => React.ReactNode;
73
74
  }
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>>;
75
+ type NativeAttrs$O = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$M>;
76
+ type AccordionItemProps = Props$M & NativeAttrs$O;
77
+ declare const AccordionItem: react.ForwardRefExoticComponent<Props$M & NativeAttrs$O & react.RefAttributes<HTMLDivElement>>;
77
78
 
78
- interface Props$G {
79
+ interface Props$L {
79
80
  as?: React.ElementType;
80
81
  title?: React.ReactNode;
81
82
  subtitle?: React.ReactNode;
@@ -93,9 +94,9 @@ interface Props$G {
93
94
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
94
95
  };
95
96
  }
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>>;
97
+ type NativeAttrs$N = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$L>;
98
+ type AccordionHeaderProps = Props$L & NativeAttrs$N;
99
+ declare const AccordionHeader: react.ForwardRefExoticComponent<Props$L & NativeAttrs$N & react.RefAttributes<HTMLDivElement>>;
99
100
 
100
101
  type AccordionBodyProps = React.HTMLAttributes<HTMLDivElement>;
101
102
  declare const AccordionBody: react.ForwardRefExoticComponent<AccordionBodyProps & react.RefAttributes<HTMLDivElement>>;
@@ -439,17 +440,62 @@ interface FormatPercentOptions {
439
440
  }
440
441
  type FormatOptions = FormatStringOptions | FormatNumberOptions | FormatDateOptions | FormatBooleanOptions | FormatCurrencyOptions | FormatPercentOptions;
441
442
 
442
- declare function useFormat(options: FormatOptions): string | undefined;
443
+ declare function useFormat(options: FormatOptions): {
444
+ value: string | undefined;
445
+ getValue: (value: any) => string | undefined;
446
+ };
447
+
448
+ type ColorScheme = 'default' | 'light' | 'dark';
449
+
450
+ type MediaQuery = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
451
+ type Responsive<T> = T | {
452
+ /**
453
+ * Minimum captured size: 0px
454
+ */
455
+ xs?: T;
456
+ /**
457
+ * Minimum captured size: 576px
458
+ */
459
+ sm?: T;
460
+ /**
461
+ * Minimum captured size: 768px
462
+ */
463
+ md?: T;
464
+ /**
465
+ * Minimum captured size: 992px
466
+ */
467
+ lg?: T;
468
+ /**
469
+ * Minimum captured size: 1200px
470
+ */
471
+ xl?: T;
472
+ /**
473
+ * Minimum captured size: 1400px
474
+ */
475
+ '2xl'?: T;
476
+ };
477
+
478
+ 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];
479
+ 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;
480
+ 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;
481
+ interface SelectionProps<TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> {
482
+ data: TItem[];
483
+ isMultiple?: TMultiple;
484
+ clearable?: TClearable;
485
+ keyField?: TKeyField;
486
+ value?: SelectionValue<TItem, TKeyField, TMultiple, TClearable>;
487
+ onChange?: SelectionOnChange<TItem, TKeyField, TMultiple, TClearable>;
488
+ }
443
489
 
444
490
  type InputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
445
- type InputColor = 'light' | 'dark' | 'inherit';
491
+ type InputColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
446
492
  type InputVariant = 'filled' | 'outlined' | 'flat' | 'text';
447
493
 
448
- interface Props$F {
494
+ interface Props$K {
449
495
  }
450
- type NativeAttrs$H = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$F>;
451
- type InputGroupProps = Props$F & NativeAttrs$H;
452
- declare const InputGroup: react.ForwardRefExoticComponent<Props$F & NativeAttrs$H & react.RefAttributes<HTMLDivElement>>;
496
+ type NativeAttrs$M = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$K>;
497
+ type InputGroupProps = Props$K & NativeAttrs$M;
498
+ declare const InputGroup: react.ForwardRefExoticComponent<Props$K & NativeAttrs$M & react.RefAttributes<HTMLDivElement>>;
453
499
 
454
500
  type ListSize = 'sm' | 'md' | 'lg';
455
501
 
@@ -459,7 +505,7 @@ interface ListProps extends React.HTMLAttributes<HTMLDivElement> {
459
505
  }
460
506
  declare const List: react.ForwardRefExoticComponent<ListProps & react.RefAttributes<HTMLDivElement>>;
461
507
 
462
- interface Props$E {
508
+ interface Props$J {
463
509
  as?: react__default.ElementType;
464
510
  title?: react__default.ReactNode;
465
511
  subtitle?: react__default.ReactNode;
@@ -477,11 +523,11 @@ interface Props$E {
477
523
  subtitle?: react__default.HTMLAttributes<HTMLDivElement>;
478
524
  };
479
525
  }
480
- type NativeAttrs$G = Omit<react__default.HTMLAttributes<HTMLDivElement>, keyof Props$E>;
481
- type ListItemProps = Props$E & NativeAttrs$G;
482
- declare const ListItem: react__default.ForwardRefExoticComponent<Props$E & NativeAttrs$G & react__default.RefAttributes<HTMLDivElement>>;
526
+ type NativeAttrs$L = Omit<react__default.HTMLAttributes<HTMLDivElement>, keyof Props$J>;
527
+ type ListItemProps = Props$J & NativeAttrs$L;
528
+ declare const ListItem: react__default.ForwardRefExoticComponent<Props$J & NativeAttrs$L & react__default.RefAttributes<HTMLDivElement>>;
483
529
 
484
- interface Props$D {
530
+ interface Props$I {
485
531
  expandVisible?: boolean;
486
532
  expandPosition?: 'start' | 'end';
487
533
  isOpen?: boolean;
@@ -489,9 +535,9 @@ interface Props$D {
489
535
  onClose?: () => void;
490
536
  onToggle?: () => void;
491
537
  }
492
- type NativeAttrs$F = Omit<ListItemProps, keyof Props$D>;
493
- type ListGroupProps = Props$D & NativeAttrs$F;
494
- declare const ListGroup: react.ForwardRefExoticComponent<Props$D & NativeAttrs$F & react.RefAttributes<HTMLDivElement>>;
538
+ type NativeAttrs$K = Omit<ListItemProps, keyof Props$I>;
539
+ type ListGroupProps = Props$I & NativeAttrs$K;
540
+ declare const ListGroup: react.ForwardRefExoticComponent<Props$I & NativeAttrs$K & react.RefAttributes<HTMLDivElement>>;
495
541
 
496
542
  interface ListSubheaderProps extends React.HTMLAttributes<HTMLDivElement> {
497
543
  as?: React.ElementType;
@@ -519,30 +565,16 @@ interface ResultProps extends React.HTMLAttributes<HTMLDivElement> {
519
565
  }
520
566
  declare const Result: React.FC<ResultProps>;
521
567
 
522
- type AutocompleteItem = Record<string, any>;
523
- type AutocompleteKeyField<TAutocompleteItem> = keyof TAutocompleteItem;
524
- interface AutocompleteSingleProps<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> {
525
- isMultiple?: false;
526
- value: TAutocompleteItem[TAutocompleteKeyField] | null;
527
- onChange?: (value: TAutocompleteItem | null) => void;
528
- onValueChange?: (value: TAutocompleteItem[TAutocompleteKeyField] | null) => void;
529
- }
530
- interface AutocompleteMultipleProps<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> {
531
- isMultiple: true;
532
- value: TAutocompleteItem[TAutocompleteKeyField][];
533
- onChange?: (value: TAutocompleteItem[]) => void;
534
- onValueChange?: (value: TAutocompleteItem[TAutocompleteKeyField][]) => void;
535
- }
536
- type NativeAttrs$E<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$C<TAutocompleteItem, TAutocompleteKeyField>>;
537
- type Props$C<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> = {
538
- data: TAutocompleteItem[];
539
- keyField?: TAutocompleteKeyField;
540
- textField?: keyof TAutocompleteItem;
568
+ type AutocompleteMultiple = false;
569
+ type AutocompleteClearable = true;
570
+ type NativeAttrs$J<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$H<TItem, TKeyField>>;
571
+ type BaseProps$1<TItem extends Record<string, any>> = {
572
+ textField?: keyof TItem;
541
573
  placeholder?: string;
542
574
  filter?: string;
543
575
  loading?: boolean;
544
576
  disabled?: boolean;
545
- clearable?: boolean;
577
+ readOnly?: boolean;
546
578
  disclosure?: Disclosure;
547
579
  virtual?: Omit<VirtualizerOptions, 'parentRef'>;
548
580
  color?: InputColor;
@@ -550,19 +582,36 @@ type Props$C<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField e
550
582
  size?: InputSize;
551
583
  startContent?: React.ReactNode;
552
584
  endContent?: React.ReactNode;
553
- onItemSelect?: (item: TAutocompleteItem) => void;
585
+ onItemSelect?: (item: TItem) => void;
554
586
  onFilterChange?: (value: string) => void;
555
- renderItem?: (item: TAutocompleteItem, props: ListItemProps) => React.ReactNode;
587
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
556
588
  renderNoData?: (props: ResultProps) => React.ReactNode;
557
- } & (AutocompleteSingleProps<TAutocompleteItem, TAutocompleteKeyField> | AutocompleteMultipleProps<TAutocompleteItem, TAutocompleteKeyField>);
558
- type AutocompleteProps<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> = Props$C<TAutocompleteItem, TAutocompleteKeyField> & NativeAttrs$E<TAutocompleteItem, TAutocompleteKeyField>;
589
+ };
590
+ type Props$H<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>;
591
+ type AutocompleteProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$H<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$J<TItem, TKeyField>;
592
+
593
+ 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;
559
594
 
560
- declare const Autocomplete: <TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = "key">(props: AutocompleteProps<TAutocompleteItem, TAutocompleteKeyField>) => react_jsx_runtime.JSX.Element;
595
+ type AutocompleteContextValue<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = {
596
+ data: TItem[];
597
+ values: TItem[TKeyField][];
598
+ keyField: TKeyField;
599
+ textField: keyof TItem;
600
+ isMultiple: boolean;
601
+ virtual?: Omit<VirtualizerOptions, 'parentRef'>;
602
+ onChange: (value: TItem[]) => void;
603
+ onItemSelect: (item: TItem) => void;
604
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
605
+ offset: number;
606
+ setOffset: React.Dispatch<React.SetStateAction<number>>;
607
+ };
608
+ declare const AutocompleteContext: react.Context<AutocompleteContextValue<Record<string, any>, string> | null>;
609
+ declare const useAutocomplete: () => AutocompleteContextValue<Record<string, any>, string>;
561
610
 
562
611
  type BackdropPlacement = 'top' | 'left' | 'center' | 'right' | 'bottom';
563
612
  type BackdropVariant = 'opaque' | 'blur' | 'transparent';
564
613
 
565
- interface Props$B {
614
+ interface Props$G {
566
615
  isOpen: boolean;
567
616
  closable?: boolean;
568
617
  placement?: BackdropPlacement;
@@ -571,14 +620,14 @@ interface Props$B {
571
620
  scrollArea?: boolean;
572
621
  onClose(): void;
573
622
  }
574
- type NativeAttrs$D = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$B>;
575
- type BackdropProps = Props$B & NativeAttrs$D;
576
- declare const Backdrop: react.ForwardRefExoticComponent<Props$B & NativeAttrs$D & react.RefAttributes<HTMLDivElement>>;
623
+ type NativeAttrs$I = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$G>;
624
+ type BackdropProps = Props$G & NativeAttrs$I;
625
+ declare const Backdrop: react.ForwardRefExoticComponent<Props$G & NativeAttrs$I & react.RefAttributes<HTMLDivElement>>;
577
626
 
578
627
  type BadgeColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
579
628
  type BadgePlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
580
629
 
581
- interface Props$A {
630
+ interface Props$F {
582
631
  /**
583
632
  * The placement of the badge relative to its content.
584
633
  */
@@ -596,8 +645,8 @@ interface Props$A {
596
645
  wrapper?: React.HTMLAttributes<HTMLDivElement>;
597
646
  };
598
647
  }
599
- type NativeAttrs$C = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$A>;
600
- type BadgeProps = Props$A & NativeAttrs$C;
648
+ type NativeAttrs$H = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$F>;
649
+ type BadgeProps = Props$F & NativeAttrs$H;
601
650
  declare const Badge: React.FC<BadgeProps>;
602
651
 
603
652
  type DataListItem = Record<string, any>;
@@ -614,7 +663,7 @@ interface DataListMultipleProps<TDataListItem extends DataListItem, TDataListKey
614
663
  onChange?: (value: TDataListItem[]) => void;
615
664
  onValueChange?: (value: TDataListItem[TDataListKeyField][]) => void;
616
665
  }
617
- type Props$z<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
666
+ type Props$E<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
618
667
  data: TDataListItem[];
619
668
  keyField?: TDataListKeyField;
620
669
  textField?: keyof DataListItem;
@@ -629,17 +678,17 @@ type Props$z<TDataListItem extends DataListItem, TDataListKeyField extends DataL
629
678
  renderItem?: (item: TDataListItem, props: ListItemProps$1) => React.ReactNode;
630
679
  renderNoData?: (props: ResultProps$1) => React.ReactNode;
631
680
  } & (DataListSingleProps<TDataListItem, TDataListKeyField> | DataListMultipleProps<TDataListItem, TDataListKeyField>);
632
- type NativeAttrs$B<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$z<TDataListItem, TDataListKeyField>>;
633
- type DataListProps<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Props$z<TDataListItem, TDataListKeyField> & NativeAttrs$B<TDataListItem, TDataListKeyField>;
681
+ type NativeAttrs$G<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$E<TDataListItem, TDataListKeyField>>;
682
+ type DataListProps<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Props$E<TDataListItem, TDataListKeyField> & NativeAttrs$G<TDataListItem, TDataListKeyField>;
634
683
 
635
684
  declare const DataList: <TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = "key">(props: DataListProps<TDataListItem, TDataListKeyField>) => react_jsx_runtime.JSX.Element;
636
685
 
637
- type ButtonVariant = 'filled' | 'outlined' | 'flat' | 'text';
638
- type ButtonColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'inherit';
686
+ type ButtonVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'bordered';
687
+ type ButtonColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
639
688
  type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
640
689
  type ButtonGroupDirection = 'row' | 'col';
641
690
 
642
- interface Props$y {
691
+ interface Props$D {
643
692
  /**
644
693
  * The HTML element type or React component to render as the button.
645
694
  */
@@ -684,20 +733,20 @@ interface Props$y {
684
733
  fontStyle?: React.CSSProperties['fontStyle'];
685
734
  };
686
735
  }
687
- type NativeAttrs$A = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$y>;
688
- type ButtonProps = Props$y & NativeAttrs$A;
689
- declare const Button: react.ForwardRefExoticComponent<Props$y & NativeAttrs$A & react.RefAttributes<HTMLButtonElement>>;
736
+ type NativeAttrs$F = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$D>;
737
+ type ButtonProps = Props$D & NativeAttrs$F;
738
+ declare const Button: react.ForwardRefExoticComponent<Props$D & NativeAttrs$F & react.RefAttributes<HTMLButtonElement>>;
690
739
 
691
- interface Props$x {
740
+ interface Props$C {
692
741
  direction?: ButtonGroupDirection;
693
742
  variant?: ButtonVariant;
694
743
  color?: ButtonColor;
695
744
  size?: ButtonSize;
696
745
  disabled?: boolean;
697
746
  }
698
- type NativeAttrs$z = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$x>;
699
- type ButtonGroupProps = Props$x & NativeAttrs$z;
700
- declare const ButtonGroup: react.ForwardRefExoticComponent<Props$x & NativeAttrs$z & react.RefAttributes<HTMLDivElement>>;
747
+ type NativeAttrs$E = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$C>;
748
+ type ButtonGroupProps = Props$C & NativeAttrs$E;
749
+ declare const ButtonGroup: react.ForwardRefExoticComponent<Props$C & NativeAttrs$E & react.RefAttributes<HTMLDivElement>>;
701
750
 
702
751
  interface ButtonGroupContextValue {
703
752
  direction: ButtonGroupDirection;
@@ -711,7 +760,7 @@ declare const useButtonGroup: () => ButtonGroupContextValue | null;
711
760
 
712
761
  type CardSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
713
762
 
714
- interface Props$w {
763
+ interface Props$B {
715
764
  as?: React.ElementType;
716
765
  size?: CardSize;
717
766
  hoverable?: boolean;
@@ -721,14 +770,14 @@ interface Props$w {
721
770
  divider?: boolean;
722
771
  css?: BoxCSS;
723
772
  }
724
- type NativeAttrs$y = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$w>;
725
- type CardProps = Props$w & NativeAttrs$y;
726
- declare const Card: react.ForwardRefExoticComponent<Props$w & NativeAttrs$y & react.RefAttributes<HTMLDivElement>>;
773
+ type NativeAttrs$D = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$B>;
774
+ type CardProps = Props$B & NativeAttrs$D;
775
+ declare const Card: react.ForwardRefExoticComponent<Props$B & NativeAttrs$D & react.RefAttributes<HTMLDivElement>>;
727
776
 
728
777
  type CardBodyProps = React.HTMLAttributes<HTMLDivElement>;
729
778
  declare const CardBody: react.ForwardRefExoticComponent<CardBodyProps & react.RefAttributes<HTMLDivElement>>;
730
779
 
731
- interface Props$v {
780
+ interface Props$A {
732
781
  as?: React.ElementType;
733
782
  title?: React.ReactNode;
734
783
  subtitle?: React.ReactNode;
@@ -738,6 +787,9 @@ interface Props$v {
738
787
  * @deprecated Use `underlined` instead
739
788
  */
740
789
  bordered?: boolean;
790
+ /**
791
+ * @deprecated Use `divider` in instead in Card
792
+ */
741
793
  underlined?: boolean;
742
794
  centered?: boolean;
743
795
  slotProps?: {
@@ -751,11 +803,11 @@ interface Props$v {
751
803
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
752
804
  };
753
805
  }
754
- type NativeAttrs$x = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$v>;
755
- type CardHeaderProps = Props$v & NativeAttrs$x;
756
- declare const CardHeader: react.ForwardRefExoticComponent<Props$v & NativeAttrs$x & react.RefAttributes<HTMLDivElement>>;
806
+ type NativeAttrs$C = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$A>;
807
+ type CardHeaderProps = Props$A & NativeAttrs$C;
808
+ declare const CardHeader: react.ForwardRefExoticComponent<Props$A & NativeAttrs$C & react.RefAttributes<HTMLDivElement>>;
757
809
 
758
- interface Props$u {
810
+ interface Props$z {
759
811
  as?: React.ElementType;
760
812
  /**
761
813
  * @deprecated Use `underlined` instead
@@ -763,9 +815,9 @@ interface Props$u {
763
815
  bordered?: boolean;
764
816
  underlined?: boolean;
765
817
  }
766
- type NativeAttrs$w = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$u>;
767
- type CardFooterProps = Props$u & NativeAttrs$w;
768
- declare const CardFooter: react.ForwardRefExoticComponent<Props$u & NativeAttrs$w & react.RefAttributes<HTMLDivElement>>;
818
+ type NativeAttrs$B = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$z>;
819
+ type CardFooterProps = Props$z & NativeAttrs$B;
820
+ declare const CardFooter: react.ForwardRefExoticComponent<Props$z & NativeAttrs$B & react.RefAttributes<HTMLDivElement>>;
769
821
 
770
822
  type CardMediaProps = React.HTMLAttributes<HTMLDivElement> & {
771
823
  topLeftContent?: React.ReactNode;
@@ -776,28 +828,28 @@ declare const CardMedia: react.ForwardRefExoticComponent<react.HTMLAttributes<HT
776
828
  topRightContent?: React.ReactNode;
777
829
  } & react.RefAttributes<HTMLDivElement>>;
778
830
 
779
- interface Props$t {
831
+ interface Props$y {
780
832
  as?: React.ElementType;
781
833
  centered?: boolean;
782
834
  css?: BoxCSS;
783
835
  }
784
- type NativeAttrs$v = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$t>;
785
- type CardTitleProps = Props$t & NativeAttrs$v;
786
- declare const CardTitle: react.ForwardRefExoticComponent<Props$t & NativeAttrs$v & react.RefAttributes<HTMLDivElement>>;
836
+ type NativeAttrs$A = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$y>;
837
+ type CardTitleProps = Props$y & NativeAttrs$A;
838
+ declare const CardTitle: react.ForwardRefExoticComponent<Props$y & NativeAttrs$A & react.RefAttributes<HTMLDivElement>>;
787
839
 
788
- interface Props$s {
840
+ interface Props$x {
789
841
  as?: React.ElementType;
790
842
  css?: BoxCSS;
791
843
  }
792
- type NativeAttrs$u = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$s>;
793
- type CardSubtitleProps = Props$s & NativeAttrs$u;
794
- declare const CardSubtitle: react.ForwardRefExoticComponent<Props$s & NativeAttrs$u & react.RefAttributes<HTMLDivElement>>;
844
+ type NativeAttrs$z = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$x>;
845
+ type CardSubtitleProps = Props$x & NativeAttrs$z;
846
+ declare const CardSubtitle: react.ForwardRefExoticComponent<Props$x & NativeAttrs$z & react.RefAttributes<HTMLDivElement>>;
795
847
 
796
- type ChipVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain';
848
+ type ChipVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain' | 'bordered';
797
849
  type ChipColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
798
850
  type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
799
851
 
800
- interface Props$r {
852
+ interface Props$w {
801
853
  /**
802
854
  * The HTML element type or React component to render as the chip.
803
855
  */
@@ -835,9 +887,9 @@ interface Props$r {
835
887
  };
836
888
  onClose?: () => void;
837
889
  }
838
- type NativeAttrs$t = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$r>;
839
- type ChipProps = Props$r & NativeAttrs$t;
840
- declare const Chip: react.ForwardRefExoticComponent<Props$r & NativeAttrs$t & react.RefAttributes<HTMLDivElement>>;
890
+ type NativeAttrs$y = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$w>;
891
+ type ChipProps = Props$w & NativeAttrs$y;
892
+ declare const Chip: react.ForwardRefExoticComponent<Props$w & NativeAttrs$y & react.RefAttributes<HTMLDivElement>>;
841
893
 
842
894
  interface CollapseProps {
843
895
  children: React.ReactNode;
@@ -866,6 +918,7 @@ declare const useCollapse: () => CollapseContextValue;
866
918
 
867
919
  interface CollapseTriggerProps {
868
920
  children: react__default.ReactNode;
921
+ disabled?: boolean;
869
922
  }
870
923
  declare const CollapseTrigger: react__default.ForwardRefExoticComponent<CollapseTriggerProps & react__default.RefAttributes<unknown>>;
871
924
 
@@ -881,7 +934,7 @@ interface DrawerClose {
881
934
  }
882
935
  type DrawerBackdrop = BackdropVariant;
883
936
 
884
- interface Props$q {
937
+ interface Props$v {
885
938
  isOpen: boolean;
886
939
  size?: DrawerSize;
887
940
  backdrop?: DrawerBackdrop;
@@ -898,11 +951,11 @@ interface Props$q {
898
951
  onClose: () => void;
899
952
  onAfterClose?: () => void;
900
953
  }
901
- type NativeAttrs$s = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$q>;
902
- type DrawerProps = Props$q & NativeAttrs$s;
903
- declare const Drawer: react.ForwardRefExoticComponent<Props$q & NativeAttrs$s & react.RefAttributes<HTMLDivElement>>;
954
+ type NativeAttrs$x = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$v>;
955
+ type DrawerProps = Props$v & NativeAttrs$x;
956
+ declare const Drawer: react.ForwardRefExoticComponent<Props$v & NativeAttrs$x & react.RefAttributes<HTMLDivElement>>;
904
957
 
905
- interface Props$p {
958
+ interface Props$u {
906
959
  as?: React.ElementType;
907
960
  title?: React.ReactNode;
908
961
  subtitle?: React.ReactNode;
@@ -918,20 +971,20 @@ interface Props$p {
918
971
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
919
972
  };
920
973
  }
921
- type NativeAttrs$r = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$p>;
922
- type DrawerHeaderProps = Props$p & NativeAttrs$r;
923
- declare const DrawerHeader: react.ForwardRefExoticComponent<Props$p & NativeAttrs$r & react.RefAttributes<HTMLDivElement>>;
974
+ type NativeAttrs$w = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$u>;
975
+ type DrawerHeaderProps = Props$u & NativeAttrs$w;
976
+ declare const DrawerHeader: react.ForwardRefExoticComponent<Props$u & NativeAttrs$w & react.RefAttributes<HTMLDivElement>>;
924
977
 
925
978
  type DrawerBodyProps = React.HTMLAttributes<HTMLDivElement>;
926
979
  declare const DrawerBody: react.ForwardRefExoticComponent<DrawerBodyProps & react.RefAttributes<HTMLDivElement>>;
927
980
 
928
- interface Props$o {
981
+ interface Props$t {
929
982
  as?: React.ElementType;
930
983
  bordered?: boolean;
931
984
  }
932
- type NativeAttrs$q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$o>;
933
- type DrawerFooterProps = Props$o & NativeAttrs$q;
934
- declare const DrawerFooter: react.ForwardRefExoticComponent<Props$o & NativeAttrs$q & react.RefAttributes<HTMLDivElement>>;
985
+ type NativeAttrs$v = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$t>;
986
+ type DrawerFooterProps = Props$t & NativeAttrs$v;
987
+ declare const DrawerFooter: react.ForwardRefExoticComponent<Props$t & NativeAttrs$v & react.RefAttributes<HTMLDivElement>>;
935
988
 
936
989
  interface DrawerContextValue {
937
990
  isOpen: boolean;
@@ -955,7 +1008,7 @@ interface IconProps {
955
1008
  }
956
1009
  declare const Icon: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<unknown>>;
957
1010
 
958
- interface Props$n {
1011
+ interface Props$s {
959
1012
  /**
960
1013
  * The HTML element type or React component to render as the menu item.
961
1014
  */
@@ -981,9 +1034,9 @@ interface Props$n {
981
1034
  */
982
1035
  disabled?: boolean;
983
1036
  }
984
- type NativeAttrs$p = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$n | 'items'>;
985
- type MenuItemProps = Props$n & NativeAttrs$p;
986
- declare const MenuItem: react.ForwardRefExoticComponent<Props$n & NativeAttrs$p & react.RefAttributes<HTMLDivElement>>;
1037
+ type NativeAttrs$u = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$s | 'items'>;
1038
+ type MenuItemProps = Props$s & NativeAttrs$u;
1039
+ declare const MenuItem: react.ForwardRefExoticComponent<Props$s & NativeAttrs$u & react.RefAttributes<HTMLDivElement>>;
987
1040
 
988
1041
  type MenuSubmenuProps = Omit<MenuItemProps, 'items'> & {
989
1042
  items?: MenuItemType[];
@@ -1007,7 +1060,7 @@ type MenuItemType = (MenuGroupProps & {
1007
1060
  }) | (MenuItemProps & {
1008
1061
  type?: 'item';
1009
1062
  });
1010
- interface Props$m {
1063
+ interface Props$r {
1011
1064
  /**
1012
1065
  * The currently selected value of the menu.
1013
1066
  */
@@ -1043,8 +1096,8 @@ interface Props$m {
1043
1096
  */
1044
1097
  onItemSelect?: (props: MenuItemProps) => void;
1045
1098
  }
1046
- type NativeAttrs$o = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$m | 'items'>;
1047
- type MenuProps = Props$m & NativeAttrs$o & {
1099
+ type NativeAttrs$t = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$r | 'items'>;
1100
+ type MenuProps = Props$r & NativeAttrs$t & {
1048
1101
  items?: MenuItemType[];
1049
1102
  };
1050
1103
  declare const Menu: React.FC<MenuProps>;
@@ -1117,29 +1170,15 @@ interface ScrollAreaProps {
1117
1170
  }
1118
1171
  declare const ScrollArea: react.ForwardRefExoticComponent<ScrollAreaProps & react.RefAttributes<HTMLDivElement>>;
1119
1172
 
1120
- type SelectItem = Record<string, any>;
1121
- type SelectKeyField<TSelectItem> = keyof TSelectItem;
1122
- interface SelectSingleProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> {
1123
- isMultiple?: false;
1124
- value: TSelectItem[TSelectKeyField] | null;
1125
- onChange?: (value: TSelectItem | null) => void;
1126
- onValueChange?: (value: TSelectItem[TSelectKeyField] | null) => void;
1127
- }
1128
- interface SelectMultipleProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> {
1129
- isMultiple: true;
1130
- value: TSelectItem[TSelectKeyField][];
1131
- onChange?: (value: TSelectItem[]) => void;
1132
- onValueChange?: (value: TSelectItem[TSelectKeyField][]) => void;
1133
- }
1134
- type NativeAttrs$n<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$l<TSelectItem, TSelectKeyField>>;
1135
- type Props$l<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = {
1136
- data: TSelectItem[];
1137
- keyField?: TSelectKeyField;
1138
- textField?: keyof TSelectItem;
1173
+ type SelectMultiple = false;
1174
+ type SelectClearable = false;
1175
+ type NativeAttrs$s<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$q<TItem, TKeyField>>;
1176
+ type BaseProps<TItem extends Record<string, any>> = {
1177
+ textField?: keyof TItem;
1139
1178
  placeholder?: string;
1140
1179
  loading?: boolean;
1141
- clearable?: boolean;
1142
1180
  disabled?: boolean;
1181
+ readOnly?: boolean;
1143
1182
  disclosure?: Disclosure;
1144
1183
  virtual?: Omit<VirtualizerOptions, 'parentRef'>;
1145
1184
  color?: InputColor;
@@ -1147,61 +1186,49 @@ type Props$l<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyFi
1147
1186
  size?: InputSize;
1148
1187
  startContent?: React.ReactNode;
1149
1188
  endContent?: React.ReactNode;
1150
- onItemSelect?: (item: TSelectItem) => void;
1151
- renderItem?: (item: TSelectItem, props: ListItemProps) => React.ReactNode;
1189
+ onItemSelect?: (item: TItem) => void;
1190
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
1152
1191
  renderNoData?: (props: ResultProps) => React.ReactNode;
1153
- } & (SelectSingleProps<TSelectItem, TSelectKeyField> | SelectMultipleProps<TSelectItem, TSelectKeyField>);
1154
- type SelectProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = Props$l<TSelectItem, TSelectKeyField> & NativeAttrs$n<TSelectItem, TSelectKeyField>;
1155
-
1156
- declare const Select: <TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = "key">(props: SelectProps<TSelectItem, TSelectKeyField>) => react_jsx_runtime.JSX.Element;
1192
+ };
1193
+ type Props$q<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>;
1194
+ type SelectProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$q<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$s<TItem, TKeyField>;
1157
1195
 
1158
- type ColorScheme = 'default' | 'light' | 'dark';
1196
+ 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;
1159
1197
 
1160
- type MediaQuery = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
1161
- type Responsive<T> = T | {
1162
- /**
1163
- * Minimum captured size: 0px
1164
- */
1165
- xs?: T;
1166
- /**
1167
- * Minimum captured size: 576px
1168
- */
1169
- sm?: T;
1170
- /**
1171
- * Minimum captured size: 768px
1172
- */
1173
- md?: T;
1174
- /**
1175
- * Minimum captured size: 992px
1176
- */
1177
- lg?: T;
1178
- /**
1179
- * Minimum captured size: 1200px
1180
- */
1181
- xl?: T;
1182
- /**
1183
- * Minimum captured size: 1400px
1184
- */
1185
- '2xl'?: T;
1198
+ type SelectContextValue<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = {
1199
+ data: TItem[];
1200
+ values: TItem[TKeyField][];
1201
+ keyField: TKeyField;
1202
+ textField: keyof TItem;
1203
+ isMultiple: boolean;
1204
+ virtual?: Omit<VirtualizerOptions, 'parentRef'>;
1205
+ onChange: (value: TItem[]) => void;
1206
+ onItemSelect: (item: TItem) => void;
1207
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
1208
+ offset: number;
1209
+ setOffset: React.Dispatch<React.SetStateAction<number>>;
1186
1210
  };
1211
+ declare const SelectContext: react.Context<SelectContextValue<Record<string, any>, string> | null>;
1212
+ declare const useSelect: () => SelectContextValue<Record<string, any>, string>;
1187
1213
 
1188
- type SwitchSize = 'sm' | 'md' | 'lg';
1214
+ type SwitchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1189
1215
  type SwitchLabelPlacement = 'before' | 'after';
1216
+ type SwitchColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1190
1217
 
1191
- interface Props$k {
1218
+ interface Props$p {
1192
1219
  size?: SwitchSize;
1193
1220
  labelPlacement?: SwitchLabelPlacement;
1194
- colorScheme?: ColorScheme;
1221
+ color?: SwitchColor;
1195
1222
  }
1196
- type NativeAttrs$m = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$k | 'value' | 'defaultValue'>;
1197
- type SwitchProps = Props$k & NativeAttrs$m;
1198
- declare const Switch: react.ForwardRefExoticComponent<Props$k & NativeAttrs$m & react.RefAttributes<HTMLInputElement>>;
1223
+ type NativeAttrs$r = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$p | 'value' | 'defaultValue'>;
1224
+ type SwitchProps = Props$p & NativeAttrs$r;
1225
+ declare const Switch: react.ForwardRefExoticComponent<Props$p & NativeAttrs$r & react.RefAttributes<HTMLInputElement>>;
1199
1226
 
1200
1227
  type TabsVariant = 'underlined' | 'outlined' | 'pills';
1201
1228
  type TabValue = string | number | symbol;
1202
1229
  type TabsAlignment = 'start' | 'center' | 'end' | 'stretch';
1203
1230
 
1204
- interface Props$j<TTabValue extends TabValue = TabValue> {
1231
+ interface Props$o<TTabValue extends TabValue = TabValue> {
1205
1232
  /**
1206
1233
  * The HTML element type or React component to render as the tab.
1207
1234
  */
@@ -1227,11 +1254,11 @@ interface Props$j<TTabValue extends TabValue = TabValue> {
1227
1254
  */
1228
1255
  endContent?: React.ReactNode;
1229
1256
  }
1230
- type NativeAttrs$l = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$j>;
1231
- type TabProps<TTabValue extends TabValue = TabValue> = Props$j<TTabValue> & NativeAttrs$l;
1232
- declare const Tab: react.ForwardRefExoticComponent<Props$j<TabValue> & NativeAttrs$l & react.RefAttributes<HTMLDivElement>>;
1257
+ type NativeAttrs$q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$o>;
1258
+ type TabProps<TTabValue extends TabValue = TabValue> = Props$o<TTabValue> & NativeAttrs$q;
1259
+ declare const Tab: react.ForwardRefExoticComponent<Props$o<TabValue> & NativeAttrs$q & react.RefAttributes<HTMLDivElement>>;
1233
1260
 
1234
- interface Props$i<TTabValue extends TabValue = TabValue> {
1261
+ interface Props$n<TTabValue extends TabValue = TabValue> {
1235
1262
  /**
1236
1263
  * The currently selected value of the tabs.
1237
1264
  */
@@ -1254,11 +1281,11 @@ interface Props$i<TTabValue extends TabValue = TabValue> {
1254
1281
  */
1255
1282
  onClose?: (value: TTabValue) => void;
1256
1283
  }
1257
- type NativeAttrs$k = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$i>;
1258
- type TabsProps<TTabValue extends TabValue = TabValue> = Props$i<TTabValue> & NativeAttrs$k;
1259
- declare const Tabs: <TTabValue extends TabValue = TabValue>(props: Props$i<TTabValue> & NativeAttrs$k & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1284
+ type NativeAttrs$p = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$n>;
1285
+ type TabsProps<TTabValue extends TabValue = TabValue> = Props$n<TTabValue> & NativeAttrs$p;
1286
+ declare const Tabs: <TTabValue extends TabValue = TabValue>(props: Props$n<TTabValue> & NativeAttrs$p & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1260
1287
 
1261
- interface Props$h {
1288
+ interface Props$m {
1262
1289
  inputRef?: React.RefObject<HTMLInputElement>;
1263
1290
  variant?: InputVariant;
1264
1291
  color?: InputColor;
@@ -1267,13 +1294,13 @@ interface Props$h {
1267
1294
  endContent?: React.ReactNode;
1268
1295
  css?: BoxCSS;
1269
1296
  }
1270
- type NativeAttrs$j = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$h>;
1271
- type TextInputProps = Props$h & NativeAttrs$j;
1272
- declare const TextInput: react.ForwardRefExoticComponent<Props$h & NativeAttrs$j & react.RefAttributes<HTMLInputElement>>;
1297
+ type NativeAttrs$o = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$m>;
1298
+ type TextInputProps = Props$m & NativeAttrs$o;
1299
+ declare const TextInput: react.ForwardRefExoticComponent<Props$m & NativeAttrs$o & react.RefAttributes<HTMLInputElement>>;
1273
1300
 
1274
1301
  type ToolbarSize = 'auto' | 'sm' | 'md' | 'lg';
1275
1302
 
1276
- interface Props$g {
1303
+ interface Props$l {
1277
1304
  size?: ToolbarSize;
1278
1305
  title?: React.ReactNode;
1279
1306
  subtitle?: React.ReactNode;
@@ -1295,8 +1322,8 @@ interface Props$g {
1295
1322
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
1296
1323
  };
1297
1324
  }
1298
- type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g>;
1299
- type ToolbarProps = Props$g & NativeAttrs$i;
1325
+ type NativeAttrs$n = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$l>;
1326
+ type ToolbarProps = Props$l & NativeAttrs$n;
1300
1327
  declare const Toolbar: React.FC<ToolbarProps>;
1301
1328
 
1302
1329
  interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
@@ -1309,24 +1336,24 @@ interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
1309
1336
  unmountOnExit?: boolean;
1310
1337
  onExited?: () => void;
1311
1338
  }
1312
- declare const Transition: react.ForwardRefExoticComponent<TransitionProps & react.RefAttributes<HTMLElement>>;
1339
+ declare const Transition: React.FC<TransitionProps>;
1313
1340
 
1314
- interface Props$f {
1341
+ interface Props$k {
1315
1342
  /**
1316
1343
  * The HTML element type or React component to render as the tab.
1317
1344
  */
1318
1345
  as?: React.ElementType;
1319
1346
  width?: number;
1320
1347
  }
1321
- type NativeAttrs$h = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$f>;
1322
- type SwipeItemProps = Props$f & NativeAttrs$h;
1323
- declare const SwipeItem: react.ForwardRefExoticComponent<Props$f & NativeAttrs$h & {
1348
+ type NativeAttrs$m = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$k>;
1349
+ type SwipeItemProps = Props$k & NativeAttrs$m;
1350
+ declare const SwipeItem: react.ForwardRefExoticComponent<Props$k & NativeAttrs$m & {
1324
1351
  children?: react.ReactNode | undefined;
1325
1352
  } & react.RefAttributes<HTMLDivElement>>;
1326
1353
 
1327
1354
  type SwiperAlignmet = 'start' | 'center' | 'end';
1328
1355
 
1329
- interface Props$e {
1356
+ interface Props$j {
1330
1357
  gap?: number;
1331
1358
  alignment?: SwiperAlignmet;
1332
1359
  autoHide?: boolean;
@@ -1336,8 +1363,8 @@ interface Props$e {
1336
1363
  arrowRightButton?: ButtonProps;
1337
1364
  };
1338
1365
  }
1339
- type NativeAttrs$g = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$e>;
1340
- type SwipeProps = Props$e & NativeAttrs$g;
1366
+ type NativeAttrs$l = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$j>;
1367
+ type SwipeProps = Props$j & NativeAttrs$l;
1341
1368
  declare const Swipe: React.FC<SwipeProps>;
1342
1369
 
1343
1370
  type ModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
@@ -1349,7 +1376,7 @@ interface ModalClose {
1349
1376
  type ModalScrollBehavior = 'inside' | 'outside';
1350
1377
  type ModalBackdrop = BackdropVariant;
1351
1378
 
1352
- interface Props$d {
1379
+ interface Props$i {
1353
1380
  isOpen: boolean;
1354
1381
  size?: ModalSize;
1355
1382
  backdrop?: ModalBackdrop;
@@ -1364,9 +1391,9 @@ interface Props$d {
1364
1391
  onClose: () => void;
1365
1392
  onAfterClose?: () => void;
1366
1393
  }
1367
- type NativeAttrs$f = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$d>;
1368
- type ModalProps = Props$d & NativeAttrs$f;
1369
- declare const Modal: react.ForwardRefExoticComponent<Props$d & NativeAttrs$f & react.RefAttributes<HTMLDivElement>>;
1394
+ type NativeAttrs$k = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$i>;
1395
+ type ModalProps = Props$i & NativeAttrs$k;
1396
+ declare const Modal: react.ForwardRefExoticComponent<Props$i & NativeAttrs$k & react.RefAttributes<HTMLDivElement>>;
1370
1397
 
1371
1398
  type ModalBodyProps = React.HTMLAttributes<HTMLDivElement>;
1372
1399
  declare const ModalBody: React.FC<ModalBodyProps>;
@@ -1375,27 +1402,28 @@ interface ModalContextValue {
1375
1402
  isOpen: boolean;
1376
1403
  scrollBehavior: ModalScrollBehavior;
1377
1404
  scrollArea: boolean;
1405
+ closable: boolean;
1378
1406
  onClose(): void;
1379
1407
  onAfterClose(): void;
1380
1408
  }
1381
1409
  declare function useModal(): ModalContextValue;
1382
1410
 
1383
- interface Props$c {
1411
+ interface Props$h {
1384
1412
  as?: React.ElementType;
1385
1413
  bordered?: boolean;
1386
1414
  }
1387
- type NativeAttrs$e = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$c>;
1388
- type ModalFooterProps = Props$c & NativeAttrs$e;
1389
- declare const ModalFooter: react.ForwardRefExoticComponent<Props$c & NativeAttrs$e & react.RefAttributes<HTMLDivElement>>;
1415
+ type NativeAttrs$j = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$h>;
1416
+ type ModalFooterProps = Props$h & NativeAttrs$j;
1417
+ declare const ModalFooter: react.ForwardRefExoticComponent<Props$h & NativeAttrs$j & react.RefAttributes<HTMLDivElement>>;
1390
1418
 
1391
- interface Props$b {
1419
+ interface Props$g {
1392
1420
  as?: React.ElementType;
1393
1421
  title?: React.ReactNode;
1394
1422
  subtitle?: React.ReactNode;
1395
1423
  startContent?: React.ReactNode;
1396
1424
  endContent?: React.ReactNode;
1397
1425
  bordered?: boolean;
1398
- close?: ModalClose;
1426
+ close?: ModalClose | boolean;
1399
1427
  slotProps?: {
1400
1428
  startContent?: React.HTMLAttributes<HTMLDivElement>;
1401
1429
  content?: React.HTMLAttributes<HTMLDivElement>;
@@ -1404,27 +1432,29 @@ interface Props$b {
1404
1432
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
1405
1433
  };
1406
1434
  }
1407
- type NativeAttrs$d = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$b>;
1408
- type ModalHeaderProps = Props$b & NativeAttrs$d;
1409
- declare const ModalHeader: react.ForwardRefExoticComponent<Props$b & NativeAttrs$d & react.RefAttributes<HTMLDivElement>>;
1435
+ type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g>;
1436
+ type ModalHeaderProps = Props$g & NativeAttrs$i;
1437
+ declare const ModalHeader: react.ForwardRefExoticComponent<Props$g & NativeAttrs$i & react.RefAttributes<HTMLDivElement>>;
1410
1438
 
1411
1439
  type CheckboxValue = string | number | symbol;
1412
- type CheckboxSize = 'sm' | 'md' | 'lg';
1440
+ type CheckboxSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1413
1441
  type CheckboxLabelPlacement = 'before' | 'after';
1414
1442
  type CheckboxGroupDirection = 'row' | 'col';
1415
1443
  type CheckboxGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
1444
+ type CheckboxColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1416
1445
 
1417
- interface Props$a<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1446
+ interface Props$f<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1418
1447
  value?: TCheckboxValue;
1419
1448
  size?: CheckboxSize;
1420
1449
  labelPlacement?: CheckboxLabelPlacement;
1421
- colorScheme?: ColorScheme;
1450
+ color?: CheckboxColor;
1451
+ indeterminate?: boolean;
1422
1452
  }
1423
- type NativeAttrs$c = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$a | 'defaultValue'>;
1424
- type CheckboxProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$a<TCheckboxValue> & NativeAttrs$c;
1425
- declare const Checkbox: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$a<TCheckboxValue> & NativeAttrs$c & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1453
+ type NativeAttrs$h = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$f | 'defaultValue'>;
1454
+ type CheckboxProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$f<TCheckboxValue> & NativeAttrs$h;
1455
+ declare const Checkbox: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$f<TCheckboxValue> & NativeAttrs$h & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1426
1456
 
1427
- interface Props$9<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1457
+ interface Props$e<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1428
1458
  value?: TCheckboxValue[];
1429
1459
  defaultValue?: TCheckboxValue[];
1430
1460
  disabled?: boolean;
@@ -1433,12 +1463,12 @@ interface Props$9<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1433
1463
  alignment?: CheckboxGroupAlignment;
1434
1464
  size?: CheckboxSize;
1435
1465
  labelPlacement?: CheckboxLabelPlacement;
1436
- colorScheme?: ColorScheme;
1466
+ color?: CheckboxColor;
1437
1467
  onChange?: (value: TCheckboxValue[]) => void;
1438
1468
  }
1439
- type NativeAttrs$b = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9>;
1440
- type CheckboxGroupProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$9<TCheckboxValue> & NativeAttrs$b;
1441
- declare const CheckboxGroup: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$9<TCheckboxValue> & NativeAttrs$b & react.RefAttributes<HTMLTableElement>) => ReturnType<React.FunctionComponent>;
1469
+ type NativeAttrs$g = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$e>;
1470
+ type CheckboxGroupProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$e<TCheckboxValue> & NativeAttrs$g;
1471
+ declare const CheckboxGroup: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$e<TCheckboxValue> & NativeAttrs$g & react.RefAttributes<HTMLTableElement>) => ReturnType<React.FunctionComponent>;
1442
1472
 
1443
1473
  interface CheckboxGroupContextValue<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1444
1474
  value: TCheckboxValue[];
@@ -1447,18 +1477,20 @@ interface CheckboxGroupContextValue<TCheckboxValue extends CheckboxValue = Check
1447
1477
  direction?: CheckboxGroupDirection;
1448
1478
  size: CheckboxSize;
1449
1479
  labelPlacement: CheckboxLabelPlacement;
1450
- colorScheme: ColorScheme;
1480
+ color: CheckboxColor;
1451
1481
  onChange: (value: TCheckboxValue[]) => void;
1452
1482
  }
1483
+ declare const CheckboxGroupContext: react.Context<CheckboxGroupContextValue<CheckboxValue> | null>;
1453
1484
  declare const useCheckboxGroup: () => CheckboxGroupContextValue<CheckboxValue> | null;
1454
1485
 
1455
1486
  type RadioValue = string | number | symbol;
1456
- type RadioSize = 'sm' | 'md' | 'lg';
1487
+ type RadioSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1457
1488
  type RadioLabelPlacement = 'before' | 'after';
1458
1489
  type RadioGroupDirection = 'row' | 'col';
1459
1490
  type RadioGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
1491
+ type RadioColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1460
1492
 
1461
- interface Props$8<TRadioValue extends RadioValue = RadioValue> {
1493
+ interface Props$d<TRadioValue extends RadioValue = RadioValue> {
1462
1494
  value?: TRadioValue;
1463
1495
  disabled?: boolean;
1464
1496
  readOnly?: boolean;
@@ -1466,11 +1498,11 @@ interface Props$8<TRadioValue extends RadioValue = RadioValue> {
1466
1498
  labelPlacement?: RadioLabelPlacement;
1467
1499
  colorScheme?: ColorScheme;
1468
1500
  }
1469
- type NativeAttrs$a = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$8 | 'defaultValue' | 'checked' | 'defaultChecked' | 'onChange'>;
1470
- type RadioProps<TRadioValue extends RadioValue = RadioValue> = Props$8<TRadioValue> & NativeAttrs$a;
1471
- declare const Radio: <TRadioValue extends RadioValue = RadioValue>(props: Props$8<TRadioValue> & NativeAttrs$a & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1501
+ type NativeAttrs$f = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$d | 'defaultValue' | 'checked' | 'defaultChecked' | 'onChange'>;
1502
+ type RadioProps<TRadioValue extends RadioValue = RadioValue> = Props$d<TRadioValue> & NativeAttrs$f;
1503
+ declare const Radio: <TRadioValue extends RadioValue = RadioValue>(props: Props$d<TRadioValue> & NativeAttrs$f & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1472
1504
 
1473
- interface Props$7<TRadioValue extends RadioValue = RadioValue> {
1505
+ interface Props$c<TRadioValue extends RadioValue = RadioValue> {
1474
1506
  name?: string;
1475
1507
  value?: TRadioValue;
1476
1508
  defaultValue?: TRadioValue;
@@ -1480,12 +1512,12 @@ interface Props$7<TRadioValue extends RadioValue = RadioValue> {
1480
1512
  alignment?: RadioGroupAlignment;
1481
1513
  size?: RadioSize;
1482
1514
  labelPlacement?: RadioLabelPlacement;
1483
- colorScheme?: ColorScheme;
1515
+ color?: RadioColor;
1484
1516
  onChange?: (value: TRadioValue) => void;
1485
1517
  }
1486
- type NativeAttrs$9 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7>;
1487
- type RadioGroupProps<TRadioValue extends RadioValue = RadioValue> = Props$7<TRadioValue> & NativeAttrs$9;
1488
- declare const RadioGroup: <TRadioValue extends RadioValue = RadioValue>(props: Props$7<TRadioValue> & NativeAttrs$9 & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1518
+ type NativeAttrs$e = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$c>;
1519
+ type RadioGroupProps<TRadioValue extends RadioValue = RadioValue> = Props$c<TRadioValue> & NativeAttrs$e;
1520
+ declare const RadioGroup: <TRadioValue extends RadioValue = RadioValue>(props: Props$c<TRadioValue> & NativeAttrs$e & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1489
1521
 
1490
1522
  interface RadioGroupContextValue {
1491
1523
  name: string;
@@ -1495,34 +1527,38 @@ interface RadioGroupContextValue {
1495
1527
  direction: RadioGroupDirection;
1496
1528
  size: RadioSize;
1497
1529
  labelPlacement: RadioLabelPlacement;
1498
- colorScheme: ColorScheme;
1530
+ color: RadioColor;
1499
1531
  onChange: (value: RadioValue) => void;
1500
1532
  }
1533
+ declare const RadioGroupContext: react.Context<RadioGroupContextValue | null>;
1501
1534
  declare const useRadioGroup: () => RadioGroupContextValue;
1502
1535
 
1503
1536
  type NavRailPlacement = 'left' | 'right';
1504
1537
 
1505
- interface Props$6 {
1538
+ interface Props$b {
1506
1539
  startContent?: React.ReactNode;
1507
1540
  endContent?: React.ReactNode;
1508
1541
  placement?: NavRailPlacement;
1509
1542
  }
1510
- type NativeAttrs$8 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
1511
- type NavRailProps = Props$6 & NativeAttrs$8;
1543
+ type NativeAttrs$d = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$b>;
1544
+ type NavRailProps = Props$b & NativeAttrs$d;
1512
1545
  declare const NavRail: React.FC<NavRailProps>;
1513
1546
 
1514
- interface Props$5 {
1547
+ interface Props$a {
1515
1548
  as?: React.ElementType;
1516
1549
  icon?: React.ReactNode;
1517
1550
  media?: React.ReactNode;
1518
1551
  label?: React.ReactNode;
1519
1552
  selected?: boolean;
1553
+ slotProps?: {
1554
+ label?: React.HTMLAttributes<HTMLDivElement>;
1555
+ };
1520
1556
  }
1521
- type NativeAttrs$7 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5>;
1522
- type NavRailItemProps = Props$5 & NativeAttrs$7;
1523
- declare const NavRailItem: react.ForwardRefExoticComponent<Props$5 & NativeAttrs$7 & react.RefAttributes<HTMLDivElement>>;
1557
+ type NativeAttrs$c = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$a>;
1558
+ type NavRailItemProps = Props$a & NativeAttrs$c;
1559
+ declare const NavRailItem: react.ForwardRefExoticComponent<Props$a & NativeAttrs$c & react.RefAttributes<HTMLDivElement>>;
1524
1560
 
1525
- type Props$4 = {
1561
+ type Props$9 = {
1526
1562
  as?: React.ElementType;
1527
1563
  label: React.ReactNode;
1528
1564
  span?: Responsive<number>;
@@ -1538,20 +1574,22 @@ type Props$4 = {
1538
1574
  mq: ContainerMediaQuery;
1539
1575
  }) => React.ReactNode;
1540
1576
  } & FormatOptions;
1541
- type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4 | 'children'>;
1542
- type DescriptionProps = Props$4 & NativeAttrs$6;
1577
+ type NativeAttrs$b = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9 | 'children'>;
1578
+ type DescriptionProps = Props$9 & NativeAttrs$b;
1543
1579
  declare const Description: react.ForwardRefExoticComponent<DescriptionProps & react.RefAttributes<HTMLDivElement>>;
1544
1580
 
1545
- type NativeAttrs$5 = React.HTMLAttributes<HTMLDivElement>;
1546
- type DescriptionEmptyProps = NativeAttrs$5;
1547
- declare const DescriptionEmpty: react.ForwardRefExoticComponent<NativeAttrs$5 & react.RefAttributes<HTMLDivElement>>;
1581
+ type NativeAttrs$a = React.HTMLAttributes<HTMLDivElement>;
1582
+ type DescriptionEmptyProps = NativeAttrs$a;
1583
+ declare const DescriptionEmpty: react.ForwardRefExoticComponent<NativeAttrs$a & react.RefAttributes<HTMLDivElement>>;
1548
1584
 
1549
1585
  type DescriptionsLayout = 'row' | 'col';
1550
1586
  type DescriptionsSize = 'sm' | 'md' | 'lg';
1551
1587
  type DescriptionsAlign = React.CSSProperties['textAlign'];
1588
+ type DescriptionsMode = 'container' | 'screen' | 'css';
1552
1589
 
1553
- interface Props$3 {
1590
+ interface Props$8 {
1554
1591
  as?: React.ElementType;
1592
+ mode?: DescriptionsMode;
1555
1593
  items?: DescriptionProps[];
1556
1594
  layout?: Responsive<DescriptionsLayout>;
1557
1595
  size?: Responsive<DescriptionsSize>;
@@ -1560,9 +1598,9 @@ interface Props$3 {
1560
1598
  labelAlign?: Responsive<DescriptionsAlign>;
1561
1599
  contentAlign?: Responsive<DescriptionsAlign>;
1562
1600
  }
1563
- type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3 | 'children'>;
1564
- type DescriptionsProps = Props$3 & NativeAttrs$4;
1565
- declare const Descriptions: react.ForwardRefExoticComponent<Props$3 & NativeAttrs$4 & react.RefAttributes<HTMLDivElement>>;
1601
+ type NativeAttrs$9 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$8 | 'children'>;
1602
+ type DescriptionsProps = Props$8 & NativeAttrs$9;
1603
+ declare const Descriptions: react.ForwardRefExoticComponent<Props$8 & NativeAttrs$9 & react.RefAttributes<HTMLDivElement>>;
1566
1604
 
1567
1605
  interface DescriptionsContextValue {
1568
1606
  mq: ContainerMediaQuery;
@@ -1575,9 +1613,9 @@ interface DescriptionsContextValue {
1575
1613
  declare const DescriptionsContext: react.Context<DescriptionsContextValue | null>;
1576
1614
  declare const useDescriptionsContext: () => DescriptionsContextValue;
1577
1615
 
1578
- type NativeAttrs$3 = React.HTMLAttributes<HTMLDivElement>;
1579
- type DescriptionTextProps = NativeAttrs$3;
1580
- declare const DescriptionText: react.ForwardRefExoticComponent<NativeAttrs$3 & react.RefAttributes<HTMLDivElement>>;
1616
+ type NativeAttrs$8 = React.HTMLAttributes<HTMLDivElement>;
1617
+ type DescriptionTextProps = NativeAttrs$8;
1618
+ declare const DescriptionText: react.ForwardRefExoticComponent<NativeAttrs$8 & react.RefAttributes<HTMLDivElement>>;
1581
1619
 
1582
1620
  declare function reactNodeToText(node: React.ReactNode): string;
1583
1621
 
@@ -1597,14 +1635,14 @@ interface ResponsiveProps$2 {
1597
1635
  justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1598
1636
  alignItems?: Responsive<React.CSSProperties['alignItems']>;
1599
1637
  }
1600
- type Props$2 = {
1638
+ type Props$7 = {
1601
1639
  as?: React.ElementType;
1602
1640
  } & ResponsiveProps$2;
1603
- type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2>;
1604
- type GridItemProps = Props$2 & NativeAttrs$2;
1641
+ type NativeAttrs$7 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7>;
1642
+ type GridItemProps = Props$7 & NativeAttrs$7;
1605
1643
  declare const GridItem: react.ForwardRefExoticComponent<{
1606
1644
  as?: React.ElementType;
1607
- } & ResponsiveProps$2 & NativeAttrs$2 & react.RefAttributes<HTMLDivElement>>;
1645
+ } & ResponsiveProps$2 & NativeAttrs$7 & react.RefAttributes<HTMLDivElement>>;
1608
1646
 
1609
1647
  interface ResponsiveProps$1 {
1610
1648
  cols?: Responsive<number>;
@@ -1622,14 +1660,16 @@ interface ResponsiveProps$1 {
1622
1660
  justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1623
1661
  alignItems?: Responsive<React.CSSProperties['alignItems']>;
1624
1662
  }
1625
- type Props$1 = {
1663
+ type Props$6 = {
1626
1664
  items?: GridItemProps[];
1627
1665
  } & ResponsiveProps$1;
1628
- type NativeAttrs$1 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$1>;
1629
- type GridSubProps = Props$1 & NativeAttrs$1;
1666
+ type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
1667
+ type GridSubProps = Props$6 & NativeAttrs$6;
1630
1668
  declare const GridSub: react.ForwardRefExoticComponent<{
1631
1669
  items?: GridItemProps[];
1632
- } & ResponsiveProps$1 & NativeAttrs$1 & react.RefAttributes<HTMLDivElement>>;
1670
+ } & ResponsiveProps$1 & NativeAttrs$6 & react.RefAttributes<HTMLDivElement>>;
1671
+
1672
+ type GridMode = 'container' | 'screen' | 'css';
1633
1673
 
1634
1674
  interface ResponsiveProps {
1635
1675
  cols?: Responsive<number>;
@@ -1645,15 +1685,20 @@ interface ResponsiveProps {
1645
1685
  gx?: Responsive<React.CSSProperties['columnGap']>;
1646
1686
  justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1647
1687
  alignItems?: Responsive<React.CSSProperties['alignItems']>;
1688
+ slotProps?: {
1689
+ wrapper?: React.HTMLAttributes<HTMLDivElement>;
1690
+ };
1648
1691
  }
1649
- type Props = {
1692
+ type Props$5 = {
1693
+ mode?: GridMode;
1650
1694
  items?: (GridItemProps | GridSubProps)[];
1651
1695
  } & ResponsiveProps;
1652
- type NativeAttrs = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props>;
1653
- type GridProps = Props & NativeAttrs;
1696
+ type NativeAttrs$5 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5>;
1697
+ type GridProps = Props$5 & NativeAttrs$5;
1654
1698
  declare const Grid: react.ForwardRefExoticComponent<{
1699
+ mode?: GridMode;
1655
1700
  items?: (GridItemProps | GridSubProps)[];
1656
- } & ResponsiveProps & NativeAttrs & react.RefAttributes<HTMLDivElement>>;
1701
+ } & ResponsiveProps & NativeAttrs$5 & react.RefAttributes<HTMLDivElement>>;
1657
1702
 
1658
1703
  interface GridContextValue {
1659
1704
  mq: ContainerMediaQuery;
@@ -1661,6 +1706,183 @@ interface GridContextValue {
1661
1706
  declare const GridContext: react.Context<GridContextValue | null>;
1662
1707
  declare const useGridContext: () => GridContextValue;
1663
1708
 
1709
+ interface IframeProps extends React.IframeHTMLAttributes<HTMLIFrameElement> {
1710
+ anchorTarget?: React.HTMLAttributeAnchorTarget;
1711
+ anchorPreventDefault?: boolean;
1712
+ }
1713
+ declare const Iframe: React.FC<IframeProps>;
1714
+
1715
+ interface HtmlProps extends IframeProps {
1716
+ }
1717
+ declare const Html: React.FC<HtmlProps>;
1718
+
1719
+ type StepColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
1720
+
1721
+ interface Props$4 {
1722
+ value?: string | number | symbol;
1723
+ title: React.ReactNode;
1724
+ subtitle: React.ReactNode;
1725
+ icon?: React.ReactNode;
1726
+ color?: StepColor;
1727
+ disabled?: boolean;
1728
+ }
1729
+ type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
1730
+ type StepProps = Props$4 & NativeAttrs$4;
1731
+ declare const Step: React.FC<StepProps>;
1732
+
1733
+ interface Props$3 {
1734
+ direction?: 'horizontal' | 'vertical';
1735
+ value?: number | string | symbol;
1736
+ color?: StepColor;
1737
+ markPreviousAsChecked?: boolean;
1738
+ }
1739
+ type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3>;
1740
+ type StepsProps = Props$3 & NativeAttrs$3;
1741
+ declare const Steps: React.FC<StepsProps>;
1742
+
1743
+ interface StepsContextValue {
1744
+ direction: 'horizontal' | 'vertical';
1745
+ value?: number | string | symbol;
1746
+ color: StepColor;
1747
+ markPreviousAsChecked: boolean;
1748
+ items: {
1749
+ value: any;
1750
+ disabled?: boolean;
1751
+ }[];
1752
+ registerItem: (item: {
1753
+ value: any;
1754
+ disabled?: boolean;
1755
+ }) => void;
1756
+ }
1757
+ declare const StepsContext: react.Context<StepsContextValue | null>;
1758
+ declare const useStepsContext: () => StepsContextValue;
1759
+
1760
+ interface TreeItemValue {
1761
+ value: string;
1762
+ selected: boolean;
1763
+ checked: boolean;
1764
+ indeterminate: boolean;
1765
+ }
1766
+ interface TreeItemBase {
1767
+ value: string;
1768
+ items?: TreeItemBase[];
1769
+ }
1770
+ interface TreeItemData {
1771
+ value: string;
1772
+ parents: string[];
1773
+ }
1774
+
1775
+ interface Props$2 extends TreeItemBase {
1776
+ title: string;
1777
+ items?: Props$2[];
1778
+ }
1779
+ type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2 | 'items'>;
1780
+ type TreeItemProps = Props$2 & NativeAttrs$2;
1781
+ declare const TreeItem: (props: TreeItemProps) => react_jsx_runtime.JSX.Element;
1782
+
1783
+ interface TreeProps$1 {
1784
+ items?: TreeItemProps[];
1785
+ value?: TreeItemValue[];
1786
+ onChange?: (value: TreeItemValue[]) => void;
1787
+ }
1788
+ declare const Tree: (props: TreeProps$1) => react_jsx_runtime.JSX.Element;
1789
+
1790
+ interface TreeContextValue {
1791
+ items: TreeItemData[];
1792
+ values: TreeItemValue[];
1793
+ setValues: (value: TreeItemValue[]) => void;
1794
+ selectValue: (value: string) => void;
1795
+ unselectValue: (value: string) => void;
1796
+ checkValue: (value: string) => void;
1797
+ uncheckValue: (value: string) => void;
1798
+ }
1799
+ declare const TreeContext: react.Context<TreeContextValue>;
1800
+
1801
+ interface TreeProps {
1802
+ items?: TreeItemBase[];
1803
+ value?: TreeItemValue[];
1804
+ onChange?: (value: TreeItemValue[]) => void;
1805
+ onSelect?: (value: string) => void;
1806
+ onUnselect?: (value: string) => void;
1807
+ }
1808
+ declare function useTree(props: TreeProps): {
1809
+ items: TreeItemData[];
1810
+ values: TreeItemValue[];
1811
+ setValues: react.Dispatch<react.SetStateAction<TreeItemValue[]>>;
1812
+ selectValue: (value: string) => void;
1813
+ unselectValue: (value: string) => void;
1814
+ checkValue: (value: string) => void;
1815
+ uncheckValue: (value: string) => void;
1816
+ };
1817
+
1818
+ declare function initializeTreeValues(items: TreeItemData[]): TreeItemValue[];
1819
+ declare function flattenTree(tree: TreeItemBase[], parents?: string[]): TreeItemData[];
1820
+ declare function updateTreeValues(values: TreeItemValue[], value: string, action: 'select' | 'unselect' | 'check' | 'uncheck', items: TreeItemData[]): TreeItemValue[];
1821
+
1822
+ interface DropdownContentProps {
1823
+ children: React.ReactNode;
1824
+ }
1825
+ declare const DropdownContent: (props: DropdownContentProps) => react_jsx_runtime.JSX.Element;
1826
+
1827
+ interface DropdownContextValue {
1828
+ isOpen: boolean;
1829
+ onClose(): void;
1830
+ onOpen(): void;
1831
+ onToggle(): void;
1832
+ floatingRootContext: FloatingRootContext;
1833
+ triggerElement: Element | null;
1834
+ setTriggerElement(el: Element | null): void;
1835
+ getTriggerProps(externalProps?: React.HTMLAttributes<any> & {
1836
+ ref?: React.Ref<any> | undefined;
1837
+ }): React.HTMLAttributes<any> & {
1838
+ ref?: React.Ref<any> | undefined;
1839
+ };
1840
+ contentElement: Element | null;
1841
+ setContentElement(el: HTMLElement | null): void;
1842
+ getContentProps(externalProps?: React.HTMLAttributes<any> & {
1843
+ ref?: React.Ref<any> | undefined;
1844
+ }): React.HTMLAttributes<any> & {
1845
+ ref?: React.Ref<any> | undefined;
1846
+ };
1847
+ }
1848
+ declare const DropdownContext: react.Context<DropdownContextValue | null>;
1849
+ declare const useDropdownContext: () => DropdownContextValue;
1850
+
1851
+ interface Props$1 {
1852
+ }
1853
+ type NativeAttrs$1 = Omit<ListItemProps, keyof Props$1>;
1854
+ type DropdownItemProps = Props$1 & NativeAttrs$1;
1855
+ declare const DropdownItem: (props: DropdownItemProps) => react_jsx_runtime.JSX.Element;
1856
+
1857
+ interface DropdownTriggerProps {
1858
+ children: React.ReactNode;
1859
+ }
1860
+ declare const DropdownTrigger: (props: DropdownTriggerProps) => react.ReactElement<any, string | react.JSXElementConstructor<any>>;
1861
+
1862
+ interface Props extends TreeItemBase {
1863
+ items?: Props[];
1864
+ }
1865
+ type NativeAttrs = Omit<ListItemProps, keyof Props | 'items'>;
1866
+ type MenuTreeItemProps = Props & NativeAttrs;
1867
+ declare const MenuTreeItem: (props: MenuTreeItemProps) => react_jsx_runtime.JSX.Element;
1868
+
1869
+ interface MenuTreeProps {
1870
+ items?: MenuTreeItemProps[];
1871
+ value?: TreeItemValue[];
1872
+ selectable?: boolean;
1873
+ checkable?: boolean;
1874
+ onChange?: (value: TreeItemValue[]) => void;
1875
+ onSelect?: (value: string) => void;
1876
+ onUnselect?: (value: string) => void;
1877
+ }
1878
+ declare const MenuTree: (props: MenuTreeProps) => react_jsx_runtime.JSX.Element;
1879
+
1880
+ interface MenuTreeContextValue {
1881
+ selectable: boolean;
1882
+ checkable: boolean;
1883
+ }
1884
+ declare const MenuTreeContex: react.Context<MenuTreeContextValue>;
1885
+
1664
1886
  declare const scrollToItem: (parentElement: Element, currentElement: Element) => void;
1665
1887
 
1666
1888
  type ClassDictionary = Record<string, any>;
@@ -1679,5 +1901,9 @@ declare function formatShortDateTime(value: Date | string | number, locales?: In
1679
1901
  declare function formatTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1680
1902
  declare function formatCurrency(value: number | bigint | Intl.StringNumericLiteral, currency?: string, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
1681
1903
  declare function formatPercent(value: any, decimals?: number, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
1904
+ declare function format(options: FormatOptions): string | undefined;
1905
+
1906
+ 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][];
1907
+ declare const valuesToValue: <TItem extends Record<string, any>, TKeyField extends keyof TItem>(values: TItem[TKeyField][]) => TItem[TKeyField] | null;
1682
1908
 
1683
- 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, DescriptionEmpty, type DescriptionEmptyProps, type DescriptionProps, DescriptionText, type DescriptionTextProps, Descriptions, type DescriptionsAlign, DescriptionsContext, type DescriptionsContextValue, type DescriptionsLayout, 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 GridProps, GridSub, type GridSubProps, Icon, type IconColor, type IconProps, type IconSize, 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, RadioGroup, type RadioGroupAlignment, type RadioGroupContextValue, type RadioGroupDirection, type RadioGroupProps, 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, 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, breakpointsMap, clsx, dateFormat, defaultBreakpoints, formatCurrency, formatDate, formatDateTime, formatPercent, formatShortDateTime, formatTime, getOpenValuesByPathname, hasResizeObserver, mergeRefs, reactNodeToText, scrollToItem, useAccordion, useAccordionItem, 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, useStep, useValueEffect, useVirtualizer };
1909
+ 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 AutocompleteClearable, AutocompleteContext, type AutocompleteContextValue, type AutocompleteMultiple, 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, DropdownContent, type DropdownContentProps, DropdownContext, type DropdownContextValue, DropdownItem, type DropdownItemProps, DropdownTrigger, type DropdownTriggerProps, 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, MenuTree, MenuTreeContex, type MenuTreeContextValue, MenuTreeItem, type MenuTreeItemProps, type MenuTreeProps, 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, type SelectClearable, SelectContext, type SelectContextValue, type SelectMultiple, type SelectProps, type SelectionItem, type SelectionOnChange, type SelectionProps, type SelectionValue, Step, type StepColor, type StepProps, Steps, StepsContext, type StepsContextValue, type StepsProps, 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, Tree, TreeContext, type TreeContextValue, TreeItem, type TreeItemBase, type TreeItemData, type TreeItemProps, type TreeItemValue, type TreeProps$1 as TreeProps, 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, flattenTree, format, formatCurrency, formatDate, formatDateTime, formatPercent, formatShortDateTime, formatTime, getOpenValuesByPathname, hasResizeObserver, initializeTreeValues, mergeRefs, reactNodeToText, scrollToItem, updateTreeValues, useAccordion, useAccordionItem, useAutocomplete, useButtonGroup, useCheckboxGroup, useCollapse, useContainerMediaQuery, useDebounce, useDescriptionsContext, useDisclosure, useDrawer, useDropdownContext, useEffectEvent, useElementSize, useFormat, useGridContext, useInfiniteQuery, useLocalStorage, useMediaQuery, useMenu, useMenuItemValue, useModal, useMutation, useOnClickOutside, usePopover, usePrevious, useQuery, useRadioGroup, useResizeObserver, useSelect, useStep, useStepsContext, useTree, useValueEffect, useVirtualizer, valueToValues, valuesToValue };