@unifiedsoftware/react-ui 2.0.0-alpha.3 → 2.0.0-alpha.31

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