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

package/dist/index.d.ts

@@ -4,11 +4,11 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
 import { VirtualizerOptions as VirtualizerOptions$1, Virtualizer as Virtualizer$1, ListItemProps as ListItemProps$1, ResultProps as ResultProps$1 } from '@unifiedsoftware/react-ui';
 import { FloatingRootContext } from '@floating-ui/react';
 
-interface Props$N {
+interface Props$O {
 }
-type NativeAttrs$P = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$N>;
-type DividerProps = Props$N & NativeAttrs$P;
-declare const Divider: react.ForwardRefExoticComponent<Props$N & NativeAttrs$P & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$Q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$O>;
+type DividerProps = Props$O & NativeAttrs$Q;
+declare const Divider: react.ForwardRefExoticComponent<Props$O & NativeAttrs$Q & react.RefAttributes<HTMLDivElement>>;
 
 type BoxShadow = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 type BorderRadius = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
@@ -36,7 +36,7 @@ interface AccordionArrow {
     position?: 'start' | 'end';
 }
 
-interface Props$M {
+interface Props$N {
     value?: any[];
     defaultValue?: any[];
     expandMode?: 'single' | 'multiple';
@@ -53,9 +53,9 @@ interface Props$M {
     }) => React.ReactNode;
     onChange?: (value: any[]) => void;
 }
-type NativeAttrs$O = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$M>;
-type AccordionProps = Props$M & NativeAttrs$O;
-declare const Accordion: react.ForwardRefExoticComponent<Props$M & NativeAttrs$O & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$P = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$N>;
+type AccordionProps = Props$N & NativeAttrs$P;
+declare const Accordion: react.ForwardRefExoticComponent<Props$N & NativeAttrs$P & react.RefAttributes<HTMLDivElement>>;
 
 interface AccordionItemContextValue {
     value: string;
@@ -64,7 +64,7 @@ interface AccordionItemContextValue {
     }) => React.ReactNode;
 }
 declare const useAccordionItem: () => AccordionItemContextValue;
-interface Props$L {
+interface Props$M {
     value?: any;
     variant?: AccordionVariant;
     color?: AccordionColor;
@@ -72,11 +72,11 @@ interface Props$L {
         isOpen: boolean;
     }) => React.ReactNode;
 }
-type NativeAttrs$N = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$L>;
-type AccordionItemProps = Props$L & NativeAttrs$N;
-declare const AccordionItem: react.ForwardRefExoticComponent<Props$L & NativeAttrs$N & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$O = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$M>;
+type AccordionItemProps = Props$M & NativeAttrs$O;
+declare const AccordionItem: react.ForwardRefExoticComponent<Props$M & NativeAttrs$O & react.RefAttributes<HTMLDivElement>>;
 
-interface Props$K {
+interface Props$L {
     as?: React.ElementType;
     title?: React.ReactNode;
     subtitle?: React.ReactNode;
@@ -94,9 +94,9 @@ interface Props$K {
         subtitle?: React.HTMLAttributes<HTMLDivElement>;
     };
 }
-type NativeAttrs$M = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$K>;
-type AccordionHeaderProps = Props$K & NativeAttrs$M;
-declare const AccordionHeader: react.ForwardRefExoticComponent<Props$K & NativeAttrs$M & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$N = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$L>;
+type AccordionHeaderProps = Props$L & NativeAttrs$N;
+declare const AccordionHeader: react.ForwardRefExoticComponent<Props$L & NativeAttrs$N & react.RefAttributes<HTMLDivElement>>;
 
 type AccordionBodyProps = React.HTMLAttributes<HTMLDivElement>;
 declare const AccordionBody: react.ForwardRefExoticComponent<AccordionBodyProps & react.RefAttributes<HTMLDivElement>>;
@@ -401,21 +401,17 @@ interface UseContainerMediaQueryOptions<TElement extends HTMLElement = HTMLEleme
 }
 declare function useContainerMediaQuery<TElement extends HTMLElement = HTMLElement>(options: UseContainerMediaQueryOptions<TElement>): ContainerMediaQuery | undefined;
 
-interface FormatStringOptions {
-    type?: 'string';
-    value?: string | null;
-}
-interface FormatNumberOptions {
-    type: 'number';
-    value?: number | string | null;
-}
-interface FormatDateOptions {
-    type: 'date';
-    value?: Date | string | number | null;
-    format?: 'datetime' | 'short datetime' | 'date' | 'time';
-    locales?: Intl.LocalesArgument;
-    options?: Intl.DateTimeFormatOptions;
-}
+declare const scrollToItem: (parentElement: Element, currentElement: Element) => void;
+
+type ClassDictionary = Record<string, any>;
+type ClassArray = ClassValue[];
+type ClassValue = ClassArray | ClassDictionary | string | number | null | boolean | undefined;
+declare function clsx(...inputs: ClassValue[]): string;
+
+type ReactRef<T> = React.RefCallback<T> | React.MutableRefObject<T>;
+declare function assignRef<T = any>(ref: ReactRef<T> | null | undefined, value: T): void;
+declare function mergeRefs<T>(...refs: (ReactRef<T> | null | undefined)[]): (node: T | null) => void;
+
 interface FormatBooleanOptions {
     type: 'boolean';
     value?: boolean | null;
@@ -424,6 +420,7 @@ interface FormatBooleanOptions {
         false?: string;
     };
 }
+
 interface FormatCurrencyOptions {
     type: 'currency';
     value?: number | bigint | Intl.StringNumericLiteral | null;
@@ -431,6 +428,43 @@ interface FormatCurrencyOptions {
     locales?: Intl.LocalesArgument;
     options?: Intl.NumberFormatOptions;
 }
+declare function formatCurrency(value: number | bigint | Intl.StringNumericLiteral, currency?: string, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
+
+interface FormatDateOptions {
+    type: 'date';
+    value?: Date | string | number | null;
+    format?: 'datetime' | 'short datetime' | 'date' | 'time';
+    locales?: Intl.LocalesArgument;
+    options?: Intl.DateTimeFormatOptions;
+}
+declare function formatDate(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+declare function formatDateTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+declare function formatShortDateTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+declare function formatTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+
+type UnitSystem = 'si' | 'iec';
+type ForcedUnit = 'B' | 'KB' | 'MB' | 'GB' | 'TB' | 'PB' | 'EB' | 'ZB' | 'YB' | 'KiB' | 'MiB' | 'GiB' | 'TiB' | 'PiB' | 'EiB' | 'ZiB' | 'YiB';
+interface FileSizeFormatOptions {
+    system?: UnitSystem;
+    maximumFractionDigits?: number;
+    minimumFractionDigits?: number;
+    unit?: ForcedUnit;
+    spacer?: string;
+    lowercase?: boolean;
+}
+interface FormatFileSizeOptions {
+    type: 'file-size';
+    value?: number;
+    locales?: Intl.LocalesArgument;
+    options?: FileSizeFormatOptions;
+}
+declare function formatFileSize(bytes: number, locales?: Intl.LocalesArgument, { system, maximumFractionDigits, minimumFractionDigits, unit, spacer, lowercase, }?: FileSizeFormatOptions): string;
+
+interface FormatNumberOptions {
+    type: 'number';
+    value?: number | string | null;
+}
+
 interface FormatPercentOptions {
     type: 'percent';
     value?: number | string | null;
@@ -438,13 +472,79 @@ interface FormatPercentOptions {
     locales?: Intl.LocalesArgument;
     options?: Intl.NumberFormatOptions;
 }
-type FormatOptions = FormatStringOptions | FormatNumberOptions | FormatDateOptions | FormatBooleanOptions | FormatCurrencyOptions | FormatPercentOptions;
+declare function formatPercent(value: any, decimals?: number, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
+
+interface FormatStringOptions {
+    type?: 'string';
+    value?: string | null;
+}
+
+type FormatOptions = FormatStringOptions | FormatNumberOptions | FormatDateOptions | FormatBooleanOptions | FormatCurrencyOptions | FormatPercentOptions | FormatFileSizeOptions;
+declare function format(options: FormatOptions): string | undefined;
+
+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];
+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;
+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;
+interface SelectionProps<TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> {
+    data: TItem[];
+    isMultiple?: TMultiple;
+    clearable?: TClearable;
+    keyField?: TKeyField;
+    value?: SelectionValue<TItem, TKeyField, TMultiple, TClearable>;
+    onChange?: SelectionOnChange<TItem, TKeyField, TMultiple, TClearable>;
+}
+
+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][];
+declare const valuesToValue: <TItem extends Record<string, any>, TKeyField extends keyof TItem>(values: TItem[TKeyField][]) => TItem[TKeyField] | null;
+
+declare function areArraysEqual<T extends string | number | symbol>(arr1: T[], arr2: T[]): boolean;
+
+declare function toLocalDateString(date: Date): string;
+declare function toLocalDateTimeString(date: Date): string;
+declare function toAlphaString(value: string): string;
+declare function toNumericString(value: string): string;
+declare function toAlphanumericString(value: string): string;
+declare function toPlainTextString(value: string): string;
+declare function toNotEmojisString(value: string): string;
+declare const STRING_RULES: readonly ["allow-emojis", "not-allow-emojis", "only-alpha", "only-numeric", "only-alphanumeric", "only-plain-text"];
+type StringRules = Array<(typeof STRING_RULES)[number]>;
+declare function toRulesString(rules: StringRules, value: string): string;
+
+declare function isEmpty<T>(value?: T | null): value is null | undefined;
+declare function isEmptyString(value?: string | null): value is null | undefined;
+declare function isNumeric(value: string): boolean;
+declare function isAlphanumeric(value: string): boolean;
+declare function containsPlainText(value: string): boolean;
+declare function doesNotContainEmojis(value: string): boolean;
+declare function validateRules(rules: StringRules, value: string): string | boolean;
+
+declare function generateId(): string;
 
 declare function useFormat(options: FormatOptions): {
     value: string | undefined;
     getValue: (value: any) => string | undefined;
 };
 
+type TimerMode = 'up' | 'down';
+interface UseTimerOptions {
+    mode: TimerMode;
+    initialSeconds: number;
+    maxSeconds?: number;
+    onTick?: (seconds: number) => void;
+    onComplete?: () => void;
+}
+declare const useTimer: ({ mode, initialSeconds, maxSeconds, onTick, onComplete }: UseTimerOptions) => {
+    seconds: number;
+    formattedTime: string;
+    isRunning: boolean;
+    isCompleted: boolean;
+    start: () => void;
+    pause: () => void;
+    reset: (newSeconds?: number) => void;
+    stop: () => void;
+};
+type Timer = ReturnType<typeof useTimer>;
+
 type ColorScheme = 'default' | 'light' | 'dark';
 
 type MediaQuery = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
@@ -475,37 +575,26 @@ type Responsive<T> = T | {
     '2xl'?: T;
 };
 
-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];
-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;
-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;
-interface SelectionProps<TItem extends Record<string, any>, TKeyField extends keyof TItem, TMultiple extends boolean | undefined, TClearable extends boolean | undefined> {
-    data: TItem[];
-    isMultiple?: TMultiple;
-    clearable?: TClearable;
-    keyField?: TKeyField;
-    value?: SelectionValue<TItem, TKeyField, TMultiple, TClearable>;
-    onChange?: SelectionOnChange<TItem, TKeyField, TMultiple, TClearable>;
-}
-
 type InputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 type InputColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
 type InputVariant = 'filled' | 'outlined' | 'flat' | 'text';
 
-interface Props$J {
+interface Props$K {
 }
-type NativeAttrs$L = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$J>;
-type InputGroupProps = Props$J & NativeAttrs$L;
-declare const InputGroup: react.ForwardRefExoticComponent<Props$J & NativeAttrs$L & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$M = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$K>;
+type InputGroupProps = Props$K & NativeAttrs$M;
+declare const InputGroup: react.ForwardRefExoticComponent<Props$K & NativeAttrs$M & react.RefAttributes<HTMLDivElement>>;
 
 type ListSize = 'sm' | 'md' | 'lg';
 
 interface ListProps extends React.HTMLAttributes<HTMLDivElement> {
     as?: React.ElementType;
     size?: ListSize;
+    divider?: boolean;
 }
 declare const List: react.ForwardRefExoticComponent<ListProps & react.RefAttributes<HTMLDivElement>>;
 
-interface Props$I {
+interface Props$J {
     as?: react__default.ElementType;
     title?: react__default.ReactNode;
     subtitle?: react__default.ReactNode;
@@ -523,11 +612,11 @@ interface Props$I {
         subtitle?: react__default.HTMLAttributes<HTMLDivElement>;
     };
 }
-type NativeAttrs$K = Omit<react__default.HTMLAttributes<HTMLDivElement>, keyof Props$I>;
-type ListItemProps = Props$I & NativeAttrs$K;
-declare const ListItem: react__default.ForwardRefExoticComponent<Props$I & NativeAttrs$K & react__default.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$L = Omit<react__default.HTMLAttributes<HTMLDivElement>, keyof Props$J>;
+type ListItemProps = Props$J & NativeAttrs$L;
+declare const ListItem: react__default.ForwardRefExoticComponent<Props$J & NativeAttrs$L & react__default.RefAttributes<HTMLDivElement>>;
 
-interface Props$H {
+interface Props$I {
     expandVisible?: boolean;
     expandPosition?: 'start' | 'end';
     isOpen?: boolean;
@@ -535,9 +624,9 @@ interface Props$H {
     onClose?: () => void;
     onToggle?: () => void;
 }
-type NativeAttrs$J = Omit<ListItemProps, keyof Props$H>;
-type ListGroupProps = Props$H & NativeAttrs$J;
-declare const ListGroup: react.ForwardRefExoticComponent<Props$H & NativeAttrs$J & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$K = Omit<ListItemProps, keyof Props$I>;
+type ListGroupProps = Props$I & NativeAttrs$K;
+declare const ListGroup: react.ForwardRefExoticComponent<Props$I & NativeAttrs$K & react.RefAttributes<HTMLDivElement>>;
 
 interface ListSubheaderProps extends React.HTMLAttributes<HTMLDivElement> {
     as?: React.ElementType;
@@ -567,7 +656,7 @@ declare const Result: React.FC<ResultProps>;
 
 type AutocompleteMultiple = false;
 type AutocompleteClearable = true;
-type NativeAttrs$I<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$G<TItem, TKeyField>>;
+type NativeAttrs$J<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$H<TItem, TKeyField>>;
 type BaseProps$1<TItem extends Record<string, any>> = {
     textField?: keyof TItem;
     placeholder?: string;
@@ -587,8 +676,8 @@ type BaseProps$1<TItem extends Record<string, any>> = {
     renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
     renderNoData?: (props: ResultProps) => React.ReactNode;
 };
-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>;
-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>;
+type Props$H<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = BaseProps$1<TItem> & SelectionProps<TItem, TKeyField, TMultiple, TClearable>;
+type AutocompleteProps<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = Props$H<TItem, TKeyField, TMultiple, TClearable> & NativeAttrs$J<TItem, TKeyField>;
 
 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;
 
@@ -611,7 +700,7 @@ declare const useAutocomplete: () => AutocompleteContextValue<Record<string, any
 type BackdropPlacement = 'top' | 'left' | 'center' | 'right' | 'bottom';
 type BackdropVariant = 'opaque' | 'blur' | 'transparent';
 
-interface Props$F {
+interface Props$G {
     isOpen: boolean;
     closable?: boolean;
     placement?: BackdropPlacement;
@@ -620,14 +709,14 @@ interface Props$F {
     scrollArea?: boolean;
     onClose(): void;
 }
-type NativeAttrs$H = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$F>;
-type BackdropProps = Props$F & NativeAttrs$H;
-declare const Backdrop: react.ForwardRefExoticComponent<Props$F & NativeAttrs$H & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$I = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$G>;
+type BackdropProps = Props$G & NativeAttrs$I;
+declare const Backdrop: react.ForwardRefExoticComponent<Props$G & NativeAttrs$I & react.RefAttributes<HTMLDivElement>>;
 
 type BadgeColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
 type BadgePlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 
-interface Props$E {
+interface Props$F {
     /**
      * The placement of the badge relative to its content.
      */
@@ -645,8 +734,8 @@ interface Props$E {
         wrapper?: React.HTMLAttributes<HTMLDivElement>;
     };
 }
-type NativeAttrs$G = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$E>;
-type BadgeProps = Props$E & NativeAttrs$G;
+type NativeAttrs$H = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$F>;
+type BadgeProps = Props$F & NativeAttrs$H;
 declare const Badge: React.FC<BadgeProps>;
 
 type DataListItem = Record<string, any>;
@@ -663,7 +752,7 @@ interface DataListMultipleProps<TDataListItem extends DataListItem, TDataListKey
     onChange?: (value: TDataListItem[]) => void;
     onValueChange?: (value: TDataListItem[TDataListKeyField][]) => void;
 }
-type Props$D<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
+type Props$E<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = {
     data: TDataListItem[];
     keyField?: TDataListKeyField;
     textField?: keyof DataListItem;
@@ -678,8 +767,8 @@ type Props$D<TDataListItem extends DataListItem, TDataListKeyField extends DataL
     renderItem?: (item: TDataListItem, props: ListItemProps$1) => React.ReactNode;
     renderNoData?: (props: ResultProps$1) => React.ReactNode;
 } & (DataListSingleProps<TDataListItem, TDataListKeyField> | DataListMultipleProps<TDataListItem, TDataListKeyField>);
-type NativeAttrs$F<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$D<TDataListItem, TDataListKeyField>>;
-type DataListProps<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Props$D<TDataListItem, TDataListKeyField> & NativeAttrs$F<TDataListItem, TDataListKeyField>;
+type NativeAttrs$G<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$E<TDataListItem, TDataListKeyField>>;
+type DataListProps<TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = 'key'> = Props$E<TDataListItem, TDataListKeyField> & NativeAttrs$G<TDataListItem, TDataListKeyField>;
 
 declare const DataList: <TDataListItem extends DataListItem, TDataListKeyField extends DataListKeyField<TDataListItem> = "key">(props: DataListProps<TDataListItem, TDataListKeyField>) => react_jsx_runtime.JSX.Element;
 
@@ -688,7 +777,7 @@ type ButtonColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'd
 type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
 type ButtonGroupDirection = 'row' | 'col';
 
-interface Props$C {
+interface Props$D {
     /**
      * The HTML element type or React component to render as the button.
      */
@@ -733,20 +822,20 @@ interface Props$C {
         fontStyle?: React.CSSProperties['fontStyle'];
     };
 }
-type NativeAttrs$E = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$C>;
-type ButtonProps = Props$C & NativeAttrs$E;
-declare const Button: react.ForwardRefExoticComponent<Props$C & NativeAttrs$E & react.RefAttributes<HTMLButtonElement>>;
+type NativeAttrs$F = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$D>;
+type ButtonProps = Props$D & NativeAttrs$F;
+declare const Button: react.ForwardRefExoticComponent<Props$D & NativeAttrs$F & react.RefAttributes<HTMLButtonElement>>;
 
-interface Props$B {
+interface Props$C {
     direction?: ButtonGroupDirection;
     variant?: ButtonVariant;
     color?: ButtonColor;
     size?: ButtonSize;
     disabled?: boolean;
 }
-type NativeAttrs$D = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$B>;
-type ButtonGroupProps = Props$B & NativeAttrs$D;
-declare const ButtonGroup: react.ForwardRefExoticComponent<Props$B & NativeAttrs$D & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$E = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$C>;
+type ButtonGroupProps = Props$C & NativeAttrs$E;
+declare const ButtonGroup: react.ForwardRefExoticComponent<Props$C & NativeAttrs$E & react.RefAttributes<HTMLDivElement>>;
 
 interface ButtonGroupContextValue {
     direction: ButtonGroupDirection;
@@ -760,7 +849,7 @@ declare const useButtonGroup: () => ButtonGroupContextValue | null;
 
 type CardSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
 
-interface Props$A {
+interface Props$B {
     as?: React.ElementType;
     size?: CardSize;
     hoverable?: boolean;
@@ -770,14 +859,14 @@ interface Props$A {
     divider?: boolean;
     css?: BoxCSS;
 }
-type NativeAttrs$C = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$A>;
-type CardProps = Props$A & NativeAttrs$C;
-declare const Card: react.ForwardRefExoticComponent<Props$A & NativeAttrs$C & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$D = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$B>;
+type CardProps = Props$B & NativeAttrs$D;
+declare const Card: react.ForwardRefExoticComponent<Props$B & NativeAttrs$D & react.RefAttributes<HTMLDivElement>>;
 
 type CardBodyProps = React.HTMLAttributes<HTMLDivElement>;
 declare const CardBody: react.ForwardRefExoticComponent<CardBodyProps & react.RefAttributes<HTMLDivElement>>;
 
-interface Props$z {
+interface Props$A {
     as?: React.ElementType;
     title?: React.ReactNode;
     subtitle?: React.ReactNode;
@@ -803,11 +892,11 @@ interface Props$z {
         subtitle?: React.HTMLAttributes<HTMLDivElement>;
     };
 }
-type NativeAttrs$B = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$z>;
-type CardHeaderProps = Props$z & NativeAttrs$B;
-declare const CardHeader: react.ForwardRefExoticComponent<Props$z & NativeAttrs$B & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$C = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$A>;
+type CardHeaderProps = Props$A & NativeAttrs$C;
+declare const CardHeader: react.ForwardRefExoticComponent<Props$A & NativeAttrs$C & react.RefAttributes<HTMLDivElement>>;
 
-interface Props$y {
+interface Props$z {
     as?: React.ElementType;
     /**
      * @deprecated Use `underlined` instead
@@ -815,9 +904,9 @@ interface Props$y {
     bordered?: boolean;
     underlined?: boolean;
 }
-type NativeAttrs$A = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$y>;
-type CardFooterProps = Props$y & NativeAttrs$A;
-declare const CardFooter: react.ForwardRefExoticComponent<Props$y & NativeAttrs$A & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$B = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$z>;
+type CardFooterProps = Props$z & NativeAttrs$B;
+declare const CardFooter: react.ForwardRefExoticComponent<Props$z & NativeAttrs$B & react.RefAttributes<HTMLDivElement>>;
 
 type CardMediaProps = React.HTMLAttributes<HTMLDivElement> & {
     topLeftContent?: React.ReactNode;
@@ -828,28 +917,28 @@ declare const CardMedia: react.ForwardRefExoticComponent<react.HTMLAttributes<HT
     topRightContent?: React.ReactNode;
 } & react.RefAttributes<HTMLDivElement>>;
 
-interface Props$x {
+interface Props$y {
     as?: React.ElementType;
     centered?: boolean;
     css?: BoxCSS;
 }
-type NativeAttrs$z = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$x>;
-type CardTitleProps = Props$x & NativeAttrs$z;
-declare const CardTitle: react.ForwardRefExoticComponent<Props$x & NativeAttrs$z & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$A = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$y>;
+type CardTitleProps = Props$y & NativeAttrs$A;
+declare const CardTitle: react.ForwardRefExoticComponent<Props$y & NativeAttrs$A & react.RefAttributes<HTMLDivElement>>;
 
-interface Props$w {
+interface Props$x {
     as?: React.ElementType;
     css?: BoxCSS;
 }
-type NativeAttrs$y = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$w>;
-type CardSubtitleProps = Props$w & NativeAttrs$y;
-declare const CardSubtitle: react.ForwardRefExoticComponent<Props$w & NativeAttrs$y & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$z = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$x>;
+type CardSubtitleProps = Props$x & NativeAttrs$z;
+declare const CardSubtitle: react.ForwardRefExoticComponent<Props$x & NativeAttrs$z & react.RefAttributes<HTMLDivElement>>;
 
 type ChipVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain' | 'bordered';
 type ChipColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
 type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 
-interface Props$v {
+interface Props$w {
     /**
      * The HTML element type or React component to render as the chip.
      */
@@ -887,9 +976,9 @@ interface Props$v {
     };
     onClose?: () => void;
 }
-type NativeAttrs$x = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$v>;
-type ChipProps = Props$v & NativeAttrs$x;
-declare const Chip: react.ForwardRefExoticComponent<Props$v & NativeAttrs$x & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$y = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$w>;
+type ChipProps = Props$w & NativeAttrs$y;
+declare const Chip: react.ForwardRefExoticComponent<Props$w & NativeAttrs$y & react.RefAttributes<HTMLDivElement>>;
 
 interface CollapseProps {
     children: React.ReactNode;
@@ -934,7 +1023,7 @@ interface DrawerClose {
 }
 type DrawerBackdrop = BackdropVariant;
 
-interface Props$u {
+interface Props$v {
     isOpen: boolean;
     size?: DrawerSize;
     backdrop?: DrawerBackdrop;
@@ -951,11 +1040,11 @@ interface Props$u {
     onClose: () => void;
     onAfterClose?: () => void;
 }
-type NativeAttrs$w = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$u>;
-type DrawerProps = Props$u & NativeAttrs$w;
-declare const Drawer: react.ForwardRefExoticComponent<Props$u & NativeAttrs$w & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$x = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$v>;
+type DrawerProps = Props$v & NativeAttrs$x;
+declare const Drawer: react.ForwardRefExoticComponent<Props$v & NativeAttrs$x & react.RefAttributes<HTMLDivElement>>;
 
-interface Props$t {
+interface Props$u {
     as?: React.ElementType;
     title?: React.ReactNode;
     subtitle?: React.ReactNode;
@@ -971,20 +1060,20 @@ interface Props$t {
         subtitle?: React.HTMLAttributes<HTMLDivElement>;
     };
 }
-type NativeAttrs$v = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$t>;
-type DrawerHeaderProps = Props$t & NativeAttrs$v;
-declare const DrawerHeader: react.ForwardRefExoticComponent<Props$t & NativeAttrs$v & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$w = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$u>;
+type DrawerHeaderProps = Props$u & NativeAttrs$w;
+declare const DrawerHeader: react.ForwardRefExoticComponent<Props$u & NativeAttrs$w & react.RefAttributes<HTMLDivElement>>;
 
 type DrawerBodyProps = React.HTMLAttributes<HTMLDivElement>;
 declare const DrawerBody: react.ForwardRefExoticComponent<DrawerBodyProps & react.RefAttributes<HTMLDivElement>>;
 
-interface Props$s {
+interface Props$t {
     as?: React.ElementType;
     bordered?: boolean;
 }
-type NativeAttrs$u = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$s>;
-type DrawerFooterProps = Props$s & NativeAttrs$u;
-declare const DrawerFooter: react.ForwardRefExoticComponent<Props$s & NativeAttrs$u & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$v = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$t>;
+type DrawerFooterProps = Props$t & NativeAttrs$v;
+declare const DrawerFooter: react.ForwardRefExoticComponent<Props$t & NativeAttrs$v & react.RefAttributes<HTMLDivElement>>;
 
 interface DrawerContextValue {
     isOpen: boolean;
@@ -999,16 +1088,27 @@ interface FieldProps extends React.HTMLAttributes<HTMLDivElement> {
 declare const Field: react.ForwardRefExoticComponent<FieldProps & react.RefAttributes<HTMLDivElement>>;
 
 type IconColor = 'inherit' | 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
-type IconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type IconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
 
 interface IconProps {
     children: React.ReactNode;
     color?: IconColor;
     size?: IconSize;
+    className?: string;
+    style?: React.CSSProperties;
+    cssVars?: {
+        color?: string;
+        fontSize?: number | string;
+    };
+    cssUtils?: {
+        opacity?: number;
+        pointer?: boolean;
+        hoverOpacity?: number;
+    };
 }
 declare const Icon: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<unknown>>;
 
-interface Props$r {
+interface Props$s {
     /**
      * The HTML element type or React component to render as the menu item.
      */
@@ -1034,9 +1134,9 @@ interface Props$r {
      */
     disabled?: boolean;
 }
-type NativeAttrs$t = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$r | 'items'>;
-type MenuItemProps = Props$r & NativeAttrs$t;
-declare const MenuItem: react.ForwardRefExoticComponent<Props$r & NativeAttrs$t & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$u = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$s | 'items'>;
+type MenuItemProps = Props$s & NativeAttrs$u;
+declare const MenuItem: react.ForwardRefExoticComponent<Props$s & NativeAttrs$u & react.RefAttributes<HTMLDivElement>>;
 
 type MenuSubmenuProps = Omit<MenuItemProps, 'items'> & {
     items?: MenuItemType[];
@@ -1060,7 +1160,7 @@ type MenuItemType = (MenuGroupProps & {
 }) | (MenuItemProps & {
     type?: 'item';
 });
-interface Props$q {
+interface Props$r {
     /**
      * The currently selected value of the menu.
      */
@@ -1096,8 +1196,8 @@ interface Props$q {
      */
     onItemSelect?: (props: MenuItemProps) => void;
 }
-type NativeAttrs$s = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$q | 'items'>;
-type MenuProps = Props$q & NativeAttrs$s & {
+type NativeAttrs$t = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$r | 'items'>;
+type MenuProps = Props$r & NativeAttrs$t & {
     items?: MenuItemType[];
 };
 declare const Menu: React.FC<MenuProps>;
@@ -1134,6 +1234,7 @@ declare const Popover: React.FC<PopoverProps>;
 
 interface PopoverContentProps extends React.HTMLAttributes<HTMLDivElement> {
     sectionValue?: string;
+    excludeTargets?: string[];
 }
 declare const PopoverContent: react.ForwardRefExoticComponent<PopoverContentProps & react.RefAttributes<HTMLDivElement>>;
 
@@ -1172,7 +1273,7 @@ declare const ScrollArea: react.ForwardRefExoticComponent<ScrollAreaProps & reac
 
 type SelectMultiple = false;
 type SelectClearable = false;
-type NativeAttrs$r<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$p<TItem, TKeyField>>;
+type NativeAttrs$s<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$q<TItem, TKeyField>>;
 type BaseProps<TItem extends Record<string, any>> = {
     textField?: keyof TItem;
     placeholder?: string;
@@ -1190,8 +1291,8 @@ type BaseProps<TItem extends Record<string, any>> = {
     renderItem?: (item: TItem, props: ListItemProps) => React.ReactNode;
     renderNoData?: (props: ResultProps) => React.ReactNode;
 };
-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>;
-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>;
+type Props$q<TItem extends Record<string, any>, TKeyField extends keyof TItem = 'key', TMultiple extends boolean | undefined = false, TClearable extends boolean | undefined = false> = BaseProps<TItem> & SelectionProps<TItem, TKeyField, TMultiple, TClearable>;
+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>;
 
 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;
 
@@ -1215,20 +1316,21 @@ type SwitchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 type SwitchLabelPlacement = 'before' | 'after';
 type SwitchColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
 
-interface Props$o {
+interface Props$p {
     size?: SwitchSize;
     labelPlacement?: SwitchLabelPlacement;
     color?: SwitchColor;
 }
-type NativeAttrs$q = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$o | 'value' | 'defaultValue'>;
-type SwitchProps = Props$o & NativeAttrs$q;
-declare const Switch: react.ForwardRefExoticComponent<Props$o & NativeAttrs$q & react.RefAttributes<HTMLInputElement>>;
+type NativeAttrs$r = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$p | 'value' | 'defaultValue'>;
+type SwitchProps = Props$p & NativeAttrs$r;
+declare const Switch: react.ForwardRefExoticComponent<Props$p & NativeAttrs$r & react.RefAttributes<HTMLInputElement>>;
 
 type TabsVariant = 'underlined' | 'outlined' | 'pills';
 type TabValue = string | number | symbol;
 type TabsAlignment = 'start' | 'center' | 'end' | 'stretch';
+type TabsSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 
-interface Props$n<TTabValue extends TabValue = TabValue> {
+interface Props$o<TTabValue extends TabValue = TabValue> {
     /**
      * The HTML element type or React component to render as the tab.
      */
@@ -1254,11 +1356,11 @@ interface Props$n<TTabValue extends TabValue = TabValue> {
      */
     endContent?: React.ReactNode;
 }
-type NativeAttrs$p = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$n>;
-type TabProps<TTabValue extends TabValue = TabValue> = Props$n<TTabValue> & NativeAttrs$p;
-declare const Tab: react.ForwardRefExoticComponent<Props$n<TabValue> & NativeAttrs$p & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$q = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$o>;
+type TabProps<TTabValue extends TabValue = TabValue> = Props$o<TTabValue> & NativeAttrs$q;
+declare const Tab: react.ForwardRefExoticComponent<Props$o<TabValue> & NativeAttrs$q & react.RefAttributes<HTMLDivElement>>;
 
-interface Props$m<TTabValue extends TabValue = TabValue> {
+interface Props$n<TTabValue extends TabValue = TabValue> {
     /**
      * The currently selected value of the tabs.
      */
@@ -1272,6 +1374,10 @@ interface Props$m<TTabValue extends TabValue = TabValue> {
      * The alignment of the tabs.
      */
     alignment?: TabsAlignment;
+    /**
+     * The size of the tabs.
+     */
+    size?: TabsSize;
     /**
      * A callback function called when the selected tab value changes.
      */
@@ -1281,11 +1387,13 @@ interface Props$m<TTabValue extends TabValue = TabValue> {
      */
     onClose?: (value: TTabValue) => void;
 }
-type NativeAttrs$o = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$m>;
-type TabsProps<TTabValue extends TabValue = TabValue> = Props$m<TTabValue> & NativeAttrs$o;
-declare const Tabs: <TTabValue extends TabValue = TabValue>(props: Props$m<TTabValue> & NativeAttrs$o & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
+type NativeAttrs$p = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$n>;
+type TabsProps<TTabValue extends TabValue = TabValue> = Props$n<TTabValue> & NativeAttrs$p;
+declare const Tabs: <TTabValue extends TabValue = TabValue>(props: Props$n<TTabValue> & NativeAttrs$p & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
 
-interface Props$l {
+interface Props$m {
+    value?: string;
+    defaultValue?: string;
     inputRef?: React.RefObject<HTMLInputElement>;
     variant?: InputVariant;
     color?: InputColor;
@@ -1293,14 +1401,16 @@ interface Props$l {
     startContent?: React.ReactNode;
     endContent?: React.ReactNode;
     css?: BoxCSS;
+    rules?: StringRules;
+    autoFormatRules?: boolean;
 }
-type NativeAttrs$n = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$l>;
-type TextInputProps = Props$l & NativeAttrs$n;
-declare const TextInput: react.ForwardRefExoticComponent<Props$l & NativeAttrs$n & react.RefAttributes<HTMLInputElement>>;
+type NativeAttrs$o = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$m>;
+type TextInputProps = Props$m & NativeAttrs$o;
+declare const TextInput: react.ForwardRefExoticComponent<Props$m & NativeAttrs$o & react.RefAttributes<HTMLInputElement>>;
 
 type ToolbarSize = 'auto' | 'sm' | 'md' | 'lg';
 
-interface Props$k {
+interface Props$l {
     size?: ToolbarSize;
     title?: React.ReactNode;
     subtitle?: React.ReactNode;
@@ -1322,8 +1432,8 @@ interface Props$k {
         subtitle?: React.HTMLAttributes<HTMLDivElement>;
     };
 }
-type NativeAttrs$m = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$k>;
-type ToolbarProps = Props$k & NativeAttrs$m;
+type NativeAttrs$n = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$l>;
+type ToolbarProps = Props$l & NativeAttrs$n;
 declare const Toolbar: React.FC<ToolbarProps>;
 
 interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
@@ -1338,22 +1448,22 @@ interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
 }
 declare const Transition: React.FC<TransitionProps>;
 
-interface Props$j {
+interface Props$k {
     /**
      * The HTML element type or React component to render as the tab.
      */
     as?: React.ElementType;
     width?: number;
 }
-type NativeAttrs$l = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$j>;
-type SwipeItemProps = Props$j & NativeAttrs$l;
-declare const SwipeItem: react.ForwardRefExoticComponent<Props$j & NativeAttrs$l & {
+type NativeAttrs$m = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$k>;
+type SwipeItemProps = Props$k & NativeAttrs$m;
+declare const SwipeItem: react.ForwardRefExoticComponent<Props$k & NativeAttrs$m & {
     children?: react.ReactNode | undefined;
 } & react.RefAttributes<HTMLDivElement>>;
 
 type SwiperAlignmet = 'start' | 'center' | 'end';
 
-interface Props$i {
+interface Props$j {
     gap?: number;
     alignment?: SwiperAlignmet;
     autoHide?: boolean;
@@ -1363,8 +1473,8 @@ interface Props$i {
         arrowRightButton?: ButtonProps;
     };
 }
-type NativeAttrs$k = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$i>;
-type SwipeProps = Props$i & NativeAttrs$k;
+type NativeAttrs$l = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$j>;
+type SwipeProps = Props$j & NativeAttrs$l;
 declare const Swipe: React.FC<SwipeProps>;
 
 type ModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
@@ -1374,9 +1484,9 @@ interface ModalClose {
     position?: 'start' | 'end';
 }
 type ModalScrollBehavior = 'inside' | 'outside';
-type ModalBackdrop = BackdropVariant;
+type ModalBackdrop = BackdropVariant | boolean;
 
-interface Props$h {
+interface Props$i {
     isOpen: boolean;
     size?: ModalSize;
     backdrop?: ModalBackdrop;
@@ -1388,18 +1498,23 @@ interface Props$h {
     slotProps?: {
         wrapper?: React.HTMLAttributes<HTMLDivElement>;
     };
+    content?: boolean;
     onClose: () => void;
     onAfterClose?: () => void;
 }
-type NativeAttrs$j = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$h>;
-type ModalProps = Props$h & NativeAttrs$j;
-declare const Modal: react.ForwardRefExoticComponent<Props$h & NativeAttrs$j & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$k = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$i>;
+type ModalProps = Props$i & NativeAttrs$k;
+declare const Modal: react.ForwardRefExoticComponent<Props$i & NativeAttrs$k & react.RefAttributes<HTMLDivElement>>;
 
 type ModalBodyProps = React.HTMLAttributes<HTMLDivElement>;
 declare const ModalBody: React.FC<ModalBodyProps>;
 
 interface ModalContextValue {
+    nodeRef: React.MutableRefObject<null>;
     isOpen: boolean;
+    size: ModalSize;
+    placement: ModalPlacement;
+    fullscreen: boolean;
     scrollBehavior: ModalScrollBehavior;
     scrollArea: boolean;
     closable: boolean;
@@ -1408,15 +1523,15 @@ interface ModalContextValue {
 }
 declare function useModal(): ModalContextValue;
 
-interface Props$g {
+interface Props$h {
     as?: React.ElementType;
     bordered?: boolean;
 }
-type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g>;
-type ModalFooterProps = Props$g & NativeAttrs$i;
-declare const ModalFooter: react.ForwardRefExoticComponent<Props$g & NativeAttrs$i & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$j = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$h>;
+type ModalFooterProps = Props$h & NativeAttrs$j;
+declare const ModalFooter: react.ForwardRefExoticComponent<Props$h & NativeAttrs$j & react.RefAttributes<HTMLDivElement>>;
 
-interface Props$f {
+interface Props$g {
     as?: React.ElementType;
     title?: React.ReactNode;
     subtitle?: React.ReactNode;
@@ -1432,9 +1547,12 @@ interface Props$f {
         subtitle?: React.HTMLAttributes<HTMLDivElement>;
     };
 }
-type NativeAttrs$h = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$f>;
-type ModalHeaderProps = Props$f & NativeAttrs$h;
-declare const ModalHeader: react.ForwardRefExoticComponent<Props$f & NativeAttrs$h & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$i = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$g>;
+type ModalHeaderProps = Props$g & NativeAttrs$i;
+declare const ModalHeader: react.ForwardRefExoticComponent<Props$g & NativeAttrs$i & react.RefAttributes<HTMLDivElement>>;
+
+type ModalContentProps = React.HTMLAttributes<HTMLDivElement>;
+declare const ModalContent: react.ForwardRefExoticComponent<ModalContentProps & react.RefAttributes<HTMLDivElement>>;
 
 type CheckboxValue = string | number | symbol;
 type CheckboxSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
@@ -1443,18 +1561,18 @@ type CheckboxGroupDirection = 'row' | 'col';
 type CheckboxGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
 type CheckboxColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
 
-interface Props$e<TCheckboxValue extends CheckboxValue = CheckboxValue> {
+interface Props$f<TCheckboxValue extends CheckboxValue = CheckboxValue> {
     value?: TCheckboxValue;
     size?: CheckboxSize;
     labelPlacement?: CheckboxLabelPlacement;
     color?: CheckboxColor;
     indeterminate?: boolean;
 }
-type NativeAttrs$g = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$e | 'defaultValue'>;
-type CheckboxProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$e<TCheckboxValue> & NativeAttrs$g;
-declare const Checkbox: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$e<TCheckboxValue> & NativeAttrs$g & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
+type NativeAttrs$h = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$f | 'defaultValue'>;
+type CheckboxProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$f<TCheckboxValue> & NativeAttrs$h;
+declare const Checkbox: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$f<TCheckboxValue> & NativeAttrs$h & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
 
-interface Props$d<TCheckboxValue extends CheckboxValue = CheckboxValue> {
+interface Props$e<TCheckboxValue extends CheckboxValue = CheckboxValue> {
     value?: TCheckboxValue[];
     defaultValue?: TCheckboxValue[];
     disabled?: boolean;
@@ -1466,9 +1584,9 @@ interface Props$d<TCheckboxValue extends CheckboxValue = CheckboxValue> {
     color?: CheckboxColor;
     onChange?: (value: TCheckboxValue[]) => void;
 }
-type NativeAttrs$f = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$d>;
-type CheckboxGroupProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$d<TCheckboxValue> & NativeAttrs$f;
-declare const CheckboxGroup: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$d<TCheckboxValue> & NativeAttrs$f & react.RefAttributes<HTMLTableElement>) => ReturnType<React.FunctionComponent>;
+type NativeAttrs$g = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$e>;
+type CheckboxGroupProps<TCheckboxValue extends CheckboxValue = CheckboxValue> = Props$e<TCheckboxValue> & NativeAttrs$g;
+declare const CheckboxGroup: <TCheckboxValue extends CheckboxValue = CheckboxValue>(props: Props$e<TCheckboxValue> & NativeAttrs$g & react.RefAttributes<HTMLTableElement>) => ReturnType<React.FunctionComponent>;
 
 interface CheckboxGroupContextValue<TCheckboxValue extends CheckboxValue = CheckboxValue> {
     value: TCheckboxValue[];
@@ -1490,7 +1608,7 @@ type RadioGroupDirection = 'row' | 'col';
 type RadioGroupAlignment = 'start' | 'center' | 'end' | 'stretch';
 type RadioColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'dark' | 'light';
 
-interface Props$c<TRadioValue extends RadioValue = RadioValue> {
+interface Props$d<TRadioValue extends RadioValue = RadioValue> {
     value?: TRadioValue;
     disabled?: boolean;
     readOnly?: boolean;
@@ -1498,11 +1616,11 @@ interface Props$c<TRadioValue extends RadioValue = RadioValue> {
     labelPlacement?: RadioLabelPlacement;
     colorScheme?: ColorScheme;
 }
-type NativeAttrs$e = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$c | 'defaultValue' | 'checked' | 'defaultChecked' | 'onChange'>;
-type RadioProps<TRadioValue extends RadioValue = RadioValue> = Props$c<TRadioValue> & NativeAttrs$e;
-declare const Radio: <TRadioValue extends RadioValue = RadioValue>(props: Props$c<TRadioValue> & NativeAttrs$e & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
+type NativeAttrs$f = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$d | 'defaultValue' | 'checked' | 'defaultChecked' | 'onChange'>;
+type RadioProps<TRadioValue extends RadioValue = RadioValue> = Props$d<TRadioValue> & NativeAttrs$f;
+declare const Radio: <TRadioValue extends RadioValue = RadioValue>(props: Props$d<TRadioValue> & NativeAttrs$f & react.RefAttributes<HTMLInputElement>) => ReturnType<React.FunctionComponent>;
 
-interface Props$b<TRadioValue extends RadioValue = RadioValue> {
+interface Props$c<TRadioValue extends RadioValue = RadioValue> {
     name?: string;
     value?: TRadioValue;
     defaultValue?: TRadioValue;
@@ -1515,9 +1633,9 @@ interface Props$b<TRadioValue extends RadioValue = RadioValue> {
     color?: RadioColor;
     onChange?: (value: TRadioValue) => void;
 }
-type NativeAttrs$d = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$b>;
-type RadioGroupProps<TRadioValue extends RadioValue = RadioValue> = Props$b<TRadioValue> & NativeAttrs$d;
-declare const RadioGroup: <TRadioValue extends RadioValue = RadioValue>(props: Props$b<TRadioValue> & NativeAttrs$d & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
+type NativeAttrs$e = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$c>;
+type RadioGroupProps<TRadioValue extends RadioValue = RadioValue> = Props$c<TRadioValue> & NativeAttrs$e;
+declare const RadioGroup: <TRadioValue extends RadioValue = RadioValue>(props: Props$c<TRadioValue> & NativeAttrs$e & react.RefAttributes<HTMLDivElement>) => ReturnType<React.FunctionComponent>;
 
 interface RadioGroupContextValue {
     name: string;
@@ -1535,16 +1653,16 @@ declare const useRadioGroup: () => RadioGroupContextValue;
 
 type NavRailPlacement = 'left' | 'right';
 
-interface Props$a {
+interface Props$b {
     startContent?: React.ReactNode;
     endContent?: React.ReactNode;
     placement?: NavRailPlacement;
 }
-type NativeAttrs$c = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$a>;
-type NavRailProps = Props$a & NativeAttrs$c;
+type NativeAttrs$d = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$b>;
+type NavRailProps = Props$b & NativeAttrs$d;
 declare const NavRail: React.FC<NavRailProps>;
 
-interface Props$9 {
+interface Props$a {
     as?: React.ElementType;
     icon?: React.ReactNode;
     media?: React.ReactNode;
@@ -1554,11 +1672,11 @@ interface Props$9 {
         label?: React.HTMLAttributes<HTMLDivElement>;
     };
 }
-type NativeAttrs$b = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9>;
-type NavRailItemProps = Props$9 & NativeAttrs$b;
-declare const NavRailItem: react.ForwardRefExoticComponent<Props$9 & NativeAttrs$b & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$c = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$a>;
+type NavRailItemProps = Props$a & NativeAttrs$c;
+declare const NavRailItem: react.ForwardRefExoticComponent<Props$a & NativeAttrs$c & react.RefAttributes<HTMLDivElement>>;
 
-type Props$8 = {
+type Props$9 = {
     as?: React.ElementType;
     label: React.ReactNode;
     span?: Responsive<number>;
@@ -1574,20 +1692,20 @@ type Props$8 = {
         mq: ContainerMediaQuery;
     }) => React.ReactNode;
 } & FormatOptions;
-type NativeAttrs$a = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$8 | 'children'>;
-type DescriptionProps = Props$8 & NativeAttrs$a;
+type NativeAttrs$b = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9 | 'children'>;
+type DescriptionProps = Props$9 & NativeAttrs$b;
 declare const Description: react.ForwardRefExoticComponent<DescriptionProps & react.RefAttributes<HTMLDivElement>>;
 
-type NativeAttrs$9 = React.HTMLAttributes<HTMLDivElement>;
-type DescriptionEmptyProps = NativeAttrs$9;
-declare const DescriptionEmpty: react.ForwardRefExoticComponent<NativeAttrs$9 & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$a = React.HTMLAttributes<HTMLDivElement>;
+type DescriptionEmptyProps = NativeAttrs$a;
+declare const DescriptionEmpty: react.ForwardRefExoticComponent<NativeAttrs$a & react.RefAttributes<HTMLDivElement>>;
 
 type DescriptionsLayout = 'row' | 'col';
 type DescriptionsSize = 'sm' | 'md' | 'lg';
 type DescriptionsAlign = React.CSSProperties['textAlign'];
 type DescriptionsMode = 'container' | 'screen' | 'css';
 
-interface Props$7 {
+interface Props$8 {
     as?: React.ElementType;
     mode?: DescriptionsMode;
     items?: DescriptionProps[];
@@ -1598,9 +1716,9 @@ interface Props$7 {
     labelAlign?: Responsive<DescriptionsAlign>;
     contentAlign?: Responsive<DescriptionsAlign>;
 }
-type NativeAttrs$8 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7 | 'children'>;
-type DescriptionsProps = Props$7 & NativeAttrs$8;
-declare const Descriptions: react.ForwardRefExoticComponent<Props$7 & NativeAttrs$8 & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$9 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$8 | 'children'>;
+type DescriptionsProps = Props$8 & NativeAttrs$9;
+declare const Descriptions: react.ForwardRefExoticComponent<Props$8 & NativeAttrs$9 & react.RefAttributes<HTMLDivElement>>;
 
 interface DescriptionsContextValue {
     mq: ContainerMediaQuery;
@@ -1613,9 +1731,9 @@ interface DescriptionsContextValue {
 declare const DescriptionsContext: react.Context<DescriptionsContextValue | null>;
 declare const useDescriptionsContext: () => DescriptionsContextValue;
 
-type NativeAttrs$7 = React.HTMLAttributes<HTMLDivElement>;
-type DescriptionTextProps = NativeAttrs$7;
-declare const DescriptionText: react.ForwardRefExoticComponent<NativeAttrs$7 & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$8 = React.HTMLAttributes<HTMLDivElement>;
+type DescriptionTextProps = NativeAttrs$8;
+declare const DescriptionText: react.ForwardRefExoticComponent<NativeAttrs$8 & react.RefAttributes<HTMLDivElement>>;
 
 declare function reactNodeToText(node: React.ReactNode): string;
 
@@ -1635,14 +1753,14 @@ interface ResponsiveProps$2 {
     justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
     alignItems?: Responsive<React.CSSProperties['alignItems']>;
 }
-type Props$6 = {
+type Props$7 = {
     as?: React.ElementType;
 } & ResponsiveProps$2;
-type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
-type GridItemProps = Props$6 & NativeAttrs$6;
+type NativeAttrs$7 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7>;
+type GridItemProps = Props$7 & NativeAttrs$7;
 declare const GridItem: react.ForwardRefExoticComponent<{
     as?: React.ElementType;
-} & ResponsiveProps$2 & NativeAttrs$6 & react.RefAttributes<HTMLDivElement>>;
+} & ResponsiveProps$2 & NativeAttrs$7 & react.RefAttributes<HTMLDivElement>>;
 
 interface ResponsiveProps$1 {
     cols?: Responsive<number>;
@@ -1660,14 +1778,14 @@ interface ResponsiveProps$1 {
     justifyContent?: Responsive<React.CSSProperties['justifyContent']>;
     alignItems?: Responsive<React.CSSProperties['alignItems']>;
 }
-type Props$5 = {
+type Props$6 = {
     items?: GridItemProps[];
 } & ResponsiveProps$1;
-type NativeAttrs$5 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5>;
-type GridSubProps = Props$5 & NativeAttrs$5;
+type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
+type GridSubProps = Props$6 & NativeAttrs$6;
 declare const GridSub: react.ForwardRefExoticComponent<{
     items?: GridItemProps[];
-} & ResponsiveProps$1 & NativeAttrs$5 & react.RefAttributes<HTMLDivElement>>;
+} & ResponsiveProps$1 & NativeAttrs$6 & react.RefAttributes<HTMLDivElement>>;
 
 type GridMode = 'container' | 'screen' | 'css';
 
@@ -1689,16 +1807,16 @@ interface ResponsiveProps {
         wrapper?: React.HTMLAttributes<HTMLDivElement>;
     };
 }
-type Props$4 = {
+type Props$5 = {
     mode?: GridMode;
     items?: (GridItemProps | GridSubProps)[];
 } & ResponsiveProps;
-type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
-type GridProps = Props$4 & NativeAttrs$4;
+type NativeAttrs$5 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5>;
+type GridProps = Props$5 & NativeAttrs$5;
 declare const Grid: react.ForwardRefExoticComponent<{
     mode?: GridMode;
     items?: (GridItemProps | GridSubProps)[];
-} & ResponsiveProps & NativeAttrs$4 & react.RefAttributes<HTMLDivElement>>;
+} & ResponsiveProps & NativeAttrs$5 & react.RefAttributes<HTMLDivElement>>;
 
 interface GridContextValue {
     mq: ContainerMediaQuery;
@@ -1718,7 +1836,7 @@ declare const Html: React.FC<HtmlProps>;
 
 type StepColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
 
-interface Props$3 {
+interface Props$4 {
     value?: string | number | symbol;
     title: React.ReactNode;
     subtitle: React.ReactNode;
@@ -1726,18 +1844,18 @@ interface Props$3 {
     color?: StepColor;
     disabled?: boolean;
 }
-type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3>;
-type StepProps = Props$3 & NativeAttrs$3;
+type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
+type StepProps = Props$4 & NativeAttrs$4;
 declare const Step: React.FC<StepProps>;
 
-interface Props$2 {
+interface Props$3 {
     direction?: 'horizontal' | 'vertical';
     value?: number | string | symbol;
     color?: StepColor;
     markPreviousAsChecked?: boolean;
 }
-type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2>;
-type StepsProps = Props$2 & NativeAttrs$2;
+type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3>;
+type StepsProps = Props$3 & NativeAttrs$3;
 declare const Steps: React.FC<StepsProps>;
 
 interface StepsContextValue {
@@ -1765,19 +1883,22 @@ interface TreeItemValue {
 }
 interface TreeItemBase {
     value: string;
+    icon?: React.ReactNode;
     items?: TreeItemBase[];
 }
 interface TreeItemData {
     value: string;
     parents: string[];
+    levelRaw: number;
+    levelAlignment: number;
 }
 
-interface Props$1 extends TreeItemBase {
+interface Props$2 extends TreeItemBase {
     title: string;
-    items?: Props$1[];
+    items?: Props$2[];
 }
-type NativeAttrs$1 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$1 | 'items'>;
-type TreeItemProps = Props$1 & NativeAttrs$1;
+type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2 | 'items'>;
+type TreeItemProps = Props$2 & NativeAttrs$2;
 declare const TreeItem: (props: TreeItemProps) => react_jsx_runtime.JSX.Element;
 
 interface TreeProps$1 {
@@ -1801,6 +1922,7 @@ declare const TreeContext: react.Context<TreeContextValue>;
 interface TreeProps {
     items?: TreeItemBase[];
     value?: TreeItemValue[];
+    checkable?: boolean;
     onChange?: (value: TreeItemValue[]) => void;
     onSelect?: (value: string) => void;
     onUnselect?: (value: string) => void;
@@ -1816,9 +1938,22 @@ declare function useTree(props: TreeProps): {
 };
 
 declare function initializeTreeValues(items: TreeItemData[]): TreeItemValue[];
-declare function flattenTree(tree: TreeItemBase[], parents?: string[]): TreeItemData[];
+declare function flattenTree(tree: TreeItemBase[], parents?: string[], levelRaw?: number, levelAlignment?: number, parentIndicators?: {
+    icon: boolean;
+    chevron: boolean;
+}, checkable?: boolean): TreeItemData[];
 declare function updateTreeValues(values: TreeItemValue[], value: string, action: 'select' | 'unselect' | 'check' | 'uncheck', items: TreeItemData[]): TreeItemValue[];
 
+interface DropdownProps {
+    isOpen?: boolean;
+    onOpen?: () => void;
+    onClose?: () => void;
+    children: ((options: {
+        isOpen: boolean;
+    }) => React.ReactNode) | React.ReactNode;
+}
+declare const Dropdown: (props: DropdownProps) => react_jsx_runtime.JSX.Element;
+
 interface DropdownContentProps {
     children: React.ReactNode;
 }
@@ -1848,10 +1983,10 @@ interface DropdownContextValue {
 declare const DropdownContext: react.Context<DropdownContextValue | null>;
 declare const useDropdownContext: () => DropdownContextValue;
 
-interface Props {
+interface Props$1 {
 }
-type NativeAttrs = Omit<ListItemProps, keyof Props>;
-type DropdownItemProps = Props & NativeAttrs;
+type NativeAttrs$1 = Omit<ListItemProps, keyof Props$1>;
+type DropdownItemProps = Props$1 & NativeAttrs$1;
 declare const DropdownItem: (props: DropdownItemProps) => react_jsx_runtime.JSX.Element;
 
 interface DropdownTriggerProps {
@@ -1859,27 +1994,233 @@ interface DropdownTriggerProps {
 }
 declare const DropdownTrigger: (props: DropdownTriggerProps) => react.ReactElement<any, string | react.JSXElementConstructor<any>>;
 
-declare const scrollToItem: (parentElement: Element, currentElement: Element) => void;
+interface ListTreeItemIndentationProps {
+    level: number;
+}
+declare const INDENT_SIZE = 18;
+declare const ListTreeItemIndentation: ({ level }: ListTreeItemIndentationProps) => react_jsx_runtime.JSX.Element;
+interface Props extends TreeItemBase {
+    icon?: React.ReactNode;
+}
+type NativeAttrs = Omit<ListItemProps, keyof Props | 'items' | 'startContent'>;
+type ListTreeItemProps = Props & NativeAttrs & {
+    items?: ListTreeItemProps[];
+};
+declare const ListTreeItem: (props: ListTreeItemProps) => react_jsx_runtime.JSX.Element;
 
-type ClassDictionary = Record<string, any>;
-type ClassArray = ClassValue[];
-type ClassValue = ClassArray | ClassDictionary | string | number | null | boolean | undefined;
-declare function clsx(...inputs: ClassValue[]): string;
+interface ListTreeProps {
+    items?: ListTreeItemProps[];
+    value?: TreeItemValue[];
+    selectable?: boolean;
+    checkable?: boolean;
+    onChange?: (value: TreeItemValue[]) => void;
+    onSelect?: (value: string) => void;
+    onUnselect?: (value: string) => void;
+}
+declare const ListTree: (props: ListTreeProps) => react_jsx_runtime.JSX.Element;
 
-type ReactRef<T> = React.RefCallback<T> | React.MutableRefObject<T>;
-declare function assignRef<T = any>(ref: ReactRef<T> | null | undefined, value: T): void;
-declare function mergeRefs<T>(...refs: (ReactRef<T> | null | undefined)[]): (node: T | null) => void;
+interface ListTreeContextValue {
+    selectable: boolean;
+    checkable: boolean;
+}
+declare const ListTreeContext: react.Context<ListTreeContextValue>;
 
-declare function dateFormat(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
-declare function formatDate(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
-declare function formatDateTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
-declare function formatShortDateTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
-declare function formatTime(value: Date | string | number, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
-declare function formatCurrency(value: number | bigint | Intl.StringNumericLiteral, currency?: string, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
-declare function formatPercent(value: any, decimals?: number, locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
-declare function format(options: FormatOptions): string | undefined;
+declare const DraggableTrigger: ({ children }: {
+    children: react__default.ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+type DraggableContentProps = react__default.HTMLAttributes<HTMLDivElement>;
+declare const DraggableContent: (props: DraggableContentProps) => react_jsx_runtime.JSX.Element;
+type DraggableContent = react__default.HTMLAttributes<HTMLDivElement> & {
+    bounces?: 'screen' | 'scroll';
+    placement?: 'center';
+    children: react__default.ReactNode;
+};
+declare const Draggable: ({ bounces: bouncesProp, placement, ...props }: DraggableContent) => react_jsx_runtime.JSX.Element;
 
-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][];
-declare const valuesToValue: <TItem extends Record<string, any>, TKeyField extends keyof TItem>(values: TItem[TKeyField][]) => TItem[TKeyField] | null;
+interface UploadFileData {
+    id: string;
+    name: string;
+    size: number;
+    file: File;
+}
 
-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 };
+interface UploadFileProps {
+    data: UploadFileData[];
+    readOnly?: boolean;
+    accept?: string;
+    max?: number;
+    multiple?: boolean;
+    disabled?: boolean;
+    onChange: (value: UploadFileData[]) => void;
+}
+declare const UploadFiles: ({ data, max, readOnly, disabled, accept, multiple, onChange }: UploadFileProps) => react_jsx_runtime.JSX.Element;
+
+type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+type Cursor = {
+    x: number;
+    y: number;
+};
+type StackMeta = {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+type WindowMeta = {
+    id: string;
+    title: string;
+    content?: react__default.ReactNode;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    minimized?: boolean;
+    maximized?: boolean;
+    snapped?: boolean;
+    closed?: boolean;
+    zIndex?: number;
+    stackId?: string;
+};
+declare function useMove(props: {
+    rect: Rect;
+    minWidth?: number;
+    minHeight?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    initialWidth?: number;
+    initialHeight?: number;
+    initialX?: number;
+    initialY?: number;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    onSize?: (rect: Rect & {
+        maximized?: boolean;
+    }) => void;
+    onDrag?: (rect: Rect, cursor: Cursor) => void;
+    onDragEnd?: (rect: Rect, cursor: Cursor) => void;
+    visible?: boolean;
+    parentRef: react__default.RefObject<HTMLDivElement | null>;
+    useTransform?: boolean;
+    prevBoundsRef: react__default.MutableRefObject<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+    zIndex?: number;
+    disabled?: boolean;
+}): {
+    windowRef: react__default.MutableRefObject<HTMLDivElement | null>;
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    style: react__default.CSSProperties;
+    visible: boolean;
+    onPointerDown_drag: (e: react__default.PointerEvent) => void;
+    positionStyles: react__default.CSSProperties;
+};
+declare function useResize({ parentRef, rect, disabled, minWidth, minHeight, maxWidth, maxHeight, onRect, }: {
+    parentRef: react__default.RefObject<HTMLDivElement | null>;
+    rect: Rect;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    disabled?: boolean;
+    onRect: (rect: Rect) => void;
+}): {
+    handles: string[];
+    disabled: boolean | undefined;
+    onResize: (e: react__default.PointerEvent, dir: string) => void;
+};
+declare function useSnapPreview({ parentRef, onDragEnd, }: {
+    parentRef: react__default.RefObject<HTMLDivElement | null>;
+    rect: Rect;
+    onDragEnd: (rect: Rect, maximized: boolean, snapped: boolean) => void;
+}): {
+    rect?: Rect | undefined;
+    style?: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    } | undefined;
+    onDrag: (nx: number, ny: number, cursorX: number, cursorY: number) => void;
+    onDragEnd: () => void;
+};
+declare function useWindow({ parentRef, prevBoundsRef, meta, parentRect, isMobile, initialWidth, initialHeight, initialX, initialY, onUpdate, }: {
+    parentRef: react__default.RefObject<HTMLDivElement | null>;
+    prevBoundsRef?: react__default.MutableRefObject<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+    meta: WindowMeta;
+    parentRect?: {
+        width?: number;
+        height?: number;
+    };
+    isMobile?: boolean;
+    initialWidth?: number;
+    initialHeight?: number;
+    initialX?: number;
+    initialY?: number;
+    onUpdate: (patch: Partial<WindowMeta>) => void;
+}): {
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    setPos: react__default.Dispatch<react__default.SetStateAction<{
+        x: number;
+        y: number;
+    }>>;
+    setSize: react__default.Dispatch<react__default.SetStateAction<{
+        width: number;
+        height: number;
+    }>>;
+    onToggleMaximize: () => void;
+};
+declare function useWindowStack({ windows, setWindows, windowContainerRef, stackContainerRef, }: {
+    windows: WindowMeta[];
+    setWindows: react__default.Dispatch<react__default.SetStateAction<WindowMeta[]>>;
+    windowContainerRef: react__default.RefObject<HTMLDivElement>;
+    stackContainerRef: react__default.RefObject<HTMLDivElement>;
+}): {
+    isMobile: boolean;
+    windowContainerRect: Rect;
+    stackContainerRect: Rect;
+    activeWindow: WindowMeta | undefined;
+    bringToFront: (id: string) => void;
+    updateWindow: (id: string, patch: Partial<WindowMeta>) => void;
+    closeWindow: (id: string) => void;
+    minimizeWindow: (id: string) => void;
+};
+declare function WindowManager({ windowContainerRef: externalWindowContainerRef, stackContainerRef: externalStackContainerRef, windows, setWindows, stacks, children, }: {
+    windows: WindowMeta[];
+    setWindows: react__default.Dispatch<react__default.SetStateAction<WindowMeta[]>>;
+    stacks: StackMeta[];
+    setStacks: react__default.Dispatch<react__default.SetStateAction<StackMeta[]>>;
+    windowContainerRef?: react__default.RefObject<HTMLDivElement>;
+    stackContainerRef?: react__default.RefObject<HTMLDivElement>;
+    children: react__default.ReactNode | ((options: {
+        content: react__default.ReactNode;
+        taskbar: react__default.ReactNode;
+    }) => react__default.ReactNode);
+}): react_jsx_runtime.JSX.Element;
+
+export { Accordion, type AccordionArrow, AccordionBody, type AccordionBodyProps, type AccordionColor, AccordionContent, type AccordionContentProps, AccordionContext, AccordionHeader, type AccordionHeaderProps, AccordionItem, type AccordionItemProps, type AccordionProps, type AccordionSize, AccordionTrigger, type AccordionTriggerProps, type AccordionVariant, Autocomplete, type AutocompleteClearable, AutocompleteContext, type AutocompleteContextValue, type AutocompleteMultiple, type AutocompleteProps, Backdrop, type BackdropPlacement, type BackdropProps, type BackdropVariant, Badge, type BadgeProps, Button, type ButtonColor, ButtonGroup, ButtonGroupContext, type ButtonGroupContextValue, type ButtonGroupDirection, type ButtonGroupProps, type ButtonProps, type ButtonSize, type ButtonVariant, Card, CardBody, type CardBodyProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, CardMedia, type CardMediaProps, type CardProps, CardSubtitle, type CardSubtitleProps, CardTitle, type CardTitleProps, Checkbox, type CheckboxColor, CheckboxGroup, type CheckboxGroupAlignment, CheckboxGroupContext, type CheckboxGroupContextValue, type CheckboxGroupDirection, type CheckboxGroupProps, type CheckboxLabelPlacement, type CheckboxProps, type CheckboxSize, type CheckboxValue, Chip, type ChipProps, Collapse, CollapseContent, type CollapseContentProps, CollapseContext, type CollapseContextValue, type CollapseProps, CollapseTrigger, type CollapseTriggerProps, type ColorScheme, type ContainerBreakpoints, ContainerMediaQuery, type Cursor, DataList, type DataListItem, type DataListKeyField, type DataListMultipleProps, type DataListProps, type DataListSingleProps, Description, DescriptionEmpty, type DescriptionEmptyProps, type DescriptionProps, DescriptionText, type DescriptionTextProps, Descriptions, type DescriptionsAlign, DescriptionsContext, type DescriptionsContextValue, type DescriptionsLayout, type DescriptionsMode, type DescriptionsProps, type DescriptionsSize, type Disclosure, Divider, type DividerProps, Draggable, DraggableContent, type DraggableContentProps, DraggableTrigger, Drawer, type DrawerBackdrop, DrawerBody, type DrawerBodyProps, type DrawerClose, DrawerContext, type DrawerContextValue, DrawerFooter, type DrawerFooterProps, DrawerHeader, type DrawerHeaderProps, type DrawerPlacement, type DrawerPosition, type DrawerProps, type DrawerSize, Dropdown, DropdownContent, type DropdownContentProps, DropdownContext, type DropdownContextValue, DropdownItem, type DropdownItemProps, type DropdownProps, DropdownTrigger, type DropdownTriggerProps, Field, type FieldProps, type FormatBooleanOptions, type FormatCurrencyOptions, type FormatDateOptions, type FormatFileSizeOptions, type FormatNumberOptions, type FormatOptions, type FormatPercentOptions, type FormatStringOptions, Grid, GridContext, type GridContextValue, GridItem, type GridItemProps, type GridMode, type GridProps, GridSub, type GridSubProps, Html, type HtmlProps, INDENT_SIZE, Icon, type IconColor, type IconProps, type IconSize, Iframe, type IframeProps, type InfiniteData, type InfiniteQueryFunction, type InfiniteQueryOptions, type InfiniteQueryRefetchOptions, type InputColor, InputGroup, type InputGroupProps, type InputSize, type InputVariant, List, ListGroup, type ListGroupProps, ListItem, type ListItemProps, type ListProps, type ListSize, ListSubheader, type ListSubheaderProps, ListTree, ListTreeContext, type ListTreeContextValue, ListTreeItem, ListTreeItemIndentation, type ListTreeItemProps, type ListTreeProps, type MediaQuery, Menu, MenuContext, type MenuContextValue, MenuGroup, type MenuGroupItemType, type MenuGroupProps, MenuItem, type MenuItemProps, type MenuItemType, type MenuProps, MenuSubmenu, type MenuSubmenuProps, MenuValueContext, Modal, type ModalBackdrop, ModalBody, type ModalBodyProps, type ModalClose, ModalContent, type ModalContentProps, ModalFooter, type ModalFooterProps, ModalHeader, type ModalHeaderProps, type ModalPlacement, type ModalProps, type ModalScrollBehavior, type ModalSize, type MutationError, type MutationFunction, type MutationOK, type MutationResult, MutationStatus, NavRail, NavRailItem, type NavRailItemProps, type NavRailPlacement, type NavRailProps, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type PopoverTriggerProps, Portal, type PortalProps, type QueryFunction, QueryStatus, Radio, type RadioColor, RadioGroup, type RadioGroupAlignment, RadioGroupContext, type RadioGroupContextValue, type RadioGroupDirection, type RadioGroupProps, type RadioLabelPlacement, type RadioProps, type RadioSize, type RadioValue, type ReactRef, type Rect, type Resize, type Responsive, Result, type ResultProps, type ResultStatus, STRING_RULES, type ScrollAlignment, ScrollArea, type ScrollAreaProps, type ScrollBehavior, type ScrollToOptions, Select, type SelectClearable, SelectContext, type SelectContextValue, type SelectMultiple, type SelectProps, type SelectionItem, type SelectionOnChange, type SelectionProps, type SelectionValue, type StackMeta, Step, type StepColor, type StepProps, Steps, StepsContext, type StepsContextValue, type StepsProps, type StringRules, Swipe, SwipeItem, type SwipeItemProps, type SwipeProps, Switch, type SwitchColor, type SwitchLabelPlacement, type SwitchProps, type SwitchSize, Tab, type TabProps, Tabs, type TabsAlignment, type TabsProps, type TabsVariant, TextInput, type TextInputProps, type Timer, type TimerMode, Toolbar, type ToolbarProps, type ToolbarSize, Transition, type TransitionProps, Tree, TreeContext, type TreeContextValue, TreeItem, type TreeItemBase, type TreeItemData, type TreeItemProps, type TreeItemValue, type TreeProps$1 as TreeProps, type UploadFileData, type UploadFileProps, UploadFiles, type UseContainerMediaQueryOptions, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, type UseResizeObserverOptions, type VirtualItem, type Virtualizer, type VirtualizerOptions, WindowManager, type WindowMeta, areArraysEqual, assignRef, breakpointsMap, clsx, containsPlainText, defaultBreakpoints, doesNotContainEmojis, flattenTree, format, formatCurrency, formatDate, formatDateTime, formatFileSize, formatPercent, formatShortDateTime, formatTime, generateId, getOpenValuesByPathname, hasResizeObserver, initializeTreeValues, isAlphanumeric, isEmpty, isEmptyString, isNumeric, mergeRefs, reactNodeToText, scrollToItem, toAlphaString, toAlphanumericString, toLocalDateString, toLocalDateTimeString, toNotEmojisString, toNumericString, toPlainTextString, toRulesString, updateTreeValues, useAccordion, useAccordionItem, useAutocomplete, useButtonGroup, useCheckboxGroup, useCollapse, useContainerMediaQuery, useDebounce, useDescriptionsContext, useDisclosure, useDrawer, useDropdownContext, useEffectEvent, useElementSize, useFormat, useGridContext, useInfiniteQuery, useLocalStorage, useMediaQuery, useMenu, useMenuItemValue, useModal, useMove, useMutation, useOnClickOutside, usePopover, usePrevious, useQuery, useRadioGroup, useResize, useResizeObserver, useSelect, useSnapPreview, useStep, useStepsContext, useTimer, useTree, useValueEffect, useVirtualizer, useWindow, useWindowStack, validateRules, valueToValues, valuesToValue };