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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/index.d.ts +643 -272
  2. package/dist/index.js +33 -1
  3. package/package.json +12 -9
package/dist/index.d.ts CHANGED
@@ -4,11 +4,11 @@ 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
  import { FloatingRootContext } from '@floating-ui/react';
6
6
 
7
- interface Props$N {
7
+ interface Props$O {
8
8
  }
9
- type NativeAttrs$P = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$N>;
10
- type DividerProps = Props$N & NativeAttrs$P;
11
- declare const Divider: react.ForwardRefExoticComponent<Props$N & NativeAttrs$P & react.RefAttributes<HTMLDivElement>>;
9
+ type NativeAttrs$R = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$O>;
10
+ type DividerProps = Props$O & NativeAttrs$R;
11
+ declare const Divider: react.ForwardRefExoticComponent<Props$O & NativeAttrs$R & react.RefAttributes<HTMLDivElement>>;
12
12
 
13
13
  type BoxShadow = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
14
14
  type BorderRadius = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
@@ -36,7 +36,7 @@ interface AccordionArrow {
36
36
  position?: 'start' | 'end';
37
37
  }
38
38
 
39
- interface Props$M {
39
+ interface Props$N {
40
40
  value?: any[];
41
41
  defaultValue?: any[];
42
42
  expandMode?: 'single' | 'multiple';
@@ -53,9 +53,9 @@ interface Props$M {
53
53
  }) => React.ReactNode;
54
54
  onChange?: (value: any[]) => void;
55
55
  }
56
- type NativeAttrs$O = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$M>;
57
- type AccordionProps = Props$M & NativeAttrs$O;
58
- declare const Accordion: react.ForwardRefExoticComponent<Props$M & NativeAttrs$O & react.RefAttributes<HTMLDivElement>>;
56
+ type NativeAttrs$Q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$N>;
57
+ type AccordionProps = Props$N & NativeAttrs$Q;
58
+ declare const Accordion: react.ForwardRefExoticComponent<Props$N & NativeAttrs$Q & react.RefAttributes<HTMLDivElement>>;
59
59
 
60
60
  interface AccordionItemContextValue {
61
61
  value: string;
@@ -64,7 +64,7 @@ interface AccordionItemContextValue {
64
64
  }) => React.ReactNode;
65
65
  }
66
66
  declare const useAccordionItem: () => AccordionItemContextValue;
67
- interface Props$L {
67
+ interface Props$M {
68
68
  value?: any;
69
69
  variant?: AccordionVariant;
70
70
  color?: AccordionColor;
@@ -72,11 +72,11 @@ interface Props$L {
72
72
  isOpen: boolean;
73
73
  }) => React.ReactNode;
74
74
  }
75
- type NativeAttrs$N = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$L>;
76
- type AccordionItemProps = Props$L & NativeAttrs$N;
77
- declare const AccordionItem: react.ForwardRefExoticComponent<Props$L & NativeAttrs$N & react.RefAttributes<HTMLDivElement>>;
75
+ type NativeAttrs$P = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$M>;
76
+ type AccordionItemProps = Props$M & NativeAttrs$P;
77
+ declare const AccordionItem: react.ForwardRefExoticComponent<Props$M & NativeAttrs$P & react.RefAttributes<HTMLDivElement>>;
78
78
 
79
- interface Props$K {
79
+ interface Props$L {
80
80
  as?: React.ElementType;
81
81
  title?: React.ReactNode;
82
82
  subtitle?: React.ReactNode;
@@ -94,9 +94,9 @@ interface Props$K {
94
94
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
95
95
  };
96
96
  }
97
- type NativeAttrs$M = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$K>;
98
- type AccordionHeaderProps = Props$K & NativeAttrs$M;
99
- declare const AccordionHeader: react.ForwardRefExoticComponent<Props$K & NativeAttrs$M & react.RefAttributes<HTMLDivElement>>;
97
+ type NativeAttrs$O = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$L>;
98
+ type AccordionHeaderProps = Props$L & NativeAttrs$O;
99
+ declare const AccordionHeader: react.ForwardRefExoticComponent<Props$L & NativeAttrs$O & react.RefAttributes<HTMLDivElement>>;
100
100
 
101
101
  type AccordionBodyProps = React.HTMLAttributes<HTMLDivElement>;
102
102
  declare const AccordionBody: react.ForwardRefExoticComponent<AccordionBodyProps & react.RefAttributes<HTMLDivElement>>;
@@ -345,6 +345,8 @@ interface UseElementSizeOptions<T> {
345
345
  }
346
346
  declare function useElementSize<T extends HTMLElement = any>(options: UseElementSizeOptions<T>): Resize;
347
347
 
348
+ declare function useExtractProps<T extends object, K extends keyof T>(props: T, keys: K[], defaults?: Partial<T>): [Pick<T, K>, Omit<T, K>];
349
+
348
350
  interface UseResizeObserverOptions<T> {
349
351
  ref?: React.RefObject<T | undefined>;
350
352
  onResize: () => void;
@@ -401,21 +403,17 @@ interface UseContainerMediaQueryOptions<TElement extends HTMLElement = HTMLEleme
401
403
  }
402
404
  declare function useContainerMediaQuery<TElement extends HTMLElement = HTMLElement>(options: UseContainerMediaQueryOptions<TElement>): ContainerMediaQuery | undefined;
403
405
 
404
- interface FormatStringOptions {
405
- type?: 'string';
406
- value?: string | null;
407
- }
408
- interface FormatNumberOptions {
409
- type: 'number';
410
- value?: number | string | null;
411
- }
412
- interface FormatDateOptions {
413
- type: 'date';
414
- value?: Date | string | number | null;
415
- format?: 'datetime' | 'short datetime' | 'date' | 'time';
416
- locales?: Intl.LocalesArgument;
417
- options?: Intl.DateTimeFormatOptions;
418
- }
406
+ declare const scrollToItem: (parentElement: Element, currentElement: Element) => void;
407
+
408
+ type ClassDictionary = Record<string, any>;
409
+ type ClassArray = ClassValue[];
410
+ type ClassValue = ClassArray | ClassDictionary | string | number | null | boolean | undefined;
411
+ declare function clsx(...inputs: ClassValue[]): string;
412
+
413
+ type ReactRef<T> = React.RefCallback<T> | React.MutableRefObject<T>;
414
+ declare function assignRef<T = any>(ref: ReactRef<T> | null | undefined, value: T): void;
415
+ declare function mergeRefs<T>(...refs: (ReactRef<T> | null | undefined)[]): (node: T | null) => void;
416
+
419
417
  interface FormatBooleanOptions {
420
418
  type: 'boolean';
421
419
  value?: boolean | null;
@@ -424,6 +422,7 @@ interface FormatBooleanOptions {
424
422
  false?: string;
425
423
  };
426
424
  }
425
+
427
426
  interface FormatCurrencyOptions {
428
427
  type: 'currency';
429
428
  value?: number | bigint | Intl.StringNumericLiteral | null;
@@ -431,6 +430,43 @@ interface FormatCurrencyOptions {
431
430
  locales?: Intl.LocalesArgument;
432
431
  options?: Intl.NumberFormatOptions;
433
432
  }
433
+ declare function formatCurrency(value: number | bigint | Intl.StringNumericLiteral, currency?: string, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
434
+
435
+ interface FormatDateOptions {
436
+ type: 'date';
437
+ value?: Date | string | number | null;
438
+ format?: 'datetime' | 'short datetime' | 'date' | 'time';
439
+ locales?: Intl.LocalesArgument;
440
+ options?: Intl.DateTimeFormatOptions;
441
+ }
442
+ declare function formatDate(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
443
+ declare function formatDateTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
444
+ declare function formatShortDateTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
445
+ declare function formatTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
446
+
447
+ type UnitSystem = 'si' | 'iec';
448
+ type ForcedUnit = 'B' | 'KB' | 'MB' | 'GB' | 'TB' | 'PB' | 'EB' | 'ZB' | 'YB' | 'KiB' | 'MiB' | 'GiB' | 'TiB' | 'PiB' | 'EiB' | 'ZiB' | 'YiB';
449
+ interface FileSizeFormatOptions {
450
+ system?: UnitSystem;
451
+ maximumFractionDigits?: number;
452
+ minimumFractionDigits?: number;
453
+ unit?: ForcedUnit;
454
+ spacer?: string;
455
+ lowercase?: boolean;
456
+ }
457
+ interface FormatFileSizeOptions {
458
+ type: 'file-size';
459
+ value?: number;
460
+ locales?: Intl.LocalesArgument;
461
+ options?: FileSizeFormatOptions;
462
+ }
463
+ declare function formatFileSize(bytes: number, locales?: Intl.LocalesArgument, { system, maximumFractionDigits, minimumFractionDigits, unit, spacer, lowercase, }?: FileSizeFormatOptions): string;
464
+
465
+ interface FormatNumberOptions {
466
+ type: 'number';
467
+ value?: number | string | null;
468
+ }
469
+
434
470
  interface FormatPercentOptions {
435
471
  type: 'percent';
436
472
  value?: number | string | null;
@@ -438,12 +474,15 @@ interface FormatPercentOptions {
438
474
  locales?: Intl.LocalesArgument;
439
475
  options?: Intl.NumberFormatOptions;
440
476
  }
441
- type FormatOptions = FormatStringOptions | FormatNumberOptions | FormatDateOptions | FormatBooleanOptions | FormatCurrencyOptions | FormatPercentOptions;
477
+ declare function formatPercent(value: any, decimals?: number, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
442
478
 
443
- declare function useFormat(options: FormatOptions): {
444
- value: string | undefined;
445
- getValue: (value: any) => string | undefined;
446
- };
479
+ interface FormatStringOptions {
480
+ type?: 'string';
481
+ value?: string | null;
482
+ }
483
+
484
+ type FormatOptions = FormatStringOptions | FormatNumberOptions | FormatDateOptions | FormatBooleanOptions | FormatCurrencyOptions | FormatPercentOptions | FormatFileSizeOptions;
485
+ declare function format(options: FormatOptions): string | undefined;
447
486
 
448
487
  type ColorScheme = 'default' | 'light' | 'dark';
449
488
 
@@ -475,37 +514,128 @@ type Responsive<T> = T | {
475
514
  '2xl'?: T;
476
515
  };
477
516
 
478
- type SelectionValue<TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = TMultiple extends true ? TClearable extends true ? TItem[TKeyField][] | null : TItem[TKeyField][] : TClearable extends true ? TItem[TKeyField] | null : TItem[TKeyField];
479
- type SelectionItem<TData extends Record<string, any>, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> = TMultiple extends true ? TClearable extends true ? TData[] | null : TData[] : TClearable extends true ? TData | null : TData;
480
- type SelectionOnChange<TData extends Record<string, any>, TKeyField extends keyof TData, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> = (value: SelectionValue<TData, TKeyField, TMultiple, TClearable>, item: SelectionItem<TData, TMultiple, TClearable>) => void;
481
- interface SelectionProps<TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> {
517
+ 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];
518
+ 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;
519
+ 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;
520
+ interface SelectionProps$1<TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> {
482
521
  data: TItem[];
483
522
  isMultiple?: TMultiple;
484
523
  clearable?: TClearable;
485
524
  keyField?: TKeyField;
486
- value?: SelectionValue<TItem, TKeyField, TMultiple, TClearable>;
487
- onChange?: SelectionOnChange<TItem, TKeyField, TMultiple, TClearable>;
525
+ value?: SelectionValue$1<TItem, TKeyField, TMultiple, TClearable>;
526
+ onChange?: SelectionOnChange$1<TItem, TKeyField, TMultiple, TClearable>;
488
527
  }
489
528
 
490
- type InputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
491
- type InputColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
529
+ 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][];
530
+ declare const valuesToValue: <TItem extends Record<string, any>, TKeyField extends keyof TItem>(values: TItem[TKeyField][]) => TItem[TKeyField] | null;
531
+
532
+ declare function areArraysEqual<T extends string | number | symbol>(arr1: T[], arr2: T[]): boolean;
533
+
534
+ declare function toLocalDateString(date: Date): string;
535
+ declare function toLocalDateTimeString(date: Date): string;
536
+ declare function toAlphaString(value: string): string;
537
+ declare function toNumericString(value: string): string;
538
+ declare function toAlphanumericString(value: string): string;
539
+ declare function toPlainTextString(value: string): string;
540
+ declare function toNotEmojisString(value: string): string;
541
+ declare const STRING_RULES: readonly ["allow-emojis", "not-allow-emojis", "only-alpha", "only-numeric", "only-alphanumeric", "only-plain-text"];
542
+ type StringRules = Array<(typeof STRING_RULES)[number]>;
543
+ declare function toRulesString(rules: StringRules, value: string): string;
544
+
545
+ declare function isEmpty<T>(value?: T | null): value is null | undefined;
546
+ declare function isEmptyString(value?: string | null): value is null | undefined;
547
+ declare function isNumeric(value: string): boolean;
548
+ declare function isAlphanumeric(value: string): boolean;
549
+ declare function containsPlainText(value: string): boolean;
550
+ declare function doesNotContainEmojis(value: string): boolean;
551
+ declare function validateRules(rules: StringRules, value: string): string | boolean;
552
+
553
+ declare function generateId(): string;
554
+
555
+ declare function useFormat(options: FormatOptions): {
556
+ value: string | undefined;
557
+ getValue: (value: any) => string | undefined;
558
+ };
559
+
560
+ type TimerMode = 'up' | 'down';
561
+ interface UseTimerOptions {
562
+ mode: TimerMode;
563
+ initialSeconds: number;
564
+ maxSeconds?: number;
565
+ onTick?: (seconds: number) => void;
566
+ onComplete?: () => void;
567
+ }
568
+ declare const useTimer: ({ mode, initialSeconds, maxSeconds, onTick, onComplete }: UseTimerOptions) => {
569
+ seconds: number;
570
+ formattedTime: string;
571
+ isRunning: boolean;
572
+ isCompleted: boolean;
573
+ start: () => void;
574
+ pause: () => void;
575
+ reset: (newSeconds?: number) => void;
576
+ stop: () => void;
577
+ };
578
+ type Timer = ReturnType<typeof useTimer>;
579
+
580
+ type SelectionItem = Record<string, any>;
581
+
492
582
  type InputVariant = 'filled' | 'outlined' | 'flat' | 'text';
583
+ type InputColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
584
+ type InputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
493
585
 
494
- interface Props$J {
586
+ interface InputBaseProps {
587
+ className?: string;
588
+ variant?: InputVariant;
589
+ color?: InputColor;
590
+ size?: InputSize;
591
+ startContent?: React.ReactNode;
592
+ endContent?: React.ReactNode;
593
+ startIcon?: React.ReactNode;
594
+ endIcon?: React.ReactNode;
595
+ startText?: string;
596
+ endText?: string;
597
+ disabled?: boolean;
598
+ clearable?: boolean;
599
+ closeButton?: boolean;
600
+ loading?: boolean;
601
+ error?: boolean;
602
+ readOnly?: boolean;
603
+ slotProps?: {
604
+ content?: React.HTMLAttributes<HTMLDivElement>;
605
+ };
495
606
  }
496
- type NativeAttrs$L = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$J>;
497
- type InputGroupProps = Props$J & NativeAttrs$L;
498
- declare const InputGroup: react.ForwardRefExoticComponent<Props$J & NativeAttrs$L & react.RefAttributes<HTMLDivElement>>;
607
+ type NativeAttrs$N = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof InputBaseProps>;
608
+ type InputWrapperProps = InputBaseProps & NativeAttrs$N;
609
+ declare const InputWrapper: react.ForwardRefExoticComponent<InputBaseProps & NativeAttrs$N & react.RefAttributes<HTMLInputElement>>;
610
+
611
+ interface InputCloseProps extends React.HTMLAttributes<HTMLDivElement> {
612
+ }
613
+ declare const InputClose: React.FC<InputCloseProps>;
614
+
615
+ interface Props$K {
616
+ }
617
+ type NativeAttrs$M = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$K>;
618
+ type InputGroupProps = Props$K & NativeAttrs$M;
619
+ declare const InputGroup: react.ForwardRefExoticComponent<Props$K & NativeAttrs$M & react.RefAttributes<HTMLDivElement>>;
620
+
621
+ interface InputSelectorProps extends React.HTMLAttributes<HTMLDivElement> {
622
+ isOpen: boolean;
623
+ }
624
+ declare const InputSelector: React.FC<InputSelectorProps>;
625
+
626
+ 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">];
499
627
 
500
628
  type ListSize = 'sm' | 'md' | 'lg';
501
629
 
502
630
  interface ListProps extends React.HTMLAttributes<HTMLDivElement> {
503
631
  as?: React.ElementType;
504
632
  size?: ListSize;
633
+ divider?: boolean;
634
+ nav?: boolean;
505
635
  }
506
636
  declare const List: react.ForwardRefExoticComponent<ListProps & react.RefAttributes<HTMLDivElement>>;
507
637
 
508
- interface Props$I {
638
+ interface Props$J {
509
639
  as?: react__default.ElementType;
510
640
  title?: react__default.ReactNode;
511
641
  subtitle?: react__default.ReactNode;
@@ -523,11 +653,11 @@ interface Props$I {
523
653
  subtitle?: react__default.HTMLAttributes<HTMLDivElement>;
524
654
  };
525
655
  }
526
- type NativeAttrs$K = Omit<react__default.HTMLAttributes<HTMLDivElement>, keyof Props$I>;
527
- type ListItemProps = Props$I & NativeAttrs$K;
528
- declare const ListItem: react__default.ForwardRefExoticComponent<Props$I & NativeAttrs$K & react__default.RefAttributes<HTMLDivElement>>;
656
+ type NativeAttrs$L = Omit<react__default.HTMLAttributes<HTMLDivElement>, keyof Props$J>;
657
+ type ListItemProps = Props$J & NativeAttrs$L;
658
+ declare const ListItem: react__default.ForwardRefExoticComponent<Props$J & NativeAttrs$L & react__default.RefAttributes<HTMLDivElement>>;
529
659
 
530
- interface Props$H {
660
+ interface Props$I {
531
661
  expandVisible?: boolean;
532
662
  expandPosition?: 'start' | 'end';
533
663
  isOpen?: boolean;
@@ -535,9 +665,9 @@ interface Props$H {
535
665
  onClose?: () => void;
536
666
  onToggle?: () => void;
537
667
  }
538
- type NativeAttrs$J = Omit<ListItemProps, keyof Props$H>;
539
- type ListGroupProps = Props$H & NativeAttrs$J;
540
- declare const ListGroup: react.ForwardRefExoticComponent<Props$H & NativeAttrs$J & react.RefAttributes<HTMLDivElement>>;
668
+ type NativeAttrs$K = Omit<ListItemProps, keyof Props$I>;
669
+ type ListGroupProps = Props$I & NativeAttrs$K;
670
+ declare const ListGroup: react.ForwardRefExoticComponent<Props$I & NativeAttrs$K & react.RefAttributes<HTMLDivElement>>;
541
671
 
542
672
  interface ListSubheaderProps extends React.HTMLAttributes<HTMLDivElement> {
543
673
  as?: React.ElementType;
@@ -567,51 +697,51 @@ declare const Result: React.FC<ResultProps>;
567
697
 
568
698
  type AutocompleteMultiple = false;
569
699
  type AutocompleteClearable = true;
570
- type NativeAttrs$I<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$G<TItem, TKeyField>>;
700
+ type AutocompleteItem = SelectionItem;
701
+ type AutocompleteKeyField<TAutocompleteItem> = keyof TAutocompleteItem;
702
+ type NativeAttrs$J<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'value'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$H<TAutocompleteItem, TAutocompleteKeyField>>;
571
703
  type BaseProps$1<TItem extends Record<string, any>> = {
572
704
  textField?: keyof TItem;
573
705
  placeholder?: string;
574
706
  filter?: string;
575
707
  loading?: boolean;
576
708
  disabled?: boolean;
577
- readOnly?: boolean;
578
709
  disclosure?: Disclosure;
579
710
  virtual?: Omit<VirtualizerOptions, 'parentRef'>;
580
- color?: InputColor;
581
- variant?: InputVariant;
582
- size?: InputSize;
583
711
  startContent?: React.ReactNode;
584
712
  endContent?: React.ReactNode;
713
+ target?: boolean;
714
+ readOnly?: boolean;
715
+ inner?: boolean;
716
+ onClear?: () => void;
585
717
  onItemSelect?: (item: TItem) => void;
586
718
  onFilterChange?: (value: string) => void;
587
719
  renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
588
720
  renderNoData?: (props: ResultProps) => React.ReactNode;
589
721
  };
590
- type Props$G<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = BaseProps$1<TItem> & SelectionProps<TItem, TKeyField, TMultiple, TClearable>;
591
- type AutocompleteProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$G<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$I<TItem, TKeyField>;
722
+ type Props$H<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'>;
723
+ type AutocompleteProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'value', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$H<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$J<TItem, TKeyField>;
724
+ 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];
725
+ 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];
726
+ 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;
727
+ 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;
728
+ 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;
729
+ interface SelectionProps<TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> {
730
+ data: TItem[];
731
+ isMultiple?: TMultiple;
732
+ clearable?: TClearable;
733
+ keyField?: TKeyField;
734
+ value?: SelectionValue<TItem, TKeyField, TMultiple, TClearable>;
735
+ onChange?: SelectionOnChange<TItem, TKeyField, TMultiple, TClearable>;
736
+ renderTrigger?: SelectionRenderTrigger<TItem, TKeyField, TMultiple, TClearable>;
737
+ }
592
738
 
593
739
  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;
594
740
 
595
- type AutocompleteContextValue<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = {
596
- data: TItem[];
597
- values: TItem[TKeyField][];
598
- keyField: TKeyField;
599
- textField: keyof TItem;
600
- isMultiple: boolean;
601
- virtual?: Omit<VirtualizerOptions, 'parentRef'>;
602
- onChange: (value: TItem[]) => void;
603
- onItemSelect: (item: TItem) => void;
604
- renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
605
- offset: number;
606
- setOffset: React.Dispatch<React.SetStateAction<number>>;
607
- };
608
- declare const AutocompleteContext: react.Context<AutocompleteContextValue<Record<string, any>, string> | null>;
609
- declare const useAutocomplete: () => AutocompleteContextValue<Record<string, any>, string>;
610
-
611
741
  type BackdropPlacement = 'top' | 'left' | 'center' | 'right' | 'bottom';
612
742
  type BackdropVariant = 'opaque' | 'blur' | 'transparent';
613
743
 
614
- interface Props$F {
744
+ interface Props$G {
615
745
  isOpen: boolean;
616
746
  closable?: boolean;
617
747
  placement?: BackdropPlacement;
@@ -620,14 +750,14 @@ interface Props$F {
620
750
  scrollArea?: boolean;
621
751
  onClose(): void;
622
752
  }
623
- type NativeAttrs$H = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$F>;
624
- type BackdropProps = Props$F & NativeAttrs$H;
625
- declare const Backdrop: react.ForwardRefExoticComponent<Props$F & NativeAttrs$H & react.RefAttributes<HTMLDivElement>>;
753
+ type NativeAttrs$I = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$G>;
754
+ type BackdropProps = Props$G & NativeAttrs$I;
755
+ declare const Backdrop: react.ForwardRefExoticComponent<Props$G & NativeAttrs$I & react.RefAttributes<HTMLDivElement>>;
626
756
 
627
757
  type BadgeColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
628
758
  type BadgePlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
629
759
 
630
- interface Props$E {
760
+ interface Props$F {
631
761
  /**
632
762
  * The placement of the badge relative to its content.
633
763
  */
@@ -645,8 +775,8 @@ interface Props$E {
645
775
  wrapper?: React.HTMLAttributes<HTMLDivElement>;
646
776
  };
647
777
  }
648
- type NativeAttrs$G = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$E>;
649
- type BadgeProps = Props$E & NativeAttrs$G;
778
+ type NativeAttrs$H = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$F>;
779
+ type BadgeProps = Props$F & NativeAttrs$H;
650
780
  declare const Badge: React.FC<BadgeProps>;
651
781
 
652
782
  type DataListItem = Record<string, any>;
@@ -663,7 +793,7 @@ interface DataListMultipleProps<TDataListItem extends DataListItem, TDataListKey
663
793
  onChange?: (value: TDataListItem[]) => void;
664
794
  onValueChange?: (value: TDataListItem[TDataListKeyField][]) => void;
665
795
  }
666
- type Props$D<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
796
+ type Props$E<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
667
797
  data: TDataListItem[];
668
798
  keyField?: TDataListKeyField;
669
799
  textField?: keyof DataListItem;
@@ -678,8 +808,8 @@ type Props$D<TDataListItem extends DataListItem, TDataListKeyField extends DataL
678
808
  renderItem?: (item: TDataListItem, props: ListItemProps$1) => React.ReactNode;
679
809
  renderNoData?: (props: ResultProps$1) => React.ReactNode;
680
810
  } & (DataListSingleProps<TDataListItem, TDataListKeyField> | DataListMultipleProps<TDataListItem, TDataListKeyField>);
681
- type NativeAttrs$F<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$D<TDataListItem, TDataListKeyField>>;
682
- type DataListProps<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Props$D<TDataListItem, TDataListKeyField> & NativeAttrs$F<TDataListItem, TDataListKeyField>;
811
+ type NativeAttrs$G<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$E<TDataListItem, TDataListKeyField>>;
812
+ type DataListProps<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Props$E<TDataListItem, TDataListKeyField> & NativeAttrs$G<TDataListItem, TDataListKeyField>;
683
813
 
684
814
  declare const DataList: <TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = "key">(props: DataListProps<TDataListItem, TDataListKeyField>) => react_jsx_runtime.JSX.Element;
685
815
 
@@ -688,7 +818,7 @@ type ButtonColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'd
688
818
  type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
689
819
  type ButtonGroupDirection = 'row' | 'col';
690
820
 
691
- interface Props$C {
821
+ interface Props$D {
692
822
  /**
693
823
  * The HTML element type or React component to render as the button.
694
824
  */
@@ -733,20 +863,20 @@ interface Props$C {
733
863
  fontStyle?: React.CSSProperties['fontStyle'];
734
864
  };
735
865
  }
736
- type NativeAttrs$E = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$C>;
737
- type ButtonProps = Props$C & NativeAttrs$E;
738
- declare const Button: react.ForwardRefExoticComponent<Props$C & NativeAttrs$E & react.RefAttributes<HTMLButtonElement>>;
866
+ type NativeAttrs$F = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$D>;
867
+ type ButtonProps = Props$D & NativeAttrs$F;
868
+ declare const Button: react.ForwardRefExoticComponent<Props$D & NativeAttrs$F & react.RefAttributes<HTMLButtonElement>>;
739
869
 
740
- interface Props$B {
870
+ interface Props$C {
741
871
  direction?: ButtonGroupDirection;
742
872
  variant?: ButtonVariant;
743
873
  color?: ButtonColor;
744
874
  size?: ButtonSize;
745
875
  disabled?: boolean;
746
876
  }
747
- type NativeAttrs$D = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$B>;
748
- type ButtonGroupProps = Props$B & NativeAttrs$D;
749
- declare const ButtonGroup: react.ForwardRefExoticComponent<Props$B & NativeAttrs$D & react.RefAttributes<HTMLDivElement>>;
877
+ type NativeAttrs$E = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$C>;
878
+ type ButtonGroupProps = Props$C & NativeAttrs$E;
879
+ declare const ButtonGroup: react.ForwardRefExoticComponent<Props$C & NativeAttrs$E & react.RefAttributes<HTMLDivElement>>;
750
880
 
751
881
  interface ButtonGroupContextValue {
752
882
  direction: ButtonGroupDirection;
@@ -760,7 +890,7 @@ declare const useButtonGroup: () => ButtonGroupContextValue | null;
760
890
 
761
891
  type CardSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
762
892
 
763
- interface Props$A {
893
+ interface Props$B {
764
894
  as?: React.ElementType;
765
895
  size?: CardSize;
766
896
  hoverable?: boolean;
@@ -770,14 +900,14 @@ interface Props$A {
770
900
  divider?: boolean;
771
901
  css?: BoxCSS;
772
902
  }
773
- type NativeAttrs$C = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$A>;
774
- type CardProps = Props$A & NativeAttrs$C;
775
- declare const Card: react.ForwardRefExoticComponent<Props$A & NativeAttrs$C & react.RefAttributes<HTMLDivElement>>;
903
+ type NativeAttrs$D = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$B>;
904
+ type CardProps = Props$B & NativeAttrs$D;
905
+ declare const Card: react.ForwardRefExoticComponent<Props$B & NativeAttrs$D & react.RefAttributes<HTMLDivElement>>;
776
906
 
777
907
  type CardBodyProps = React.HTMLAttributes<HTMLDivElement>;
778
908
  declare const CardBody: react.ForwardRefExoticComponent<CardBodyProps & react.RefAttributes<HTMLDivElement>>;
779
909
 
780
- interface Props$z {
910
+ interface Props$A {
781
911
  as?: React.ElementType;
782
912
  title?: React.ReactNode;
783
913
  subtitle?: React.ReactNode;
@@ -803,11 +933,11 @@ interface Props$z {
803
933
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
804
934
  };
805
935
  }
806
- type NativeAttrs$B = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$z>;
807
- type CardHeaderProps = Props$z & NativeAttrs$B;
808
- declare const CardHeader: react.ForwardRefExoticComponent<Props$z & NativeAttrs$B & react.RefAttributes<HTMLDivElement>>;
936
+ type NativeAttrs$C = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$A>;
937
+ type CardHeaderProps = Props$A & NativeAttrs$C;
938
+ declare const CardHeader: react.ForwardRefExoticComponent<Props$A & NativeAttrs$C & react.RefAttributes<HTMLDivElement>>;
809
939
 
810
- interface Props$y {
940
+ interface Props$z {
811
941
  as?: React.ElementType;
812
942
  /**
813
943
  * @deprecated Use `underlined` instead
@@ -815,9 +945,9 @@ interface Props$y {
815
945
  bordered?: boolean;
816
946
  underlined?: boolean;
817
947
  }
818
- type NativeAttrs$A = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$y>;
819
- type CardFooterProps = Props$y & NativeAttrs$A;
820
- declare const CardFooter: react.ForwardRefExoticComponent<Props$y & NativeAttrs$A & react.RefAttributes<HTMLDivElement>>;
948
+ type NativeAttrs$B = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$z>;
949
+ type CardFooterProps = Props$z & NativeAttrs$B;
950
+ declare const CardFooter: react.ForwardRefExoticComponent<Props$z & NativeAttrs$B & react.RefAttributes<HTMLDivElement>>;
821
951
 
822
952
  type CardMediaProps = React.HTMLAttributes<HTMLDivElement> & {
823
953
  topLeftContent?: React.ReactNode;
@@ -828,28 +958,28 @@ declare const CardMedia: react.ForwardRefExoticComponent<react.HTMLAttributes<HT
828
958
  topRightContent?: React.ReactNode;
829
959
  } & react.RefAttributes<HTMLDivElement>>;
830
960
 
831
- interface Props$x {
961
+ interface Props$y {
832
962
  as?: React.ElementType;
833
963
  centered?: boolean;
834
964
  css?: BoxCSS;
835
965
  }
836
- type NativeAttrs$z = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$x>;
837
- type CardTitleProps = Props$x & NativeAttrs$z;
838
- declare const CardTitle: react.ForwardRefExoticComponent<Props$x & NativeAttrs$z & react.RefAttributes<HTMLDivElement>>;
966
+ type NativeAttrs$A = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$y>;
967
+ type CardTitleProps = Props$y & NativeAttrs$A;
968
+ declare const CardTitle: react.ForwardRefExoticComponent<Props$y & NativeAttrs$A & react.RefAttributes<HTMLDivElement>>;
839
969
 
840
- interface Props$w {
970
+ interface Props$x {
841
971
  as?: React.ElementType;
842
972
  css?: BoxCSS;
843
973
  }
844
- type NativeAttrs$y = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$w>;
845
- type CardSubtitleProps = Props$w & NativeAttrs$y;
846
- declare const CardSubtitle: react.ForwardRefExoticComponent<Props$w & NativeAttrs$y & react.RefAttributes<HTMLDivElement>>;
974
+ type NativeAttrs$z = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$x>;
975
+ type CardSubtitleProps = Props$x & NativeAttrs$z;
976
+ declare const CardSubtitle: react.ForwardRefExoticComponent<Props$x & NativeAttrs$z & react.RefAttributes<HTMLDivElement>>;
847
977
 
848
978
  type ChipVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain' | 'bordered';
849
979
  type ChipColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
850
980
  type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
851
981
 
852
- interface Props$v {
982
+ interface Props$w {
853
983
  /**
854
984
  * The HTML element type or React component to render as the chip.
855
985
  */
@@ -887,9 +1017,9 @@ interface Props$v {
887
1017
  };
888
1018
  onClose?: () => void;
889
1019
  }
890
- type NativeAttrs$x = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$v>;
891
- type ChipProps = Props$v & NativeAttrs$x;
892
- declare const Chip: react.ForwardRefExoticComponent<Props$v & NativeAttrs$x & react.RefAttributes<HTMLDivElement>>;
1020
+ type NativeAttrs$y = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$w>;
1021
+ type ChipProps = Props$w & NativeAttrs$y;
1022
+ declare const Chip: react.ForwardRefExoticComponent<Props$w & NativeAttrs$y & react.RefAttributes<HTMLDivElement>>;
893
1023
 
894
1024
  interface CollapseProps {
895
1025
  children: React.ReactNode;
@@ -934,7 +1064,7 @@ interface DrawerClose {
934
1064
  }
935
1065
  type DrawerBackdrop = BackdropVariant;
936
1066
 
937
- interface Props$u {
1067
+ interface Props$v {
938
1068
  isOpen: boolean;
939
1069
  size?: DrawerSize;
940
1070
  backdrop?: DrawerBackdrop;
@@ -951,11 +1081,11 @@ interface Props$u {
951
1081
  onClose: () => void;
952
1082
  onAfterClose?: () => void;
953
1083
  }
954
- type NativeAttrs$w = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$u>;
955
- type DrawerProps = Props$u & NativeAttrs$w;
956
- declare const Drawer: react.ForwardRefExoticComponent<Props$u & NativeAttrs$w & react.RefAttributes<HTMLDivElement>>;
1084
+ type NativeAttrs$x = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$v>;
1085
+ type DrawerProps = Props$v & NativeAttrs$x;
1086
+ declare const Drawer: react.ForwardRefExoticComponent<Props$v & NativeAttrs$x & react.RefAttributes<HTMLDivElement>>;
957
1087
 
958
- interface Props$t {
1088
+ interface Props$u {
959
1089
  as?: React.ElementType;
960
1090
  title?: React.ReactNode;
961
1091
  subtitle?: React.ReactNode;
@@ -971,20 +1101,20 @@ interface Props$t {
971
1101
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
972
1102
  };
973
1103
  }
974
- type NativeAttrs$v = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$t>;
975
- type DrawerHeaderProps = Props$t & NativeAttrs$v;
976
- declare const DrawerHeader: react.ForwardRefExoticComponent<Props$t & NativeAttrs$v & react.RefAttributes<HTMLDivElement>>;
1104
+ type NativeAttrs$w = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$u>;
1105
+ type DrawerHeaderProps = Props$u & NativeAttrs$w;
1106
+ declare const DrawerHeader: react.ForwardRefExoticComponent<Props$u & NativeAttrs$w & react.RefAttributes<HTMLDivElement>>;
977
1107
 
978
1108
  type DrawerBodyProps = React.HTMLAttributes<HTMLDivElement>;
979
1109
  declare const DrawerBody: react.ForwardRefExoticComponent<DrawerBodyProps & react.RefAttributes<HTMLDivElement>>;
980
1110
 
981
- interface Props$s {
1111
+ interface Props$t {
982
1112
  as?: React.ElementType;
983
1113
  bordered?: boolean;
984
1114
  }
985
- type NativeAttrs$u = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$s>;
986
- type DrawerFooterProps = Props$s & NativeAttrs$u;
987
- declare const DrawerFooter: react.ForwardRefExoticComponent<Props$s & NativeAttrs$u & react.RefAttributes<HTMLDivElement>>;
1115
+ type NativeAttrs$v = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$t>;
1116
+ type DrawerFooterProps = Props$t & NativeAttrs$v;
1117
+ declare const DrawerFooter: react.ForwardRefExoticComponent<Props$t & NativeAttrs$v & react.RefAttributes<HTMLDivElement>>;
988
1118
 
989
1119
  interface DrawerContextValue {
990
1120
  isOpen: boolean;
@@ -999,16 +1129,27 @@ interface FieldProps extends React.HTMLAttributes<HTMLDivElement> {
999
1129
  declare const Field: react.ForwardRefExoticComponent<FieldProps & react.RefAttributes<HTMLDivElement>>;
1000
1130
 
1001
1131
  type IconColor = 'inherit' | 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
1002
- type IconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1132
+ type IconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
1003
1133
 
1004
1134
  interface IconProps {
1005
1135
  children: React.ReactNode;
1006
1136
  color?: IconColor;
1007
1137
  size?: IconSize;
1138
+ className?: string;
1139
+ style?: React.CSSProperties;
1140
+ cssVars?: {
1141
+ color?: string;
1142
+ fontSize?: number | string;
1143
+ };
1144
+ cssUtils?: {
1145
+ opacity?: number;
1146
+ pointer?: boolean;
1147
+ hoverOpacity?: number;
1148
+ };
1008
1149
  }
1009
1150
  declare const Icon: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<unknown>>;
1010
1151
 
1011
- interface Props$r {
1152
+ interface Props$s {
1012
1153
  /**
1013
1154
  * The HTML element type or React component to render as the menu item.
1014
1155
  */
@@ -1034,9 +1175,9 @@ interface Props$r {
1034
1175
  */
1035
1176
  disabled?: boolean;
1036
1177
  }
1037
- type NativeAttrs$t = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$r | 'items'>;
1038
- type MenuItemProps = Props$r & NativeAttrs$t;
1039
- declare const MenuItem: react.ForwardRefExoticComponent<Props$r & NativeAttrs$t & react.RefAttributes<HTMLDivElement>>;
1178
+ type NativeAttrs$u = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$s | 'items'>;
1179
+ type MenuItemProps = Props$s & NativeAttrs$u;
1180
+ declare const MenuItem: react.ForwardRefExoticComponent<Props$s & NativeAttrs$u & react.RefAttributes<HTMLDivElement>>;
1040
1181
 
1041
1182
  type MenuSubmenuProps = Omit<MenuItemProps, 'items'> & {
1042
1183
  items?: MenuItemType[];
@@ -1060,7 +1201,7 @@ type MenuItemType = (MenuGroupProps & {
1060
1201
  }) | (MenuItemProps & {
1061
1202
  type?: 'item';
1062
1203
  });
1063
- interface Props$q {
1204
+ interface Props$r {
1064
1205
  /**
1065
1206
  * The currently selected value of the menu.
1066
1207
  */
@@ -1096,8 +1237,8 @@ interface Props$q {
1096
1237
  */
1097
1238
  onItemSelect?: (props: MenuItemProps) => void;
1098
1239
  }
1099
- type NativeAttrs$s = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$q | 'items'>;
1100
- type MenuProps = Props$q & NativeAttrs$s & {
1240
+ type NativeAttrs$t = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$r | 'items'>;
1241
+ type MenuProps = Props$r & NativeAttrs$t & {
1101
1242
  items?: MenuItemType[];
1102
1243
  };
1103
1244
  declare const Menu: React.FC<MenuProps>;
@@ -1134,6 +1275,7 @@ declare const Popover: React.FC<PopoverProps>;
1134
1275
 
1135
1276
  interface PopoverContentProps extends React.HTMLAttributes<HTMLDivElement> {
1136
1277
  sectionValue?: string;
1278
+ excludeTargets?: string[];
1137
1279
  }
1138
1280
  declare const PopoverContent: react.ForwardRefExoticComponent<PopoverContentProps & react.RefAttributes<HTMLDivElement>>;
1139
1281
 
@@ -1172,7 +1314,7 @@ declare const ScrollArea: react.ForwardRefExoticComponent<ScrollAreaProps & reac
1172
1314
 
1173
1315
  type SelectMultiple = false;
1174
1316
  type SelectClearable = false;
1175
- type NativeAttrs$r<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$p<TItem, TKeyField>>;
1317
+ type NativeAttrs$s<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$q<TItem, TKeyField>>;
1176
1318
  type BaseProps<TItem extends Record<string, any>> = {
1177
1319
  textField?: keyof TItem;
1178
1320
  placeholder?: string;
@@ -1190,8 +1332,8 @@ type BaseProps<TItem extends Record<string, any>> = {
1190
1332
  renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
1191
1333
  renderNoData?: (props: ResultProps) => React.ReactNode;
1192
1334
  };
1193
- 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<TItem, TKeyField, TMultiple, TClearable>;
1194
- type SelectProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$p<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$r<TItem, TKeyField>;
1335
+ 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$1<TItem, TKeyField, TMultiple, TClearable>;
1336
+ 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>;
1195
1337
 
1196
1338
  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;
1197
1339
 
@@ -1215,20 +1357,21 @@ type SwitchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1215
1357
  type SwitchLabelPlacement = 'before' | 'after';
1216
1358
  type SwitchColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1217
1359
 
1218
- interface Props$o {
1360
+ interface Props$p {
1219
1361
  size?: SwitchSize;
1220
1362
  labelPlacement?: SwitchLabelPlacement;
1221
1363
  color?: SwitchColor;
1222
1364
  }
1223
- type NativeAttrs$q = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$o | 'value' | 'defaultValue'>;
1224
- type SwitchProps = Props$o & NativeAttrs$q;
1225
- declare const Switch: react.ForwardRefExoticComponent<Props$o & NativeAttrs$q & react.RefAttributes<HTMLInputElement>>;
1365
+ type NativeAttrs$r = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$p | 'value' | 'defaultValue'>;
1366
+ type SwitchProps = Props$p & NativeAttrs$r;
1367
+ declare const Switch: react.ForwardRefExoticComponent<Props$p & NativeAttrs$r & react.RefAttributes<HTMLInputElement>>;
1226
1368
 
1227
1369
  type TabsVariant = 'underlined' | 'outlined' | 'pills';
1228
1370
  type TabValue = string | number | symbol;
1229
1371
  type TabsAlignment = 'start' | 'center' | 'end' | 'stretch';
1372
+ type TabsSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1230
1373
 
1231
- interface Props$n<TTabValue extends TabValue = TabValue> {
1374
+ interface Props$o<TTabValue extends TabValue = TabValue> {
1232
1375
  /**
1233
1376
  * The HTML element type or React component to render as the tab.
1234
1377
  */
@@ -1254,11 +1397,11 @@ interface Props$n<TTabValue extends TabValue = TabValue> {
1254
1397
  */
1255
1398
  endContent?: React.ReactNode;
1256
1399
  }
1257
- type NativeAttrs$p = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$n>;
1258
- type TabProps<TTabValue extends TabValue = TabValue> = Props$n<TTabValue> & NativeAttrs$p;
1259
- declare const Tab: react.ForwardRefExoticComponent<Props$n<TabValue> & NativeAttrs$p & react.RefAttributes<HTMLDivElement>>;
1400
+ type NativeAttrs$q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$o>;
1401
+ type TabProps<TTabValue extends TabValue = TabValue> = Props$o<TTabValue> & NativeAttrs$q;
1402
+ declare const Tab: react.ForwardRefExoticComponent<Props$o<TabValue> & NativeAttrs$q & react.RefAttributes<HTMLDivElement>>;
1260
1403
 
1261
- interface Props$m<TTabValue extends TabValue = TabValue> {
1404
+ interface Props$n<TTabValue extends TabValue = TabValue> {
1262
1405
  /**
1263
1406
  * The currently selected value of the tabs.
1264
1407
  */
@@ -1272,6 +1415,10 @@ interface Props$m<TTabValue extends TabValue = TabValue> {
1272
1415
  * The alignment of the tabs.
1273
1416
  */
1274
1417
  alignment?: TabsAlignment;
1418
+ /**
1419
+ * The size of the tabs.
1420
+ */
1421
+ size?: TabsSize;
1275
1422
  /**
1276
1423
  * A callback function called when the selected tab value changes.
1277
1424
  */
@@ -1281,11 +1428,13 @@ interface Props$m<TTabValue extends TabValue = TabValue> {
1281
1428
  */
1282
1429
  onClose?: (value: TTabValue) => void;
1283
1430
  }
1284
- type NativeAttrs$o = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$m>;
1285
- type TabsProps<TTabValue extends TabValue = TabValue> = Props$m<TTabValue> & NativeAttrs$o;
1286
- declare const Tabs: <TTabValue extends TabValue = TabValue>(props: Props$m<TTabValue> & NativeAttrs$o & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1431
+ type NativeAttrs$p = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$n>;
1432
+ type TabsProps<TTabValue extends TabValue = TabValue> = Props$n<TTabValue> & NativeAttrs$p;
1433
+ declare const Tabs: <TTabValue extends TabValue = TabValue>(props: Props$n<TTabValue> & NativeAttrs$p & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1287
1434
 
1288
- interface Props$l {
1435
+ interface Props$m {
1436
+ value?: string;
1437
+ defaultValue?: string;
1289
1438
  inputRef?: React.RefObject<HTMLInputElement>;
1290
1439
  variant?: InputVariant;
1291
1440
  color?: InputColor;
@@ -1293,27 +1442,26 @@ interface Props$l {
1293
1442
  startContent?: React.ReactNode;
1294
1443
  endContent?: React.ReactNode;
1295
1444
  css?: BoxCSS;
1445
+ rules?: StringRules;
1446
+ autoFormatRules?: boolean;
1296
1447
  }
1297
- type NativeAttrs$n = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$l>;
1298
- type TextInputProps = Props$l & NativeAttrs$n;
1299
- declare const TextInput: react.ForwardRefExoticComponent<Props$l & NativeAttrs$n & react.RefAttributes<HTMLInputElement>>;
1448
+ type NativeAttrs$o = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$m>;
1449
+ type TextInputProps = Props$m & NativeAttrs$o;
1450
+ declare const TextInput: react.ForwardRefExoticComponent<Props$m & NativeAttrs$o & react.RefAttributes<HTMLInputElement>>;
1300
1451
 
1301
1452
  type ToolbarSize = 'auto' | 'sm' | 'md' | 'lg';
1453
+ type ToolbarVariant = 'filled' | 'text';
1454
+ type ToolbarColor = 'secondary' | 'primary';
1302
1455
 
1303
- interface Props$k {
1456
+ interface Props$l {
1304
1457
  size?: ToolbarSize;
1305
1458
  title?: React.ReactNode;
1306
1459
  subtitle?: React.ReactNode;
1307
1460
  startContent?: React.ReactNode;
1308
1461
  endContent?: React.ReactNode;
1309
- /**
1310
- * @deprecated Use `startContent` instead
1311
- */
1312
- startAction?: React.ReactNode;
1313
- /**
1314
- * @deprecated Use `endContent` instead
1315
- */
1316
- endAction?: React.ReactNode;
1462
+ bordered?: boolean;
1463
+ variant?: ToolbarVariant;
1464
+ color?: ToolbarColor;
1317
1465
  slotProps?: {
1318
1466
  startContent?: React.HTMLAttributes<HTMLDivElement>;
1319
1467
  content?: React.HTMLAttributes<HTMLDivElement>;
@@ -1322,8 +1470,8 @@ interface Props$k {
1322
1470
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
1323
1471
  };
1324
1472
  }
1325
- type NativeAttrs$m = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$k>;
1326
- type ToolbarProps = Props$k & NativeAttrs$m;
1473
+ type NativeAttrs$n = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$l>;
1474
+ type ToolbarProps = Props$l & NativeAttrs$n;
1327
1475
  declare const Toolbar: React.FC<ToolbarProps>;
1328
1476
 
1329
1477
  interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
@@ -1338,22 +1486,22 @@ interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
1338
1486
  }
1339
1487
  declare const Transition: React.FC<TransitionProps>;
1340
1488
 
1341
- interface Props$j {
1489
+ interface Props$k {
1342
1490
  /**
1343
1491
  * The HTML element type or React component to render as the tab.
1344
1492
  */
1345
1493
  as?: React.ElementType;
1346
1494
  width?: number;
1347
1495
  }
1348
- type NativeAttrs$l = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$j>;
1349
- type SwipeItemProps = Props$j & NativeAttrs$l;
1350
- declare const SwipeItem: react.ForwardRefExoticComponent<Props$j & NativeAttrs$l & {
1496
+ type NativeAttrs$m = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$k>;
1497
+ type SwipeItemProps = Props$k & NativeAttrs$m;
1498
+ declare const SwipeItem: react.ForwardRefExoticComponent<Props$k & NativeAttrs$m & {
1351
1499
  children?: react.ReactNode | undefined;
1352
1500
  } & react.RefAttributes<HTMLDivElement>>;
1353
1501
 
1354
1502
  type SwiperAlignmet = 'start' | 'center' | 'end';
1355
1503
 
1356
- interface Props$i {
1504
+ interface Props$j {
1357
1505
  gap?: number;
1358
1506
  alignment?: SwiperAlignmet;
1359
1507
  autoHide?: boolean;
@@ -1363,8 +1511,8 @@ interface Props$i {
1363
1511
  arrowRightButton?: ButtonProps;
1364
1512
  };
1365
1513
  }
1366
- type NativeAttrs$k = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$i>;
1367
- type SwipeProps = Props$i & NativeAttrs$k;
1514
+ type NativeAttrs$l = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$j>;
1515
+ type SwipeProps = Props$j & NativeAttrs$l;
1368
1516
  declare const Swipe: React.FC<SwipeProps>;
1369
1517
 
1370
1518
  type ModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
@@ -1374,9 +1522,9 @@ interface ModalClose {
1374
1522
  position?: 'start' | 'end';
1375
1523
  }
1376
1524
  type ModalScrollBehavior = 'inside' | 'outside';
1377
- type ModalBackdrop = BackdropVariant;
1525
+ type ModalBackdrop = BackdropVariant | boolean;
1378
1526
 
1379
- interface Props$h {
1527
+ interface Props$i {
1380
1528
  isOpen: boolean;
1381
1529
  size?: ModalSize;
1382
1530
  backdrop?: ModalBackdrop;
@@ -1388,18 +1536,23 @@ interface Props$h {
1388
1536
  slotProps?: {
1389
1537
  wrapper?: React.HTMLAttributes<HTMLDivElement>;
1390
1538
  };
1539
+ content?: boolean;
1391
1540
  onClose: () => void;
1392
1541
  onAfterClose?: () => void;
1393
1542
  }
1394
- type NativeAttrs$j = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$h>;
1395
- type ModalProps = Props$h & NativeAttrs$j;
1396
- declare const Modal: react.ForwardRefExoticComponent<Props$h & NativeAttrs$j & react.RefAttributes<HTMLDivElement>>;
1543
+ type NativeAttrs$k = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$i>;
1544
+ type ModalProps = Props$i & NativeAttrs$k;
1545
+ declare const Modal: react.ForwardRefExoticComponent<Props$i & NativeAttrs$k & react.RefAttributes<HTMLDivElement>>;
1397
1546
 
1398
1547
  type ModalBodyProps = React.HTMLAttributes<HTMLDivElement>;
1399
1548
  declare const ModalBody: React.FC<ModalBodyProps>;
1400
1549
 
1401
1550
  interface ModalContextValue {
1551
+ nodeRef: React.MutableRefObject<null>;
1402
1552
  isOpen: boolean;
1553
+ size: ModalSize;
1554
+ placement: ModalPlacement;
1555
+ fullscreen: boolean;
1403
1556
  scrollBehavior: ModalScrollBehavior;
1404
1557
  scrollArea: boolean;
1405
1558
  closable: boolean;
@@ -1408,15 +1561,15 @@ interface ModalContextValue {
1408
1561
  }
1409
1562
  declare function useModal(): ModalContextValue;
1410
1563
 
1411
- interface Props$g {
1564
+ interface Props$h {
1412
1565
  as?: React.ElementType;
1413
1566
  bordered?: boolean;
1414
1567
  }
1415
- type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g>;
1416
- type ModalFooterProps = Props$g & NativeAttrs$i;
1417
- declare const ModalFooter: react.ForwardRefExoticComponent<Props$g & NativeAttrs$i & react.RefAttributes<HTMLDivElement>>;
1568
+ type NativeAttrs$j = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$h>;
1569
+ type ModalFooterProps = Props$h & NativeAttrs$j;
1570
+ declare const ModalFooter: react.ForwardRefExoticComponent<Props$h & NativeAttrs$j & react.RefAttributes<HTMLDivElement>>;
1418
1571
 
1419
- interface Props$f {
1572
+ interface Props$g {
1420
1573
  as?: React.ElementType;
1421
1574
  title?: React.ReactNode;
1422
1575
  subtitle?: React.ReactNode;
@@ -1432,9 +1585,12 @@ interface Props$f {
1432
1585
  subtitle?: React.HTMLAttributes<HTMLDivElement>;
1433
1586
  };
1434
1587
  }
1435
- type NativeAttrs$h = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$f>;
1436
- type ModalHeaderProps = Props$f & NativeAttrs$h;
1437
- declare const ModalHeader: react.ForwardRefExoticComponent<Props$f & NativeAttrs$h & react.RefAttributes<HTMLDivElement>>;
1588
+ type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g>;
1589
+ type ModalHeaderProps = Props$g & NativeAttrs$i;
1590
+ declare const ModalHeader: react.ForwardRefExoticComponent<Props$g & NativeAttrs$i & react.RefAttributes<HTMLDivElement>>;
1591
+
1592
+ type ModalContentProps = React.HTMLAttributes<HTMLDivElement>;
1593
+ declare const ModalContent: react.ForwardRefExoticComponent<ModalContentProps & react.RefAttributes<HTMLDivElement>>;
1438
1594
 
1439
1595
  type CheckboxValue = string | number | symbol;
1440
1596
  type CheckboxSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
@@ -1443,18 +1599,18 @@ type CheckboxGroupDirection = 'row' | 'col';
1443
1599
  type CheckboxGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
1444
1600
  type CheckboxColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1445
1601
 
1446
- interface Props$e<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1602
+ interface Props$f<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1447
1603
  value?: TCheckboxValue;
1448
1604
  size?: CheckboxSize;
1449
1605
  labelPlacement?: CheckboxLabelPlacement;
1450
1606
  color?: CheckboxColor;
1451
1607
  indeterminate?: boolean;
1452
1608
  }
1453
- type NativeAttrs$g = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$e | 'defaultValue'>;
1454
- type CheckboxProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$e<TCheckboxValue> & NativeAttrs$g;
1455
- declare const Checkbox: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$e<TCheckboxValue> & NativeAttrs$g & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1609
+ type NativeAttrs$h = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$f | 'defaultValue'>;
1610
+ type CheckboxProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$f<TCheckboxValue> & NativeAttrs$h;
1611
+ declare const Checkbox: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$f<TCheckboxValue> & NativeAttrs$h & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1456
1612
 
1457
- interface Props$d<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1613
+ interface Props$e<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1458
1614
  value?: TCheckboxValue[];
1459
1615
  defaultValue?: TCheckboxValue[];
1460
1616
  disabled?: boolean;
@@ -1466,9 +1622,9 @@ interface Props$d<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1466
1622
  color?: CheckboxColor;
1467
1623
  onChange?: (value: TCheckboxValue[]) => void;
1468
1624
  }
1469
- type NativeAttrs$f = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$d>;
1470
- type CheckboxGroupProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$d<TCheckboxValue> & NativeAttrs$f;
1471
- declare const CheckboxGroup: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$d<TCheckboxValue> & NativeAttrs$f & react.RefAttributes<HTMLTableElement>) => ReturnType<React.FunctionComponent>;
1625
+ type NativeAttrs$g = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$e>;
1626
+ type CheckboxGroupProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$e<TCheckboxValue> & NativeAttrs$g;
1627
+ declare const CheckboxGroup: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$e<TCheckboxValue> & NativeAttrs$g & react.RefAttributes<HTMLTableElement>) => ReturnType<React.FunctionComponent>;
1472
1628
 
1473
1629
  interface CheckboxGroupContextValue<TCheckboxValue extends CheckboxValue = CheckboxValue> {
1474
1630
  value: TCheckboxValue[];
@@ -1490,7 +1646,7 @@ type RadioGroupDirection = 'row' | 'col';
1490
1646
  type RadioGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
1491
1647
  type RadioColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
1492
1648
 
1493
- interface Props$c<TRadioValue extends RadioValue = RadioValue> {
1649
+ interface Props$d<TRadioValue extends RadioValue = RadioValue> {
1494
1650
  value?: TRadioValue;
1495
1651
  disabled?: boolean;
1496
1652
  readOnly?: boolean;
@@ -1498,11 +1654,11 @@ interface Props$c<TRadioValue extends RadioValue = RadioValue> {
1498
1654
  labelPlacement?: RadioLabelPlacement;
1499
1655
  colorScheme?: ColorScheme;
1500
1656
  }
1501
- type NativeAttrs$e = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$c | 'defaultValue' | 'checked' | 'defaultChecked' | 'onChange'>;
1502
- type RadioProps<TRadioValue extends RadioValue = RadioValue> = Props$c<TRadioValue> & NativeAttrs$e;
1503
- declare const Radio: <TRadioValue extends RadioValue = RadioValue>(props: Props$c<TRadioValue> & NativeAttrs$e & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1657
+ type NativeAttrs$f = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$d | 'defaultValue' | 'checked' | 'defaultChecked' | 'onChange'>;
1658
+ type RadioProps<TRadioValue extends RadioValue = RadioValue> = Props$d<TRadioValue> & NativeAttrs$f;
1659
+ declare const Radio: <TRadioValue extends RadioValue = RadioValue>(props: Props$d<TRadioValue> & NativeAttrs$f & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
1504
1660
 
1505
- interface Props$b<TRadioValue extends RadioValue = RadioValue> {
1661
+ interface Props$c<TRadioValue extends RadioValue = RadioValue> {
1506
1662
  name?: string;
1507
1663
  value?: TRadioValue;
1508
1664
  defaultValue?: TRadioValue;
@@ -1515,9 +1671,9 @@ interface Props$b<TRadioValue extends RadioValue = RadioValue> {
1515
1671
  color?: RadioColor;
1516
1672
  onChange?: (value: TRadioValue) => void;
1517
1673
  }
1518
- type NativeAttrs$d = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$b>;
1519
- type RadioGroupProps<TRadioValue extends RadioValue = RadioValue> = Props$b<TRadioValue> & NativeAttrs$d;
1520
- declare const RadioGroup: <TRadioValue extends RadioValue = RadioValue>(props: Props$b<TRadioValue> & NativeAttrs$d & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1674
+ type NativeAttrs$e = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$c>;
1675
+ type RadioGroupProps<TRadioValue extends RadioValue = RadioValue> = Props$c<TRadioValue> & NativeAttrs$e;
1676
+ declare const RadioGroup: <TRadioValue extends RadioValue = RadioValue>(props: Props$c<TRadioValue> & NativeAttrs$e & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
1521
1677
 
1522
1678
  interface RadioGroupContextValue {
1523
1679
  name: string;
@@ -1535,16 +1691,16 @@ declare const useRadioGroup: () => RadioGroupContextValue;
1535
1691
 
1536
1692
  type NavRailPlacement = 'left' | 'right';
1537
1693
 
1538
- interface Props$a {
1694
+ interface Props$b {
1539
1695
  startContent?: React.ReactNode;
1540
1696
  endContent?: React.ReactNode;
1541
1697
  placement?: NavRailPlacement;
1542
1698
  }
1543
- type NativeAttrs$c = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$a>;
1544
- type NavRailProps = Props$a & NativeAttrs$c;
1699
+ type NativeAttrs$d = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$b>;
1700
+ type NavRailProps = Props$b & NativeAttrs$d;
1545
1701
  declare const NavRail: React.FC<NavRailProps>;
1546
1702
 
1547
- interface Props$9 {
1703
+ interface Props$a {
1548
1704
  as?: React.ElementType;
1549
1705
  icon?: React.ReactNode;
1550
1706
  media?: React.ReactNode;
@@ -1554,11 +1710,11 @@ interface Props$9 {
1554
1710
  label?: React.HTMLAttributes<HTMLDivElement>;
1555
1711
  };
1556
1712
  }
1557
- type NativeAttrs$b = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9>;
1558
- type NavRailItemProps = Props$9 & NativeAttrs$b;
1559
- declare const NavRailItem: react.ForwardRefExoticComponent<Props$9 & NativeAttrs$b & react.RefAttributes<HTMLDivElement>>;
1713
+ type NativeAttrs$c = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$a>;
1714
+ type NavRailItemProps = Props$a & NativeAttrs$c;
1715
+ declare const NavRailItem: react.ForwardRefExoticComponent<Props$a & NativeAttrs$c & react.RefAttributes<HTMLDivElement>>;
1560
1716
 
1561
- type Props$8 = {
1717
+ type Props$9 = {
1562
1718
  as?: React.ElementType;
1563
1719
  label: React.ReactNode;
1564
1720
  span?: Responsive<number>;
@@ -1574,20 +1730,20 @@ type Props$8 = {
1574
1730
  mq: ContainerMediaQuery;
1575
1731
  }) => React.ReactNode;
1576
1732
  } & FormatOptions;
1577
- type NativeAttrs$a = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$8 | 'children'>;
1578
- type DescriptionProps = Props$8 & NativeAttrs$a;
1733
+ type NativeAttrs$b = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9 | 'children'>;
1734
+ type DescriptionProps = Props$9 & NativeAttrs$b;
1579
1735
  declare const Description: react.ForwardRefExoticComponent<DescriptionProps & react.RefAttributes<HTMLDivElement>>;
1580
1736
 
1581
- type NativeAttrs$9 = React.HTMLAttributes<HTMLDivElement>;
1582
- type DescriptionEmptyProps = NativeAttrs$9;
1583
- declare const DescriptionEmpty: react.ForwardRefExoticComponent<NativeAttrs$9 & react.RefAttributes<HTMLDivElement>>;
1737
+ type NativeAttrs$a = React.HTMLAttributes<HTMLDivElement>;
1738
+ type DescriptionEmptyProps = NativeAttrs$a;
1739
+ declare const DescriptionEmpty: react.ForwardRefExoticComponent<NativeAttrs$a & react.RefAttributes<HTMLDivElement>>;
1584
1740
 
1585
1741
  type DescriptionsLayout = 'row' | 'col';
1586
1742
  type DescriptionsSize = 'sm' | 'md' | 'lg';
1587
1743
  type DescriptionsAlign = React.CSSProperties['textAlign'];
1588
1744
  type DescriptionsMode = 'container' | 'screen' | 'css';
1589
1745
 
1590
- interface Props$7 {
1746
+ interface Props$8 {
1591
1747
  as?: React.ElementType;
1592
1748
  mode?: DescriptionsMode;
1593
1749
  items?: DescriptionProps[];
@@ -1598,9 +1754,9 @@ interface Props$7 {
1598
1754
  labelAlign?: Responsive<DescriptionsAlign>;
1599
1755
  contentAlign?: Responsive<DescriptionsAlign>;
1600
1756
  }
1601
- type NativeAttrs$8 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7 | 'children'>;
1602
- type DescriptionsProps = Props$7 & NativeAttrs$8;
1603
- declare const Descriptions: react.ForwardRefExoticComponent<Props$7 & NativeAttrs$8 & react.RefAttributes<HTMLDivElement>>;
1757
+ type NativeAttrs$9 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$8 | 'children'>;
1758
+ type DescriptionsProps = Props$8 & NativeAttrs$9;
1759
+ declare const Descriptions: react.ForwardRefExoticComponent<Props$8 & NativeAttrs$9 & react.RefAttributes<HTMLDivElement>>;
1604
1760
 
1605
1761
  interface DescriptionsContextValue {
1606
1762
  mq: ContainerMediaQuery;
@@ -1613,9 +1769,9 @@ interface DescriptionsContextValue {
1613
1769
  declare const DescriptionsContext: react.Context<DescriptionsContextValue | null>;
1614
1770
  declare const useDescriptionsContext: () => DescriptionsContextValue;
1615
1771
 
1616
- type NativeAttrs$7 = React.HTMLAttributes<HTMLDivElement>;
1617
- type DescriptionTextProps = NativeAttrs$7;
1618
- declare const DescriptionText: react.ForwardRefExoticComponent<NativeAttrs$7 & react.RefAttributes<HTMLDivElement>>;
1772
+ type NativeAttrs$8 = React.HTMLAttributes<HTMLDivElement>;
1773
+ type DescriptionTextProps = NativeAttrs$8;
1774
+ declare const DescriptionText: react.ForwardRefExoticComponent<NativeAttrs$8 & react.RefAttributes<HTMLDivElement>>;
1619
1775
 
1620
1776
  declare function reactNodeToText(node: React.ReactNode): string;
1621
1777
 
@@ -1635,14 +1791,14 @@ interface ResponsiveProps$2 {
1635
1791
  justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1636
1792
  alignItems?: Responsive<React.CSSProperties['alignItems']>;
1637
1793
  }
1638
- type Props$6 = {
1794
+ type Props$7 = {
1639
1795
  as?: React.ElementType;
1640
1796
  } & ResponsiveProps$2;
1641
- type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
1642
- type GridItemProps = Props$6 & NativeAttrs$6;
1797
+ type NativeAttrs$7 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7>;
1798
+ type GridItemProps = Props$7 & NativeAttrs$7;
1643
1799
  declare const GridItem: react.ForwardRefExoticComponent<{
1644
1800
  as?: React.ElementType;
1645
- } & ResponsiveProps$2 & NativeAttrs$6 & react.RefAttributes<HTMLDivElement>>;
1801
+ } & ResponsiveProps$2 & NativeAttrs$7 & react.RefAttributes<HTMLDivElement>>;
1646
1802
 
1647
1803
  interface ResponsiveProps$1 {
1648
1804
  cols?: Responsive<number>;
@@ -1660,14 +1816,14 @@ interface ResponsiveProps$1 {
1660
1816
  justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
1661
1817
  alignItems?: Responsive<React.CSSProperties['alignItems']>;
1662
1818
  }
1663
- type Props$5 = {
1819
+ type Props$6 = {
1664
1820
  items?: GridItemProps[];
1665
1821
  } & ResponsiveProps$1;
1666
- type NativeAttrs$5 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5>;
1667
- type GridSubProps = Props$5 & NativeAttrs$5;
1822
+ type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
1823
+ type GridSubProps = Props$6 & NativeAttrs$6;
1668
1824
  declare const GridSub: react.ForwardRefExoticComponent<{
1669
1825
  items?: GridItemProps[];
1670
- } & ResponsiveProps$1 & NativeAttrs$5 & react.RefAttributes<HTMLDivElement>>;
1826
+ } & ResponsiveProps$1 & NativeAttrs$6 & react.RefAttributes<HTMLDivElement>>;
1671
1827
 
1672
1828
  type GridMode = 'container' | 'screen' | 'css';
1673
1829
 
@@ -1689,16 +1845,16 @@ interface ResponsiveProps {
1689
1845
  wrapper?: React.HTMLAttributes<HTMLDivElement>;
1690
1846
  };
1691
1847
  }
1692
- type Props$4 = {
1848
+ type Props$5 = {
1693
1849
  mode?: GridMode;
1694
1850
  items?: (GridItemProps | GridSubProps)[];
1695
1851
  } & ResponsiveProps;
1696
- type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
1697
- type GridProps = Props$4 & NativeAttrs$4;
1852
+ type NativeAttrs$5 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5>;
1853
+ type GridProps = Props$5 & NativeAttrs$5;
1698
1854
  declare const Grid: react.ForwardRefExoticComponent<{
1699
1855
  mode?: GridMode;
1700
1856
  items?: (GridItemProps | GridSubProps)[];
1701
- } & ResponsiveProps & NativeAttrs$4 & react.RefAttributes<HTMLDivElement>>;
1857
+ } & ResponsiveProps & NativeAttrs$5 & react.RefAttributes<HTMLDivElement>>;
1702
1858
 
1703
1859
  interface GridContextValue {
1704
1860
  mq: ContainerMediaQuery;
@@ -1718,7 +1874,7 @@ declare const Html: React.FC<HtmlProps>;
1718
1874
 
1719
1875
  type StepColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
1720
1876
 
1721
- interface Props$3 {
1877
+ interface Props$4 {
1722
1878
  value?: string | number | symbol;
1723
1879
  title: React.ReactNode;
1724
1880
  subtitle: React.ReactNode;
@@ -1726,18 +1882,18 @@ interface Props$3 {
1726
1882
  color?: StepColor;
1727
1883
  disabled?: boolean;
1728
1884
  }
1729
- type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3>;
1730
- type StepProps = Props$3 & NativeAttrs$3;
1885
+ type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
1886
+ type StepProps = Props$4 & NativeAttrs$4;
1731
1887
  declare const Step: React.FC<StepProps>;
1732
1888
 
1733
- interface Props$2 {
1889
+ interface Props$3 {
1734
1890
  direction?: 'horizontal' | 'vertical';
1735
1891
  value?: number | string | symbol;
1736
1892
  color?: StepColor;
1737
1893
  markPreviousAsChecked?: boolean;
1738
1894
  }
1739
- type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2>;
1740
- type StepsProps = Props$2 & NativeAttrs$2;
1895
+ type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3>;
1896
+ type StepsProps = Props$3 & NativeAttrs$3;
1741
1897
  declare const Steps: React.FC<StepsProps>;
1742
1898
 
1743
1899
  interface StepsContextValue {
@@ -1765,19 +1921,22 @@ interface TreeItemValue {
1765
1921
  }
1766
1922
  interface TreeItemBase {
1767
1923
  value: string;
1924
+ icon?: React.ReactNode;
1768
1925
  items?: TreeItemBase[];
1769
1926
  }
1770
1927
  interface TreeItemData {
1771
1928
  value: string;
1772
1929
  parents: string[];
1930
+ levelRaw: number;
1931
+ levelAlignment: number;
1773
1932
  }
1774
1933
 
1775
- interface Props$1 extends TreeItemBase {
1934
+ interface Props$2 extends TreeItemBase {
1776
1935
  title: string;
1777
- items?: Props$1[];
1936
+ items?: Props$2[];
1778
1937
  }
1779
- type NativeAttrs$1 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$1 | 'items'>;
1780
- type TreeItemProps = Props$1 & NativeAttrs$1;
1938
+ type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2 | 'items'>;
1939
+ type TreeItemProps = Props$2 & NativeAttrs$2;
1781
1940
  declare const TreeItem: (props: TreeItemProps) => react_jsx_runtime.JSX.Element;
1782
1941
 
1783
1942
  interface TreeProps$1 {
@@ -1801,6 +1960,7 @@ declare const TreeContext: react.Context<TreeContextValue>;
1801
1960
  interface TreeProps {
1802
1961
  items?: TreeItemBase[];
1803
1962
  value?: TreeItemValue[];
1963
+ checkable?: boolean;
1804
1964
  onChange?: (value: TreeItemValue[]) => void;
1805
1965
  onSelect?: (value: string) => void;
1806
1966
  onUnselect?: (value: string) => void;
@@ -1816,11 +1976,26 @@ declare function useTree(props: TreeProps): {
1816
1976
  };
1817
1977
 
1818
1978
  declare function initializeTreeValues(items: TreeItemData[]): TreeItemValue[];
1819
- declare function flattenTree(tree: TreeItemBase[], parents?: string[]): TreeItemData[];
1979
+ declare function flattenTree(tree: TreeItemBase[], parents?: string[], levelRaw?: number, levelAlignment?: number, parentIndicators?: {
1980
+ icon: boolean;
1981
+ chevron: boolean;
1982
+ }, checkable?: boolean): TreeItemData[];
1820
1983
  declare function updateTreeValues(values: TreeItemValue[], value: string, action: 'select' | 'unselect' | 'check' | 'uncheck', items: TreeItemData[]): TreeItemValue[];
1821
1984
 
1985
+ interface DropdownProps {
1986
+ isOpen?: boolean;
1987
+ onOpen?: () => void;
1988
+ onClose?: () => void;
1989
+ children: ((options: {
1990
+ isOpen: boolean;
1991
+ }) => React.ReactNode) | React.ReactNode;
1992
+ }
1993
+ declare const Dropdown: (props: DropdownProps) => react_jsx_runtime.JSX.Element;
1994
+
1822
1995
  interface DropdownContentProps {
1823
1996
  children: React.ReactNode;
1997
+ className?: string;
1998
+ style?: React.CSSProperties;
1824
1999
  }
1825
2000
  declare const DropdownContent: (props: DropdownContentProps) => react_jsx_runtime.JSX.Element;
1826
2001
 
@@ -1848,10 +2023,10 @@ interface DropdownContextValue {
1848
2023
  declare const DropdownContext: react.Context<DropdownContextValue | null>;
1849
2024
  declare const useDropdownContext: () => DropdownContextValue;
1850
2025
 
1851
- interface Props {
2026
+ interface Props$1 {
1852
2027
  }
1853
- type NativeAttrs = Omit<ListItemProps, keyof Props>;
1854
- type DropdownItemProps = Props & NativeAttrs;
2028
+ type NativeAttrs$1 = Omit<ListItemProps, keyof Props$1>;
2029
+ type DropdownItemProps = Props$1 & NativeAttrs$1;
1855
2030
  declare const DropdownItem: (props: DropdownItemProps) => react_jsx_runtime.JSX.Element;
1856
2031
 
1857
2032
  interface DropdownTriggerProps {
@@ -1859,27 +2034,223 @@ interface DropdownTriggerProps {
1859
2034
  }
1860
2035
  declare const DropdownTrigger: (props: DropdownTriggerProps) => react.ReactElement<any, string | react.JSXElementConstructor<any>>;
1861
2036
 
1862
- declare const scrollToItem: (parentElement: Element, currentElement: Element) => void;
2037
+ interface ListTreeItemIndentationProps {
2038
+ level: number;
2039
+ }
2040
+ declare const INDENT_SIZE = 18;
2041
+ declare const ListTreeItemIndentation: ({ level }: ListTreeItemIndentationProps) => react_jsx_runtime.JSX.Element;
2042
+ interface Props extends TreeItemBase {
2043
+ icon?: React.ReactNode;
2044
+ }
2045
+ type NativeAttrs = Omit<ListItemProps, keyof Props | 'items' | 'startContent'>;
2046
+ type ListTreeItemProps = Props & NativeAttrs & {
2047
+ items?: ListTreeItemProps[];
2048
+ };
2049
+ declare const ListTreeItem: (props: ListTreeItemProps) => react_jsx_runtime.JSX.Element;
1863
2050
 
1864
- type ClassDictionary = Record<string, any>;
1865
- type ClassArray = ClassValue[];
1866
- type ClassValue = ClassArray | ClassDictionary | string | number | null | boolean | undefined;
1867
- declare function clsx(...inputs: ClassValue[]): string;
2051
+ interface ListTreeProps {
2052
+ items?: ListTreeItemProps[];
2053
+ value?: TreeItemValue[];
2054
+ selectable?: boolean;
2055
+ checkable?: boolean;
2056
+ onChange?: (value: TreeItemValue[]) => void;
2057
+ onSelect?: (value: string) => void;
2058
+ onUnselect?: (value: string) => void;
2059
+ }
2060
+ declare const ListTree: (props: ListTreeProps) => react_jsx_runtime.JSX.Element;
1868
2061
 
1869
- type ReactRef<T> = React.RefCallback<T> | React.MutableRefObject<T>;
1870
- declare function assignRef<T = any>(ref: ReactRef<T> | null | undefined, value: T): void;
1871
- declare function mergeRefs<T>(...refs: (ReactRef<T> | null | undefined)[]): (node: T | null) => void;
2062
+ interface ListTreeContextValue {
2063
+ selectable: boolean;
2064
+ checkable: boolean;
2065
+ }
2066
+ declare const ListTreeContext: react.Context<ListTreeContextValue>;
1872
2067
 
1873
- declare function dateFormat(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1874
- declare function formatDate(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1875
- declare function formatDateTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1876
- declare function formatShortDateTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1877
- declare function formatTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
1878
- declare function formatCurrency(value: number | bigint | Intl.StringNumericLiteral, currency?: string, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
1879
- declare function formatPercent(value: any, decimals?: number, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
1880
- declare function format(options: FormatOptions): string | undefined;
2068
+ declare const DraggableTrigger: ({ children }: {
2069
+ children: react__default.ReactNode;
2070
+ }) => react_jsx_runtime.JSX.Element;
2071
+ type DraggableContentProps = react__default.HTMLAttributes<HTMLDivElement>;
2072
+ declare const DraggableContent: (props: DraggableContentProps) => react_jsx_runtime.JSX.Element;
2073
+ type DraggableContent = react__default.HTMLAttributes<HTMLDivElement> & {
2074
+ bounces?: 'screen' | 'scroll';
2075
+ placement?: 'center';
2076
+ children: react__default.ReactNode;
2077
+ };
2078
+ declare const Draggable: ({ bounces: bouncesProp, placement, ...props }: DraggableContent) => react_jsx_runtime.JSX.Element;
1881
2079
 
1882
- 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][];
1883
- declare const valuesToValue: <TItem extends Record<string, any>, TKeyField extends keyof TItem>(values: TItem[TKeyField][]) => TItem[TKeyField] | null;
2080
+ interface UploadFileData {
2081
+ id: string;
2082
+ name: string;
2083
+ size: number;
2084
+ file: File;
2085
+ }
2086
+
2087
+ interface UploadFileProps {
2088
+ data: UploadFileData[];
2089
+ readOnly?: boolean;
2090
+ accept?: string;
2091
+ max?: number;
2092
+ multiple?: boolean;
2093
+ disabled?: boolean;
2094
+ onChange: (value: UploadFileData[]) => void;
2095
+ }
2096
+ declare const UploadFiles: ({ data, max, readOnly, disabled, accept, multiple, onChange }: UploadFileProps) => react_jsx_runtime.JSX.Element;
2097
+
2098
+ type Optional<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
2099
+ type Rect = {
2100
+ x: number;
2101
+ y: number;
2102
+ width: number;
2103
+ height: number;
2104
+ };
2105
+ type LayoutMeta = {
2106
+ id: string;
2107
+ x: number;
2108
+ y: number;
2109
+ width: number;
2110
+ height: number;
2111
+ minWidth?: number;
2112
+ maxWidth?: number;
2113
+ minHeight?: number;
2114
+ maxHeight?: number;
2115
+ };
2116
+ type PanelMeta = {
2117
+ id: string;
2118
+ title: string;
2119
+ icon?: React.ReactNode;
2120
+ render?: React.ReactNode;
2121
+ x?: number;
2122
+ y?: number;
2123
+ width?: number;
2124
+ height?: number;
2125
+ minimized?: boolean;
2126
+ maximized?: boolean;
2127
+ snapped?: boolean;
2128
+ closed?: boolean;
2129
+ zIndex: number;
2130
+ zIndexFloating: number;
2131
+ zIndexLayout: number;
2132
+ layoutId?: string;
2133
+ closable?: boolean;
2134
+ minWidth?: number;
2135
+ maxWidth?: number;
2136
+ minHeight?: number;
2137
+ maxHeight?: number;
2138
+ };
2139
+ type Direction = 'top' | 'bottom' | 'left' | 'right';
2140
+ interface EdgeFlags {
2141
+ top: boolean;
2142
+ bottom: boolean;
2143
+ left: boolean;
2144
+ right: boolean;
2145
+ }
2146
+ interface LayoutRect extends Rect {
2147
+ id: string;
2148
+ gridX: number;
2149
+ gridY: number;
2150
+ gridW: number;
2151
+ gridH: number;
2152
+ isEmpty: boolean;
2153
+ isVertical: boolean;
2154
+ baseFull: Rect;
2155
+ baseEmpty: Rect;
2156
+ dimensions: Rect;
2157
+ fullDimensions: Rect;
2158
+ emptyDimensions: Rect;
2159
+ edges: LayoutEdge[];
2160
+ gridEdges: EdgeFlags;
2161
+ gridBorders: EdgeFlags;
2162
+ }
2163
+ interface LayoutEdge {
2164
+ layoutId: string | null;
2165
+ direction: Direction;
2166
+ border: boolean;
2167
+ }
2168
+
2169
+ declare function useLayoutPanelManager({ layouts, setLayouts, panels, setPanels, windowContainerRef, layoutContainerRef, }: {
2170
+ layouts: LayoutMeta[];
2171
+ setLayouts: React.Dispatch<React.SetStateAction<LayoutMeta[]>>;
2172
+ panels: PanelMeta[];
2173
+ setPanels: React.Dispatch<React.SetStateAction<PanelMeta[]>>;
2174
+ windowContainerRef: React.RefObject<HTMLDivElement>;
2175
+ layoutContainerRef: React.RefObject<HTMLDivElement>;
2176
+ }): {
2177
+ isMobile: boolean;
2178
+ layouts: LayoutMeta[];
2179
+ setLayouts: react.Dispatch<react.SetStateAction<LayoutMeta[]>>;
2180
+ panels: PanelMeta[];
2181
+ panelsRef: react.MutableRefObject<Record<string, PanelMeta>>;
2182
+ setPanels: react.Dispatch<react.SetStateAction<PanelMeta[]>>;
2183
+ layoutContainerRef: react.RefObject<HTMLDivElement>;
2184
+ windowContainerRef: react.RefObject<HTMLDivElement>;
2185
+ windowContainerRect: Rect;
2186
+ layoutContainerRect: Rect;
2187
+ panelPrevRectsRef: react.MutableRefObject<Record<string, Rect>>;
2188
+ activePanel: string | null;
2189
+ activeFloatingPanel: string | null;
2190
+ layoutPanelIds: Record<string, string[]>;
2191
+ selectWindow: (id: string) => void;
2192
+ updateWindow: (id: string, patch: Partial<PanelMeta>) => void;
2193
+ closeWindow: (id: string) => void;
2194
+ minimizeWindow: (id: string) => void;
2195
+ createWindow: (win: Optional<Omit<PanelMeta, "zIndex" | "zIndexFloating" | "zIndexLayout">, "id">) => string;
2196
+ newPositions: LayoutRect[];
2197
+ simulateLayoutPositions: (panelId: string, layoutId: string) => LayoutRect[];
2198
+ hoveredLayoutIdRef: react.MutableRefObject<Record<string, string | null>>;
2199
+ hoveredLayoutId: Record<string, string | null>;
2200
+ setHoveredLayoutId: react.Dispatch<react.SetStateAction<Record<string, string | null>>>;
2201
+ activePanelsByLayout: Record<string, string | null>;
2202
+ updateLayoutSize: (layoutId: string, newRect: Rect, isResizing?: boolean) => void;
2203
+ registerTabDragHandler: (panelId: string, handler: (event: React.PointerEvent) => void) => void;
2204
+ getTabDragHandler: (panelId: string) => (event: React.PointerEvent) => void;
2205
+ };
2206
+
2207
+ declare const useLayoutManager: () => {
2208
+ isMobile: boolean;
2209
+ layouts: LayoutMeta[];
2210
+ setLayouts: react__default.Dispatch<react__default.SetStateAction<LayoutMeta[]>>;
2211
+ panels: PanelMeta[];
2212
+ panelsRef: react__default.MutableRefObject<Record<string, PanelMeta>>;
2213
+ setPanels: react__default.Dispatch<react__default.SetStateAction<PanelMeta[]>>;
2214
+ layoutContainerRef: react__default.RefObject<HTMLDivElement>;
2215
+ windowContainerRef: react__default.RefObject<HTMLDivElement>;
2216
+ windowContainerRect: Rect;
2217
+ layoutContainerRect: Rect;
2218
+ panelPrevRectsRef: react__default.MutableRefObject<Record<string, Rect>>;
2219
+ activePanel: string | null;
2220
+ activeFloatingPanel: string | null;
2221
+ layoutPanelIds: Record<string, string[]>;
2222
+ selectWindow: (id: string) => void;
2223
+ updateWindow: (id: string, patch: Partial<PanelMeta>) => void;
2224
+ closeWindow: (id: string) => void;
2225
+ minimizeWindow: (id: string) => void;
2226
+ createWindow: (win: Optional<Omit<PanelMeta, "zIndex" | "zIndexFloating" | "zIndexLayout">, "id">) => string;
2227
+ newPositions: LayoutRect[];
2228
+ simulateLayoutPositions: (panelId: string, layoutId: string) => LayoutRect[];
2229
+ hoveredLayoutIdRef: react__default.MutableRefObject<Record<string, string | null>>;
2230
+ hoveredLayoutId: Record<string, string | null>;
2231
+ setHoveredLayoutId: react__default.Dispatch<react__default.SetStateAction<Record<string, string | null>>>;
2232
+ activePanelsByLayout: Record<string, string | null>;
2233
+ updateLayoutSize: (layoutId: string, newRect: Rect, isResizing?: boolean) => void;
2234
+ registerTabDragHandler: (panelId: string, handler: (event: react__default.PointerEvent) => void) => void;
2235
+ getTabDragHandler: (panelId: string) => (event: react__default.PointerEvent) => void;
2236
+ };
2237
+ declare function LayoutManager({ children, ...manager }: ReturnType<typeof useLayoutPanelManager> & {
2238
+ children: react__default.ReactNode;
2239
+ }): react_jsx_runtime.JSX.Element;
2240
+
2241
+ declare function LayoutCollisions({ layoutIds }: {
2242
+ layoutIds: string[];
2243
+ }): react_jsx_runtime.JSX.Element | undefined;
2244
+
2245
+ declare function Layouts(): react_jsx_runtime.JSX.Element | undefined;
2246
+
2247
+ declare function Panels(): react_jsx_runtime.JSX.Element;
2248
+
2249
+ declare function Taskbar(): react_jsx_runtime.JSX.Element;
2250
+
2251
+ interface PanelContextValue {
2252
+ panel: PanelMeta;
2253
+ }
2254
+ declare const usePanel: () => PanelContextValue;
1884
2255
 
1885
- export { Accordion, type AccordionArrow, AccordionBody, type AccordionBodyProps, type AccordionColor, AccordionContent, type AccordionContentProps, AccordionContext, AccordionHeader, type AccordionHeaderProps, AccordionItem, type AccordionItemProps, type AccordionProps, type AccordionSize, AccordionTrigger, type AccordionTriggerProps, type AccordionVariant, Autocomplete, type AutocompleteClearable, AutocompleteContext, type AutocompleteContextValue, type AutocompleteMultiple, type AutocompleteProps, Backdrop, type BackdropPlacement, type BackdropProps, type BackdropVariant, Badge, type BadgeProps, Button, type ButtonColor, ButtonGroup, ButtonGroupContext, type ButtonGroupContextValue, type ButtonGroupDirection, type ButtonGroupProps, type ButtonProps, type ButtonSize, type ButtonVariant, Card, CardBody, type CardBodyProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, CardMedia, type CardMediaProps, type CardProps, CardSubtitle, type CardSubtitleProps, CardTitle, type CardTitleProps, Checkbox, type CheckboxColor, CheckboxGroup, type CheckboxGroupAlignment, CheckboxGroupContext, type CheckboxGroupContextValue, type CheckboxGroupDirection, type CheckboxGroupProps, type CheckboxLabelPlacement, type CheckboxProps, type CheckboxSize, type CheckboxValue, Chip, type ChipProps, Collapse, CollapseContent, type CollapseContentProps, CollapseContext, type CollapseContextValue, type CollapseProps, CollapseTrigger, type CollapseTriggerProps, type ColorScheme, type ContainerBreakpoints, ContainerMediaQuery, DataList, type DataListItem, type DataListKeyField, type DataListMultipleProps, type DataListProps, type DataListSingleProps, Description, DescriptionEmpty, type DescriptionEmptyProps, type DescriptionProps, DescriptionText, type DescriptionTextProps, Descriptions, type DescriptionsAlign, DescriptionsContext, type DescriptionsContextValue, type DescriptionsLayout, type DescriptionsMode, type DescriptionsProps, type DescriptionsSize, type Disclosure, Divider, type DividerProps, Drawer, type DrawerBackdrop, DrawerBody, type DrawerBodyProps, type DrawerClose, DrawerContext, type DrawerContextValue, DrawerFooter, type DrawerFooterProps, DrawerHeader, type DrawerHeaderProps, type DrawerPlacement, type DrawerPosition, type DrawerProps, type DrawerSize, DropdownContent, type DropdownContentProps, DropdownContext, type DropdownContextValue, DropdownItem, type DropdownItemProps, DropdownTrigger, type DropdownTriggerProps, Field, type FieldProps, type FormatBooleanOptions, type FormatCurrencyOptions, type FormatDateOptions, type FormatNumberOptions, type FormatOptions, type FormatPercentOptions, type FormatStringOptions, Grid, GridContext, type GridContextValue, GridItem, type GridItemProps, type GridMode, type GridProps, GridSub, type GridSubProps, Html, type HtmlProps, Icon, type IconColor, type IconProps, type IconSize, Iframe, type IframeProps, type InfiniteData, type InfiniteQueryFunction, type InfiniteQueryOptions, type InfiniteQueryRefetchOptions, type InputColor, InputGroup, type InputGroupProps, type InputSize, type InputVariant, List, ListGroup, type ListGroupProps, ListItem, type ListItemProps, type ListProps, type ListSize, ListSubheader, type ListSubheaderProps, type MediaQuery, Menu, MenuContext, type MenuContextValue, MenuGroup, type MenuGroupItemType, type MenuGroupProps, MenuItem, type MenuItemProps, type MenuItemType, type MenuProps, MenuSubmenu, type MenuSubmenuProps, MenuValueContext, Modal, type ModalBackdrop, ModalBody, type ModalBodyProps, type ModalClose, ModalFooter, type ModalFooterProps, ModalHeader, type ModalHeaderProps, type ModalPlacement, type ModalProps, type ModalScrollBehavior, type ModalSize, type MutationError, type MutationFunction, type MutationOK, type MutationResult, MutationStatus, NavRail, NavRailItem, type NavRailItemProps, type NavRailPlacement, type NavRailProps, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type PopoverTriggerProps, Portal, type PortalProps, type QueryFunction, QueryStatus, Radio, type RadioColor, RadioGroup, type RadioGroupAlignment, RadioGroupContext, type RadioGroupContextValue, type RadioGroupDirection, type RadioGroupProps, type RadioLabelPlacement, type RadioProps, type RadioSize, type RadioValue, type ReactRef, type Resize, type Responsive, Result, type ResultProps, type ResultStatus, type ScrollAlignment, ScrollArea, type ScrollAreaProps, type ScrollBehavior, type ScrollToOptions, Select, type SelectClearable, SelectContext, type SelectContextValue, type SelectMultiple, type SelectProps, type SelectionItem, type SelectionOnChange, type SelectionProps, type SelectionValue, Step, type StepColor, type StepProps, Steps, StepsContext, type StepsContextValue, type StepsProps, Swipe, SwipeItem, type SwipeItemProps, type SwipeProps, Switch, type SwitchColor, type SwitchLabelPlacement, type SwitchProps, type SwitchSize, Tab, type TabProps, Tabs, type TabsAlignment, type TabsProps, type TabsVariant, TextInput, type TextInputProps, Toolbar, type ToolbarProps, type ToolbarSize, Transition, type TransitionProps, Tree, TreeContext, type TreeContextValue, TreeItem, type TreeItemBase, type TreeItemData, type TreeItemProps, type TreeItemValue, type TreeProps$1 as TreeProps, type UseContainerMediaQueryOptions, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, type UseResizeObserverOptions, type VirtualItem, type Virtualizer, type VirtualizerOptions, assignRef, breakpointsMap, clsx, dateFormat, defaultBreakpoints, flattenTree, format, formatCurrency, formatDate, formatDateTime, formatPercent, formatShortDateTime, formatTime, getOpenValuesByPathname, hasResizeObserver, initializeTreeValues, mergeRefs, reactNodeToText, scrollToItem, updateTreeValues, useAccordion, useAccordionItem, useAutocomplete, useButtonGroup, useCheckboxGroup, useCollapse, useContainerMediaQuery, useDebounce, useDescriptionsContext, useDisclosure, useDrawer, useDropdownContext, useEffectEvent, useElementSize, useFormat, useGridContext, useInfiniteQuery, useLocalStorage, useMediaQuery, useMenu, useMenuItemValue, useModal, useMutation, useOnClickOutside, usePopover, usePrevious, useQuery, useRadioGroup, useResizeObserver, useSelect, useStep, useStepsContext, useTree, useValueEffect, useVirtualizer, valueToValues, valuesToValue };
2256
+ 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, 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 InputBaseProps, InputClose, type InputCloseProps, type InputColor, InputGroup, type InputGroupProps, InputSelector, type InputSelectorProps, type InputSize, type InputVariant, InputWrapper, type InputWrapperProps, LayoutManager, LayoutCollisions as LayoutManagerColissions, Layouts as LayoutManagerLayouts, Panels as LayoutManagerPanels, Taskbar as LayoutManagerTaskbar, type LayoutMeta, 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, 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, useDropdownContext, useEffectEvent, useElementSize, useExtractProps, useFormat, useGridContext, useInfiniteQuery, useInputProps, useLayoutManager, usePanel as useLayoutManagerPanel, useLayoutPanelManager, useLocalStorage, useMediaQuery, useMenu, useMenuItemValue, useModal, useMutation, useOnClickOutside, usePopover, usePrevious, useQuery, useRadioGroup, useResizeObserver, useSelect, useStep, useStepsContext, useTimer, useTree, useValueEffect, useVirtualizer, validateRules, valueToValues, valuesToValue };