@unifiedsoftware/react-ui 2.0.1-beta.2 → 2.0.1-beta.21

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 +586 -428
  2. package/dist/index.js +3 -3
  3. package/package.json +2 -1
package/dist/index.d.ts CHANGED
@@ -2,13 +2,15 @@ import * as react from 'react';
2
2
  import react__default, { Dispatch, SetStateAction } from 'react';
3
3
  import * as react_jsx_runtime from 'react/jsx-runtime';
4
4
  import { VirtualizerOptions as VirtualizerOptions$1, Virtualizer as Virtualizer$1, ListItemProps as ListItemProps$1, ResultProps as ResultProps$1 } from '@unifiedsoftware/react-ui';
5
- import { FloatingRootContext } from '@floating-ui/react';
5
+ import { Menu as Menu$1 } from '@base-ui/react/menu';
6
+ import * as _base_ui_react_navigation_menu from '@base-ui/react/navigation-menu';
7
+ import { NavigationMenu as NavigationMenu$1 } from '@base-ui/react/navigation-menu';
6
8
 
7
- interface Props$O {
9
+ interface Props$N {
8
10
  }
9
- type NativeAttrs$Q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$O>;
10
- type DividerProps = Props$O & NativeAttrs$Q;
11
- declare const Divider: react.ForwardRefExoticComponent<Props$O & NativeAttrs$Q & react.RefAttributes<HTMLDivElement>>;
11
+ type NativeAttrs$Q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$N>;
12
+ type DividerProps = Props$N & NativeAttrs$Q;
13
+ declare const Divider: react.ForwardRefExoticComponent<Props$N & NativeAttrs$Q & react.RefAttributes<HTMLDivElement>>;
12
14
 
13
15
  type BoxShadow = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
14
16
  type BorderRadius = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
@@ -36,7 +38,7 @@ interface AccordionArrow {
36
38
  position?: 'start' | 'end';
37
39
  }
38
40
 
39
- interface Props$N {
41
+ interface Props$M {
40
42
  value?: any[];
41
43
  defaultValue?: any[];
42
44
  expandMode?: 'single' | 'multiple';
@@ -53,9 +55,9 @@ interface Props$N {
53
55
  }) => React.ReactNode;
54
56
  onChange?: (value: any[]) => void;
55
57
  }
56
- type NativeAttrs$P = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$N>;
57
- type AccordionProps = Props$N & NativeAttrs$P;
58
- declare const Accordion: react.ForwardRefExoticComponent<Props$N & NativeAttrs$P & react.RefAttributes<HTMLDivElement>>;
58
+ type NativeAttrs$P = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$M>;
59
+ type AccordionProps = Props$M & NativeAttrs$P;
60
+ declare const Accordion: react.ForwardRefExoticComponent<Props$M & NativeAttrs$P & react.RefAttributes<HTMLDivElement>>;
59
61
 
60
62
  interface AccordionItemContextValue {
61
63
  value: string;
@@ -64,7 +66,7 @@ interface AccordionItemContextValue {
64
66
  }) => React.ReactNode;
65
67
  }
66
68
  declare const useAccordionItem: () => AccordionItemContextValue;
67
- interface Props$M {
69
+ interface Props$L {
68
70
  value?: any;
69
71
  variant?: AccordionVariant;
70
72
  color?: AccordionColor;
@@ -72,11 +74,11 @@ interface Props$M {
72
74
  isOpen: boolean;
73
75
  }) => React.ReactNode;
74
76
  }
75
- type NativeAttrs$O = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$M>;
76
- type AccordionItemProps = Props$M & NativeAttrs$O;
77
- declare const AccordionItem: react.ForwardRefExoticComponent<Props$M & NativeAttrs$O & react.RefAttributes<HTMLDivElement>>;
77
+ type NativeAttrs$O = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$L>;
78
+ type AccordionItemProps = Props$L & NativeAttrs$O;
79
+ declare const AccordionItem: react.ForwardRefExoticComponent<Props$L & NativeAttrs$O & react.RefAttributes<HTMLDivElement>>;
78
80
 
79
- interface Props$L {
81
+ interface Props$K {
80
82
  as?: React.ElementType;
81
83
  title?: React.ReactNode;
82
84
  subtitle?: React.ReactNode;
@@ -94,9 +96,9 @@ interface Props$L {
94
96
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
95
97
  };
96
98
  }
97
- type NativeAttrs$N = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$L>;
98
- type AccordionHeaderProps = Props$L & NativeAttrs$N;
99
- declare const AccordionHeader: react.ForwardRefExoticComponent<Props$L & NativeAttrs$N & react.RefAttributes<HTMLDivElement>>;
99
+ type NativeAttrs$N = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$K>;
100
+ type AccordionHeaderProps = Props$K & NativeAttrs$N;
101
+ declare const AccordionHeader: react.ForwardRefExoticComponent<Props$K & NativeAttrs$N & react.RefAttributes<HTMLDivElement>>;
100
102
 
101
103
  type AccordionBodyProps = React.HTMLAttributes<HTMLDivElement>;
102
104
  declare const AccordionBody: react.ForwardRefExoticComponent<AccordionBodyProps & react.RefAttributes<HTMLDivElement>>;
@@ -345,6 +347,8 @@ interface UseElementSizeOptions<T> {
345
347
  }
346
348
  declare function useElementSize<T extends HTMLElement = any>(options: UseElementSizeOptions<T>): Resize;
347
349
 
350
+ declare function useExtractProps<T extends object, K extends keyof T>(props: T, keys: K[], defaults?: Partial<T>): [Pick<T, K>, Omit<T, K>];
351
+
348
352
  interface UseResizeObserverOptions<T> {
349
353
  ref?: React.RefObject<T | undefined>;
350
354
  onResize: () => void;
@@ -482,19 +486,49 @@ interface FormatStringOptions {
482
486
  type FormatOptions = FormatStringOptions | FormatNumberOptions | FormatDateOptions | FormatBooleanOptions | FormatCurrencyOptions | FormatPercentOptions | FormatFileSizeOptions;
483
487
  declare function format(options: FormatOptions): string | undefined;
484
488
 
485
- 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];
486
- 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;
487
- 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;
488
- interface SelectionProps<TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> {
489
+ type ColorScheme = 'default' | 'light' | 'dark';
490
+
491
+ type MediaQuery = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
492
+ type Responsive<T> = T | {
493
+ /**
494
+ * Minimum captured size: 0px
495
+ */
496
+ xs?: T;
497
+ /**
498
+ * Minimum captured size: 576px
499
+ */
500
+ sm?: T;
501
+ /**
502
+ * Minimum captured size: 768px
503
+ */
504
+ md?: T;
505
+ /**
506
+ * Minimum captured size: 992px
507
+ */
508
+ lg?: T;
509
+ /**
510
+ * Minimum captured size: 1200px
511
+ */
512
+ xl?: T;
513
+ /**
514
+ * Minimum captured size: 1400px
515
+ */
516
+ '2xl'?: T;
517
+ };
518
+
519
+ type SelectionValue$1<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];
520
+ type SelectionItem$1<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;
521
+ type SelectionOnChange$1<TData extends Record<string, any>, TKeyField extends keyof TData, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> = (value: SelectionValue$1<TData, TKeyField, TMultiple, TClearable>, item: SelectionItem$1<TData, TMultiple, TClearable>) => void;
522
+ interface SelectionProps$1<TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> {
489
523
  data: TItem[];
490
524
  isMultiple?: TMultiple;
491
525
  clearable?: TClearable;
492
526
  keyField?: TKeyField;
493
- value?: SelectionValue<TItem, TKeyField, TMultiple, TClearable>;
494
- onChange?: SelectionOnChange<TItem, TKeyField, TMultiple, TClearable>;
527
+ value?: SelectionValue$1<TItem, TKeyField, TMultiple, TClearable>;
528
+ onChange?: SelectionOnChange$1<TItem, TKeyField, TMultiple, TClearable>;
495
529
  }
496
530
 
497
- 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][];
531
+ declare const valueToValues: <TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false>(value?: SelectionValue$1<TItem, TKeyField, TMultiple, TClearable>) => TItem[TKeyField][];
498
532
  declare const valuesToValue: <TItem extends Record<string, any>, TKeyField extends keyof TItem>(values: TItem[TKeyField][]) => TItem[TKeyField] | null;
499
533
 
500
534
  declare function areArraysEqual<T extends string | number | symbol>(arr1: T[], arr2: T[]): boolean;
@@ -545,45 +579,53 @@ declare const useTimer: ({ mode, initialSeconds, maxSeconds, onTick, onComplete
545
579
  };
546
580
  type Timer = ReturnType<typeof useTimer>;
547
581
 
548
- type ColorScheme = 'default' | 'light' | 'dark';
582
+ type SelectionItem = Record<string, any>;
549
583
 
550
- type MediaQuery = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
551
- type Responsive<T> = T | {
552
- /**
553
- * Minimum captured size: 0px
554
- */
555
- xs?: T;
556
- /**
557
- * Minimum captured size: 576px
558
- */
559
- sm?: T;
560
- /**
561
- * Minimum captured size: 768px
562
- */
563
- md?: T;
564
- /**
565
- * Minimum captured size: 992px
566
- */
567
- lg?: T;
568
- /**
569
- * Minimum captured size: 1200px
570
- */
571
- xl?: T;
572
- /**
573
- * Minimum captured size: 1400px
574
- */
575
- '2xl'?: T;
576
- };
577
-
578
- type InputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
579
- type InputColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
580
584
  type InputVariant = 'filled' | 'outlined' | 'flat' | 'text';
585
+ type InputColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
586
+ type InputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
581
587
 
582
- interface Props$K {
588
+ interface InputBaseProps {
589
+ className?: string;
590
+ variant?: InputVariant;
591
+ color?: InputColor;
592
+ size?: InputSize;
593
+ startContent?: React.ReactNode;
594
+ endContent?: React.ReactNode;
595
+ startIcon?: React.ReactNode;
596
+ endIcon?: React.ReactNode;
597
+ startText?: string;
598
+ endText?: string;
599
+ disabled?: boolean;
600
+ clearable?: boolean;
601
+ closeButton?: boolean;
602
+ loading?: boolean;
603
+ error?: boolean;
604
+ readOnly?: boolean;
605
+ slotProps?: {
606
+ content?: React.HTMLAttributes<HTMLDivElement>;
607
+ };
583
608
  }
584
- type NativeAttrs$M = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$K>;
585
- type InputGroupProps = Props$K & NativeAttrs$M;
586
- declare const InputGroup: react.ForwardRefExoticComponent<Props$K & NativeAttrs$M & react.RefAttributes<HTMLDivElement>>;
609
+ type NativeAttrs$M = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof InputBaseProps>;
610
+ type InputWrapperProps = InputBaseProps & NativeAttrs$M;
611
+ declare const InputWrapper: react.ForwardRefExoticComponent<InputBaseProps & NativeAttrs$M & react.RefAttributes<HTMLInputElement>>;
612
+
613
+ interface InputCloseProps extends React.HTMLAttributes<HTMLDivElement> {
614
+ }
615
+ declare const InputClose: React.FC<InputCloseProps>;
616
+
617
+ interface Props$J {
618
+ }
619
+ type NativeAttrs$L = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$J>;
620
+ type InputGroupProps = Props$J & NativeAttrs$L;
621
+ declare const InputGroup: react.ForwardRefExoticComponent<Props$J & NativeAttrs$L & react.RefAttributes<HTMLDivElement>>;
622
+
623
+ interface InputSelectorProps extends React.HTMLAttributes<HTMLDivElement> {
624
+ isOpen: boolean;
625
+ }
626
+ declare const InputSelector: React.FC<InputSelectorProps>;
627
+
628
+ declare function useInputProps<TProps extends InputBaseProps = InputBaseProps>(props: TProps): [Pick<TProps, "className" | "color" | "size" | "variant" | "disabled" | "startContent" | "endContent" | "slotProps" | "error" | "readOnly" | "startIcon" | "endIcon" | "startText" | "endText" | "loading">, Omit<TProps, "className" | "color" | "size" | "variant" | "disabled" | "startContent" | "endContent" | "slotProps" | "error" | "readOnly" | "startIcon" | "endIcon" | "startText" | "endText" | "loading">];
587
629
 
588
630
  type ListSize = 'sm' | 'md' | 'lg';
589
631
 
@@ -591,20 +633,25 @@ interface ListProps extends React.HTMLAttributes<HTMLDivElement> {
591
633
  as?: React.ElementType;
592
634
  size?: ListSize;
593
635
  divider?: boolean;
636
+ nav?: boolean;
594
637
  }
595
638
  declare const List: react.ForwardRefExoticComponent<ListProps & react.RefAttributes<HTMLDivElement>>;
596
639
 
597
- interface Props$J {
598
- as?: react__default.ElementType;
640
+ interface ListItemBaseProps {
599
641
  title?: react__default.ReactNode;
600
642
  subtitle?: react__default.ReactNode;
601
643
  startContent?: react__default.ReactNode;
602
644
  endContent?: react__default.ReactNode;
603
- level?: number;
604
- hoverable?: boolean;
605
645
  selected?: boolean;
606
646
  disabled?: boolean;
647
+ cssVars?: {
648
+ paddingInline?: react__default.CSSProperties['paddingInline'];
649
+ paddingBlock?: react__default.CSSProperties['paddingBlock'];
650
+ minHeight?: react__default.CSSProperties['minHeight'];
651
+ height?: react__default.CSSProperties['height'];
652
+ };
607
653
  slotProps?: {
654
+ container?: react__default.HTMLAttributes<HTMLDivElement>;
608
655
  startContent?: react__default.HTMLAttributes<HTMLDivElement>;
609
656
  content?: react__default.HTMLAttributes<HTMLDivElement>;
610
657
  endContent?: react__default.HTMLAttributes<HTMLDivElement>;
@@ -612,11 +659,16 @@ interface Props$J {
612
659
  subtitle?: react__default.HTMLAttributes<HTMLDivElement>;
613
660
  };
614
661
  }
615
- type NativeAttrs$L = Omit<react__default.HTMLAttributes<HTMLDivElement>, keyof Props$J>;
616
- type ListItemProps = Props$J & NativeAttrs$L;
617
- declare const ListItem: react__default.ForwardRefExoticComponent<Props$J & NativeAttrs$L & react__default.RefAttributes<HTMLDivElement>>;
662
+ interface Props$I extends ListItemBaseProps {
663
+ as?: react__default.ElementType;
664
+ level?: number;
665
+ hoverable?: boolean;
666
+ }
667
+ type NativeAttrs$K = Omit<react__default.HTMLAttributes<HTMLDivElement>, keyof Props$I>;
668
+ type ListItemProps = Props$I & NativeAttrs$K;
669
+ declare const ListItem: react__default.ForwardRefExoticComponent<Props$I & NativeAttrs$K & react__default.RefAttributes<HTMLDivElement>>;
618
670
 
619
- interface Props$I {
671
+ interface Props$H {
620
672
  expandVisible?: boolean;
621
673
  expandPosition?: 'start' | 'end';
622
674
  isOpen?: boolean;
@@ -624,9 +676,9 @@ interface Props$I {
624
676
  onClose?: () => void;
625
677
  onToggle?: () => void;
626
678
  }
627
- type NativeAttrs$K = Omit<ListItemProps, keyof Props$I>;
628
- type ListGroupProps = Props$I & NativeAttrs$K;
629
- declare const ListGroup: react.ForwardRefExoticComponent<Props$I & NativeAttrs$K & react.RefAttributes<HTMLDivElement>>;
679
+ type NativeAttrs$J = Omit<ListItemProps, keyof Props$H>;
680
+ type ListGroupProps = Props$H & NativeAttrs$J;
681
+ declare const ListGroup: react.ForwardRefExoticComponent<Props$H & NativeAttrs$J & react.RefAttributes<HTMLDivElement>>;
630
682
 
631
683
  interface ListSubheaderProps extends React.HTMLAttributes<HTMLDivElement> {
632
684
  as?: React.ElementType;
@@ -656,51 +708,52 @@ declare const Result: React.FC<ResultProps>;
656
708
 
657
709
  type AutocompleteMultiple = false;
658
710
  type AutocompleteClearable = true;
659
- type NativeAttrs$J<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$H<TItem, TKeyField>>;
711
+ type AutocompleteItem = SelectionItem;
712
+ type AutocompleteKeyField<TAutocompleteItem> = keyof TAutocompleteItem;
713
+ type NativeAttrs$I<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'value'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$G<TAutocompleteItem, TAutocompleteKeyField>>;
660
714
  type BaseProps$1<TItem extends Record<string, any>> = {
661
715
  textField?: keyof TItem;
662
716
  placeholder?: string;
663
717
  filter?: string;
664
718
  loading?: boolean;
665
719
  disabled?: boolean;
666
- readOnly?: boolean;
667
720
  disclosure?: Disclosure;
668
721
  virtual?: Omit<VirtualizerOptions, 'parentRef'>;
669
- color?: InputColor;
670
- variant?: InputVariant;
671
- size?: InputSize;
672
722
  startContent?: React.ReactNode;
673
723
  endContent?: React.ReactNode;
724
+ target?: boolean;
725
+ readOnly?: boolean;
726
+ inner?: boolean;
727
+ onClear?: () => void;
674
728
  onItemSelect?: (item: TItem) => void;
675
729
  onFilterChange?: (value: string) => void;
730
+ customFilter?: (item: TItem, filter: string) => boolean;
676
731
  renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
677
732
  renderNoData?: (props: ResultProps) => React.ReactNode;
678
733
  };
679
- type Props$H<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = BaseProps$1<TItem> & SelectionProps<TItem, TKeyField, TMultiple, TClearable>;
680
- type AutocompleteProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$H<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$J<TItem, TKeyField>;
734
+ type Props$G<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'value', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = BaseProps$1<TItem> & SelectionProps<TItem, TKeyField, TMultiple, TClearable> & Omit<InputBaseProps, 'clearable'>;
735
+ type AutocompleteProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'value', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$G<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$I<TItem, TKeyField>;
736
+ 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][] | undefined | null : TItem[TKeyField][] : TClearable extends true ? TItem[TKeyField] | undefined | null : TItem[TKeyField];
737
+ type SelectionOnChangeValue<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];
738
+ type SelectionOnChangeItem<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;
739
+ type SelectionOnChange<TData extends Record<string, any>, TKeyField extends keyof TData, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> = (value: SelectionOnChangeValue<TData, TKeyField, TMultiple, TClearable>, item: SelectionOnChangeItem<TData, TMultiple, TClearable>) => void;
740
+ type SelectionRenderTrigger<TData extends Record<string, any>, TKeyField extends keyof TData, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> = (value?: SelectionOnChangeValue<TData, TKeyField, TMultiple, TClearable>, item?: SelectionOnChangeItem<TData, TMultiple, TClearable>) => React.ReactNode;
741
+ interface SelectionProps<TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> {
742
+ data: TItem[];
743
+ isMultiple?: TMultiple;
744
+ clearable?: TClearable;
745
+ keyField?: TKeyField;
746
+ value?: SelectionValue<TItem, TKeyField, TMultiple, TClearable>;
747
+ onChange?: SelectionOnChange<TItem, TKeyField, TMultiple, TClearable>;
748
+ renderTrigger?: SelectionRenderTrigger<TItem, TKeyField, TMultiple, TClearable>;
749
+ }
681
750
 
682
751
  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;
683
752
 
684
- type AutocompleteContextValue<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = {
685
- data: TItem[];
686
- values: TItem[TKeyField][];
687
- keyField: TKeyField;
688
- textField: keyof TItem;
689
- isMultiple: boolean;
690
- virtual?: Omit<VirtualizerOptions, 'parentRef'>;
691
- onChange: (value: TItem[]) => void;
692
- onItemSelect: (item: TItem) => void;
693
- renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
694
- offset: number;
695
- setOffset: React.Dispatch<React.SetStateAction<number>>;
696
- };
697
- declare const AutocompleteContext: react.Context<AutocompleteContextValue<Record<string, any>, string> | null>;
698
- declare const useAutocomplete: () => AutocompleteContextValue<Record<string, any>, string>;
699
-
700
753
  type BackdropPlacement = 'top' | 'left' | 'center' | 'right' | 'bottom';
701
754
  type BackdropVariant = 'opaque' | 'blur' | 'transparent';
702
755
 
703
- interface Props$G {
756
+ interface Props$F {
704
757
  isOpen: boolean;
705
758
  closable?: boolean;
706
759
  placement?: BackdropPlacement;
@@ -709,14 +762,14 @@ interface Props$G {
709
762
  scrollArea?: boolean;
710
763
  onClose(): void;
711
764
  }
712
- type NativeAttrs$I = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$G>;
713
- type BackdropProps = Props$G & NativeAttrs$I;
714
- declare const Backdrop: react.ForwardRefExoticComponent<Props$G & NativeAttrs$I & react.RefAttributes<HTMLDivElement>>;
765
+ type NativeAttrs$H = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$F>;
766
+ type BackdropProps = Props$F & NativeAttrs$H;
767
+ declare const Backdrop: react.ForwardRefExoticComponent<Props$F & NativeAttrs$H & react.RefAttributes<HTMLDivElement>>;
715
768
 
716
769
  type BadgeColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
717
770
  type BadgePlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
718
771
 
719
- interface Props$F {
772
+ interface Props$E {
720
773
  /**
721
774
  * The placement of the badge relative to its content.
722
775
  */
@@ -734,8 +787,8 @@ interface Props$F {
734
787
  wrapper?: React.HTMLAttributes<HTMLDivElement>;
735
788
  };
736
789
  }
737
- type NativeAttrs$H = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$F>;
738
- type BadgeProps = Props$F & NativeAttrs$H;
790
+ type NativeAttrs$G = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$E>;
791
+ type BadgeProps = Props$E & NativeAttrs$G;
739
792
  declare const Badge: React.FC<BadgeProps>;
740
793
 
741
794
  type DataListItem = Record<string, any>;
@@ -752,7 +805,7 @@ interface DataListMultipleProps<TDataListItem extends DataListItem, TDataListKey
752
805
  onChange?: (value: TDataListItem[]) => void;
753
806
  onValueChange?: (value: TDataListItem[TDataListKeyField][]) => void;
754
807
  }
755
- type Props$E<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
808
+ type Props$D<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
756
809
  data: TDataListItem[];
757
810
  keyField?: TDataListKeyField;
758
811
  textField?: keyof DataListItem;
@@ -767,8 +820,8 @@ type Props$E<TDataListItem extends DataListItem, TDataListKeyField extends DataL
767
820
  renderItem?: (item: TDataListItem, props: ListItemProps$1) => React.ReactNode;
768
821
  renderNoData?: (props: ResultProps$1) => React.ReactNode;
769
822
  } & (DataListSingleProps<TDataListItem, TDataListKeyField> | DataListMultipleProps<TDataListItem, TDataListKeyField>);
770
- type NativeAttrs$G<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$E<TDataListItem, TDataListKeyField>>;
771
- type DataListProps<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Props$E<TDataListItem, TDataListKeyField> & NativeAttrs$G<TDataListItem, TDataListKeyField>;
823
+ type NativeAttrs$F<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$D<TDataListItem, TDataListKeyField>>;
824
+ type DataListProps<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Props$D<TDataListItem, TDataListKeyField> & NativeAttrs$F<TDataListItem, TDataListKeyField>;
772
825
 
773
826
  declare const DataList: <TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = "key">(props: DataListProps<TDataListItem, TDataListKeyField>) => react_jsx_runtime.JSX.Element;
774
827
 
@@ -777,7 +830,7 @@ type ButtonColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'd
777
830
  type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
778
831
  type ButtonGroupDirection = 'row' | 'col';
779
832
 
780
- interface Props$D {
833
+ interface Props$C {
781
834
  /**
782
835
  * The HTML element type or React component to render as the button.
783
836
  */
@@ -822,20 +875,20 @@ interface Props$D {
822
875
  fontStyle?: React.CSSProperties['fontStyle'];
823
876
  };
824
877
  }
825
- type NativeAttrs$F = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$D>;
826
- type ButtonProps = Props$D & NativeAttrs$F;
827
- declare const Button: react.ForwardRefExoticComponent<Props$D & NativeAttrs$F & react.RefAttributes<HTMLButtonElement>>;
878
+ type NativeAttrs$E = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$C>;
879
+ type ButtonProps = Props$C & NativeAttrs$E;
880
+ declare const Button: react.ForwardRefExoticComponent<Props$C & NativeAttrs$E & react.RefAttributes<HTMLButtonElement>>;
828
881
 
829
- interface Props$C {
882
+ interface Props$B {
830
883
  direction?: ButtonGroupDirection;
831
884
  variant?: ButtonVariant;
832
885
  color?: ButtonColor;
833
886
  size?: ButtonSize;
834
887
  disabled?: boolean;
835
888
  }
836
- type NativeAttrs$E = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$C>;
837
- type ButtonGroupProps = Props$C & NativeAttrs$E;
838
- declare const ButtonGroup: react.ForwardRefExoticComponent<Props$C & NativeAttrs$E & react.RefAttributes<HTMLDivElement>>;
889
+ type NativeAttrs$D = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$B>;
890
+ type ButtonGroupProps = Props$B & NativeAttrs$D;
891
+ declare const ButtonGroup: react.ForwardRefExoticComponent<Props$B & NativeAttrs$D & react.RefAttributes<HTMLDivElement>>;
839
892
 
840
893
  interface ButtonGroupContextValue {
841
894
  direction: ButtonGroupDirection;
@@ -849,7 +902,7 @@ declare const useButtonGroup: () => ButtonGroupContextValue | null;
849
902
 
850
903
  type CardSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
851
904
 
852
- interface Props$B {
905
+ interface Props$A {
853
906
  as?: React.ElementType;
854
907
  size?: CardSize;
855
908
  hoverable?: boolean;
@@ -859,14 +912,14 @@ interface Props$B {
859
912
  divider?: boolean;
860
913
  css?: BoxCSS;
861
914
  }
862
- type NativeAttrs$D = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$B>;
863
- type CardProps = Props$B & NativeAttrs$D;
864
- declare const Card: react.ForwardRefExoticComponent<Props$B & NativeAttrs$D & react.RefAttributes<HTMLDivElement>>;
915
+ type NativeAttrs$C = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$A>;
916
+ type CardProps = Props$A & NativeAttrs$C;
917
+ declare const Card: react.ForwardRefExoticComponent<Props$A & NativeAttrs$C & react.RefAttributes<HTMLDivElement>>;
865
918
 
866
919
  type CardBodyProps = React.HTMLAttributes<HTMLDivElement>;
867
920
  declare const CardBody: react.ForwardRefExoticComponent<CardBodyProps & react.RefAttributes<HTMLDivElement>>;
868
921
 
869
- interface Props$A {
922
+ interface Props$z {
870
923
  as?: React.ElementType;
871
924
  title?: React.ReactNode;
872
925
  subtitle?: React.ReactNode;
@@ -892,11 +945,11 @@ interface Props$A {
892
945
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
893
946
  };
894
947
  }
895
- type NativeAttrs$C = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$A>;
896
- type CardHeaderProps = Props$A & NativeAttrs$C;
897
- declare const CardHeader: react.ForwardRefExoticComponent<Props$A & NativeAttrs$C & react.RefAttributes<HTMLDivElement>>;
948
+ type NativeAttrs$B = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$z>;
949
+ type CardHeaderProps = Props$z & NativeAttrs$B;
950
+ declare const CardHeader: react.ForwardRefExoticComponent<Props$z & NativeAttrs$B & react.RefAttributes<HTMLDivElement>>;
898
951
 
899
- interface Props$z {
952
+ interface Props$y {
900
953
  as?: React.ElementType;
901
954
  /**
902
955
  * @deprecated Use `underlined` instead
@@ -904,9 +957,9 @@ interface Props$z {
904
957
  bordered?: boolean;
905
958
  underlined?: boolean;
906
959
  }
907
- type NativeAttrs$B = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$z>;
908
- type CardFooterProps = Props$z & NativeAttrs$B;
909
- declare const CardFooter: react.ForwardRefExoticComponent<Props$z & NativeAttrs$B & react.RefAttributes<HTMLDivElement>>;
960
+ type NativeAttrs$A = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$y>;
961
+ type CardFooterProps = Props$y & NativeAttrs$A;
962
+ declare const CardFooter: react.ForwardRefExoticComponent<Props$y & NativeAttrs$A & react.RefAttributes<HTMLDivElement>>;
910
963
 
911
964
  type CardMediaProps = React.HTMLAttributes<HTMLDivElement> & {
912
965
  topLeftContent?: React.ReactNode;
@@ -917,28 +970,28 @@ declare const CardMedia: react.ForwardRefExoticComponent<react.HTMLAttributes<HT
917
970
  topRightContent?: React.ReactNode;
918
971
  } & react.RefAttributes<HTMLDivElement>>;
919
972
 
920
- interface Props$y {
973
+ interface Props$x {
921
974
  as?: React.ElementType;
922
975
  centered?: boolean;
923
976
  css?: BoxCSS;
924
977
  }
925
- type NativeAttrs$A = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$y>;
926
- type CardTitleProps = Props$y & NativeAttrs$A;
927
- declare const CardTitle: react.ForwardRefExoticComponent<Props$y & NativeAttrs$A & react.RefAttributes<HTMLDivElement>>;
978
+ type NativeAttrs$z = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$x>;
979
+ type CardTitleProps = Props$x & NativeAttrs$z;
980
+ declare const CardTitle: react.ForwardRefExoticComponent<Props$x & NativeAttrs$z & react.RefAttributes<HTMLDivElement>>;
928
981
 
929
- interface Props$x {
982
+ interface Props$w {
930
983
  as?: React.ElementType;
931
984
  css?: BoxCSS;
932
985
  }
933
- type NativeAttrs$z = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$x>;
934
- type CardSubtitleProps = Props$x & NativeAttrs$z;
935
- declare const CardSubtitle: react.ForwardRefExoticComponent<Props$x & NativeAttrs$z & react.RefAttributes<HTMLDivElement>>;
986
+ type NativeAttrs$y = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$w>;
987
+ type CardSubtitleProps = Props$w & NativeAttrs$y;
988
+ declare const CardSubtitle: react.ForwardRefExoticComponent<Props$w & NativeAttrs$y & react.RefAttributes<HTMLDivElement>>;
936
989
 
937
990
  type ChipVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain' | 'bordered';
938
991
  type ChipColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
939
992
  type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
940
993
 
941
- interface Props$w {
994
+ interface Props$v {
942
995
  /**
943
996
  * The HTML element type or React component to render as the chip.
944
997
  */
@@ -976,9 +1029,9 @@ interface Props$w {
976
1029
  };
977
1030
  onClose?: () => void;
978
1031
  }
979
- type NativeAttrs$y = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$w>;
980
- type ChipProps = Props$w & NativeAttrs$y;
981
- declare const Chip: react.ForwardRefExoticComponent<Props$w & NativeAttrs$y & react.RefAttributes<HTMLDivElement>>;
1032
+ type NativeAttrs$x = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$v>;
1033
+ type ChipProps = Props$v & NativeAttrs$x;
1034
+ declare const Chip: react.ForwardRefExoticComponent<Props$v & NativeAttrs$x & react.RefAttributes<HTMLDivElement>>;
982
1035
 
983
1036
  interface CollapseProps {
984
1037
  children: React.ReactNode;
@@ -1023,7 +1076,7 @@ interface DrawerClose {
1023
1076
  }
1024
1077
  type DrawerBackdrop = BackdropVariant;
1025
1078
 
1026
- interface Props$v {
1079
+ interface Props$u {
1027
1080
  isOpen: boolean;
1028
1081
  size?: DrawerSize;
1029
1082
  backdrop?: DrawerBackdrop;
@@ -1040,11 +1093,11 @@ interface Props$v {
1040
1093
  onClose: () => void;
1041
1094
  onAfterClose?: () => void;
1042
1095
  }
1043
- type NativeAttrs$x = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$v>;
1044
- type DrawerProps = Props$v & NativeAttrs$x;
1045
- declare const Drawer: react.ForwardRefExoticComponent<Props$v & NativeAttrs$x & react.RefAttributes<HTMLDivElement>>;
1096
+ type NativeAttrs$w = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$u>;
1097
+ type DrawerProps = Props$u & NativeAttrs$w;
1098
+ declare const Drawer: react.ForwardRefExoticComponent<Props$u & NativeAttrs$w & react.RefAttributes<HTMLDivElement>>;
1046
1099
 
1047
- interface Props$u {
1100
+ interface Props$t {
1048
1101
  as?: React.ElementType;
1049
1102
  title?: React.ReactNode;
1050
1103
  subtitle?: React.ReactNode;
@@ -1060,20 +1113,20 @@ interface Props$u {
1060
1113
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
1061
1114
  };
1062
1115
  }
1063
- type NativeAttrs$w = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$u>;
1064
- type DrawerHeaderProps = Props$u & NativeAttrs$w;
1065
- declare const DrawerHeader: react.ForwardRefExoticComponent<Props$u & NativeAttrs$w & react.RefAttributes<HTMLDivElement>>;
1116
+ type NativeAttrs$v = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$t>;
1117
+ type DrawerHeaderProps = Props$t & NativeAttrs$v;
1118
+ declare const DrawerHeader: react.ForwardRefExoticComponent<Props$t & NativeAttrs$v & react.RefAttributes<HTMLDivElement>>;
1066
1119
 
1067
1120
  type DrawerBodyProps = React.HTMLAttributes<HTMLDivElement>;
1068
1121
  declare const DrawerBody: react.ForwardRefExoticComponent<DrawerBodyProps & react.RefAttributes<HTMLDivElement>>;
1069
1122
 
1070
- interface Props$t {
1123
+ interface Props$s {
1071
1124
  as?: React.ElementType;
1072
1125
  bordered?: boolean;
1073
1126
  }
1074
- type NativeAttrs$v = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$t>;
1075
- type DrawerFooterProps = Props$t & NativeAttrs$v;
1076
- declare const DrawerFooter: react.ForwardRefExoticComponent<Props$t & NativeAttrs$v & react.RefAttributes<HTMLDivElement>>;
1127
+ type NativeAttrs$u = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$s>;
1128
+ type DrawerFooterProps = Props$s & NativeAttrs$u;
1129
+ declare const DrawerFooter: react.ForwardRefExoticComponent<Props$s & NativeAttrs$u & react.RefAttributes<HTMLDivElement>>;
1077
1130
 
1078
1131
  interface DrawerContextValue {
1079
1132
  isOpen: boolean;
@@ -1108,7 +1161,7 @@ interface IconProps {
1108
1161
  }
1109
1162
  declare const Icon: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<unknown>>;
1110
1163
 
1111
- interface Props$s {
1164
+ interface Props$r {
1112
1165
  /**
1113
1166
  * The HTML element type or React component to render as the menu item.
1114
1167
  */
@@ -1134,9 +1187,9 @@ interface Props$s {
1134
1187
  */
1135
1188
  disabled?: boolean;
1136
1189
  }
1137
- type NativeAttrs$u = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$s | 'items'>;
1138
- type MenuItemProps = Props$s & NativeAttrs$u;
1139
- declare const MenuItem: react.ForwardRefExoticComponent<Props$s & NativeAttrs$u & react.RefAttributes<HTMLDivElement>>;
1190
+ type NativeAttrs$t = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$r | 'items'>;
1191
+ type MenuItemProps = Props$r & NativeAttrs$t;
1192
+ declare const MenuItem: react.ForwardRefExoticComponent<Props$r & NativeAttrs$t & react.RefAttributes<HTMLDivElement>>;
1140
1193
 
1141
1194
  type MenuSubmenuProps = Omit<MenuItemProps, 'items'> & {
1142
1195
  items?: MenuItemType[];
@@ -1160,7 +1213,7 @@ type MenuItemType = (MenuGroupProps & {
1160
1213
  }) | (MenuItemProps & {
1161
1214
  type?: 'item';
1162
1215
  });
1163
- interface Props$r {
1216
+ interface Props$q {
1164
1217
  /**
1165
1218
  * The currently selected value of the menu.
1166
1219
  */
@@ -1196,8 +1249,8 @@ interface Props$r {
1196
1249
  */
1197
1250
  onItemSelect?: (props: MenuItemProps) => void;
1198
1251
  }
1199
- type NativeAttrs$t = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$r | 'items'>;
1200
- type MenuProps = Props$r & NativeAttrs$t & {
1252
+ type NativeAttrs$s = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$q | 'items'>;
1253
+ type MenuProps = Props$q & NativeAttrs$s & {
1201
1254
  items?: MenuItemType[];
1202
1255
  };
1203
1256
  declare const Menu: React.FC<MenuProps>;
@@ -1273,7 +1326,7 @@ declare const ScrollArea: react.ForwardRefExoticComponent<ScrollAreaProps & reac
1273
1326
 
1274
1327
  type SelectMultiple = false;
1275
1328
  type SelectClearable = false;
1276
- type NativeAttrs$s<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$q<TItem, TKeyField>>;
1329
+ type NativeAttrs$r<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$p<TItem, TKeyField>>;
1277
1330
  type BaseProps<TItem extends Record<string, any>> = {
1278
1331
  textField?: keyof TItem;
1279
1332
  placeholder?: string;
@@ -1291,8 +1344,8 @@ type BaseProps<TItem extends Record<string, any>> = {
1291
1344
  renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
1292
1345
  renderNoData?: (props: ResultProps) => React.ReactNode;
1293
1346
  };
1294
- type Props$q<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = BaseProps<TItem> & SelectionProps<TItem, TKeyField, TMultiple, TClearable>;
1295
- type SelectProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$q<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$s<TItem, TKeyField>;
1347
+ type Props$p<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = BaseProps<TItem> & SelectionProps$1<TItem, TKeyField, TMultiple, TClearable>;
1348
+ type SelectProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$p<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$r<TItem, TKeyField>;
1296
1349
 
1297
1350
  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;
1298
1351
 
@@ -1316,21 +1369,21 @@ type SwitchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1316
1369
  type SwitchLabelPlacement = 'before' | 'after';
1317
1370
  type SwitchColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1318
1371
 
1319
- interface Props$p {
1372
+ interface Props$o {
1320
1373
  size?: SwitchSize;
1321
1374
  labelPlacement?: SwitchLabelPlacement;
1322
1375
  color?: SwitchColor;
1323
1376
  }
1324
- type NativeAttrs$r = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$p | 'value' | 'defaultValue'>;
1325
- type SwitchProps = Props$p & NativeAttrs$r;
1326
- declare const Switch: react.ForwardRefExoticComponent<Props$p & NativeAttrs$r & react.RefAttributes<HTMLInputElement>>;
1377
+ type NativeAttrs$q = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$o | 'value' | 'defaultValue'>;
1378
+ type SwitchProps = Props$o & NativeAttrs$q;
1379
+ declare const Switch: react.ForwardRefExoticComponent<Props$o & NativeAttrs$q & react.RefAttributes<HTMLInputElement>>;
1327
1380
 
1328
1381
  type TabsVariant = 'underlined' | 'outlined' | 'pills';
1329
1382
  type TabValue = string | number | symbol;
1330
1383
  type TabsAlignment = 'start' | 'center' | 'end' | 'stretch';
1331
1384
  type TabsSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1332
1385
 
1333
- interface Props$o<TTabValue extends TabValue = TabValue> {
1386
+ interface Props$n<TTabValue extends TabValue = TabValue> {
1334
1387
  /**
1335
1388
  * The HTML element type or React component to render as the tab.
1336
1389
  */
@@ -1356,11 +1409,11 @@ interface Props$o<TTabValue extends TabValue = TabValue> {
1356
1409
  */
1357
1410
  endContent?: React.ReactNode;
1358
1411
  }
1359
- type NativeAttrs$q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$o>;
1360
- type TabProps<TTabValue extends TabValue = TabValue> = Props$o<TTabValue> & NativeAttrs$q;
1361
- declare const Tab: react.ForwardRefExoticComponent<Props$o<TabValue> & NativeAttrs$q & react.RefAttributes<HTMLDivElement>>;
1412
+ type NativeAttrs$p = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$n>;
1413
+ type TabProps<TTabValue extends TabValue = TabValue> = Props$n<TTabValue> & NativeAttrs$p;
1414
+ declare const Tab: react.ForwardRefExoticComponent<Props$n<TabValue> & NativeAttrs$p & react.RefAttributes<HTMLDivElement>>;
1362
1415
 
1363
- interface Props$n<TTabValue extends TabValue = TabValue> {
1416
+ interface Props$m<TTabValue extends TabValue = TabValue> {
1364
1417
  /**
1365
1418
  * The currently selected value of the tabs.
1366
1419
  */
@@ -1387,11 +1440,11 @@ interface Props$n<TTabValue extends TabValue = TabValue> {
1387
1440
  */
1388
1441
  onClose?: (value: TTabValue) => void;
1389
1442
  }
1390
- type NativeAttrs$p = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$n>;
1391
- type TabsProps<TTabValue extends TabValue = TabValue> = Props$n<TTabValue> & NativeAttrs$p;
1392
- declare const Tabs: <TTabValue extends TabValue = TabValue>(props: Props$n<TTabValue> & NativeAttrs$p & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1443
+ type NativeAttrs$o = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$m>;
1444
+ type TabsProps<TTabValue extends TabValue = TabValue> = Props$m<TTabValue> & NativeAttrs$o;
1445
+ declare const Tabs: <TTabValue extends TabValue = TabValue>(props: Props$m<TTabValue> & NativeAttrs$o & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1393
1446
 
1394
- interface Props$m {
1447
+ interface Props$l {
1395
1448
  value?: string;
1396
1449
  defaultValue?: string;
1397
1450
  inputRef?: React.RefObject<HTMLInputElement>;
@@ -1404,26 +1457,23 @@ interface Props$m {
1404
1457
  rules?: StringRules;
1405
1458
  autoFormatRules?: boolean;
1406
1459
  }
1407
- type NativeAttrs$o = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$m>;
1408
- type TextInputProps = Props$m & NativeAttrs$o;
1409
- declare const TextInput: react.ForwardRefExoticComponent<Props$m & NativeAttrs$o & react.RefAttributes<HTMLInputElement>>;
1460
+ type NativeAttrs$n = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$l>;
1461
+ type TextInputProps = Props$l & NativeAttrs$n;
1462
+ declare const TextInput: react.ForwardRefExoticComponent<Props$l & NativeAttrs$n & react.RefAttributes<HTMLInputElement>>;
1410
1463
 
1411
1464
  type ToolbarSize = 'auto' | 'sm' | 'md' | 'lg';
1465
+ type ToolbarVariant = 'filled' | 'text';
1466
+ type ToolbarColor = 'secondary' | 'primary';
1412
1467
 
1413
- interface Props$l {
1468
+ interface Props$k {
1414
1469
  size?: ToolbarSize;
1415
1470
  title?: React.ReactNode;
1416
1471
  subtitle?: React.ReactNode;
1417
1472
  startContent?: React.ReactNode;
1418
1473
  endContent?: React.ReactNode;
1419
- /**
1420
- * @deprecated Use `startContent` instead
1421
- */
1422
- startAction?: React.ReactNode;
1423
- /**
1424
- * @deprecated Use `endContent` instead
1425
- */
1426
- endAction?: React.ReactNode;
1474
+ bordered?: boolean;
1475
+ variant?: ToolbarVariant;
1476
+ color?: ToolbarColor;
1427
1477
  slotProps?: {
1428
1478
  startContent?: React.HTMLAttributes<HTMLDivElement>;
1429
1479
  content?: React.HTMLAttributes<HTMLDivElement>;
@@ -1432,8 +1482,8 @@ interface Props$l {
1432
1482
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
1433
1483
  };
1434
1484
  }
1435
- type NativeAttrs$n = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$l>;
1436
- type ToolbarProps = Props$l & NativeAttrs$n;
1485
+ type NativeAttrs$m = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$k>;
1486
+ type ToolbarProps = Props$k & NativeAttrs$m;
1437
1487
  declare const Toolbar: React.FC<ToolbarProps>;
1438
1488
 
1439
1489
  interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
@@ -1448,22 +1498,22 @@ interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
1448
1498
  }
1449
1499
  declare const Transition: React.FC<TransitionProps>;
1450
1500
 
1451
- interface Props$k {
1501
+ interface Props$j {
1452
1502
  /**
1453
1503
  * The HTML element type or React component to render as the tab.
1454
1504
  */
1455
1505
  as?: React.ElementType;
1456
1506
  width?: number;
1457
1507
  }
1458
- type NativeAttrs$m = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$k>;
1459
- type SwipeItemProps = Props$k & NativeAttrs$m;
1460
- declare const SwipeItem: react.ForwardRefExoticComponent<Props$k & NativeAttrs$m & {
1508
+ type NativeAttrs$l = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$j>;
1509
+ type SwipeItemProps = Props$j & NativeAttrs$l;
1510
+ declare const SwipeItem: react.ForwardRefExoticComponent<Props$j & NativeAttrs$l & {
1461
1511
  children?: react.ReactNode | undefined;
1462
1512
  } & react.RefAttributes<HTMLDivElement>>;
1463
1513
 
1464
1514
  type SwiperAlignmet = 'start' | 'center' | 'end';
1465
1515
 
1466
- interface Props$j {
1516
+ interface Props$i {
1467
1517
  gap?: number;
1468
1518
  alignment?: SwiperAlignmet;
1469
1519
  autoHide?: boolean;
@@ -1473,8 +1523,8 @@ interface Props$j {
1473
1523
  arrowRightButton?: ButtonProps;
1474
1524
  };
1475
1525
  }
1476
- type NativeAttrs$l = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$j>;
1477
- type SwipeProps = Props$j & NativeAttrs$l;
1526
+ type NativeAttrs$k = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$i>;
1527
+ type SwipeProps = Props$i & NativeAttrs$k;
1478
1528
  declare const Swipe: React.FC<SwipeProps>;
1479
1529
 
1480
1530
  type ModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
@@ -1486,7 +1536,7 @@ interface ModalClose {
1486
1536
  type ModalScrollBehavior = 'inside' | 'outside';
1487
1537
  type ModalBackdrop = BackdropVariant | boolean;
1488
1538
 
1489
- interface Props$i {
1539
+ interface Props$h {
1490
1540
  isOpen: boolean;
1491
1541
  size?: ModalSize;
1492
1542
  backdrop?: ModalBackdrop;
@@ -1502,9 +1552,9 @@ interface Props$i {
1502
1552
  onClose: () => void;
1503
1553
  onAfterClose?: () => void;
1504
1554
  }
1505
- type NativeAttrs$k = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$i>;
1506
- type ModalProps = Props$i & NativeAttrs$k;
1507
- declare const Modal: react.ForwardRefExoticComponent<Props$i & NativeAttrs$k & react.RefAttributes<HTMLDivElement>>;
1555
+ type NativeAttrs$j = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$h>;
1556
+ type ModalProps = Props$h & NativeAttrs$j;
1557
+ declare const Modal: react.ForwardRefExoticComponent<Props$h & NativeAttrs$j & react.RefAttributes<HTMLDivElement>>;
1508
1558
 
1509
1559
  type ModalBodyProps = React.HTMLAttributes<HTMLDivElement>;
1510
1560
  declare const ModalBody: React.FC<ModalBodyProps>;
@@ -1523,15 +1573,15 @@ interface ModalContextValue {
1523
1573
  }
1524
1574
  declare function useModal(): ModalContextValue;
1525
1575
 
1526
- interface Props$h {
1576
+ interface Props$g {
1527
1577
  as?: React.ElementType;
1528
1578
  bordered?: boolean;
1529
1579
  }
1530
- type NativeAttrs$j = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$h>;
1531
- type ModalFooterProps = Props$h & NativeAttrs$j;
1532
- declare const ModalFooter: react.ForwardRefExoticComponent<Props$h & NativeAttrs$j & react.RefAttributes<HTMLDivElement>>;
1580
+ type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g>;
1581
+ type ModalFooterProps = Props$g & NativeAttrs$i;
1582
+ declare const ModalFooter: react.ForwardRefExoticComponent<Props$g & NativeAttrs$i & react.RefAttributes<HTMLDivElement>>;
1533
1583
 
1534
- interface Props$g {
1584
+ interface Props$f {
1535
1585
  as?: React.ElementType;
1536
1586
  title?: React.ReactNode;
1537
1587
  subtitle?: React.ReactNode;
@@ -1547,9 +1597,9 @@ interface Props$g {
1547
1597
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
1548
1598
  };
1549
1599
  }
1550
- type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g>;
1551
- type ModalHeaderProps = Props$g & NativeAttrs$i;
1552
- declare const ModalHeader: react.ForwardRefExoticComponent<Props$g & NativeAttrs$i & react.RefAttributes<HTMLDivElement>>;
1600
+ type NativeAttrs$h = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$f>;
1601
+ type ModalHeaderProps = Props$f & NativeAttrs$h;
1602
+ declare const ModalHeader: react.ForwardRefExoticComponent<Props$f & NativeAttrs$h & react.RefAttributes<HTMLDivElement>>;
1553
1603
 
1554
1604
  type ModalContentProps = React.HTMLAttributes<HTMLDivElement>;
1555
1605
  declare const ModalContent: react.ForwardRefExoticComponent<ModalContentProps & react.RefAttributes<HTMLDivElement>>;
@@ -1561,18 +1611,18 @@ type CheckboxGroupDirection = 'row' | 'col';
1561
1611
  type CheckboxGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
1562
1612
  type CheckboxColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1563
1613
 
1564
- interface Props$f<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1614
+ interface Props$e<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1565
1615
  value?: TCheckboxValue;
1566
1616
  size?: CheckboxSize;
1567
1617
  labelPlacement?: CheckboxLabelPlacement;
1568
1618
  color?: CheckboxColor;
1569
1619
  indeterminate?: boolean;
1570
1620
  }
1571
- type NativeAttrs$h = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$f | 'defaultValue'>;
1572
- type CheckboxProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$f<TCheckboxValue> & NativeAttrs$h;
1573
- declare const Checkbox: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$f<TCheckboxValue> & NativeAttrs$h & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1621
+ type NativeAttrs$g = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$e | 'defaultValue'>;
1622
+ type CheckboxProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$e<TCheckboxValue> & NativeAttrs$g;
1623
+ declare const Checkbox: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$e<TCheckboxValue> & NativeAttrs$g & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1574
1624
 
1575
- interface Props$e<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1625
+ interface Props$d<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1576
1626
  value?: TCheckboxValue[];
1577
1627
  defaultValue?: TCheckboxValue[];
1578
1628
  disabled?: boolean;
@@ -1584,9 +1634,9 @@ interface Props$e<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1584
1634
  color?: CheckboxColor;
1585
1635
  onChange?: (value: TCheckboxValue[]) => void;
1586
1636
  }
1587
- type NativeAttrs$g = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$e>;
1588
- type CheckboxGroupProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$e<TCheckboxValue> & NativeAttrs$g;
1589
- declare const CheckboxGroup: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$e<TCheckboxValue> & NativeAttrs$g & react.RefAttributes<HTMLTableElement>) => ReturnType<React.FunctionComponent>;
1637
+ type NativeAttrs$f = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$d>;
1638
+ type CheckboxGroupProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$d<TCheckboxValue> & NativeAttrs$f;
1639
+ declare const CheckboxGroup: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$d<TCheckboxValue> & NativeAttrs$f & react.RefAttributes<HTMLTableElement>) => ReturnType<React.FunctionComponent>;
1590
1640
 
1591
1641
  interface CheckboxGroupContextValue<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1592
1642
  value: TCheckboxValue[];
@@ -1608,7 +1658,7 @@ type RadioGroupDirection = 'row' | 'col';
1608
1658
  type RadioGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
1609
1659
  type RadioColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1610
1660
 
1611
- interface Props$d<TRadioValue extends RadioValue = RadioValue> {
1661
+ interface Props$c<TRadioValue extends RadioValue = RadioValue> {
1612
1662
  value?: TRadioValue;
1613
1663
  disabled?: boolean;
1614
1664
  readOnly?: boolean;
@@ -1616,11 +1666,11 @@ interface Props$d<TRadioValue extends RadioValue = RadioValue> {
1616
1666
  labelPlacement?: RadioLabelPlacement;
1617
1667
  colorScheme?: ColorScheme;
1618
1668
  }
1619
- type NativeAttrs$f = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$d | 'defaultValue' | 'checked' | 'defaultChecked' | 'onChange'>;
1620
- type RadioProps<TRadioValue extends RadioValue = RadioValue> = Props$d<TRadioValue> & NativeAttrs$f;
1621
- declare const Radio: <TRadioValue extends RadioValue = RadioValue>(props: Props$d<TRadioValue> & NativeAttrs$f & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1669
+ type NativeAttrs$e = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$c | 'defaultValue' | 'checked' | 'defaultChecked' | 'onChange'>;
1670
+ type RadioProps<TRadioValue extends RadioValue = RadioValue> = Props$c<TRadioValue> & NativeAttrs$e;
1671
+ declare const Radio: <TRadioValue extends RadioValue = RadioValue>(props: Props$c<TRadioValue> & NativeAttrs$e & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1622
1672
 
1623
- interface Props$c<TRadioValue extends RadioValue = RadioValue> {
1673
+ interface Props$b<TRadioValue extends RadioValue = RadioValue> {
1624
1674
  name?: string;
1625
1675
  value?: TRadioValue;
1626
1676
  defaultValue?: TRadioValue;
@@ -1633,9 +1683,9 @@ interface Props$c<TRadioValue extends RadioValue = RadioValue> {
1633
1683
  color?: RadioColor;
1634
1684
  onChange?: (value: TRadioValue) => void;
1635
1685
  }
1636
- type NativeAttrs$e = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$c>;
1637
- type RadioGroupProps<TRadioValue extends RadioValue = RadioValue> = Props$c<TRadioValue> & NativeAttrs$e;
1638
- declare const RadioGroup: <TRadioValue extends RadioValue = RadioValue>(props: Props$c<TRadioValue> & NativeAttrs$e & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1686
+ type NativeAttrs$d = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$b>;
1687
+ type RadioGroupProps<TRadioValue extends RadioValue = RadioValue> = Props$b<TRadioValue> & NativeAttrs$d;
1688
+ declare const RadioGroup: <TRadioValue extends RadioValue = RadioValue>(props: Props$b<TRadioValue> & NativeAttrs$d & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1639
1689
 
1640
1690
  interface RadioGroupContextValue {
1641
1691
  name: string;
@@ -1653,16 +1703,16 @@ declare const useRadioGroup: () => RadioGroupContextValue;
1653
1703
 
1654
1704
  type NavRailPlacement = 'left' | 'right';
1655
1705
 
1656
- interface Props$b {
1706
+ interface Props$a {
1657
1707
  startContent?: React.ReactNode;
1658
1708
  endContent?: React.ReactNode;
1659
1709
  placement?: NavRailPlacement;
1660
1710
  }
1661
- type NativeAttrs$d = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$b>;
1662
- type NavRailProps = Props$b & NativeAttrs$d;
1711
+ type NativeAttrs$c = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$a>;
1712
+ type NavRailProps = Props$a & NativeAttrs$c;
1663
1713
  declare const NavRail: React.FC<NavRailProps>;
1664
1714
 
1665
- interface Props$a {
1715
+ interface Props$9 {
1666
1716
  as?: React.ElementType;
1667
1717
  icon?: React.ReactNode;
1668
1718
  media?: React.ReactNode;
@@ -1672,11 +1722,11 @@ interface Props$a {
1672
1722
  label?: React.HTMLAttributes<HTMLDivElement>;
1673
1723
  };
1674
1724
  }
1675
- type NativeAttrs$c = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$a>;
1676
- type NavRailItemProps = Props$a & NativeAttrs$c;
1677
- declare const NavRailItem: react.ForwardRefExoticComponent<Props$a & NativeAttrs$c & react.RefAttributes<HTMLDivElement>>;
1725
+ type NativeAttrs$b = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9>;
1726
+ type NavRailItemProps = Props$9 & NativeAttrs$b;
1727
+ declare const NavRailItem: react.ForwardRefExoticComponent<Props$9 & NativeAttrs$b & react.RefAttributes<HTMLDivElement>>;
1678
1728
 
1679
- type Props$9 = {
1729
+ type Props$8 = {
1680
1730
  as?: React.ElementType;
1681
1731
  label: React.ReactNode;
1682
1732
  span?: Responsive<number>;
@@ -1692,20 +1742,20 @@ type Props$9 = {
1692
1742
  mq: ContainerMediaQuery;
1693
1743
  }) => React.ReactNode;
1694
1744
  } & FormatOptions;
1695
- type NativeAttrs$b = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9 | 'children'>;
1696
- type DescriptionProps = Props$9 & NativeAttrs$b;
1745
+ type NativeAttrs$a = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$8 | 'children'>;
1746
+ type DescriptionProps = Props$8 & NativeAttrs$a;
1697
1747
  declare const Description: react.ForwardRefExoticComponent<DescriptionProps & react.RefAttributes<HTMLDivElement>>;
1698
1748
 
1699
- type NativeAttrs$a = React.HTMLAttributes<HTMLDivElement>;
1700
- type DescriptionEmptyProps = NativeAttrs$a;
1701
- declare const DescriptionEmpty: react.ForwardRefExoticComponent<NativeAttrs$a & react.RefAttributes<HTMLDivElement>>;
1749
+ type NativeAttrs$9 = React.HTMLAttributes<HTMLDivElement>;
1750
+ type DescriptionEmptyProps = NativeAttrs$9;
1751
+ declare const DescriptionEmpty: react.ForwardRefExoticComponent<NativeAttrs$9 & react.RefAttributes<HTMLDivElement>>;
1702
1752
 
1703
1753
  type DescriptionsLayout = 'row' | 'col';
1704
1754
  type DescriptionsSize = 'sm' | 'md' | 'lg';
1705
1755
  type DescriptionsAlign = React.CSSProperties['textAlign'];
1706
1756
  type DescriptionsMode = 'container' | 'screen' | 'css';
1707
1757
 
1708
- interface Props$8 {
1758
+ interface Props$7 {
1709
1759
  as?: React.ElementType;
1710
1760
  mode?: DescriptionsMode;
1711
1761
  items?: DescriptionProps[];
@@ -1716,9 +1766,9 @@ interface Props$8 {
1716
1766
  labelAlign?: Responsive<DescriptionsAlign>;
1717
1767
  contentAlign?: Responsive<DescriptionsAlign>;
1718
1768
  }
1719
- type NativeAttrs$9 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$8 | 'children'>;
1720
- type DescriptionsProps = Props$8 & NativeAttrs$9;
1721
- declare const Descriptions: react.ForwardRefExoticComponent<Props$8 & NativeAttrs$9 & react.RefAttributes<HTMLDivElement>>;
1769
+ type NativeAttrs$8 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7 | 'children'>;
1770
+ type DescriptionsProps = Props$7 & NativeAttrs$8;
1771
+ declare const Descriptions: react.ForwardRefExoticComponent<Props$7 & NativeAttrs$8 & react.RefAttributes<HTMLDivElement>>;
1722
1772
 
1723
1773
  interface DescriptionsContextValue {
1724
1774
  mq: ContainerMediaQuery;
@@ -1731,9 +1781,9 @@ interface DescriptionsContextValue {
1731
1781
  declare const DescriptionsContext: react.Context<DescriptionsContextValue | null>;
1732
1782
  declare const useDescriptionsContext: () => DescriptionsContextValue;
1733
1783
 
1734
- type NativeAttrs$8 = React.HTMLAttributes<HTMLDivElement>;
1735
- type DescriptionTextProps = NativeAttrs$8;
1736
- declare const DescriptionText: react.ForwardRefExoticComponent<NativeAttrs$8 & react.RefAttributes<HTMLDivElement>>;
1784
+ type NativeAttrs$7 = React.HTMLAttributes<HTMLDivElement>;
1785
+ type DescriptionTextProps = NativeAttrs$7;
1786
+ declare const DescriptionText: react.ForwardRefExoticComponent<NativeAttrs$7 & react.RefAttributes<HTMLDivElement>>;
1737
1787
 
1738
1788
  declare function reactNodeToText(node: React.ReactNode): string;
1739
1789
 
@@ -1753,14 +1803,14 @@ interface ResponsiveProps$2 {
1753
1803
  justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1754
1804
  alignItems?: Responsive<React.CSSProperties['alignItems']>;
1755
1805
  }
1756
- type Props$7 = {
1806
+ type Props$6 = {
1757
1807
  as?: React.ElementType;
1758
1808
  } & ResponsiveProps$2;
1759
- type NativeAttrs$7 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7>;
1760
- type GridItemProps = Props$7 & NativeAttrs$7;
1809
+ type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
1810
+ type GridItemProps = Props$6 & NativeAttrs$6;
1761
1811
  declare const GridItem: react.ForwardRefExoticComponent<{
1762
1812
  as?: React.ElementType;
1763
- } & ResponsiveProps$2 & NativeAttrs$7 & react.RefAttributes<HTMLDivElement>>;
1813
+ } & ResponsiveProps$2 & NativeAttrs$6 & react.RefAttributes<HTMLDivElement>>;
1764
1814
 
1765
1815
  interface ResponsiveProps$1 {
1766
1816
  cols?: Responsive<number>;
@@ -1778,14 +1828,14 @@ interface ResponsiveProps$1 {
1778
1828
  justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1779
1829
  alignItems?: Responsive<React.CSSProperties['alignItems']>;
1780
1830
  }
1781
- type Props$6 = {
1831
+ type Props$5 = {
1782
1832
  items?: GridItemProps[];
1783
1833
  } & ResponsiveProps$1;
1784
- type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
1785
- type GridSubProps = Props$6 & NativeAttrs$6;
1834
+ type NativeAttrs$5 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5>;
1835
+ type GridSubProps = Props$5 & NativeAttrs$5;
1786
1836
  declare const GridSub: react.ForwardRefExoticComponent<{
1787
1837
  items?: GridItemProps[];
1788
- } & ResponsiveProps$1 & NativeAttrs$6 & react.RefAttributes<HTMLDivElement>>;
1838
+ } & ResponsiveProps$1 & NativeAttrs$5 & react.RefAttributes<HTMLDivElement>>;
1789
1839
 
1790
1840
  type GridMode = 'container' | 'screen' | 'css';
1791
1841
 
@@ -1807,16 +1857,16 @@ interface ResponsiveProps {
1807
1857
  wrapper?: React.HTMLAttributes<HTMLDivElement>;
1808
1858
  };
1809
1859
  }
1810
- type Props$5 = {
1860
+ type Props$4 = {
1811
1861
  mode?: GridMode;
1812
1862
  items?: (GridItemProps | GridSubProps)[];
1813
1863
  } & ResponsiveProps;
1814
- type NativeAttrs$5 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5>;
1815
- type GridProps = Props$5 & NativeAttrs$5;
1864
+ type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
1865
+ type GridProps = Props$4 & NativeAttrs$4;
1816
1866
  declare const Grid: react.ForwardRefExoticComponent<{
1817
1867
  mode?: GridMode;
1818
1868
  items?: (GridItemProps | GridSubProps)[];
1819
- } & ResponsiveProps & NativeAttrs$5 & react.RefAttributes<HTMLDivElement>>;
1869
+ } & ResponsiveProps & NativeAttrs$4 & react.RefAttributes<HTMLDivElement>>;
1820
1870
 
1821
1871
  interface GridContextValue {
1822
1872
  mq: ContainerMediaQuery;
@@ -1836,7 +1886,7 @@ declare const Html: React.FC<HtmlProps>;
1836
1886
 
1837
1887
  type StepColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
1838
1888
 
1839
- interface Props$4 {
1889
+ interface Props$3 {
1840
1890
  value?: string | number | symbol;
1841
1891
  title: React.ReactNode;
1842
1892
  subtitle: React.ReactNode;
@@ -1844,18 +1894,18 @@ interface Props$4 {
1844
1894
  color?: StepColor;
1845
1895
  disabled?: boolean;
1846
1896
  }
1847
- type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
1848
- type StepProps = Props$4 & NativeAttrs$4;
1897
+ type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3>;
1898
+ type StepProps = Props$3 & NativeAttrs$3;
1849
1899
  declare const Step: React.FC<StepProps>;
1850
1900
 
1851
- interface Props$3 {
1901
+ interface Props$2 {
1852
1902
  direction?: 'horizontal' | 'vertical';
1853
1903
  value?: number | string | symbol;
1854
1904
  color?: StepColor;
1855
1905
  markPreviousAsChecked?: boolean;
1856
1906
  }
1857
- type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3>;
1858
- type StepsProps = Props$3 & NativeAttrs$3;
1907
+ type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2>;
1908
+ type StepsProps = Props$2 & NativeAttrs$2;
1859
1909
  declare const Steps: React.FC<StepsProps>;
1860
1910
 
1861
1911
  interface StepsContextValue {
@@ -1893,12 +1943,12 @@ interface TreeItemData {
1893
1943
  levelAlignment: number;
1894
1944
  }
1895
1945
 
1896
- interface Props$2 extends TreeItemBase {
1946
+ interface Props$1 extends TreeItemBase {
1897
1947
  title: string;
1898
- items?: Props$2[];
1948
+ items?: Props$1[];
1899
1949
  }
1900
- type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2 | 'items'>;
1901
- type TreeItemProps = Props$2 & NativeAttrs$2;
1950
+ type NativeAttrs$1 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$1 | 'items'>;
1951
+ type TreeItemProps = Props$1 & NativeAttrs$1;
1902
1952
  declare const TreeItem: (props: TreeItemProps) => react_jsx_runtime.JSX.Element;
1903
1953
 
1904
1954
  interface TreeProps$1 {
@@ -1950,49 +2000,79 @@ interface DropdownProps {
1950
2000
  onClose?: () => void;
1951
2001
  children: ((options: {
1952
2002
  isOpen: boolean;
1953
- }) => React.ReactNode) | React.ReactNode;
2003
+ }) => react.ReactNode) | react.ReactNode;
1954
2004
  }
1955
- declare const Dropdown: (props: DropdownProps) => react_jsx_runtime.JSX.Element;
2005
+ declare const Dropdown: {
2006
+ (props: DropdownProps): react_jsx_runtime.JSX.Element;
2007
+ displayName: string;
2008
+ };
1956
2009
 
1957
- interface DropdownContentProps {
1958
- children: React.ReactNode;
2010
+ interface DropdownTriggerProps {
2011
+ children: react.ReactElement;
2012
+ className?: string;
1959
2013
  }
1960
- declare const DropdownContent: (props: DropdownContentProps) => react_jsx_runtime.JSX.Element;
2014
+ declare const DropdownTrigger: {
2015
+ (props: DropdownTriggerProps): react_jsx_runtime.JSX.Element;
2016
+ displayName: string;
2017
+ };
1961
2018
 
1962
- interface DropdownContextValue {
1963
- isOpen: boolean;
1964
- onClose(): void;
1965
- onOpen(): void;
1966
- onToggle(): void;
1967
- floatingRootContext: FloatingRootContext;
1968
- triggerElement: Element | null;
1969
- setTriggerElement(el: Element | null): void;
1970
- getTriggerProps(externalProps?: React.HTMLAttributes<any> & {
1971
- ref?: React.Ref<any> | undefined;
1972
- }): React.HTMLAttributes<any> & {
1973
- ref?: React.Ref<any> | undefined;
2019
+ type DropdownSize = 'sm' | 'md' | 'lg';
2020
+
2021
+ type Side = 'top' | 'bottom' | 'left' | 'right' | 'inline-start' | 'inline-end';
2022
+ type Align = 'start' | 'end' | 'center';
2023
+ type OffsetFunction = (data: {
2024
+ side: Side;
2025
+ align: Align;
2026
+ anchor: {
2027
+ width: number;
2028
+ height: number;
1974
2029
  };
1975
- contentElement: Element | null;
1976
- setContentElement(el: HTMLElement | null): void;
1977
- getContentProps(externalProps?: React.HTMLAttributes<any> & {
1978
- ref?: React.Ref<any> | undefined;
1979
- }): React.HTMLAttributes<any> & {
1980
- ref?: React.Ref<any> | undefined;
2030
+ positioner: {
2031
+ width: number;
2032
+ height: number;
1981
2033
  };
2034
+ }) => number;
2035
+ interface DropdownContentProps {
2036
+ children: react.ReactNode;
2037
+ className?: string;
2038
+ sideOffset?: number | OffsetFunction;
2039
+ size?: DropdownSize;
2040
+ style?: react.CSSProperties;
1982
2041
  }
1983
- declare const DropdownContext: react.Context<DropdownContextValue | null>;
1984
- declare const useDropdownContext: () => DropdownContextValue;
2042
+ declare const DropdownContent: react.ForwardRefExoticComponent<DropdownContentProps & react.RefAttributes<HTMLDivElement>>;
1985
2043
 
1986
- interface Props$1 {
2044
+ interface DropdownItemProps extends Omit<ListItemProps, 'as' | 'level' | 'hoverable'> {
2045
+ disabled?: boolean;
2046
+ className?: string;
1987
2047
  }
1988
- type NativeAttrs$1 = Omit<ListItemProps, keyof Props$1>;
1989
- type DropdownItemProps = Props$1 & NativeAttrs$1;
1990
- declare const DropdownItem: (props: DropdownItemProps) => react_jsx_runtime.JSX.Element;
2048
+ declare const DropdownItem: react.ForwardRefExoticComponent<DropdownItemProps & react.RefAttributes<HTMLDivElement>>;
1991
2049
 
1992
- interface DropdownTriggerProps {
1993
- children: React.ReactNode;
2050
+ interface DropdownSeparatorProps extends react.ComponentPropsWithoutRef<typeof Menu$1.Separator> {
2051
+ className?: string;
1994
2052
  }
1995
- declare const DropdownTrigger: (props: DropdownTriggerProps) => react.ReactElement<any, string | react.JSXElementConstructor<any>>;
2053
+ declare const DropdownSeparator: react.ForwardRefExoticComponent<DropdownSeparatorProps & react.RefAttributes<HTMLDivElement>>;
2054
+
2055
+ interface DropdownArrowProps extends react.ComponentPropsWithoutRef<typeof Menu$1.Arrow> {
2056
+ children?: react.ReactNode;
2057
+ className?: string;
2058
+ }
2059
+ declare const DropdownArrow: react.ForwardRefExoticComponent<DropdownArrowProps & react.RefAttributes<HTMLDivElement>>;
2060
+
2061
+ interface DropdownSubmenuProps {
2062
+ children: react.ReactNode;
2063
+ className?: string;
2064
+ }
2065
+ declare const DropdownSubmenu: {
2066
+ (props: DropdownSubmenuProps): react_jsx_runtime.JSX.Element;
2067
+ displayName: string;
2068
+ };
2069
+
2070
+ interface DropdownSubmenuTriggerItemProps extends Omit<react.ComponentPropsWithoutRef<typeof Menu$1.SubmenuTrigger>, 'children' | 'render' | 'title'>, Omit<ListItemBaseProps, 'as' | 'hoverable' | 'level'> {
2071
+ showChevron?: boolean;
2072
+ chevronIcon?: react.ReactNode;
2073
+ className?: string;
2074
+ }
2075
+ declare const DropdownSubmenuTriggerItem: react.ForwardRefExoticComponent<DropdownSubmenuTriggerItemProps & react.RefAttributes<HTMLDivElement>>;
1996
2076
 
1997
2077
  interface ListTreeItemIndentationProps {
1998
2078
  level: number;
@@ -2055,27 +2135,32 @@ interface UploadFileProps {
2055
2135
  }
2056
2136
  declare const UploadFiles: ({ data, max, readOnly, disabled, accept, multiple, onChange }: UploadFileProps) => react_jsx_runtime.JSX.Element;
2057
2137
 
2138
+ type Optional<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
2058
2139
  type Rect = {
2059
2140
  x: number;
2060
2141
  y: number;
2061
2142
  width: number;
2062
2143
  height: number;
2063
2144
  };
2064
- type Cursor = {
2065
- x: number;
2066
- y: number;
2067
- };
2068
- type StackMeta = {
2145
+ type LayoutMeta = {
2069
2146
  id: string;
2147
+ title: string;
2070
2148
  x: number;
2071
2149
  y: number;
2072
2150
  width: number;
2073
2151
  height: number;
2152
+ minWidth?: number;
2153
+ maxWidth?: number;
2154
+ minHeight?: number;
2155
+ maxHeight?: number;
2156
+ adaptive?: boolean;
2157
+ readOnly?: boolean;
2074
2158
  };
2075
- type WindowMeta = {
2159
+ type PanelMeta<TData extends Record<string, any> = Record<string, any>> = {
2076
2160
  id: string;
2077
2161
  title: string;
2078
- content?: react__default.ReactNode;
2162
+ icon?: React.ReactNode;
2163
+ render?: React.ReactNode;
2079
2164
  x?: number;
2080
2165
  y?: number;
2081
2166
  width?: number;
@@ -2083,144 +2168,217 @@ type WindowMeta = {
2083
2168
  minimized?: boolean;
2084
2169
  maximized?: boolean;
2085
2170
  snapped?: boolean;
2171
+ dock: boolean;
2172
+ docked: boolean;
2173
+ undockLayoutId?: string;
2174
+ zIndex: number;
2175
+ zIndexFloating: number;
2176
+ zIndexLayout: number;
2177
+ layoutId?: string;
2178
+ layoutMinimized?: boolean;
2179
+ closable: boolean;
2086
2180
  closed?: boolean;
2087
- zIndex?: number;
2088
- stackId?: string;
2089
- };
2090
- declare function useMove(props: {
2091
- rect: Rect;
2092
- minWidth?: number;
2093
- minHeight?: number;
2094
- maxWidth?: number;
2095
- maxHeight?: number;
2096
- initialWidth?: number;
2097
- initialHeight?: number;
2098
- initialX?: number;
2099
- initialY?: number;
2100
- x?: number;
2101
- y?: number;
2102
- width?: number;
2103
- height?: number;
2104
- onSize?: (rect: Rect & {
2105
- maximized?: boolean;
2106
- }) => void;
2107
- onDrag?: (rect: Rect, cursor: Cursor) => void;
2108
- onDragEnd?: (rect: Rect, cursor: Cursor) => void;
2109
- visible?: boolean;
2110
- parentRef: react__default.RefObject<HTMLDivElement | null>;
2111
- useTransform?: boolean;
2112
- prevBoundsRef: react__default.MutableRefObject<{
2113
- x: number;
2114
- y: number;
2115
- width: number;
2116
- height: number;
2117
- } | null>;
2118
- zIndex?: number;
2119
- disabled?: boolean;
2120
- }): {
2121
- windowRef: react__default.MutableRefObject<HTMLDivElement | null>;
2122
- rect: {
2123
- x: number;
2124
- y: number;
2125
- width: number;
2126
- height: number;
2127
- };
2128
- style: react__default.CSSProperties;
2129
- visible: boolean;
2130
- onPointerDown_drag: (e: react__default.PointerEvent) => void;
2131
- positionStyles: react__default.CSSProperties;
2132
- };
2133
- declare function useResize({ parentRef, rect, disabled, minWidth, minHeight, maxWidth, maxHeight, onRect, }: {
2134
- parentRef: react__default.RefObject<HTMLDivElement | null>;
2135
- rect: Rect;
2136
2181
  minWidth?: number;
2137
2182
  maxWidth?: number;
2138
2183
  minHeight?: number;
2139
2184
  maxHeight?: number;
2140
- disabled?: boolean;
2141
- onRect: (rect: Rect) => void;
2142
- }): {
2143
- handles: string[];
2144
- disabled: boolean | undefined;
2145
- onResize: (e: react__default.PointerEvent, dir: string) => void;
2146
- };
2147
- declare function useSnapPreview({ parentRef, onDragEnd, }: {
2148
- parentRef: react__default.RefObject<HTMLDivElement | null>;
2149
- rect: Rect;
2150
- onDragEnd: (rect: Rect, maximized: boolean, snapped: boolean) => void;
2151
- }): {
2152
- rect?: Rect | undefined;
2153
- style?: {
2154
- left: number;
2155
- top: number;
2156
- width: number;
2157
- height: number;
2158
- } | undefined;
2159
- onDrag: (nx: number, ny: number, cursorX: number, cursorY: number) => void;
2160
- onDragEnd: () => void;
2185
+ data: TData;
2161
2186
  };
2162
- declare function useWindow({ parentRef, prevBoundsRef, meta, parentRect, isMobile, initialWidth, initialHeight, initialX, initialY, onUpdate, }: {
2163
- parentRef: react__default.RefObject<HTMLDivElement | null>;
2164
- prevBoundsRef?: react__default.MutableRefObject<{
2165
- x: number;
2166
- y: number;
2167
- width: number;
2168
- height: number;
2169
- } | null>;
2170
- meta: WindowMeta;
2171
- parentRect?: {
2172
- width?: number;
2173
- height?: number;
2174
- };
2175
- isMobile?: boolean;
2176
- initialWidth?: number;
2177
- initialHeight?: number;
2178
- initialX?: number;
2179
- initialY?: number;
2180
- onUpdate: (patch: Partial<WindowMeta>) => void;
2187
+ type Direction = 'top' | 'bottom' | 'left' | 'right';
2188
+ interface EdgeFlags {
2189
+ top: boolean;
2190
+ bottom: boolean;
2191
+ left: boolean;
2192
+ right: boolean;
2193
+ }
2194
+ interface LayoutRect {
2195
+ id: string;
2196
+ title: string;
2197
+ adaptive: boolean;
2198
+ readOnly: boolean;
2199
+ gridX: number;
2200
+ gridY: number;
2201
+ gridW: number;
2202
+ gridH: number;
2203
+ isEmpty: boolean;
2204
+ isVertical: boolean;
2205
+ baseFull: Rect;
2206
+ baseEmpty: Rect;
2207
+ dimensions: Rect;
2208
+ fullDimensions: Rect;
2209
+ emptyDimensions: Rect;
2210
+ dropZoneRect: Rect;
2211
+ dropAreaRect: Rect;
2212
+ edges: LayoutEdge[];
2213
+ gridEdges: EdgeFlags;
2214
+ gridBorders: EdgeFlags;
2215
+ neighbors: Partial<Record<Direction, string | null>>;
2216
+ realNeighbors: Partial<Record<Direction, string | null>>;
2217
+ actualNeighbors: Partial<Record<Direction, string | null>>;
2218
+ expansionNeighbors: Partial<Record<Direction, string | null>>;
2219
+ collisionNeighbors: Partial<Record<Direction, string | null>>;
2220
+ }
2221
+ interface LayoutEdge {
2222
+ layoutId: string | null;
2223
+ direction: Direction;
2224
+ border: boolean;
2225
+ }
2226
+
2227
+ declare function useLayoutPanelManager({ layouts, setLayouts, panels, setPanels, windowContainerRef, layoutContainerRef, }: {
2228
+ layouts: LayoutMeta[];
2229
+ setLayouts: React.Dispatch<React.SetStateAction<LayoutMeta[]>>;
2230
+ panels: PanelMeta[];
2231
+ setPanels: React.Dispatch<React.SetStateAction<PanelMeta[]>>;
2232
+ windowContainerRef: React.RefObject<HTMLDivElement>;
2233
+ layoutContainerRef: React.RefObject<HTMLDivElement>;
2181
2234
  }): {
2182
- rect: {
2183
- x: number;
2184
- y: number;
2185
- width: number;
2186
- height: number;
2187
- };
2188
- setPos: react__default.Dispatch<react__default.SetStateAction<{
2189
- x: number;
2190
- y: number;
2191
- }>>;
2192
- setSize: react__default.Dispatch<react__default.SetStateAction<{
2193
- width: number;
2194
- height: number;
2195
- }>>;
2196
- onToggleMaximize: () => void;
2235
+ isMobile: boolean;
2236
+ layouts: LayoutMeta[];
2237
+ setLayouts: react.Dispatch<react.SetStateAction<LayoutMeta[]>>;
2238
+ panels: PanelMeta[];
2239
+ panelsRef: react.MutableRefObject<PanelMeta[]>;
2240
+ setPanels: react.Dispatch<react.SetStateAction<PanelMeta[]>>;
2241
+ layoutContainerRef: react.RefObject<HTMLDivElement>;
2242
+ windowContainerRef: react.RefObject<HTMLDivElement>;
2243
+ windowContainerRect: Rect;
2244
+ layoutContainerRect: Rect;
2245
+ panelPrevRectsRef: react.MutableRefObject<Record<string, Rect>>;
2246
+ activePanelId: string | null;
2247
+ activePanel: PanelMeta | undefined;
2248
+ activeFloatingPanel: string | null;
2249
+ layoutPanelIds: Record<string, string[]>;
2250
+ createPanel: <TData extends Record<string, any> = Record<string, any>>(panel: Optional<Omit<PanelMeta<TData>, "zIndex" | "zIndexFloating" | "zIndexLayout">, "id" | "dock" | "docked" | "closable" | "data">) => string;
2251
+ selectPanel: (id: string) => void;
2252
+ updatePanel: (id: string, patch: Partial<PanelMeta>) => void;
2253
+ closePanel: (id: string) => void;
2254
+ minimizePanel: (id: string) => void;
2255
+ dockPanel: (id: string) => void;
2256
+ undockPanel: (id: string) => void;
2257
+ maximizeLayoutPanel: (id: string) => void;
2258
+ minimizeLayoutPanel: (id: string) => void;
2259
+ layoutRects: LayoutRect[];
2260
+ simulateLayoutPositions: (panelId: string, layoutId: string) => LayoutRect[];
2261
+ hoveredLayoutIdRef: react.MutableRefObject<Record<string, string | null>>;
2262
+ hoveredLayoutId: Record<string, string | null>;
2263
+ setHoveredLayoutId: react.Dispatch<react.SetStateAction<Record<string, string | null>>>;
2264
+ hoveredPanelIdsRef: react.MutableRefObject<Record<string, string | null>>;
2265
+ hoveredPanelIds: Record<string, string | null>;
2266
+ setHoveredPanelIds: react.Dispatch<react.SetStateAction<Record<string, string | null>>>;
2267
+ activePanelsByLayout: Record<string, string | null>;
2268
+ updateLayoutSize: (layoutId: string, newRect: Rect, isResizing?: boolean) => void;
2269
+ registerTabDragHandler: (panelId: string, handler: (event: React.PointerEvent) => void) => void;
2270
+ getTabDragHandler: (panelId: string) => (event: React.PointerEvent) => void;
2197
2271
  };
2198
- declare function useWindowStack({ windows, setWindows, windowContainerRef, stackContainerRef, }: {
2199
- windows: WindowMeta[];
2200
- setWindows: react__default.Dispatch<react__default.SetStateAction<WindowMeta[]>>;
2201
- windowContainerRef: react__default.RefObject<HTMLDivElement>;
2202
- stackContainerRef: react__default.RefObject<HTMLDivElement>;
2203
- }): {
2272
+ type LayoutManagerInstance = ReturnType<typeof useLayoutPanelManager>;
2273
+
2274
+ declare const useLayoutManager: () => {
2204
2275
  isMobile: boolean;
2276
+ layouts: LayoutMeta[];
2277
+ setLayouts: react__default.Dispatch<react__default.SetStateAction<LayoutMeta[]>>;
2278
+ panels: PanelMeta[];
2279
+ panelsRef: react__default.MutableRefObject<PanelMeta[]>;
2280
+ setPanels: react__default.Dispatch<react__default.SetStateAction<PanelMeta[]>>;
2281
+ layoutContainerRef: react__default.RefObject<HTMLDivElement>;
2282
+ windowContainerRef: react__default.RefObject<HTMLDivElement>;
2205
2283
  windowContainerRect: Rect;
2206
- stackContainerRect: Rect;
2207
- activeWindow: WindowMeta | undefined;
2208
- bringToFront: (id: string) => void;
2209
- updateWindow: (id: string, patch: Partial<WindowMeta>) => void;
2210
- closeWindow: (id: string) => void;
2211
- minimizeWindow: (id: string) => void;
2284
+ layoutContainerRect: Rect;
2285
+ panelPrevRectsRef: react__default.MutableRefObject<Record<string, Rect>>;
2286
+ activePanelId: string | null;
2287
+ activePanel: PanelMeta | undefined;
2288
+ activeFloatingPanel: string | null;
2289
+ layoutPanelIds: Record<string, string[]>;
2290
+ createPanel: <TData extends Record<string, any> = Record<string, any>>(panel: Optional<Omit<PanelMeta<TData>, "zIndex" | "zIndexFloating" | "zIndexLayout">, "id" | "dock" | "docked" | "closable" | "data">) => string;
2291
+ selectPanel: (id: string) => void;
2292
+ updatePanel: (id: string, patch: Partial<PanelMeta>) => void;
2293
+ closePanel: (id: string) => void;
2294
+ minimizePanel: (id: string) => void;
2295
+ dockPanel: (id: string) => void;
2296
+ undockPanel: (id: string) => void;
2297
+ maximizeLayoutPanel: (id: string) => void;
2298
+ minimizeLayoutPanel: (id: string) => void;
2299
+ layoutRects: LayoutRect[];
2300
+ simulateLayoutPositions: (panelId: string, layoutId: string) => LayoutRect[];
2301
+ hoveredLayoutIdRef: react__default.MutableRefObject<Record<string, string | null>>;
2302
+ hoveredLayoutId: Record<string, string | null>;
2303
+ setHoveredLayoutId: react__default.Dispatch<react__default.SetStateAction<Record<string, string | null>>>;
2304
+ hoveredPanelIdsRef: react__default.MutableRefObject<Record<string, string | null>>;
2305
+ hoveredPanelIds: Record<string, string | null>;
2306
+ setHoveredPanelIds: react__default.Dispatch<react__default.SetStateAction<Record<string, string | null>>>;
2307
+ activePanelsByLayout: Record<string, string | null>;
2308
+ updateLayoutSize: (layoutId: string, newRect: Rect, isResizing?: boolean) => void;
2309
+ registerTabDragHandler: (panelId: string, handler: (event: react__default.PointerEvent) => void) => void;
2310
+ getTabDragHandler: (panelId: string) => (event: react__default.PointerEvent) => void;
2212
2311
  };
2213
- declare function WindowManager({ windowContainerRef: externalWindowContainerRef, stackContainerRef: externalStackContainerRef, windows, setWindows, stacks, children, }: {
2214
- windows: WindowMeta[];
2215
- setWindows: react__default.Dispatch<react__default.SetStateAction<WindowMeta[]>>;
2216
- stacks: StackMeta[];
2217
- setStacks: react__default.Dispatch<react__default.SetStateAction<StackMeta[]>>;
2218
- windowContainerRef?: react__default.RefObject<HTMLDivElement>;
2219
- stackContainerRef?: react__default.RefObject<HTMLDivElement>;
2220
- children: react__default.ReactNode | ((options: {
2221
- content: react__default.ReactNode;
2222
- taskbar: react__default.ReactNode;
2223
- }) => react__default.ReactNode);
2312
+ declare function LayoutManager({ children, ...manager }: LayoutManagerInstance & {
2313
+ children: react__default.ReactNode;
2224
2314
  }): react_jsx_runtime.JSX.Element;
2225
2315
 
2226
- 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, type Cursor, 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, Draggable, DraggableContent, type DraggableContentProps, DraggableTrigger, 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, Dropdown, DropdownContent, type DropdownContentProps, DropdownContext, type DropdownContextValue, DropdownItem, type DropdownItemProps, type DropdownProps, DropdownTrigger, type DropdownTriggerProps, Field, type FieldProps, type FormatBooleanOptions, type FormatCurrencyOptions, type FormatDateOptions, type FormatFileSizeOptions, 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, INDENT_SIZE, 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, ListTree, ListTreeContext, type ListTreeContextValue, ListTreeItem, ListTreeItemIndentation, type ListTreeItemProps, type ListTreeProps, 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, ModalContent, type ModalContentProps, 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 Rect, type Resize, type Responsive, Result, type ResultProps, type ResultStatus, STRING_RULES, 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, type StackMeta, Step, type StepColor, type StepProps, Steps, StepsContext, type StepsContextValue, type StepsProps, type StringRules, 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, type Timer, type TimerMode, Toolbar, type ToolbarProps, type ToolbarSize, Transition, type TransitionProps, Tree, TreeContext, type TreeContextValue, TreeItem, type TreeItemBase, type TreeItemData, type TreeItemProps, type TreeItemValue, type TreeProps$1 as TreeProps, type UploadFileData, type UploadFileProps, UploadFiles, type UseContainerMediaQueryOptions, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, type UseResizeObserverOptions, type VirtualItem, type Virtualizer, type VirtualizerOptions, WindowManager, type WindowMeta, areArraysEqual, assignRef, breakpointsMap, clsx, containsPlainText, defaultBreakpoints, doesNotContainEmojis, flattenTree, format, formatCurrency, formatDate, formatDateTime, formatFileSize, formatPercent, formatShortDateTime, formatTime, generateId, getOpenValuesByPathname, hasResizeObserver, initializeTreeValues, isAlphanumeric, isEmpty, isEmptyString, isNumeric, mergeRefs, reactNodeToText, scrollToItem, toAlphaString, toAlphanumericString, toLocalDateString, toLocalDateTimeString, toNotEmojisString, toNumericString, toPlainTextString, toRulesString, updateTreeValues, useAccordion, useAccordionItem, useAutocomplete, useButtonGroup, useCheckboxGroup, useCollapse, useContainerMediaQuery, useDebounce, useDescriptionsContext, useDisclosure, useDrawer, useDropdownContext, useEffectEvent, useElementSize, useFormat, useGridContext, useInfiniteQuery, useLocalStorage, useMediaQuery, useMenu, useMenuItemValue, useModal, useMove, useMutation, useOnClickOutside, usePopover, usePrevious, useQuery, useRadioGroup, useResize, useResizeObserver, useSelect, useSnapPreview, useStep, useStepsContext, useTimer, useTree, useValueEffect, useVirtualizer, useWindow, useWindowStack, validateRules, valueToValues, valuesToValue };
2316
+ declare function LayoutCollisions({ layoutIds }: {
2317
+ layoutIds: string[];
2318
+ }): react_jsx_runtime.JSX.Element | undefined;
2319
+
2320
+ declare function Layouts(): react_jsx_runtime.JSX.Element | undefined;
2321
+
2322
+ declare function Panels(): react_jsx_runtime.JSX.Element;
2323
+
2324
+ declare function Taskbar(): react_jsx_runtime.JSX.Element;
2325
+
2326
+ declare const LayoutsDebug: () => react_jsx_runtime.JSX.Element;
2327
+
2328
+ declare const DropzoneLayouts: () => react_jsx_runtime.JSX.Element | null;
2329
+
2330
+ declare const DockLayouts: () => react_jsx_runtime.JSX.Element;
2331
+
2332
+ declare const usePanel: () => PanelMeta;
2333
+ declare const usePanelData: <TData extends Record<string, any>>() => TData;
2334
+
2335
+ interface NavigationMenuItemProps extends Omit<ListItemProps, 'hoverable' | 'level'> {
2336
+ children?: react.ReactNode;
2337
+ className?: string;
2338
+ style?: react.CSSProperties;
2339
+ onClick?: react.MouseEventHandler<HTMLDivElement>;
2340
+ }
2341
+ declare const NavigationMenuItem: react.ForwardRefExoticComponent<NavigationMenuItemProps & react.RefAttributes<HTMLDivElement>>;
2342
+
2343
+ interface NavigationMenuGroupProps {
2344
+ label?: string;
2345
+ children: react.ReactNode;
2346
+ className?: string;
2347
+ }
2348
+ declare const NavigationMenuGroup: react.ForwardRefExoticComponent<NavigationMenuGroupProps & react.RefAttributes<HTMLDivElement>>;
2349
+
2350
+ interface NavigationMenuSeparatorProps {
2351
+ className?: string;
2352
+ }
2353
+ declare const NavigationMenuSeparator: react.ForwardRefExoticComponent<NavigationMenuSeparatorProps & react.RefAttributes<HTMLDivElement>>;
2354
+
2355
+ interface NavigationMenuGridProps {
2356
+ columns?: 1 | 2 | 3 | 4;
2357
+ gap?: string;
2358
+ children: react.ReactNode;
2359
+ className?: string;
2360
+ }
2361
+ declare const NavigationMenuGrid: react.ForwardRefExoticComponent<NavigationMenuGridProps & react.RefAttributes<HTMLDivElement>>;
2362
+
2363
+ type NavigationMenuSize = 'sm' | 'md' | 'lg';
2364
+ interface NavigationMenuProps extends react.ComponentPropsWithoutRef<typeof NavigationMenu$1.Root> {
2365
+ size?: NavigationMenuSize;
2366
+ }
2367
+ declare const NavigationMenu: react.ForwardRefExoticComponent<NavigationMenuProps & react.RefAttributes<HTMLElement>>;
2368
+ declare const NavigationMenuList: react.ForwardRefExoticComponent<Omit<_base_ui_react_navigation_menu.NavigationMenuListProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
2369
+ interface NavigationMenuTriggerItemProps extends Omit<react.ComponentPropsWithoutRef<typeof NavigationMenu$1.Trigger>, 'title'>, Omit<ListItemBaseProps, 'as' | 'hoverable' | 'level'> {
2370
+ showChevron?: boolean;
2371
+ }
2372
+ declare const NavigationMenuTriggerItem: react.ForwardRefExoticComponent<NavigationMenuTriggerItemProps & react.RefAttributes<HTMLButtonElement>>;
2373
+ declare const NavigationMenuContent: react.ForwardRefExoticComponent<Omit<_base_ui_react_navigation_menu.NavigationMenuContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
2374
+ declare const NavigationMenuLink: react.ForwardRefExoticComponent<Omit<_base_ui_react_navigation_menu.NavigationMenuLinkProps & react.RefAttributes<HTMLAnchorElement>, "ref"> & react.RefAttributes<HTMLAnchorElement>>;
2375
+ declare const NavigationMenuIcon: react.ForwardRefExoticComponent<Omit<_base_ui_react_navigation_menu.NavigationMenuIconProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
2376
+ declare const NavigationMenuPortal: react.ForwardRefExoticComponent<_base_ui_react_navigation_menu.NavigationMenuPortalProps & react.RefAttributes<HTMLDivElement>>;
2377
+ declare const NavigationMenuPositioner: react.ForwardRefExoticComponent<Omit<_base_ui_react_navigation_menu.NavigationMenuPositionerProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
2378
+ declare const NavigationMenuPopup: react.ForwardRefExoticComponent<Omit<_base_ui_react_navigation_menu.NavigationMenuPopupProps & react.RefAttributes<HTMLElement>, "ref"> & react.RefAttributes<HTMLElement>>;
2379
+ declare const NavigationMenuArrow: react.ForwardRefExoticComponent<Omit<_base_ui_react_navigation_menu.NavigationMenuArrowProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
2380
+ declare const NavigationMenuViewport: react.ForwardRefExoticComponent<Omit<_base_ui_react_navigation_menu.NavigationMenuViewportProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
2381
+
2382
+ declare const NavigationMenuItemRoot: react.ForwardRefExoticComponent<_base_ui_react_navigation_menu.NavigationMenuItemProps & react.RefAttributes<HTMLDivElement>>;
2383
+
2384
+ 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, type AutocompleteItem, type AutocompleteKeyField, 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, Draggable, DraggableContent, type DraggableContentProps, DraggableTrigger, 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, Dropdown, DropdownArrow, type DropdownArrowProps, DropdownContent, type DropdownContentProps, DropdownItem, type DropdownItemProps, type DropdownProps, DropdownSeparator, type DropdownSeparatorProps, type DropdownSize, DropdownSubmenu, type DropdownSubmenuProps, DropdownSubmenuTriggerItem, DropdownTrigger, type DropdownTriggerProps, Field, type FieldProps, type FormatBooleanOptions, type FormatCurrencyOptions, type FormatDateOptions, type FormatFileSizeOptions, 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, INDENT_SIZE, Icon, type IconColor, type IconProps, type IconSize, Iframe, type IframeProps, type InfiniteData, type InfiniteQueryFunction, type InfiniteQueryOptions, type InfiniteQueryRefetchOptions, type InputBaseProps, InputClose, type InputCloseProps, type InputColor, InputGroup, type InputGroupProps, InputSelector, type InputSelectorProps, type InputSize, type InputVariant, InputWrapper, type InputWrapperProps, LayoutManager, LayoutCollisions as LayoutManagerColissions, DockLayouts as LayoutManagerDockLayouts, DropzoneLayouts as LayoutManagerDropzoneLayouts, type LayoutManagerInstance, Layouts as LayoutManagerLayouts, Panels as LayoutManagerPanels, Taskbar as LayoutManagerTaskbar, type LayoutMeta, LayoutsDebug, List, ListGroup, type ListGroupProps, ListItem, type ListItemProps, type ListProps, type ListSize, ListSubheader, type ListSubheaderProps, ListTree, ListTreeContext, type ListTreeContextValue, ListTreeItem, ListTreeItemIndentation, type ListTreeItemProps, type ListTreeProps, 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, ModalContent, type ModalContentProps, 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, NavigationMenu, NavigationMenuArrow, NavigationMenuContent, NavigationMenuGrid, type NavigationMenuGridProps, NavigationMenuGroup, type NavigationMenuGroupProps, NavigationMenuIcon, NavigationMenuItem, type NavigationMenuItemProps, NavigationMenuItemRoot, NavigationMenuLink, NavigationMenuList, NavigationMenuPopup, NavigationMenuPortal, NavigationMenuPositioner, type NavigationMenuProps, NavigationMenuSeparator, type NavigationMenuSeparatorProps, type NavigationMenuSize, NavigationMenuTriggerItem, NavigationMenuViewport, type PanelMeta, 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, STRING_RULES, type ScrollAlignment, ScrollArea, type ScrollAreaProps, type ScrollBehavior, type ScrollToOptions, Select, type SelectClearable, SelectContext, type SelectContextValue, type SelectMultiple, type SelectProps, type SelectionItem$1 as SelectionItem, type SelectionOnChange$1 as SelectionOnChange, type SelectionProps$1 as SelectionProps, type SelectionValue$1 as SelectionValue, Step, type StepColor, type StepProps, Steps, StepsContext, type StepsContextValue, type StepsProps, type StringRules, 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, type Timer, type TimerMode, Toolbar, type ToolbarColor, type ToolbarProps, type ToolbarSize, type ToolbarVariant, Transition, type TransitionProps, Tree, TreeContext, type TreeContextValue, TreeItem, type TreeItemBase, type TreeItemData, type TreeItemProps, type TreeItemValue, type TreeProps$1 as TreeProps, type UploadFileData, type UploadFileProps, UploadFiles, type UseContainerMediaQueryOptions, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, type UseResizeObserverOptions, type VirtualItem, type Virtualizer, type VirtualizerOptions, areArraysEqual, assignRef, breakpointsMap, clsx, containsPlainText, defaultBreakpoints, doesNotContainEmojis, flattenTree, format, formatCurrency, formatDate, formatDateTime, formatFileSize, formatPercent, formatShortDateTime, formatTime, generateId, getOpenValuesByPathname, hasResizeObserver, initializeTreeValues, isAlphanumeric, isEmpty, isEmptyString, isNumeric, mergeRefs, reactNodeToText, scrollToItem, toAlphaString, toAlphanumericString, toLocalDateString, toLocalDateTimeString, toNotEmojisString, toNumericString, toPlainTextString, toRulesString, updateTreeValues, useAccordion, useAccordionItem, useButtonGroup, useCheckboxGroup, useCollapse, useContainerMediaQuery, useDebounce, useDescriptionsContext, useDisclosure, useDrawer, useEffectEvent, useElementSize, useExtractProps, useFormat, useGridContext, useInfiniteQuery, useInputProps, useLayoutManager, usePanel as useLayoutManagerPanel, usePanelData as useLayoutManagerPanelData, useLayoutPanelManager, useLocalStorage, useMediaQuery, useMenu, useMenuItemValue, useModal, useMutation, useOnClickOutside, usePopover, usePrevious, useQuery, useRadioGroup, useResizeObserver, useSelect, useStep, useStepsContext, useTimer, useTree, useValueEffect, useVirtualizer, validateRules, valueToValues, valuesToValue };