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

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 +361 -270
  2. package/dist/index.js +1 -1
  3. package/package.json +2 -1
package/dist/index.d.ts CHANGED
@@ -3,11 +3,11 @@ 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$J {
6
+ interface Props$L {
7
7
  }
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>>;
8
+ type NativeAttrs$N = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$L>;
9
+ type DividerProps = Props$L & NativeAttrs$N;
10
+ declare const Divider: react.ForwardRefExoticComponent<Props$L & NativeAttrs$N & react.RefAttributes<HTMLDivElement>>;
11
11
 
12
12
  type BoxShadow = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
13
13
  type BorderRadius = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
@@ -35,7 +35,7 @@ interface AccordionArrow {
35
35
  position?: 'start' | 'end';
36
36
  }
37
37
 
38
- interface Props$I {
38
+ interface Props$K {
39
39
  value?: any[];
40
40
  defaultValue?: any[];
41
41
  expandMode?: 'single' | 'multiple';
@@ -52,9 +52,9 @@ interface Props$I {
52
52
  }) => React.ReactNode;
53
53
  onChange?: (value: any[]) => void;
54
54
  }
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>>;
55
+ type NativeAttrs$M = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$K>;
56
+ type AccordionProps = Props$K & NativeAttrs$M;
57
+ declare const Accordion: react.ForwardRefExoticComponent<Props$K & NativeAttrs$M & react.RefAttributes<HTMLDivElement>>;
58
58
 
59
59
  interface AccordionItemContextValue {
60
60
  value: string;
@@ -63,7 +63,7 @@ interface AccordionItemContextValue {
63
63
  }) => React.ReactNode;
64
64
  }
65
65
  declare const useAccordionItem: () => AccordionItemContextValue;
66
- interface Props$H {
66
+ interface Props$J {
67
67
  value?: any;
68
68
  variant?: AccordionVariant;
69
69
  color?: AccordionColor;
@@ -71,11 +71,11 @@ interface Props$H {
71
71
  isOpen: boolean;
72
72
  }) => React.ReactNode;
73
73
  }
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>>;
74
+ type NativeAttrs$L = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$J>;
75
+ type AccordionItemProps = Props$J & NativeAttrs$L;
76
+ declare const AccordionItem: react.ForwardRefExoticComponent<Props$J & NativeAttrs$L & react.RefAttributes<HTMLDivElement>>;
77
77
 
78
- interface Props$G {
78
+ interface Props$I {
79
79
  as?: React.ElementType;
80
80
  title?: React.ReactNode;
81
81
  subtitle?: React.ReactNode;
@@ -93,9 +93,9 @@ interface Props$G {
93
93
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
94
94
  };
95
95
  }
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>>;
96
+ type NativeAttrs$K = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$I>;
97
+ type AccordionHeaderProps = Props$I & NativeAttrs$K;
98
+ declare const AccordionHeader: react.ForwardRefExoticComponent<Props$I & NativeAttrs$K & react.RefAttributes<HTMLDivElement>>;
99
99
 
100
100
  type AccordionBodyProps = React.HTMLAttributes<HTMLDivElement>;
101
101
  declare const AccordionBody: react.ForwardRefExoticComponent<AccordionBodyProps & react.RefAttributes<HTMLDivElement>>;
@@ -439,17 +439,62 @@ interface FormatPercentOptions {
439
439
  }
440
440
  type FormatOptions = FormatStringOptions | FormatNumberOptions | FormatDateOptions | FormatBooleanOptions | FormatCurrencyOptions | FormatPercentOptions;
441
441
 
442
- declare function useFormat(options: FormatOptions): string | undefined;
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
+ }
443
488
 
444
489
  type InputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
445
- type InputColor = 'light' | 'dark' | 'inherit';
490
+ type InputColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
446
491
  type InputVariant = 'filled' | 'outlined' | 'flat' | 'text';
447
492
 
448
- interface Props$F {
493
+ interface Props$H {
449
494
  }
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>>;
495
+ type NativeAttrs$J = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$H>;
496
+ type InputGroupProps = Props$H & NativeAttrs$J;
497
+ declare const InputGroup: react.ForwardRefExoticComponent<Props$H & NativeAttrs$J & react.RefAttributes<HTMLDivElement>>;
453
498
 
454
499
  type ListSize = 'sm' | 'md' | 'lg';
455
500
 
@@ -459,7 +504,7 @@ interface ListProps extends React.HTMLAttributes<HTMLDivElement> {
459
504
  }
460
505
  declare const List: react.ForwardRefExoticComponent<ListProps & react.RefAttributes<HTMLDivElement>>;
461
506
 
462
- interface Props$E {
507
+ interface Props$G {
463
508
  as?: react__default.ElementType;
464
509
  title?: react__default.ReactNode;
465
510
  subtitle?: react__default.ReactNode;
@@ -477,11 +522,11 @@ interface Props$E {
477
522
  subtitle?: react__default.HTMLAttributes<HTMLDivElement>;
478
523
  };
479
524
  }
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>>;
525
+ type NativeAttrs$I = Omit<react__default.HTMLAttributes<HTMLDivElement>, keyof Props$G>;
526
+ type ListItemProps = Props$G & NativeAttrs$I;
527
+ declare const ListItem: react__default.ForwardRefExoticComponent<Props$G & NativeAttrs$I & react__default.RefAttributes<HTMLDivElement>>;
483
528
 
484
- interface Props$D {
529
+ interface Props$F {
485
530
  expandVisible?: boolean;
486
531
  expandPosition?: 'start' | 'end';
487
532
  isOpen?: boolean;
@@ -489,9 +534,9 @@ interface Props$D {
489
534
  onClose?: () => void;
490
535
  onToggle?: () => void;
491
536
  }
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>>;
537
+ type NativeAttrs$H = Omit<ListItemProps, keyof Props$F>;
538
+ type ListGroupProps = Props$F & NativeAttrs$H;
539
+ declare const ListGroup: react.ForwardRefExoticComponent<Props$F & NativeAttrs$H & react.RefAttributes<HTMLDivElement>>;
495
540
 
496
541
  interface ListSubheaderProps extends React.HTMLAttributes<HTMLDivElement> {
497
542
  as?: React.ElementType;
@@ -519,30 +564,16 @@ interface ResultProps extends React.HTMLAttributes<HTMLDivElement> {
519
564
  }
520
565
  declare const Result: React.FC<ResultProps>;
521
566
 
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;
567
+ type AutocompleteMultiple = false;
568
+ type AutocompleteClearable = true;
569
+ type NativeAttrs$G<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$E<TItem, TKeyField>>;
570
+ type BaseProps$1<TItem extends Record<string, any>> = {
571
+ textField?: keyof TItem;
541
572
  placeholder?: string;
542
573
  filter?: string;
543
574
  loading?: boolean;
544
575
  disabled?: boolean;
545
- clearable?: boolean;
576
+ readOnly?: boolean;
546
577
  disclosure?: Disclosure;
547
578
  virtual?: Omit<VirtualizerOptions, 'parentRef'>;
548
579
  color?: InputColor;
@@ -550,19 +581,36 @@ type Props$C<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField e
550
581
  size?: InputSize;
551
582
  startContent?: React.ReactNode;
552
583
  endContent?: React.ReactNode;
553
- onItemSelect?: (item: TAutocompleteItem) => void;
584
+ onItemSelect?: (item: TItem) => void;
554
585
  onFilterChange?: (value: string) => void;
555
- renderItem?: (item: TAutocompleteItem, props: ListItemProps) => React.ReactNode;
586
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
556
587
  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>;
588
+ };
589
+ type Props$E<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>;
590
+ type AutocompleteProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$E<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$G<TItem, TKeyField>;
559
591
 
560
- declare const Autocomplete: <TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = "key">(props: AutocompleteProps<TAutocompleteItem, TAutocompleteKeyField>) => react_jsx_runtime.JSX.Element;
592
+ 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;
593
+
594
+ type AutocompleteContextValue<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = {
595
+ data: TItem[];
596
+ values: TItem[TKeyField][];
597
+ keyField: TKeyField;
598
+ textField: keyof TItem;
599
+ isMultiple: boolean;
600
+ virtual?: Omit<VirtualizerOptions, 'parentRef'>;
601
+ onChange: (value: TItem[]) => void;
602
+ onItemSelect: (item: TItem) => void;
603
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
604
+ offset: number;
605
+ setOffset: React.Dispatch<React.SetStateAction<number>>;
606
+ };
607
+ declare const AutocompleteContext: react.Context<AutocompleteContextValue<Record<string, any>, string> | null>;
608
+ declare const useAutocomplete: () => AutocompleteContextValue<Record<string, any>, string>;
561
609
 
562
610
  type BackdropPlacement = 'top' | 'left' | 'center' | 'right' | 'bottom';
563
611
  type BackdropVariant = 'opaque' | 'blur' | 'transparent';
564
612
 
565
- interface Props$B {
613
+ interface Props$D {
566
614
  isOpen: boolean;
567
615
  closable?: boolean;
568
616
  placement?: BackdropPlacement;
@@ -571,14 +619,14 @@ interface Props$B {
571
619
  scrollArea?: boolean;
572
620
  onClose(): void;
573
621
  }
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>>;
622
+ type NativeAttrs$F = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$D>;
623
+ type BackdropProps = Props$D & NativeAttrs$F;
624
+ declare const Backdrop: react.ForwardRefExoticComponent<Props$D & NativeAttrs$F & react.RefAttributes<HTMLDivElement>>;
577
625
 
578
626
  type BadgeColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
579
627
  type BadgePlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
580
628
 
581
- interface Props$A {
629
+ interface Props$C {
582
630
  /**
583
631
  * The placement of the badge relative to its content.
584
632
  */
@@ -596,8 +644,8 @@ interface Props$A {
596
644
  wrapper?: React.HTMLAttributes<HTMLDivElement>;
597
645
  };
598
646
  }
599
- type NativeAttrs$C = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$A>;
600
- type BadgeProps = Props$A & NativeAttrs$C;
647
+ type NativeAttrs$E = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$C>;
648
+ type BadgeProps = Props$C & NativeAttrs$E;
601
649
  declare const Badge: React.FC<BadgeProps>;
602
650
 
603
651
  type DataListItem = Record<string, any>;
@@ -614,7 +662,7 @@ interface DataListMultipleProps<TDataListItem extends DataListItem, TDataListKey
614
662
  onChange?: (value: TDataListItem[]) => void;
615
663
  onValueChange?: (value: TDataListItem[TDataListKeyField][]) => void;
616
664
  }
617
- type Props$z<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
665
+ type Props$B<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
618
666
  data: TDataListItem[];
619
667
  keyField?: TDataListKeyField;
620
668
  textField?: keyof DataListItem;
@@ -629,17 +677,17 @@ type Props$z<TDataListItem extends DataListItem, TDataListKeyField extends DataL
629
677
  renderItem?: (item: TDataListItem, props: ListItemProps$1) => React.ReactNode;
630
678
  renderNoData?: (props: ResultProps$1) => React.ReactNode;
631
679
  } & (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>;
680
+ type NativeAttrs$D<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$B<TDataListItem, TDataListKeyField>>;
681
+ type DataListProps<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Props$B<TDataListItem, TDataListKeyField> & NativeAttrs$D<TDataListItem, TDataListKeyField>;
634
682
 
635
683
  declare const DataList: <TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = "key">(props: DataListProps<TDataListItem, TDataListKeyField>) => react_jsx_runtime.JSX.Element;
636
684
 
637
- type ButtonVariant = 'filled' | 'outlined' | 'flat' | 'text';
638
- type ButtonColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'inherit';
685
+ type ButtonVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'bordered';
686
+ type ButtonColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
639
687
  type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
640
688
  type ButtonGroupDirection = 'row' | 'col';
641
689
 
642
- interface Props$y {
690
+ interface Props$A {
643
691
  /**
644
692
  * The HTML element type or React component to render as the button.
645
693
  */
@@ -684,20 +732,20 @@ interface Props$y {
684
732
  fontStyle?: React.CSSProperties['fontStyle'];
685
733
  };
686
734
  }
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>>;
735
+ type NativeAttrs$C = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$A>;
736
+ type ButtonProps = Props$A & NativeAttrs$C;
737
+ declare const Button: react.ForwardRefExoticComponent<Props$A & NativeAttrs$C & react.RefAttributes<HTMLButtonElement>>;
690
738
 
691
- interface Props$x {
739
+ interface Props$z {
692
740
  direction?: ButtonGroupDirection;
693
741
  variant?: ButtonVariant;
694
742
  color?: ButtonColor;
695
743
  size?: ButtonSize;
696
744
  disabled?: boolean;
697
745
  }
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>>;
746
+ type NativeAttrs$B = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$z>;
747
+ type ButtonGroupProps = Props$z & NativeAttrs$B;
748
+ declare const ButtonGroup: react.ForwardRefExoticComponent<Props$z & NativeAttrs$B & react.RefAttributes<HTMLDivElement>>;
701
749
 
702
750
  interface ButtonGroupContextValue {
703
751
  direction: ButtonGroupDirection;
@@ -711,7 +759,7 @@ declare const useButtonGroup: () => ButtonGroupContextValue | null;
711
759
 
712
760
  type CardSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
713
761
 
714
- interface Props$w {
762
+ interface Props$y {
715
763
  as?: React.ElementType;
716
764
  size?: CardSize;
717
765
  hoverable?: boolean;
@@ -721,14 +769,14 @@ interface Props$w {
721
769
  divider?: boolean;
722
770
  css?: BoxCSS;
723
771
  }
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>>;
772
+ type NativeAttrs$A = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$y>;
773
+ type CardProps = Props$y & NativeAttrs$A;
774
+ declare const Card: react.ForwardRefExoticComponent<Props$y & NativeAttrs$A & react.RefAttributes<HTMLDivElement>>;
727
775
 
728
776
  type CardBodyProps = React.HTMLAttributes<HTMLDivElement>;
729
777
  declare const CardBody: react.ForwardRefExoticComponent<CardBodyProps & react.RefAttributes<HTMLDivElement>>;
730
778
 
731
- interface Props$v {
779
+ interface Props$x {
732
780
  as?: React.ElementType;
733
781
  title?: React.ReactNode;
734
782
  subtitle?: React.ReactNode;
@@ -738,6 +786,9 @@ interface Props$v {
738
786
  * @deprecated Use `underlined` instead
739
787
  */
740
788
  bordered?: boolean;
789
+ /**
790
+ * @deprecated Use `divider` in instead in Card
791
+ */
741
792
  underlined?: boolean;
742
793
  centered?: boolean;
743
794
  slotProps?: {
@@ -751,11 +802,11 @@ interface Props$v {
751
802
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
752
803
  };
753
804
  }
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>>;
805
+ type NativeAttrs$z = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$x>;
806
+ type CardHeaderProps = Props$x & NativeAttrs$z;
807
+ declare const CardHeader: react.ForwardRefExoticComponent<Props$x & NativeAttrs$z & react.RefAttributes<HTMLDivElement>>;
757
808
 
758
- interface Props$u {
809
+ interface Props$w {
759
810
  as?: React.ElementType;
760
811
  /**
761
812
  * @deprecated Use `underlined` instead
@@ -763,9 +814,9 @@ interface Props$u {
763
814
  bordered?: boolean;
764
815
  underlined?: boolean;
765
816
  }
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>>;
817
+ type NativeAttrs$y = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$w>;
818
+ type CardFooterProps = Props$w & NativeAttrs$y;
819
+ declare const CardFooter: react.ForwardRefExoticComponent<Props$w & NativeAttrs$y & react.RefAttributes<HTMLDivElement>>;
769
820
 
770
821
  type CardMediaProps = React.HTMLAttributes<HTMLDivElement> & {
771
822
  topLeftContent?: React.ReactNode;
@@ -776,28 +827,28 @@ declare const CardMedia: react.ForwardRefExoticComponent<react.HTMLAttributes<HT
776
827
  topRightContent?: React.ReactNode;
777
828
  } & react.RefAttributes<HTMLDivElement>>;
778
829
 
779
- interface Props$t {
830
+ interface Props$v {
780
831
  as?: React.ElementType;
781
832
  centered?: boolean;
782
833
  css?: BoxCSS;
783
834
  }
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>>;
835
+ type NativeAttrs$x = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$v>;
836
+ type CardTitleProps = Props$v & NativeAttrs$x;
837
+ declare const CardTitle: react.ForwardRefExoticComponent<Props$v & NativeAttrs$x & react.RefAttributes<HTMLDivElement>>;
787
838
 
788
- interface Props$s {
839
+ interface Props$u {
789
840
  as?: React.ElementType;
790
841
  css?: BoxCSS;
791
842
  }
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>>;
843
+ type NativeAttrs$w = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$u>;
844
+ type CardSubtitleProps = Props$u & NativeAttrs$w;
845
+ declare const CardSubtitle: react.ForwardRefExoticComponent<Props$u & NativeAttrs$w & react.RefAttributes<HTMLDivElement>>;
795
846
 
796
- type ChipVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain';
847
+ type ChipVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain' | 'bordered';
797
848
  type ChipColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
798
849
  type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
799
850
 
800
- interface Props$r {
851
+ interface Props$t {
801
852
  /**
802
853
  * The HTML element type or React component to render as the chip.
803
854
  */
@@ -835,9 +886,9 @@ interface Props$r {
835
886
  };
836
887
  onClose?: () => void;
837
888
  }
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>>;
889
+ type NativeAttrs$v = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$t>;
890
+ type ChipProps = Props$t & NativeAttrs$v;
891
+ declare const Chip: react.ForwardRefExoticComponent<Props$t & NativeAttrs$v & react.RefAttributes<HTMLDivElement>>;
841
892
 
842
893
  interface CollapseProps {
843
894
  children: React.ReactNode;
@@ -881,7 +932,7 @@ interface DrawerClose {
881
932
  }
882
933
  type DrawerBackdrop = BackdropVariant;
883
934
 
884
- interface Props$q {
935
+ interface Props$s {
885
936
  isOpen: boolean;
886
937
  size?: DrawerSize;
887
938
  backdrop?: DrawerBackdrop;
@@ -898,11 +949,11 @@ interface Props$q {
898
949
  onClose: () => void;
899
950
  onAfterClose?: () => void;
900
951
  }
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>>;
952
+ type NativeAttrs$u = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$s>;
953
+ type DrawerProps = Props$s & NativeAttrs$u;
954
+ declare const Drawer: react.ForwardRefExoticComponent<Props$s & NativeAttrs$u & react.RefAttributes<HTMLDivElement>>;
904
955
 
905
- interface Props$p {
956
+ interface Props$r {
906
957
  as?: React.ElementType;
907
958
  title?: React.ReactNode;
908
959
  subtitle?: React.ReactNode;
@@ -918,20 +969,20 @@ interface Props$p {
918
969
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
919
970
  };
920
971
  }
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>>;
972
+ type NativeAttrs$t = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$r>;
973
+ type DrawerHeaderProps = Props$r & NativeAttrs$t;
974
+ declare const DrawerHeader: react.ForwardRefExoticComponent<Props$r & NativeAttrs$t & react.RefAttributes<HTMLDivElement>>;
924
975
 
925
976
  type DrawerBodyProps = React.HTMLAttributes<HTMLDivElement>;
926
977
  declare const DrawerBody: react.ForwardRefExoticComponent<DrawerBodyProps & react.RefAttributes<HTMLDivElement>>;
927
978
 
928
- interface Props$o {
979
+ interface Props$q {
929
980
  as?: React.ElementType;
930
981
  bordered?: boolean;
931
982
  }
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>>;
983
+ type NativeAttrs$s = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$q>;
984
+ type DrawerFooterProps = Props$q & NativeAttrs$s;
985
+ declare const DrawerFooter: react.ForwardRefExoticComponent<Props$q & NativeAttrs$s & react.RefAttributes<HTMLDivElement>>;
935
986
 
936
987
  interface DrawerContextValue {
937
988
  isOpen: boolean;
@@ -955,7 +1006,7 @@ interface IconProps {
955
1006
  }
956
1007
  declare const Icon: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<unknown>>;
957
1008
 
958
- interface Props$n {
1009
+ interface Props$p {
959
1010
  /**
960
1011
  * The HTML element type or React component to render as the menu item.
961
1012
  */
@@ -981,9 +1032,9 @@ interface Props$n {
981
1032
  */
982
1033
  disabled?: boolean;
983
1034
  }
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>>;
1035
+ type NativeAttrs$r = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$p | 'items'>;
1036
+ type MenuItemProps = Props$p & NativeAttrs$r;
1037
+ declare const MenuItem: react.ForwardRefExoticComponent<Props$p & NativeAttrs$r & react.RefAttributes<HTMLDivElement>>;
987
1038
 
988
1039
  type MenuSubmenuProps = Omit<MenuItemProps, 'items'> & {
989
1040
  items?: MenuItemType[];
@@ -1007,7 +1058,7 @@ type MenuItemType = (MenuGroupProps & {
1007
1058
  }) | (MenuItemProps & {
1008
1059
  type?: 'item';
1009
1060
  });
1010
- interface Props$m {
1061
+ interface Props$o {
1011
1062
  /**
1012
1063
  * The currently selected value of the menu.
1013
1064
  */
@@ -1043,8 +1094,8 @@ interface Props$m {
1043
1094
  */
1044
1095
  onItemSelect?: (props: MenuItemProps) => void;
1045
1096
  }
1046
- type NativeAttrs$o = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$m | 'items'>;
1047
- type MenuProps = Props$m & NativeAttrs$o & {
1097
+ type NativeAttrs$q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$o | 'items'>;
1098
+ type MenuProps = Props$o & NativeAttrs$q & {
1048
1099
  items?: MenuItemType[];
1049
1100
  };
1050
1101
  declare const Menu: React.FC<MenuProps>;
@@ -1117,29 +1168,15 @@ interface ScrollAreaProps {
1117
1168
  }
1118
1169
  declare const ScrollArea: react.ForwardRefExoticComponent<ScrollAreaProps & react.RefAttributes<HTMLDivElement>>;
1119
1170
 
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;
1171
+ type SelectMultiple = false;
1172
+ type SelectClearable = false;
1173
+ type NativeAttrs$p<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$n<TItem, TKeyField>>;
1174
+ type BaseProps<TItem extends Record<string, any>> = {
1175
+ textField?: keyof TItem;
1139
1176
  placeholder?: string;
1140
1177
  loading?: boolean;
1141
- clearable?: boolean;
1142
1178
  disabled?: boolean;
1179
+ readOnly?: boolean;
1143
1180
  disclosure?: Disclosure;
1144
1181
  virtual?: Omit<VirtualizerOptions, 'parentRef'>;
1145
1182
  color?: InputColor;
@@ -1147,61 +1184,49 @@ type Props$l<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyFi
1147
1184
  size?: InputSize;
1148
1185
  startContent?: React.ReactNode;
1149
1186
  endContent?: React.ReactNode;
1150
- onItemSelect?: (item: TSelectItem) => void;
1151
- renderItem?: (item: TSelectItem, props: ListItemProps) => React.ReactNode;
1187
+ onItemSelect?: (item: TItem) => void;
1188
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
1152
1189
  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;
1190
+ };
1191
+ type Props$n<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>;
1192
+ type SelectProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$n<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$p<TItem, TKeyField>;
1157
1193
 
1158
- type ColorScheme = 'default' | 'light' | 'dark';
1194
+ 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
1195
 
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;
1196
+ type SelectContextValue<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = {
1197
+ data: TItem[];
1198
+ values: TItem[TKeyField][];
1199
+ keyField: TKeyField;
1200
+ textField: keyof TItem;
1201
+ isMultiple: boolean;
1202
+ virtual?: Omit<VirtualizerOptions, 'parentRef'>;
1203
+ onChange: (value: TItem[]) => void;
1204
+ onItemSelect: (item: TItem) => void;
1205
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
1206
+ offset: number;
1207
+ setOffset: React.Dispatch<React.SetStateAction<number>>;
1186
1208
  };
1209
+ declare const SelectContext: react.Context<SelectContextValue<Record<string, any>, string> | null>;
1210
+ declare const useSelect: () => SelectContextValue<Record<string, any>, string>;
1187
1211
 
1188
- type SwitchSize = 'sm' | 'md' | 'lg';
1212
+ type SwitchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1189
1213
  type SwitchLabelPlacement = 'before' | 'after';
1214
+ type SwitchColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1190
1215
 
1191
- interface Props$k {
1216
+ interface Props$m {
1192
1217
  size?: SwitchSize;
1193
1218
  labelPlacement?: SwitchLabelPlacement;
1194
- colorScheme?: ColorScheme;
1219
+ color?: SwitchColor;
1195
1220
  }
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>>;
1221
+ type NativeAttrs$o = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$m | 'value' | 'defaultValue'>;
1222
+ type SwitchProps = Props$m & NativeAttrs$o;
1223
+ declare const Switch: react.ForwardRefExoticComponent<Props$m & NativeAttrs$o & react.RefAttributes<HTMLInputElement>>;
1199
1224
 
1200
1225
  type TabsVariant = 'underlined' | 'outlined' | 'pills';
1201
1226
  type TabValue = string | number | symbol;
1202
1227
  type TabsAlignment = 'start' | 'center' | 'end' | 'stretch';
1203
1228
 
1204
- interface Props$j<TTabValue extends TabValue = TabValue> {
1229
+ interface Props$l<TTabValue extends TabValue = TabValue> {
1205
1230
  /**
1206
1231
  * The HTML element type or React component to render as the tab.
1207
1232
  */
@@ -1227,11 +1252,11 @@ interface Props$j<TTabValue extends TabValue = TabValue> {
1227
1252
  */
1228
1253
  endContent?: React.ReactNode;
1229
1254
  }
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>>;
1255
+ type NativeAttrs$n = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$l>;
1256
+ type TabProps<TTabValue extends TabValue = TabValue> = Props$l<TTabValue> & NativeAttrs$n;
1257
+ declare const Tab: react.ForwardRefExoticComponent<Props$l<TabValue> & NativeAttrs$n & react.RefAttributes<HTMLDivElement>>;
1233
1258
 
1234
- interface Props$i<TTabValue extends TabValue = TabValue> {
1259
+ interface Props$k<TTabValue extends TabValue = TabValue> {
1235
1260
  /**
1236
1261
  * The currently selected value of the tabs.
1237
1262
  */
@@ -1254,11 +1279,11 @@ interface Props$i<TTabValue extends TabValue = TabValue> {
1254
1279
  */
1255
1280
  onClose?: (value: TTabValue) => void;
1256
1281
  }
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>;
1282
+ type NativeAttrs$m = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$k>;
1283
+ type TabsProps<TTabValue extends TabValue = TabValue> = Props$k<TTabValue> & NativeAttrs$m;
1284
+ declare const Tabs: <TTabValue extends TabValue = TabValue>(props: Props$k<TTabValue> & NativeAttrs$m & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1260
1285
 
1261
- interface Props$h {
1286
+ interface Props$j {
1262
1287
  inputRef?: React.RefObject<HTMLInputElement>;
1263
1288
  variant?: InputVariant;
1264
1289
  color?: InputColor;
@@ -1267,13 +1292,13 @@ interface Props$h {
1267
1292
  endContent?: React.ReactNode;
1268
1293
  css?: BoxCSS;
1269
1294
  }
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>>;
1295
+ type NativeAttrs$l = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$j>;
1296
+ type TextInputProps = Props$j & NativeAttrs$l;
1297
+ declare const TextInput: react.ForwardRefExoticComponent<Props$j & NativeAttrs$l & react.RefAttributes<HTMLInputElement>>;
1273
1298
 
1274
1299
  type ToolbarSize = 'auto' | 'sm' | 'md' | 'lg';
1275
1300
 
1276
- interface Props$g {
1301
+ interface Props$i {
1277
1302
  size?: ToolbarSize;
1278
1303
  title?: React.ReactNode;
1279
1304
  subtitle?: React.ReactNode;
@@ -1295,8 +1320,8 @@ interface Props$g {
1295
1320
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
1296
1321
  };
1297
1322
  }
1298
- type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g>;
1299
- type ToolbarProps = Props$g & NativeAttrs$i;
1323
+ type NativeAttrs$k = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$i>;
1324
+ type ToolbarProps = Props$i & NativeAttrs$k;
1300
1325
  declare const Toolbar: React.FC<ToolbarProps>;
1301
1326
 
1302
1327
  interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
@@ -1309,24 +1334,24 @@ interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
1309
1334
  unmountOnExit?: boolean;
1310
1335
  onExited?: () => void;
1311
1336
  }
1312
- declare const Transition: react.ForwardRefExoticComponent<TransitionProps & react.RefAttributes<HTMLElement>>;
1337
+ declare const Transition: React.FC<TransitionProps>;
1313
1338
 
1314
- interface Props$f {
1339
+ interface Props$h {
1315
1340
  /**
1316
1341
  * The HTML element type or React component to render as the tab.
1317
1342
  */
1318
1343
  as?: React.ElementType;
1319
1344
  width?: number;
1320
1345
  }
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 & {
1346
+ type NativeAttrs$j = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$h>;
1347
+ type SwipeItemProps = Props$h & NativeAttrs$j;
1348
+ declare const SwipeItem: react.ForwardRefExoticComponent<Props$h & NativeAttrs$j & {
1324
1349
  children?: react.ReactNode | undefined;
1325
1350
  } & react.RefAttributes<HTMLDivElement>>;
1326
1351
 
1327
1352
  type SwiperAlignmet = 'start' | 'center' | 'end';
1328
1353
 
1329
- interface Props$e {
1354
+ interface Props$g {
1330
1355
  gap?: number;
1331
1356
  alignment?: SwiperAlignmet;
1332
1357
  autoHide?: boolean;
@@ -1336,8 +1361,8 @@ interface Props$e {
1336
1361
  arrowRightButton?: ButtonProps;
1337
1362
  };
1338
1363
  }
1339
- type NativeAttrs$g = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$e>;
1340
- type SwipeProps = Props$e & NativeAttrs$g;
1364
+ type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g>;
1365
+ type SwipeProps = Props$g & NativeAttrs$i;
1341
1366
  declare const Swipe: React.FC<SwipeProps>;
1342
1367
 
1343
1368
  type ModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
@@ -1349,7 +1374,7 @@ interface ModalClose {
1349
1374
  type ModalScrollBehavior = 'inside' | 'outside';
1350
1375
  type ModalBackdrop = BackdropVariant;
1351
1376
 
1352
- interface Props$d {
1377
+ interface Props$f {
1353
1378
  isOpen: boolean;
1354
1379
  size?: ModalSize;
1355
1380
  backdrop?: ModalBackdrop;
@@ -1364,9 +1389,9 @@ interface Props$d {
1364
1389
  onClose: () => void;
1365
1390
  onAfterClose?: () => void;
1366
1391
  }
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>>;
1392
+ type NativeAttrs$h = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$f>;
1393
+ type ModalProps = Props$f & NativeAttrs$h;
1394
+ declare const Modal: react.ForwardRefExoticComponent<Props$f & NativeAttrs$h & react.RefAttributes<HTMLDivElement>>;
1370
1395
 
1371
1396
  type ModalBodyProps = React.HTMLAttributes<HTMLDivElement>;
1372
1397
  declare const ModalBody: React.FC<ModalBodyProps>;
@@ -1375,27 +1400,28 @@ interface ModalContextValue {
1375
1400
  isOpen: boolean;
1376
1401
  scrollBehavior: ModalScrollBehavior;
1377
1402
  scrollArea: boolean;
1403
+ closable: boolean;
1378
1404
  onClose(): void;
1379
1405
  onAfterClose(): void;
1380
1406
  }
1381
1407
  declare function useModal(): ModalContextValue;
1382
1408
 
1383
- interface Props$c {
1409
+ interface Props$e {
1384
1410
  as?: React.ElementType;
1385
1411
  bordered?: boolean;
1386
1412
  }
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>>;
1413
+ type NativeAttrs$g = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$e>;
1414
+ type ModalFooterProps = Props$e & NativeAttrs$g;
1415
+ declare const ModalFooter: react.ForwardRefExoticComponent<Props$e & NativeAttrs$g & react.RefAttributes<HTMLDivElement>>;
1390
1416
 
1391
- interface Props$b {
1417
+ interface Props$d {
1392
1418
  as?: React.ElementType;
1393
1419
  title?: React.ReactNode;
1394
1420
  subtitle?: React.ReactNode;
1395
1421
  startContent?: React.ReactNode;
1396
1422
  endContent?: React.ReactNode;
1397
1423
  bordered?: boolean;
1398
- close?: ModalClose;
1424
+ close?: ModalClose | boolean;
1399
1425
  slotProps?: {
1400
1426
  startContent?: React.HTMLAttributes<HTMLDivElement>;
1401
1427
  content?: React.HTMLAttributes<HTMLDivElement>;
@@ -1404,27 +1430,28 @@ interface Props$b {
1404
1430
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
1405
1431
  };
1406
1432
  }
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>>;
1433
+ type NativeAttrs$f = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$d>;
1434
+ type ModalHeaderProps = Props$d & NativeAttrs$f;
1435
+ declare const ModalHeader: react.ForwardRefExoticComponent<Props$d & NativeAttrs$f & react.RefAttributes<HTMLDivElement>>;
1410
1436
 
1411
1437
  type CheckboxValue = string | number | symbol;
1412
- type CheckboxSize = 'sm' | 'md' | 'lg';
1438
+ type CheckboxSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1413
1439
  type CheckboxLabelPlacement = 'before' | 'after';
1414
1440
  type CheckboxGroupDirection = 'row' | 'col';
1415
1441
  type CheckboxGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
1442
+ type CheckboxColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1416
1443
 
1417
- interface Props$a<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1444
+ interface Props$c<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1418
1445
  value?: TCheckboxValue;
1419
1446
  size?: CheckboxSize;
1420
1447
  labelPlacement?: CheckboxLabelPlacement;
1421
- colorScheme?: ColorScheme;
1448
+ color?: CheckboxColor;
1422
1449
  }
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>;
1450
+ type NativeAttrs$e = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$c | 'defaultValue'>;
1451
+ type CheckboxProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$c<TCheckboxValue> & NativeAttrs$e;
1452
+ declare const Checkbox: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$c<TCheckboxValue> & NativeAttrs$e & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1426
1453
 
1427
- interface Props$9<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1454
+ interface Props$b<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1428
1455
  value?: TCheckboxValue[];
1429
1456
  defaultValue?: TCheckboxValue[];
1430
1457
  disabled?: boolean;
@@ -1433,12 +1460,12 @@ interface Props$9<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1433
1460
  alignment?: CheckboxGroupAlignment;
1434
1461
  size?: CheckboxSize;
1435
1462
  labelPlacement?: CheckboxLabelPlacement;
1436
- colorScheme?: ColorScheme;
1463
+ color?: CheckboxColor;
1437
1464
  onChange?: (value: TCheckboxValue[]) => void;
1438
1465
  }
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>;
1466
+ type NativeAttrs$d = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$b>;
1467
+ type CheckboxGroupProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$b<TCheckboxValue> & NativeAttrs$d;
1468
+ declare const CheckboxGroup: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$b<TCheckboxValue> & NativeAttrs$d & react.RefAttributes<HTMLTableElement>) => ReturnType<React.FunctionComponent>;
1442
1469
 
1443
1470
  interface CheckboxGroupContextValue<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1444
1471
  value: TCheckboxValue[];
@@ -1447,18 +1474,20 @@ interface CheckboxGroupContextValue<TCheckboxValue extends CheckboxValue = Check
1447
1474
  direction?: CheckboxGroupDirection;
1448
1475
  size: CheckboxSize;
1449
1476
  labelPlacement: CheckboxLabelPlacement;
1450
- colorScheme: ColorScheme;
1477
+ color: CheckboxColor;
1451
1478
  onChange: (value: TCheckboxValue[]) => void;
1452
1479
  }
1480
+ declare const CheckboxGroupContext: react.Context<CheckboxGroupContextValue<CheckboxValue> | null>;
1453
1481
  declare const useCheckboxGroup: () => CheckboxGroupContextValue<CheckboxValue> | null;
1454
1482
 
1455
1483
  type RadioValue = string | number | symbol;
1456
- type RadioSize = 'sm' | 'md' | 'lg';
1484
+ type RadioSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1457
1485
  type RadioLabelPlacement = 'before' | 'after';
1458
1486
  type RadioGroupDirection = 'row' | 'col';
1459
1487
  type RadioGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
1488
+ type RadioColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1460
1489
 
1461
- interface Props$8<TRadioValue extends RadioValue = RadioValue> {
1490
+ interface Props$a<TRadioValue extends RadioValue = RadioValue> {
1462
1491
  value?: TRadioValue;
1463
1492
  disabled?: boolean;
1464
1493
  readOnly?: boolean;
@@ -1466,11 +1495,11 @@ interface Props$8<TRadioValue extends RadioValue = RadioValue> {
1466
1495
  labelPlacement?: RadioLabelPlacement;
1467
1496
  colorScheme?: ColorScheme;
1468
1497
  }
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>;
1498
+ type NativeAttrs$c = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$a | 'defaultValue' | 'checked' | 'defaultChecked' | 'onChange'>;
1499
+ type RadioProps<TRadioValue extends RadioValue = RadioValue> = Props$a<TRadioValue> & NativeAttrs$c;
1500
+ declare const Radio: <TRadioValue extends RadioValue = RadioValue>(props: Props$a<TRadioValue> & NativeAttrs$c & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1472
1501
 
1473
- interface Props$7<TRadioValue extends RadioValue = RadioValue> {
1502
+ interface Props$9<TRadioValue extends RadioValue = RadioValue> {
1474
1503
  name?: string;
1475
1504
  value?: TRadioValue;
1476
1505
  defaultValue?: TRadioValue;
@@ -1480,12 +1509,12 @@ interface Props$7<TRadioValue extends RadioValue = RadioValue> {
1480
1509
  alignment?: RadioGroupAlignment;
1481
1510
  size?: RadioSize;
1482
1511
  labelPlacement?: RadioLabelPlacement;
1483
- colorScheme?: ColorScheme;
1512
+ color?: RadioColor;
1484
1513
  onChange?: (value: TRadioValue) => void;
1485
1514
  }
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>;
1515
+ type NativeAttrs$b = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9>;
1516
+ type RadioGroupProps<TRadioValue extends RadioValue = RadioValue> = Props$9<TRadioValue> & NativeAttrs$b;
1517
+ declare const RadioGroup: <TRadioValue extends RadioValue = RadioValue>(props: Props$9<TRadioValue> & NativeAttrs$b & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1489
1518
 
1490
1519
  interface RadioGroupContextValue {
1491
1520
  name: string;
@@ -1495,34 +1524,35 @@ interface RadioGroupContextValue {
1495
1524
  direction: RadioGroupDirection;
1496
1525
  size: RadioSize;
1497
1526
  labelPlacement: RadioLabelPlacement;
1498
- colorScheme: ColorScheme;
1527
+ color: RadioColor;
1499
1528
  onChange: (value: RadioValue) => void;
1500
1529
  }
1530
+ declare const RadioGroupContext: react.Context<RadioGroupContextValue | null>;
1501
1531
  declare const useRadioGroup: () => RadioGroupContextValue;
1502
1532
 
1503
1533
  type NavRailPlacement = 'left' | 'right';
1504
1534
 
1505
- interface Props$6 {
1535
+ interface Props$8 {
1506
1536
  startContent?: React.ReactNode;
1507
1537
  endContent?: React.ReactNode;
1508
1538
  placement?: NavRailPlacement;
1509
1539
  }
1510
- type NativeAttrs$8 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
1511
- type NavRailProps = Props$6 & NativeAttrs$8;
1540
+ type NativeAttrs$a = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$8>;
1541
+ type NavRailProps = Props$8 & NativeAttrs$a;
1512
1542
  declare const NavRail: React.FC<NavRailProps>;
1513
1543
 
1514
- interface Props$5 {
1544
+ interface Props$7 {
1515
1545
  as?: React.ElementType;
1516
1546
  icon?: React.ReactNode;
1517
1547
  media?: React.ReactNode;
1518
1548
  label?: React.ReactNode;
1519
1549
  selected?: boolean;
1520
1550
  }
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>>;
1551
+ type NativeAttrs$9 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7>;
1552
+ type NavRailItemProps = Props$7 & NativeAttrs$9;
1553
+ declare const NavRailItem: react.ForwardRefExoticComponent<Props$7 & NativeAttrs$9 & react.RefAttributes<HTMLDivElement>>;
1524
1554
 
1525
- type Props$4 = {
1555
+ type Props$6 = {
1526
1556
  as?: React.ElementType;
1527
1557
  label: React.ReactNode;
1528
1558
  span?: Responsive<number>;
@@ -1538,20 +1568,22 @@ type Props$4 = {
1538
1568
  mq: ContainerMediaQuery;
1539
1569
  }) => React.ReactNode;
1540
1570
  } & FormatOptions;
1541
- type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4 | 'children'>;
1542
- type DescriptionProps = Props$4 & NativeAttrs$6;
1571
+ type NativeAttrs$8 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6 | 'children'>;
1572
+ type DescriptionProps = Props$6 & NativeAttrs$8;
1543
1573
  declare const Description: react.ForwardRefExoticComponent<DescriptionProps & react.RefAttributes<HTMLDivElement>>;
1544
1574
 
1545
- type NativeAttrs$5 = React.HTMLAttributes<HTMLDivElement>;
1546
- type DescriptionEmptyProps = NativeAttrs$5;
1547
- declare const DescriptionEmpty: react.ForwardRefExoticComponent<NativeAttrs$5 & react.RefAttributes<HTMLDivElement>>;
1575
+ type NativeAttrs$7 = React.HTMLAttributes<HTMLDivElement>;
1576
+ type DescriptionEmptyProps = NativeAttrs$7;
1577
+ declare const DescriptionEmpty: react.ForwardRefExoticComponent<NativeAttrs$7 & react.RefAttributes<HTMLDivElement>>;
1548
1578
 
1549
1579
  type DescriptionsLayout = 'row' | 'col';
1550
1580
  type DescriptionsSize = 'sm' | 'md' | 'lg';
1551
1581
  type DescriptionsAlign = React.CSSProperties['textAlign'];
1582
+ type DescriptionsMode = 'container' | 'screen' | 'css';
1552
1583
 
1553
- interface Props$3 {
1584
+ interface Props$5 {
1554
1585
  as?: React.ElementType;
1586
+ mode?: DescriptionsMode;
1555
1587
  items?: DescriptionProps[];
1556
1588
  layout?: Responsive<DescriptionsLayout>;
1557
1589
  size?: Responsive<DescriptionsSize>;
@@ -1560,9 +1592,9 @@ interface Props$3 {
1560
1592
  labelAlign?: Responsive<DescriptionsAlign>;
1561
1593
  contentAlign?: Responsive<DescriptionsAlign>;
1562
1594
  }
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>>;
1595
+ type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5 | 'children'>;
1596
+ type DescriptionsProps = Props$5 & NativeAttrs$6;
1597
+ declare const Descriptions: react.ForwardRefExoticComponent<Props$5 & NativeAttrs$6 & react.RefAttributes<HTMLDivElement>>;
1566
1598
 
1567
1599
  interface DescriptionsContextValue {
1568
1600
  mq: ContainerMediaQuery;
@@ -1575,9 +1607,9 @@ interface DescriptionsContextValue {
1575
1607
  declare const DescriptionsContext: react.Context<DescriptionsContextValue | null>;
1576
1608
  declare const useDescriptionsContext: () => DescriptionsContextValue;
1577
1609
 
1578
- type NativeAttrs$3 = React.HTMLAttributes<HTMLDivElement>;
1579
- type DescriptionTextProps = NativeAttrs$3;
1580
- declare const DescriptionText: react.ForwardRefExoticComponent<NativeAttrs$3 & react.RefAttributes<HTMLDivElement>>;
1610
+ type NativeAttrs$5 = React.HTMLAttributes<HTMLDivElement>;
1611
+ type DescriptionTextProps = NativeAttrs$5;
1612
+ declare const DescriptionText: react.ForwardRefExoticComponent<NativeAttrs$5 & react.RefAttributes<HTMLDivElement>>;
1581
1613
 
1582
1614
  declare function reactNodeToText(node: React.ReactNode): string;
1583
1615
 
@@ -1597,14 +1629,14 @@ interface ResponsiveProps$2 {
1597
1629
  justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1598
1630
  alignItems?: Responsive<React.CSSProperties['alignItems']>;
1599
1631
  }
1600
- type Props$2 = {
1632
+ type Props$4 = {
1601
1633
  as?: React.ElementType;
1602
1634
  } & ResponsiveProps$2;
1603
- type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2>;
1604
- type GridItemProps = Props$2 & NativeAttrs$2;
1635
+ type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
1636
+ type GridItemProps = Props$4 & NativeAttrs$4;
1605
1637
  declare const GridItem: react.ForwardRefExoticComponent<{
1606
1638
  as?: React.ElementType;
1607
- } & ResponsiveProps$2 & NativeAttrs$2 & react.RefAttributes<HTMLDivElement>>;
1639
+ } & ResponsiveProps$2 & NativeAttrs$4 & react.RefAttributes<HTMLDivElement>>;
1608
1640
 
1609
1641
  interface ResponsiveProps$1 {
1610
1642
  cols?: Responsive<number>;
@@ -1622,14 +1654,16 @@ interface ResponsiveProps$1 {
1622
1654
  justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1623
1655
  alignItems?: Responsive<React.CSSProperties['alignItems']>;
1624
1656
  }
1625
- type Props$1 = {
1657
+ type Props$3 = {
1626
1658
  items?: GridItemProps[];
1627
1659
  } & ResponsiveProps$1;
1628
- type NativeAttrs$1 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$1>;
1629
- type GridSubProps = Props$1 & NativeAttrs$1;
1660
+ type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3>;
1661
+ type GridSubProps = Props$3 & NativeAttrs$3;
1630
1662
  declare const GridSub: react.ForwardRefExoticComponent<{
1631
1663
  items?: GridItemProps[];
1632
- } & ResponsiveProps$1 & NativeAttrs$1 & react.RefAttributes<HTMLDivElement>>;
1664
+ } & ResponsiveProps$1 & NativeAttrs$3 & react.RefAttributes<HTMLDivElement>>;
1665
+
1666
+ type GridMode = 'container' | 'screen' | 'css';
1633
1667
 
1634
1668
  interface ResponsiveProps {
1635
1669
  cols?: Responsive<number>;
@@ -1646,14 +1680,16 @@ interface ResponsiveProps {
1646
1680
  justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1647
1681
  alignItems?: Responsive<React.CSSProperties['alignItems']>;
1648
1682
  }
1649
- type Props = {
1683
+ type Props$2 = {
1684
+ mode?: GridMode;
1650
1685
  items?: (GridItemProps | GridSubProps)[];
1651
1686
  } & ResponsiveProps;
1652
- type NativeAttrs = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props>;
1653
- type GridProps = Props & NativeAttrs;
1687
+ type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2>;
1688
+ type GridProps = Props$2 & NativeAttrs$2;
1654
1689
  declare const Grid: react.ForwardRefExoticComponent<{
1690
+ mode?: GridMode;
1655
1691
  items?: (GridItemProps | GridSubProps)[];
1656
- } & ResponsiveProps & NativeAttrs & react.RefAttributes<HTMLDivElement>>;
1692
+ } & ResponsiveProps & NativeAttrs$2 & react.RefAttributes<HTMLDivElement>>;
1657
1693
 
1658
1694
  interface GridContextValue {
1659
1695
  mq: ContainerMediaQuery;
@@ -1661,6 +1697,57 @@ interface GridContextValue {
1661
1697
  declare const GridContext: react.Context<GridContextValue | null>;
1662
1698
  declare const useGridContext: () => GridContextValue;
1663
1699
 
1700
+ interface IframeProps extends React.IframeHTMLAttributes<HTMLIFrameElement> {
1701
+ anchorTarget?: React.HTMLAttributeAnchorTarget;
1702
+ anchorPreventDefault?: boolean;
1703
+ }
1704
+ declare const Iframe: React.FC<IframeProps>;
1705
+
1706
+ interface HtmlProps extends IframeProps {
1707
+ }
1708
+ declare const Html: React.FC<HtmlProps>;
1709
+
1710
+ type StepColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
1711
+
1712
+ interface Props$1 {
1713
+ value?: string | number | symbol;
1714
+ title: React.ReactNode;
1715
+ subtitle: React.ReactNode;
1716
+ icon?: React.ReactNode;
1717
+ color?: StepColor;
1718
+ disabled?: boolean;
1719
+ }
1720
+ type NativeAttrs$1 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$1>;
1721
+ type StepProps = Props$1 & NativeAttrs$1;
1722
+ declare const Step: React.FC<StepProps>;
1723
+
1724
+ interface Props {
1725
+ direction?: 'horizontal' | 'vertical';
1726
+ value?: number | string | symbol;
1727
+ color?: StepColor;
1728
+ markPreviousAsChecked?: boolean;
1729
+ }
1730
+ type NativeAttrs = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props>;
1731
+ type StepsProps = Props & NativeAttrs;
1732
+ declare const Steps: React.FC<StepsProps>;
1733
+
1734
+ interface StepsContextValue {
1735
+ direction: 'horizontal' | 'vertical';
1736
+ value?: number | string | symbol;
1737
+ color: StepColor;
1738
+ markPreviousAsChecked: boolean;
1739
+ items: {
1740
+ value: any;
1741
+ disabled?: boolean;
1742
+ }[];
1743
+ registerItem: (item: {
1744
+ value: any;
1745
+ disabled?: boolean;
1746
+ }) => void;
1747
+ }
1748
+ declare const StepsContext: react.Context<StepsContextValue | null>;
1749
+ declare const useStepsContext: () => StepsContextValue;
1750
+
1664
1751
  declare const scrollToItem: (parentElement: Element, currentElement: Element) => void;
1665
1752
 
1666
1753
  type ClassDictionary = Record<string, any>;
@@ -1679,5 +1766,9 @@ declare function formatShortDateTime(value: Date | string | number, locales?: In
1679
1766
  declare function formatTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1680
1767
  declare function formatCurrency(value: number | bigint | Intl.StringNumericLiteral, currency?: string, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
1681
1768
  declare function formatPercent(value: any, decimals?: number, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
1769
+ declare function format(options: FormatOptions): string | undefined;
1770
+
1771
+ 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][];
1772
+ declare const valuesToValue: <TItem extends Record<string, any>, TKeyField extends keyof TItem>(values: TItem[TKeyField][]) => TItem[TKeyField] | null;
1682
1773
 
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 };
1774
+ 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, 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, 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, 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, useStepsContext, useValueEffect, useVirtualizer, valueToValues, valuesToValue };