@unifiedsoftware/react-ui 2.0.0-alpha.8 → 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 +386 -290
  2. package/dist/index.js +1 -1
  3. package/package.json +2 -1
package/dist/index.d.ts CHANGED
@@ -3,21 +3,39 @@ import react__default, { Dispatch, SetStateAction } from 'react';
3
3
  import * as react_jsx_runtime from 'react/jsx-runtime';
4
4
  import { VirtualizerOptions as VirtualizerOptions$1, Virtualizer as Virtualizer$1, ListItemProps as ListItemProps$1, ResultProps as ResultProps$1 } from '@unifiedsoftware/react-ui';
5
5
 
6
- interface Props$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
+
12
+ type BoxShadow = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
13
+ type BorderRadius = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
14
+ type TransitionDuration = 0 | 100 | 200 | 300;
15
+ type TransitionProperty = 'none' | 'all' | 'shadow';
16
+ type BoxState = 'base' | 'hover' | 'active';
17
+ type BoxProperties = {
18
+ shadow?: BoxShadow;
19
+ rounded?: BorderRadius;
20
+ transitionProperty?: TransitionProperty;
21
+ transitionDuration?: TransitionDuration;
22
+ };
23
+ type BoxApplyState<T> = T | {
24
+ [K in BoxState]?: T;
25
+ };
26
+ type BoxCSS = {
27
+ [K in keyof BoxProperties]: BoxApplyState<BoxProperties[K]>;
28
+ };
11
29
 
12
30
  type AccordionSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
13
31
  type AccordionVariant = 'plain' | 'flat' | 'tonal' | 'filled';
14
- type AccordionColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'inherit';
32
+ type AccordionColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
15
33
  interface AccordionArrow {
16
34
  isVisible?: boolean;
17
35
  position?: 'start' | 'end';
18
36
  }
19
37
 
20
- interface Props$I {
38
+ interface Props$K {
21
39
  value?: any[];
22
40
  defaultValue?: any[];
23
41
  expandMode?: 'single' | 'multiple';
@@ -27,15 +45,16 @@ interface Props$I {
27
45
  color?: AccordionColor;
28
46
  splitted?: boolean;
29
47
  bordered?: boolean;
30
- shadow?: boolean;
48
+ centered?: boolean;
49
+ css?: BoxCSS;
31
50
  indicator?: ({ isOpen }: {
32
51
  isOpen: boolean;
33
52
  }) => React.ReactNode;
34
53
  onChange?: (value: any[]) => void;
35
54
  }
36
- type NativeAttrs$K = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$I>;
37
- type AccordionProps = Props$I & NativeAttrs$K;
38
- 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>>;
39
58
 
40
59
  interface AccordionItemContextValue {
41
60
  value: string;
@@ -44,7 +63,7 @@ interface AccordionItemContextValue {
44
63
  }) => React.ReactNode;
45
64
  }
46
65
  declare const useAccordionItem: () => AccordionItemContextValue;
47
- interface Props$H {
66
+ interface Props$J {
48
67
  value?: any;
49
68
  variant?: AccordionVariant;
50
69
  color?: AccordionColor;
@@ -52,17 +71,18 @@ interface Props$H {
52
71
  isOpen: boolean;
53
72
  }) => React.ReactNode;
54
73
  }
55
- type NativeAttrs$J = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$H>;
56
- type AccordionItemProps = Props$H & NativeAttrs$J;
57
- 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>>;
58
77
 
59
- interface Props$G {
78
+ interface Props$I {
60
79
  as?: React.ElementType;
61
80
  title?: React.ReactNode;
62
81
  subtitle?: React.ReactNode;
63
82
  startContent?: React.ReactNode;
64
83
  endContent?: React.ReactNode;
65
84
  bordered?: boolean;
85
+ centered?: boolean;
66
86
  collapsible?: boolean;
67
87
  arrow?: AccordionArrow;
68
88
  slotProps?: {
@@ -73,9 +93,9 @@ interface Props$G {
73
93
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
74
94
  };
75
95
  }
76
- type NativeAttrs$I = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$G>;
77
- type AccordionHeaderProps = Props$G & NativeAttrs$I;
78
- 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>>;
79
99
 
80
100
  type AccordionBodyProps = React.HTMLAttributes<HTMLDivElement>;
81
101
  declare const AccordionBody: react.ForwardRefExoticComponent<AccordionBodyProps & react.RefAttributes<HTMLDivElement>>;
@@ -94,6 +114,9 @@ interface AccordionContextValue {
94
114
  arrow: AccordionArrow;
95
115
  variant: AccordionVariant;
96
116
  color: AccordionColor;
117
+ splitted?: boolean;
118
+ centered?: boolean;
119
+ css?: BoxCSS;
97
120
  indicator?: ({ isOpen }: {
98
121
  isOpen: boolean;
99
122
  }) => React.ReactNode;
@@ -416,17 +439,62 @@ interface FormatPercentOptions {
416
439
  }
417
440
  type FormatOptions = FormatStringOptions | FormatNumberOptions | FormatDateOptions | FormatBooleanOptions | FormatCurrencyOptions | FormatPercentOptions;
418
441
 
419
- 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
+ }
420
488
 
421
489
  type InputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
422
- type InputColor = 'light' | 'dark' | 'inherit';
490
+ type InputColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
423
491
  type InputVariant = 'filled' | 'outlined' | 'flat' | 'text';
424
492
 
425
- interface Props$F {
493
+ interface Props$H {
426
494
  }
427
- type NativeAttrs$H = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$F>;
428
- type InputGroupProps = Props$F & NativeAttrs$H;
429
- 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>>;
430
498
 
431
499
  type ListSize = 'sm' | 'md' | 'lg';
432
500
 
@@ -436,7 +504,7 @@ interface ListProps extends React.HTMLAttributes<HTMLDivElement> {
436
504
  }
437
505
  declare const List: react.ForwardRefExoticComponent<ListProps & react.RefAttributes<HTMLDivElement>>;
438
506
 
439
- interface Props$E {
507
+ interface Props$G {
440
508
  as?: react__default.ElementType;
441
509
  title?: react__default.ReactNode;
442
510
  subtitle?: react__default.ReactNode;
@@ -454,11 +522,11 @@ interface Props$E {
454
522
  subtitle?: react__default.HTMLAttributes<HTMLDivElement>;
455
523
  };
456
524
  }
457
- type NativeAttrs$G = Omit<react__default.HTMLAttributes<HTMLDivElement>, keyof Props$E>;
458
- type ListItemProps = Props$E & NativeAttrs$G;
459
- 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>>;
460
528
 
461
- interface Props$D {
529
+ interface Props$F {
462
530
  expandVisible?: boolean;
463
531
  expandPosition?: 'start' | 'end';
464
532
  isOpen?: boolean;
@@ -466,9 +534,9 @@ interface Props$D {
466
534
  onClose?: () => void;
467
535
  onToggle?: () => void;
468
536
  }
469
- type NativeAttrs$F = Omit<ListItemProps, keyof Props$D>;
470
- type ListGroupProps = Props$D & NativeAttrs$F;
471
- 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>>;
472
540
 
473
541
  interface ListSubheaderProps extends React.HTMLAttributes<HTMLDivElement> {
474
542
  as?: React.ElementType;
@@ -496,30 +564,16 @@ interface ResultProps extends React.HTMLAttributes<HTMLDivElement> {
496
564
  }
497
565
  declare const Result: React.FC<ResultProps>;
498
566
 
499
- type AutocompleteItem = Record<string, any>;
500
- type AutocompleteKeyField<TAutocompleteItem> = keyof TAutocompleteItem;
501
- interface AutocompleteSingleProps<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> {
502
- isMultiple?: false;
503
- value: TAutocompleteItem[TAutocompleteKeyField] | null;
504
- onChange?: (value: TAutocompleteItem | null) => void;
505
- onValueChange?: (value: TAutocompleteItem[TAutocompleteKeyField] | null) => void;
506
- }
507
- interface AutocompleteMultipleProps<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> {
508
- isMultiple: true;
509
- value: TAutocompleteItem[TAutocompleteKeyField][];
510
- onChange?: (value: TAutocompleteItem[]) => void;
511
- onValueChange?: (value: TAutocompleteItem[TAutocompleteKeyField][]) => void;
512
- }
513
- type NativeAttrs$E<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$C<TAutocompleteItem, TAutocompleteKeyField>>;
514
- type Props$C<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> = {
515
- data: TAutocompleteItem[];
516
- keyField?: TAutocompleteKeyField;
517
- 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;
518
572
  placeholder?: string;
519
573
  filter?: string;
520
574
  loading?: boolean;
521
575
  disabled?: boolean;
522
- clearable?: boolean;
576
+ readOnly?: boolean;
523
577
  disclosure?: Disclosure;
524
578
  virtual?: Omit<VirtualizerOptions, 'parentRef'>;
525
579
  color?: InputColor;
@@ -527,19 +581,36 @@ type Props$C<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField e
527
581
  size?: InputSize;
528
582
  startContent?: React.ReactNode;
529
583
  endContent?: React.ReactNode;
530
- onItemSelect?: (item: TAutocompleteItem) => void;
584
+ onItemSelect?: (item: TItem) => void;
531
585
  onFilterChange?: (value: string) => void;
532
- renderItem?: (item: TAutocompleteItem, props: ListItemProps) => React.ReactNode;
586
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
533
587
  renderNoData?: (props: ResultProps) => React.ReactNode;
534
- } & (AutocompleteSingleProps<TAutocompleteItem, TAutocompleteKeyField> | AutocompleteMultipleProps<TAutocompleteItem, TAutocompleteKeyField>);
535
- 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>;
591
+
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;
536
593
 
537
- declare const Autocomplete: <TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = "key">(props: AutocompleteProps<TAutocompleteItem, TAutocompleteKeyField>) => react_jsx_runtime.JSX.Element;
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>;
538
609
 
539
610
  type BackdropPlacement = 'top' | 'left' | 'center' | 'right' | 'bottom';
540
611
  type BackdropVariant = 'opaque' | 'blur' | 'transparent';
541
612
 
542
- interface Props$B {
613
+ interface Props$D {
543
614
  isOpen: boolean;
544
615
  closable?: boolean;
545
616
  placement?: BackdropPlacement;
@@ -548,14 +619,14 @@ interface Props$B {
548
619
  scrollArea?: boolean;
549
620
  onClose(): void;
550
621
  }
551
- type NativeAttrs$D = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$B>;
552
- type BackdropProps = Props$B & NativeAttrs$D;
553
- 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>>;
554
625
 
555
626
  type BadgeColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
556
627
  type BadgePlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
557
628
 
558
- interface Props$A {
629
+ interface Props$C {
559
630
  /**
560
631
  * The placement of the badge relative to its content.
561
632
  */
@@ -573,8 +644,8 @@ interface Props$A {
573
644
  wrapper?: React.HTMLAttributes<HTMLDivElement>;
574
645
  };
575
646
  }
576
- type NativeAttrs$C = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$A>;
577
- type BadgeProps = Props$A & NativeAttrs$C;
647
+ type NativeAttrs$E = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$C>;
648
+ type BadgeProps = Props$C & NativeAttrs$E;
578
649
  declare const Badge: React.FC<BadgeProps>;
579
650
 
580
651
  type DataListItem = Record<string, any>;
@@ -591,7 +662,7 @@ interface DataListMultipleProps<TDataListItem extends DataListItem, TDataListKey
591
662
  onChange?: (value: TDataListItem[]) => void;
592
663
  onValueChange?: (value: TDataListItem[TDataListKeyField][]) => void;
593
664
  }
594
- type Props$z<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
665
+ type Props$B<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
595
666
  data: TDataListItem[];
596
667
  keyField?: TDataListKeyField;
597
668
  textField?: keyof DataListItem;
@@ -606,17 +677,17 @@ type Props$z<TDataListItem extends DataListItem, TDataListKeyField extends DataL
606
677
  renderItem?: (item: TDataListItem, props: ListItemProps$1) => React.ReactNode;
607
678
  renderNoData?: (props: ResultProps$1) => React.ReactNode;
608
679
  } & (DataListSingleProps<TDataListItem, TDataListKeyField> | DataListMultipleProps<TDataListItem, TDataListKeyField>);
609
- type NativeAttrs$B<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$z<TDataListItem, TDataListKeyField>>;
610
- 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>;
611
682
 
612
683
  declare const DataList: <TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = "key">(props: DataListProps<TDataListItem, TDataListKeyField>) => react_jsx_runtime.JSX.Element;
613
684
 
614
- type ButtonVariant = 'filled' | 'outlined' | 'flat' | 'text';
615
- 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';
616
687
  type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
617
688
  type ButtonGroupDirection = 'row' | 'col';
618
689
 
619
- interface Props$y {
690
+ interface Props$A {
620
691
  /**
621
692
  * The HTML element type or React component to render as the button.
622
693
  */
@@ -661,20 +732,20 @@ interface Props$y {
661
732
  fontStyle?: React.CSSProperties['fontStyle'];
662
733
  };
663
734
  }
664
- type NativeAttrs$A = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$y>;
665
- type ButtonProps = Props$y & NativeAttrs$A;
666
- 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>>;
667
738
 
668
- interface Props$x {
739
+ interface Props$z {
669
740
  direction?: ButtonGroupDirection;
670
741
  variant?: ButtonVariant;
671
742
  color?: ButtonColor;
672
743
  size?: ButtonSize;
673
744
  disabled?: boolean;
674
745
  }
675
- type NativeAttrs$z = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$x>;
676
- type ButtonGroupProps = Props$x & NativeAttrs$z;
677
- 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>>;
678
749
 
679
750
  interface ButtonGroupContextValue {
680
751
  direction: ButtonGroupDirection;
@@ -686,27 +757,9 @@ interface ButtonGroupContextValue {
686
757
  declare const ButtonGroupContext: react.Context<ButtonGroupContextValue | null>;
687
758
  declare const useButtonGroup: () => ButtonGroupContextValue | null;
688
759
 
689
- type BoxShadow = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
690
- type BorderRadius = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
691
- type TransitionDuration = 0 | 100 | 200 | 300;
692
- type TransitionProperty = 'none' | 'all' | 'shadow';
693
- type BoxState = 'base' | 'hover' | 'active';
694
- type BoxProperties = {
695
- shadow?: BoxShadow;
696
- rounded?: BorderRadius;
697
- transitionProperty?: TransitionProperty;
698
- transitionDuration?: TransitionDuration;
699
- };
700
- type BoxApplyState<T> = T | {
701
- [K in BoxState]?: T;
702
- };
703
- type BoxCSS = {
704
- [K in keyof BoxProperties]: BoxApplyState<BoxProperties[K]>;
705
- };
706
-
707
760
  type CardSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
708
761
 
709
- interface Props$w {
762
+ interface Props$y {
710
763
  as?: React.ElementType;
711
764
  size?: CardSize;
712
765
  hoverable?: boolean;
@@ -716,14 +769,14 @@ interface Props$w {
716
769
  divider?: boolean;
717
770
  css?: BoxCSS;
718
771
  }
719
- type NativeAttrs$y = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$w>;
720
- type CardProps = Props$w & NativeAttrs$y;
721
- 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>>;
722
775
 
723
776
  type CardBodyProps = React.HTMLAttributes<HTMLDivElement>;
724
777
  declare const CardBody: react.ForwardRefExoticComponent<CardBodyProps & react.RefAttributes<HTMLDivElement>>;
725
778
 
726
- interface Props$v {
779
+ interface Props$x {
727
780
  as?: React.ElementType;
728
781
  title?: React.ReactNode;
729
782
  subtitle?: React.ReactNode;
@@ -733,6 +786,9 @@ interface Props$v {
733
786
  * @deprecated Use `underlined` instead
734
787
  */
735
788
  bordered?: boolean;
789
+ /**
790
+ * @deprecated Use `divider` in instead in Card
791
+ */
736
792
  underlined?: boolean;
737
793
  centered?: boolean;
738
794
  slotProps?: {
@@ -746,11 +802,11 @@ interface Props$v {
746
802
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
747
803
  };
748
804
  }
749
- type NativeAttrs$x = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$v>;
750
- type CardHeaderProps = Props$v & NativeAttrs$x;
751
- 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>>;
752
808
 
753
- interface Props$u {
809
+ interface Props$w {
754
810
  as?: React.ElementType;
755
811
  /**
756
812
  * @deprecated Use `underlined` instead
@@ -758,9 +814,9 @@ interface Props$u {
758
814
  bordered?: boolean;
759
815
  underlined?: boolean;
760
816
  }
761
- type NativeAttrs$w = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$u>;
762
- type CardFooterProps = Props$u & NativeAttrs$w;
763
- 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>>;
764
820
 
765
821
  type CardMediaProps = React.HTMLAttributes<HTMLDivElement> & {
766
822
  topLeftContent?: React.ReactNode;
@@ -771,28 +827,28 @@ declare const CardMedia: react.ForwardRefExoticComponent<react.HTMLAttributes<HT
771
827
  topRightContent?: React.ReactNode;
772
828
  } & react.RefAttributes<HTMLDivElement>>;
773
829
 
774
- interface Props$t {
830
+ interface Props$v {
775
831
  as?: React.ElementType;
776
832
  centered?: boolean;
777
833
  css?: BoxCSS;
778
834
  }
779
- type NativeAttrs$v = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$t>;
780
- type CardTitleProps = Props$t & NativeAttrs$v;
781
- 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>>;
782
838
 
783
- interface Props$s {
839
+ interface Props$u {
784
840
  as?: React.ElementType;
785
841
  css?: BoxCSS;
786
842
  }
787
- type NativeAttrs$u = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$s>;
788
- type CardSubtitleProps = Props$s & NativeAttrs$u;
789
- 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>>;
790
846
 
791
- type ChipVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain';
847
+ type ChipVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain' | 'bordered';
792
848
  type ChipColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
793
849
  type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
794
850
 
795
- interface Props$r {
851
+ interface Props$t {
796
852
  /**
797
853
  * The HTML element type or React component to render as the chip.
798
854
  */
@@ -830,9 +886,9 @@ interface Props$r {
830
886
  };
831
887
  onClose?: () => void;
832
888
  }
833
- type NativeAttrs$t = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$r>;
834
- type ChipProps = Props$r & NativeAttrs$t;
835
- 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>>;
836
892
 
837
893
  interface CollapseProps {
838
894
  children: React.ReactNode;
@@ -876,7 +932,7 @@ interface DrawerClose {
876
932
  }
877
933
  type DrawerBackdrop = BackdropVariant;
878
934
 
879
- interface Props$q {
935
+ interface Props$s {
880
936
  isOpen: boolean;
881
937
  size?: DrawerSize;
882
938
  backdrop?: DrawerBackdrop;
@@ -893,11 +949,11 @@ interface Props$q {
893
949
  onClose: () => void;
894
950
  onAfterClose?: () => void;
895
951
  }
896
- type NativeAttrs$s = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$q>;
897
- type DrawerProps = Props$q & NativeAttrs$s;
898
- 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>>;
899
955
 
900
- interface Props$p {
956
+ interface Props$r {
901
957
  as?: React.ElementType;
902
958
  title?: React.ReactNode;
903
959
  subtitle?: React.ReactNode;
@@ -913,20 +969,20 @@ interface Props$p {
913
969
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
914
970
  };
915
971
  }
916
- type NativeAttrs$r = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$p>;
917
- type DrawerHeaderProps = Props$p & NativeAttrs$r;
918
- 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>>;
919
975
 
920
976
  type DrawerBodyProps = React.HTMLAttributes<HTMLDivElement>;
921
977
  declare const DrawerBody: react.ForwardRefExoticComponent<DrawerBodyProps & react.RefAttributes<HTMLDivElement>>;
922
978
 
923
- interface Props$o {
979
+ interface Props$q {
924
980
  as?: React.ElementType;
925
981
  bordered?: boolean;
926
982
  }
927
- type NativeAttrs$q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$o>;
928
- type DrawerFooterProps = Props$o & NativeAttrs$q;
929
- 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>>;
930
986
 
931
987
  interface DrawerContextValue {
932
988
  isOpen: boolean;
@@ -950,7 +1006,7 @@ interface IconProps {
950
1006
  }
951
1007
  declare const Icon: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<unknown>>;
952
1008
 
953
- interface Props$n {
1009
+ interface Props$p {
954
1010
  /**
955
1011
  * The HTML element type or React component to render as the menu item.
956
1012
  */
@@ -976,9 +1032,9 @@ interface Props$n {
976
1032
  */
977
1033
  disabled?: boolean;
978
1034
  }
979
- type NativeAttrs$p = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$n | 'items'>;
980
- type MenuItemProps = Props$n & NativeAttrs$p;
981
- 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>>;
982
1038
 
983
1039
  type MenuSubmenuProps = Omit<MenuItemProps, 'items'> & {
984
1040
  items?: MenuItemType[];
@@ -1002,7 +1058,7 @@ type MenuItemType = (MenuGroupProps & {
1002
1058
  }) | (MenuItemProps & {
1003
1059
  type?: 'item';
1004
1060
  });
1005
- interface Props$m {
1061
+ interface Props$o {
1006
1062
  /**
1007
1063
  * The currently selected value of the menu.
1008
1064
  */
@@ -1038,8 +1094,8 @@ interface Props$m {
1038
1094
  */
1039
1095
  onItemSelect?: (props: MenuItemProps) => void;
1040
1096
  }
1041
- type NativeAttrs$o = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$m | 'items'>;
1042
- 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 & {
1043
1099
  items?: MenuItemType[];
1044
1100
  };
1045
1101
  declare const Menu: React.FC<MenuProps>;
@@ -1112,29 +1168,15 @@ interface ScrollAreaProps {
1112
1168
  }
1113
1169
  declare const ScrollArea: react.ForwardRefExoticComponent<ScrollAreaProps & react.RefAttributes<HTMLDivElement>>;
1114
1170
 
1115
- type SelectItem = Record<string, any>;
1116
- type SelectKeyField<TSelectItem> = keyof TSelectItem;
1117
- interface SelectSingleProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> {
1118
- isMultiple?: false;
1119
- value: TSelectItem[TSelectKeyField] | null;
1120
- onChange?: (value: TSelectItem | null) => void;
1121
- onValueChange?: (value: TSelectItem[TSelectKeyField] | null) => void;
1122
- }
1123
- interface SelectMultipleProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> {
1124
- isMultiple: true;
1125
- value: TSelectItem[TSelectKeyField][];
1126
- onChange?: (value: TSelectItem[]) => void;
1127
- onValueChange?: (value: TSelectItem[TSelectKeyField][]) => void;
1128
- }
1129
- type NativeAttrs$n<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$l<TSelectItem, TSelectKeyField>>;
1130
- type Props$l<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = {
1131
- data: TSelectItem[];
1132
- keyField?: TSelectKeyField;
1133
- 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;
1134
1176
  placeholder?: string;
1135
1177
  loading?: boolean;
1136
- clearable?: boolean;
1137
1178
  disabled?: boolean;
1179
+ readOnly?: boolean;
1138
1180
  disclosure?: Disclosure;
1139
1181
  virtual?: Omit<VirtualizerOptions, 'parentRef'>;
1140
1182
  color?: InputColor;
@@ -1142,61 +1184,49 @@ type Props$l<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyFi
1142
1184
  size?: InputSize;
1143
1185
  startContent?: React.ReactNode;
1144
1186
  endContent?: React.ReactNode;
1145
- onItemSelect?: (item: TSelectItem) => void;
1146
- renderItem?: (item: TSelectItem, props: ListItemProps) => React.ReactNode;
1187
+ onItemSelect?: (item: TItem) => void;
1188
+ renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
1147
1189
  renderNoData?: (props: ResultProps) => React.ReactNode;
1148
- } & (SelectSingleProps<TSelectItem, TSelectKeyField> | SelectMultipleProps<TSelectItem, TSelectKeyField>);
1149
- type SelectProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = Props$l<TSelectItem, TSelectKeyField> & NativeAttrs$n<TSelectItem, TSelectKeyField>;
1150
-
1151
- 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>;
1152
1193
 
1153
- 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;
1154
1195
 
1155
- type MediaQuery = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
1156
- type Responsive<T> = T | {
1157
- /**
1158
- * Minimum captured size: 0px
1159
- */
1160
- xs?: T;
1161
- /**
1162
- * Minimum captured size: 576px
1163
- */
1164
- sm?: T;
1165
- /**
1166
- * Minimum captured size: 768px
1167
- */
1168
- md?: T;
1169
- /**
1170
- * Minimum captured size: 992px
1171
- */
1172
- lg?: T;
1173
- /**
1174
- * Minimum captured size: 1200px
1175
- */
1176
- xl?: T;
1177
- /**
1178
- * Minimum captured size: 1400px
1179
- */
1180
- '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>>;
1181
1208
  };
1209
+ declare const SelectContext: react.Context<SelectContextValue<Record<string, any>, string> | null>;
1210
+ declare const useSelect: () => SelectContextValue<Record<string, any>, string>;
1182
1211
 
1183
- type SwitchSize = 'sm' | 'md' | 'lg';
1212
+ type SwitchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1184
1213
  type SwitchLabelPlacement = 'before' | 'after';
1214
+ type SwitchColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1185
1215
 
1186
- interface Props$k {
1216
+ interface Props$m {
1187
1217
  size?: SwitchSize;
1188
1218
  labelPlacement?: SwitchLabelPlacement;
1189
- colorScheme?: ColorScheme;
1219
+ color?: SwitchColor;
1190
1220
  }
1191
- type NativeAttrs$m = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$k | 'value' | 'defaultValue'>;
1192
- type SwitchProps = Props$k & NativeAttrs$m;
1193
- 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>>;
1194
1224
 
1195
1225
  type TabsVariant = 'underlined' | 'outlined' | 'pills';
1196
1226
  type TabValue = string | number | symbol;
1197
1227
  type TabsAlignment = 'start' | 'center' | 'end' | 'stretch';
1198
1228
 
1199
- interface Props$j<TTabValue extends TabValue = TabValue> {
1229
+ interface Props$l<TTabValue extends TabValue = TabValue> {
1200
1230
  /**
1201
1231
  * The HTML element type or React component to render as the tab.
1202
1232
  */
@@ -1222,11 +1252,11 @@ interface Props$j<TTabValue extends TabValue = TabValue> {
1222
1252
  */
1223
1253
  endContent?: React.ReactNode;
1224
1254
  }
1225
- type NativeAttrs$l = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$j>;
1226
- type TabProps<TTabValue extends TabValue = TabValue> = Props$j<TTabValue> & NativeAttrs$l;
1227
- 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>>;
1228
1258
 
1229
- interface Props$i<TTabValue extends TabValue = TabValue> {
1259
+ interface Props$k<TTabValue extends TabValue = TabValue> {
1230
1260
  /**
1231
1261
  * The currently selected value of the tabs.
1232
1262
  */
@@ -1249,11 +1279,11 @@ interface Props$i<TTabValue extends TabValue = TabValue> {
1249
1279
  */
1250
1280
  onClose?: (value: TTabValue) => void;
1251
1281
  }
1252
- type NativeAttrs$k = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$i>;
1253
- type TabsProps<TTabValue extends TabValue = TabValue> = Props$i<TTabValue> & NativeAttrs$k;
1254
- 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>;
1255
1285
 
1256
- interface Props$h {
1286
+ interface Props$j {
1257
1287
  inputRef?: React.RefObject<HTMLInputElement>;
1258
1288
  variant?: InputVariant;
1259
1289
  color?: InputColor;
@@ -1262,13 +1292,13 @@ interface Props$h {
1262
1292
  endContent?: React.ReactNode;
1263
1293
  css?: BoxCSS;
1264
1294
  }
1265
- type NativeAttrs$j = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$h>;
1266
- type TextInputProps = Props$h & NativeAttrs$j;
1267
- 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>>;
1268
1298
 
1269
1299
  type ToolbarSize = 'auto' | 'sm' | 'md' | 'lg';
1270
1300
 
1271
- interface Props$g {
1301
+ interface Props$i {
1272
1302
  size?: ToolbarSize;
1273
1303
  title?: React.ReactNode;
1274
1304
  subtitle?: React.ReactNode;
@@ -1290,8 +1320,8 @@ interface Props$g {
1290
1320
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
1291
1321
  };
1292
1322
  }
1293
- type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g>;
1294
- type ToolbarProps = Props$g & NativeAttrs$i;
1323
+ type NativeAttrs$k = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$i>;
1324
+ type ToolbarProps = Props$i & NativeAttrs$k;
1295
1325
  declare const Toolbar: React.FC<ToolbarProps>;
1296
1326
 
1297
1327
  interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
@@ -1304,24 +1334,24 @@ interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
1304
1334
  unmountOnExit?: boolean;
1305
1335
  onExited?: () => void;
1306
1336
  }
1307
- declare const Transition: react.ForwardRefExoticComponent<TransitionProps & react.RefAttributes<HTMLElement>>;
1337
+ declare const Transition: React.FC<TransitionProps>;
1308
1338
 
1309
- interface Props$f {
1339
+ interface Props$h {
1310
1340
  /**
1311
1341
  * The HTML element type or React component to render as the tab.
1312
1342
  */
1313
1343
  as?: React.ElementType;
1314
1344
  width?: number;
1315
1345
  }
1316
- type NativeAttrs$h = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$f>;
1317
- type SwipeItemProps = Props$f & NativeAttrs$h;
1318
- 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 & {
1319
1349
  children?: react.ReactNode | undefined;
1320
1350
  } & react.RefAttributes<HTMLDivElement>>;
1321
1351
 
1322
1352
  type SwiperAlignmet = 'start' | 'center' | 'end';
1323
1353
 
1324
- interface Props$e {
1354
+ interface Props$g {
1325
1355
  gap?: number;
1326
1356
  alignment?: SwiperAlignmet;
1327
1357
  autoHide?: boolean;
@@ -1331,8 +1361,8 @@ interface Props$e {
1331
1361
  arrowRightButton?: ButtonProps;
1332
1362
  };
1333
1363
  }
1334
- type NativeAttrs$g = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$e>;
1335
- type SwipeProps = Props$e & NativeAttrs$g;
1364
+ type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g>;
1365
+ type SwipeProps = Props$g & NativeAttrs$i;
1336
1366
  declare const Swipe: React.FC<SwipeProps>;
1337
1367
 
1338
1368
  type ModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
@@ -1344,7 +1374,7 @@ interface ModalClose {
1344
1374
  type ModalScrollBehavior = 'inside' | 'outside';
1345
1375
  type ModalBackdrop = BackdropVariant;
1346
1376
 
1347
- interface Props$d {
1377
+ interface Props$f {
1348
1378
  isOpen: boolean;
1349
1379
  size?: ModalSize;
1350
1380
  backdrop?: ModalBackdrop;
@@ -1359,9 +1389,9 @@ interface Props$d {
1359
1389
  onClose: () => void;
1360
1390
  onAfterClose?: () => void;
1361
1391
  }
1362
- type NativeAttrs$f = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$d>;
1363
- type ModalProps = Props$d & NativeAttrs$f;
1364
- 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>>;
1365
1395
 
1366
1396
  type ModalBodyProps = React.HTMLAttributes<HTMLDivElement>;
1367
1397
  declare const ModalBody: React.FC<ModalBodyProps>;
@@ -1370,27 +1400,28 @@ interface ModalContextValue {
1370
1400
  isOpen: boolean;
1371
1401
  scrollBehavior: ModalScrollBehavior;
1372
1402
  scrollArea: boolean;
1403
+ closable: boolean;
1373
1404
  onClose(): void;
1374
1405
  onAfterClose(): void;
1375
1406
  }
1376
1407
  declare function useModal(): ModalContextValue;
1377
1408
 
1378
- interface Props$c {
1409
+ interface Props$e {
1379
1410
  as?: React.ElementType;
1380
1411
  bordered?: boolean;
1381
1412
  }
1382
- type NativeAttrs$e = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$c>;
1383
- type ModalFooterProps = Props$c & NativeAttrs$e;
1384
- 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>>;
1385
1416
 
1386
- interface Props$b {
1417
+ interface Props$d {
1387
1418
  as?: React.ElementType;
1388
1419
  title?: React.ReactNode;
1389
1420
  subtitle?: React.ReactNode;
1390
1421
  startContent?: React.ReactNode;
1391
1422
  endContent?: React.ReactNode;
1392
1423
  bordered?: boolean;
1393
- close?: ModalClose;
1424
+ close?: ModalClose | boolean;
1394
1425
  slotProps?: {
1395
1426
  startContent?: React.HTMLAttributes<HTMLDivElement>;
1396
1427
  content?: React.HTMLAttributes<HTMLDivElement>;
@@ -1399,27 +1430,28 @@ interface Props$b {
1399
1430
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
1400
1431
  };
1401
1432
  }
1402
- type NativeAttrs$d = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$b>;
1403
- type ModalHeaderProps = Props$b & NativeAttrs$d;
1404
- 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>>;
1405
1436
 
1406
1437
  type CheckboxValue = string | number | symbol;
1407
- type CheckboxSize = 'sm' | 'md' | 'lg';
1438
+ type CheckboxSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1408
1439
  type CheckboxLabelPlacement = 'before' | 'after';
1409
1440
  type CheckboxGroupDirection = 'row' | 'col';
1410
1441
  type CheckboxGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
1442
+ type CheckboxColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1411
1443
 
1412
- interface Props$a<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1444
+ interface Props$c<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1413
1445
  value?: TCheckboxValue;
1414
1446
  size?: CheckboxSize;
1415
1447
  labelPlacement?: CheckboxLabelPlacement;
1416
- colorScheme?: ColorScheme;
1448
+ color?: CheckboxColor;
1417
1449
  }
1418
- type NativeAttrs$c = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$a | 'defaultValue'>;
1419
- type CheckboxProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$a<TCheckboxValue> & NativeAttrs$c;
1420
- 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>;
1421
1453
 
1422
- interface Props$9<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1454
+ interface Props$b<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1423
1455
  value?: TCheckboxValue[];
1424
1456
  defaultValue?: TCheckboxValue[];
1425
1457
  disabled?: boolean;
@@ -1428,12 +1460,12 @@ interface Props$9<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1428
1460
  alignment?: CheckboxGroupAlignment;
1429
1461
  size?: CheckboxSize;
1430
1462
  labelPlacement?: CheckboxLabelPlacement;
1431
- colorScheme?: ColorScheme;
1463
+ color?: CheckboxColor;
1432
1464
  onChange?: (value: TCheckboxValue[]) => void;
1433
1465
  }
1434
- type NativeAttrs$b = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9>;
1435
- type CheckboxGroupProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$9<TCheckboxValue> & NativeAttrs$b;
1436
- 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>;
1437
1469
 
1438
1470
  interface CheckboxGroupContextValue<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1439
1471
  value: TCheckboxValue[];
@@ -1442,18 +1474,20 @@ interface CheckboxGroupContextValue<TCheckboxValue extends CheckboxValue = Check
1442
1474
  direction?: CheckboxGroupDirection;
1443
1475
  size: CheckboxSize;
1444
1476
  labelPlacement: CheckboxLabelPlacement;
1445
- colorScheme: ColorScheme;
1477
+ color: CheckboxColor;
1446
1478
  onChange: (value: TCheckboxValue[]) => void;
1447
1479
  }
1480
+ declare const CheckboxGroupContext: react.Context<CheckboxGroupContextValue<CheckboxValue> | null>;
1448
1481
  declare const useCheckboxGroup: () => CheckboxGroupContextValue<CheckboxValue> | null;
1449
1482
 
1450
1483
  type RadioValue = string | number | symbol;
1451
- type RadioSize = 'sm' | 'md' | 'lg';
1484
+ type RadioSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1452
1485
  type RadioLabelPlacement = 'before' | 'after';
1453
1486
  type RadioGroupDirection = 'row' | 'col';
1454
1487
  type RadioGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
1488
+ type RadioColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1455
1489
 
1456
- interface Props$8<TRadioValue extends RadioValue = RadioValue> {
1490
+ interface Props$a<TRadioValue extends RadioValue = RadioValue> {
1457
1491
  value?: TRadioValue;
1458
1492
  disabled?: boolean;
1459
1493
  readOnly?: boolean;
@@ -1461,11 +1495,11 @@ interface Props$8<TRadioValue extends RadioValue = RadioValue> {
1461
1495
  labelPlacement?: RadioLabelPlacement;
1462
1496
  colorScheme?: ColorScheme;
1463
1497
  }
1464
- type NativeAttrs$a = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$8 | 'defaultValue' | 'checked' | 'defaultChecked' | 'onChange'>;
1465
- type RadioProps<TRadioValue extends RadioValue = RadioValue> = Props$8<TRadioValue> & NativeAttrs$a;
1466
- 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>;
1467
1501
 
1468
- interface Props$7<TRadioValue extends RadioValue = RadioValue> {
1502
+ interface Props$9<TRadioValue extends RadioValue = RadioValue> {
1469
1503
  name?: string;
1470
1504
  value?: TRadioValue;
1471
1505
  defaultValue?: TRadioValue;
@@ -1475,12 +1509,12 @@ interface Props$7<TRadioValue extends RadioValue = RadioValue> {
1475
1509
  alignment?: RadioGroupAlignment;
1476
1510
  size?: RadioSize;
1477
1511
  labelPlacement?: RadioLabelPlacement;
1478
- colorScheme?: ColorScheme;
1512
+ color?: RadioColor;
1479
1513
  onChange?: (value: TRadioValue) => void;
1480
1514
  }
1481
- type NativeAttrs$9 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7>;
1482
- type RadioGroupProps<TRadioValue extends RadioValue = RadioValue> = Props$7<TRadioValue> & NativeAttrs$9;
1483
- 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>;
1484
1518
 
1485
1519
  interface RadioGroupContextValue {
1486
1520
  name: string;
@@ -1490,34 +1524,35 @@ interface RadioGroupContextValue {
1490
1524
  direction: RadioGroupDirection;
1491
1525
  size: RadioSize;
1492
1526
  labelPlacement: RadioLabelPlacement;
1493
- colorScheme: ColorScheme;
1527
+ color: RadioColor;
1494
1528
  onChange: (value: RadioValue) => void;
1495
1529
  }
1530
+ declare const RadioGroupContext: react.Context<RadioGroupContextValue | null>;
1496
1531
  declare const useRadioGroup: () => RadioGroupContextValue;
1497
1532
 
1498
1533
  type NavRailPlacement = 'left' | 'right';
1499
1534
 
1500
- interface Props$6 {
1535
+ interface Props$8 {
1501
1536
  startContent?: React.ReactNode;
1502
1537
  endContent?: React.ReactNode;
1503
1538
  placement?: NavRailPlacement;
1504
1539
  }
1505
- type NativeAttrs$8 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
1506
- type NavRailProps = Props$6 & NativeAttrs$8;
1540
+ type NativeAttrs$a = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$8>;
1541
+ type NavRailProps = Props$8 & NativeAttrs$a;
1507
1542
  declare const NavRail: React.FC<NavRailProps>;
1508
1543
 
1509
- interface Props$5 {
1544
+ interface Props$7 {
1510
1545
  as?: React.ElementType;
1511
1546
  icon?: React.ReactNode;
1512
1547
  media?: React.ReactNode;
1513
1548
  label?: React.ReactNode;
1514
1549
  selected?: boolean;
1515
1550
  }
1516
- type NativeAttrs$7 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5>;
1517
- type NavRailItemProps = Props$5 & NativeAttrs$7;
1518
- 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>>;
1519
1554
 
1520
- type Props$4 = {
1555
+ type Props$6 = {
1521
1556
  as?: React.ElementType;
1522
1557
  label: React.ReactNode;
1523
1558
  span?: Responsive<number>;
@@ -1533,20 +1568,22 @@ type Props$4 = {
1533
1568
  mq: ContainerMediaQuery;
1534
1569
  }) => React.ReactNode;
1535
1570
  } & FormatOptions;
1536
- type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4 | 'children'>;
1537
- 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;
1538
1573
  declare const Description: react.ForwardRefExoticComponent<DescriptionProps & react.RefAttributes<HTMLDivElement>>;
1539
1574
 
1540
- type NativeAttrs$5 = React.HTMLAttributes<HTMLDivElement>;
1541
- type DescriptionEmptyProps = NativeAttrs$5;
1542
- 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>>;
1543
1578
 
1544
1579
  type DescriptionsLayout = 'row' | 'col';
1545
1580
  type DescriptionsSize = 'sm' | 'md' | 'lg';
1546
1581
  type DescriptionsAlign = React.CSSProperties['textAlign'];
1582
+ type DescriptionsMode = 'container' | 'screen' | 'css';
1547
1583
 
1548
- interface Props$3 {
1584
+ interface Props$5 {
1549
1585
  as?: React.ElementType;
1586
+ mode?: DescriptionsMode;
1550
1587
  items?: DescriptionProps[];
1551
1588
  layout?: Responsive<DescriptionsLayout>;
1552
1589
  size?: Responsive<DescriptionsSize>;
@@ -1555,9 +1592,9 @@ interface Props$3 {
1555
1592
  labelAlign?: Responsive<DescriptionsAlign>;
1556
1593
  contentAlign?: Responsive<DescriptionsAlign>;
1557
1594
  }
1558
- type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3 | 'children'>;
1559
- type DescriptionsProps = Props$3 & NativeAttrs$4;
1560
- 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>>;
1561
1598
 
1562
1599
  interface DescriptionsContextValue {
1563
1600
  mq: ContainerMediaQuery;
@@ -1570,9 +1607,9 @@ interface DescriptionsContextValue {
1570
1607
  declare const DescriptionsContext: react.Context<DescriptionsContextValue | null>;
1571
1608
  declare const useDescriptionsContext: () => DescriptionsContextValue;
1572
1609
 
1573
- type NativeAttrs$3 = React.HTMLAttributes<HTMLDivElement>;
1574
- type DescriptionTextProps = NativeAttrs$3;
1575
- 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>>;
1576
1613
 
1577
1614
  declare function reactNodeToText(node: React.ReactNode): string;
1578
1615
 
@@ -1592,14 +1629,14 @@ interface ResponsiveProps$2 {
1592
1629
  justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1593
1630
  alignItems?: Responsive<React.CSSProperties['alignItems']>;
1594
1631
  }
1595
- type Props$2 = {
1632
+ type Props$4 = {
1596
1633
  as?: React.ElementType;
1597
1634
  } & ResponsiveProps$2;
1598
- type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2>;
1599
- type GridItemProps = Props$2 & NativeAttrs$2;
1635
+ type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
1636
+ type GridItemProps = Props$4 & NativeAttrs$4;
1600
1637
  declare const GridItem: react.ForwardRefExoticComponent<{
1601
1638
  as?: React.ElementType;
1602
- } & ResponsiveProps$2 & NativeAttrs$2 & react.RefAttributes<HTMLDivElement>>;
1639
+ } & ResponsiveProps$2 & NativeAttrs$4 & react.RefAttributes<HTMLDivElement>>;
1603
1640
 
1604
1641
  interface ResponsiveProps$1 {
1605
1642
  cols?: Responsive<number>;
@@ -1617,14 +1654,16 @@ interface ResponsiveProps$1 {
1617
1654
  justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1618
1655
  alignItems?: Responsive<React.CSSProperties['alignItems']>;
1619
1656
  }
1620
- type Props$1 = {
1657
+ type Props$3 = {
1621
1658
  items?: GridItemProps[];
1622
1659
  } & ResponsiveProps$1;
1623
- type NativeAttrs$1 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$1>;
1624
- type GridSubProps = Props$1 & NativeAttrs$1;
1660
+ type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3>;
1661
+ type GridSubProps = Props$3 & NativeAttrs$3;
1625
1662
  declare const GridSub: react.ForwardRefExoticComponent<{
1626
1663
  items?: GridItemProps[];
1627
- } & ResponsiveProps$1 & NativeAttrs$1 & react.RefAttributes<HTMLDivElement>>;
1664
+ } & ResponsiveProps$1 & NativeAttrs$3 & react.RefAttributes<HTMLDivElement>>;
1665
+
1666
+ type GridMode = 'container' | 'screen' | 'css';
1628
1667
 
1629
1668
  interface ResponsiveProps {
1630
1669
  cols?: Responsive<number>;
@@ -1641,14 +1680,16 @@ interface ResponsiveProps {
1641
1680
  justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1642
1681
  alignItems?: Responsive<React.CSSProperties['alignItems']>;
1643
1682
  }
1644
- type Props = {
1683
+ type Props$2 = {
1684
+ mode?: GridMode;
1645
1685
  items?: (GridItemProps | GridSubProps)[];
1646
1686
  } & ResponsiveProps;
1647
- type NativeAttrs = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props>;
1648
- type GridProps = Props & NativeAttrs;
1687
+ type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2>;
1688
+ type GridProps = Props$2 & NativeAttrs$2;
1649
1689
  declare const Grid: react.ForwardRefExoticComponent<{
1690
+ mode?: GridMode;
1650
1691
  items?: (GridItemProps | GridSubProps)[];
1651
- } & ResponsiveProps & NativeAttrs & react.RefAttributes<HTMLDivElement>>;
1692
+ } & ResponsiveProps & NativeAttrs$2 & react.RefAttributes<HTMLDivElement>>;
1652
1693
 
1653
1694
  interface GridContextValue {
1654
1695
  mq: ContainerMediaQuery;
@@ -1656,6 +1697,57 @@ interface GridContextValue {
1656
1697
  declare const GridContext: react.Context<GridContextValue | null>;
1657
1698
  declare const useGridContext: () => GridContextValue;
1658
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
+
1659
1751
  declare const scrollToItem: (parentElement: Element, currentElement: Element) => void;
1660
1752
 
1661
1753
  type ClassDictionary = Record<string, any>;
@@ -1674,5 +1766,9 @@ declare function formatShortDateTime(value: Date | string | number, locales?: In
1674
1766
  declare function formatTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1675
1767
  declare function formatCurrency(value: number | bigint | Intl.StringNumericLiteral, currency?: string, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
1676
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;
1677
1773
 
1678
- 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 };