@unifiedsoftware/react-ui 1.0.23 → 1.0.24

package/dist/index.d.ts

@@ -2,690 +2,690 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import react__default, { Dispatch, SetStateAction } from 'react';
 
-declare global {
-    interface WindowEventMap {
-        'local-storage': CustomEvent;
-    }
-}
-type SetValue<T> = Dispatch<SetStateAction<T>>;
-/**
- * It's a React hook that allows you to store and retrieve data from localStorage
- * @param {string} key - string
- * @param {T} initialValue - The initial value to use if the key doesn't exist in localStorage.
- * @returns An array of two items. The first item is the value of the local storage key. The second
- * item is a function that can be used to set the value of the local storage key.
- */
+declare global {
+    interface WindowEventMap {
+        'local-storage': CustomEvent;
+    }
+}
+type SetValue<T> = Dispatch<SetStateAction<T>>;
+/**
+ * It's a React hook that allows you to store and retrieve data from localStorage
+ * @param {string} key - string
+ * @param {T} initialValue - The initial value to use if the key doesn't exist in localStorage.
+ * @returns An array of two items. The first item is the value of the local storage key. The second
+ * item is a function that can be used to set the value of the local storage key.
+ */
 declare function useLocalStorage<T>(key: string, initialValue: T): [T, SetValue<T>];
 
-/**
- * It returns the previous value of the given value
- * @param {any} value - any - The value to track.
- * @returns The previous value of the variable.
- */
+/**
+ * It returns the previous value of the given value
+ * @param {any} value - any - The value to track.
+ * @returns The previous value of the variable.
+ */
 declare const usePrevious: (value: any) => undefined;
 
-interface Disclosure {
-    isOpen: boolean;
-    onOpen: () => void;
-    onClose: () => void;
-    onToggle: () => void;
-}
-declare function useDisclosure({ defaultValue }?: {
-    defaultValue?: boolean;
+interface Disclosure {
+    isOpen: boolean;
+    onOpen: () => void;
+    onClose: () => void;
+    onToggle: () => void;
+}
+declare function useDisclosure({ defaultValue }?: {
+    defaultValue?: boolean;
 }): Disclosure;
 
-type Handler = (event: MouseEvent) => void;
+type Handler = (event: MouseEvent) => void;
 declare const useOnClickOutside: <T extends HTMLElement = HTMLElement>(ref: react.RefObject<T>, handler: Handler) => void;
 
-interface Helpers {
-    goToNextStep: () => void;
-    goToPrevStep: () => void;
-    reset: () => void;
-    canGoToNextStep: boolean;
-    canGoToPrevStep: boolean;
-    setStep: Dispatch<SetStateAction<number>>;
-}
-/**
- * It returns a tuple with the current step and an object with functions to manipulate the step
- * @param {number} maxStep - number - The maximum number of steps in the stepper.
- * @returns An array with two elements. The first element is the current step. The second element is an
- * object with the following properties:
- */
+interface Helpers {
+    goToNextStep: () => void;
+    goToPrevStep: () => void;
+    reset: () => void;
+    canGoToNextStep: boolean;
+    canGoToPrevStep: boolean;
+    setStep: Dispatch<SetStateAction<number>>;
+}
+/**
+ * It returns a tuple with the current step and an object with functions to manipulate the step
+ * @param {number} maxStep - number - The maximum number of steps in the stepper.
+ * @returns An array with two elements. The first element is the current step. The second element is an
+ * object with the following properties:
+ */
 declare const useStep: (maxStep: number) => [number, Helpers];
 
 declare function useDebounce<T>(value: T, delay?: number): T;
 
-type ScrollAlignment = 'start' | 'center' | 'end' | 'auto';
-type ScrollBehavior = 'auto' | 'smooth';
-interface ScrollToOptions {
-    align?: ScrollAlignment;
-    behavior?: ScrollBehavior;
-}
-type Key = number | string;
-interface Virtualizer {
-    getVirtualItems: () => VirtualItem[];
-    getTotalSize: () => number;
-    scrollToIndex: (index: number, options: ScrollToOptions) => void;
-    scrollToOffset: (toOffset: number, options: ScrollToOptions) => void;
-}
-interface VirtualItem {
-    key: Key;
-    index: number;
-    start: number;
-    end: number;
-    size: number;
-    lane: number;
-}
-
-interface VirtualizerOptions {
-    parentRef: React.MutableRefObject<Element | null>;
-    total?: number;
-    overscan?: number;
-    count?: number;
-    hasNextPage?: boolean;
-    isFetchingNextPage?: boolean;
-    onFetchNextPage?: () => Promise<void> | void;
-    estimateSize: (index: number) => number;
-}
+type ScrollAlignment = 'start' | 'center' | 'end' | 'auto';
+type ScrollBehavior = 'auto' | 'smooth';
+interface ScrollToOptions {
+    align?: ScrollAlignment;
+    behavior?: ScrollBehavior;
+}
+type Key = number | string;
+interface Virtualizer {
+    getVirtualItems: () => VirtualItem[];
+    getTotalSize: () => number;
+    scrollToIndex: (index: number, options: ScrollToOptions) => void;
+    scrollToOffset: (toOffset: number, options: ScrollToOptions) => void;
+}
+interface VirtualItem {
+    key: Key;
+    index: number;
+    start: number;
+    end: number;
+    size: number;
+    lane: number;
+}
+
+interface VirtualizerOptions {
+    parentRef: React.MutableRefObject<Element | null>;
+    total?: number;
+    overscan?: number;
+    count?: number;
+    hasNextPage?: boolean;
+    isFetchingNextPage?: boolean;
+    onFetchNextPage?: () => Promise<void> | void;
+    estimateSize: (index: number) => number;
+}
 declare function useVirtualizer(options: VirtualizerOptions): Virtualizer;
 
-declare enum QueryStatus {
-    IDLE = 0,
-    LOADING = 1,
-    SUCCESS = 2,
-    ERROR = 3
-}
-interface QueryOptions {
-    page?: number;
-}
-interface InfiniteData<TData = any> {
-    pages: TData[];
-}
-type QueryFunction<TData = unknown> = (options: QueryOptions) => Promise<TData>;
-interface UseInfiniteQueryOptions<TData = unknown> {
-    query: QueryFunction<TData>;
-    getNextPage: (lastPage: TData, allPages: TData[]) => number | undefined;
-    disabled?: boolean;
-}
-interface UseInfiniteQueryResult<TData = unknown, TError = unknown> {
-    status: QueryStatus;
-    data?: InfiniteData<TData>;
-    error?: TError;
-    hasNextPage?: boolean;
-    isFetchingNextPage: boolean;
-    fetchNextPage: () => Promise<void>;
+declare enum QueryStatus {
+    IDLE = 0,
+    LOADING = 1,
+    SUCCESS = 2,
+    ERROR = 3
+}
+interface QueryOptions {
+    page?: number;
+}
+interface InfiniteData<TData = any> {
+    pages: TData[];
+}
+type QueryFunction<TData = unknown> = (options: QueryOptions) => Promise<TData>;
+interface UseInfiniteQueryOptions<TData = unknown> {
+    query: QueryFunction<TData>;
+    getNextPage: (lastPage: TData, allPages: TData[]) => number | undefined;
+    disabled?: boolean;
+}
+interface UseInfiniteQueryResult<TData = unknown, TError = unknown> {
+    status: QueryStatus;
+    data?: InfiniteData<TData>;
+    error?: TError;
+    hasNextPage?: boolean;
+    isFetchingNextPage: boolean;
+    fetchNextPage: () => Promise<void>;
 }
 
 declare function useInfiniteQuery<TData = unknown, TError = unknown>(options: UseInfiniteQueryOptions<TData>, deps?: React.DependencyList): UseInfiniteQueryResult<TData, TError>;
 
-interface Resize {
-    width: number;
-    height: number;
-}
-interface UseElementSizeOptions<T> {
-    ref?: React.MutableRefObject<T | null>;
-    target?: T;
-    callback?: (resize: Resize) => void;
-}
+interface Resize {
+    width: number;
+    height: number;
+}
+interface UseElementSizeOptions<T> {
+    ref?: React.MutableRefObject<T | null>;
+    target?: T;
+    callback?: (resize: Resize) => void;
+}
 declare function useElementSize<T extends HTMLElement = any>(options: UseElementSizeOptions<T>): Resize;
 
-interface UseResizeObserverOptions<T> {
-    ref?: React.RefObject<T | undefined>;
-    onResize: () => void;
-}
-declare function hasResizeObserver(): boolean;
+interface UseResizeObserverOptions<T> {
+    ref?: React.RefObject<T | undefined>;
+    onResize: () => void;
+}
+declare function hasResizeObserver(): boolean;
 declare function useResizeObserver<T extends Element>(options: UseResizeObserverOptions<T>): void;
 
 declare function useEffectEvent<T extends Function>(fn: T): T;
 
-type SetValueAction<S> = (prev: S) => Generator<any, void, unknown>;
+type SetValueAction<S> = (prev: S) => Generator<any, void, unknown>;
 declare function useValueEffect<S>(defaultValue: S | (() => S)): [S, Dispatch<SetValueAction<S>>];
 
-interface ListProps extends React.HTMLAttributes<HTMLDivElement> {
-    as?: React.ElementType;
-}
+interface ListProps extends React.HTMLAttributes<HTMLDivElement> {
+    as?: React.ElementType;
+}
 declare const List: react.ForwardRefExoticComponent<ListProps & react.RefAttributes<HTMLDivElement>>;
 
-interface ListItemProps extends react__default.HTMLAttributes<HTMLDivElement> {
-    as?: react__default.ElementType;
-    title?: string;
-    subtitle?: string;
-    startContent?: react__default.ReactNode;
-    endContent?: react__default.ReactNode;
-    level?: number;
-    hoverable?: boolean;
-    selected?: boolean;
-    disabled?: boolean;
-    slotProps?: {
-        title?: react__default.HTMLAttributes<HTMLDivElement>;
-        subtitle?: react__default.HTMLAttributes<HTMLDivElement>;
-    };
-}
+interface ListItemProps extends react__default.HTMLAttributes<HTMLDivElement> {
+    as?: react__default.ElementType;
+    title?: string;
+    subtitle?: string;
+    startContent?: react__default.ReactNode;
+    endContent?: react__default.ReactNode;
+    level?: number;
+    hoverable?: boolean;
+    selected?: boolean;
+    disabled?: boolean;
+    slotProps?: {
+        title?: react__default.HTMLAttributes<HTMLDivElement>;
+        subtitle?: react__default.HTMLAttributes<HTMLDivElement>;
+    };
+}
 declare const ListItem: react__default.ForwardRefExoticComponent<ListItemProps & react__default.RefAttributes<HTMLDivElement>>;
 
-type ListGroupProps = ListItemProps & {
-    expandVisible?: boolean;
-    expandPosition?: 'start' | 'end';
-    isOpen?: boolean;
-    onOpen?: () => void;
-    onClose?: () => void;
-    onToggle?: () => void;
-};
-declare const ListGroup: react.ForwardRefExoticComponent<ListItemProps & {
-    expandVisible?: boolean | undefined;
-    expandPosition?: "start" | "end" | undefined;
-    isOpen?: boolean | undefined;
-    onOpen?: (() => void) | undefined;
-    onClose?: (() => void) | undefined;
-    onToggle?: (() => void) | undefined;
+type ListGroupProps = ListItemProps & {
+    expandVisible?: boolean;
+    expandPosition?: 'start' | 'end';
+    isOpen?: boolean;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onToggle?: () => void;
+};
+declare const ListGroup: react.ForwardRefExoticComponent<ListItemProps & {
+    expandVisible?: boolean | undefined;
+    expandPosition?: "start" | "end" | undefined;
+    isOpen?: boolean | undefined;
+    onOpen?: (() => void) | undefined;
+    onClose?: (() => void) | undefined;
+    onToggle?: (() => void) | undefined;
 } & react.RefAttributes<HTMLDivElement>>;
 
-type AutocompleteItem = Record<string, any>;
-type AutocompleteKeyField<TAutocompleteItem> = keyof TAutocompleteItem;
-interface AutocompleteSingleProps<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> {
-    isMultiple?: false;
-    value: TAutocompleteItem[TAutocompleteKeyField] | null;
-    onChange?: (value: TAutocompleteItem | null) => void;
-    onValueChange?: (value: TAutocompleteItem[TAutocompleteKeyField] | null) => void;
-}
-interface AutocompleteMultipleProps<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> {
-    isMultiple: true;
-    value: TAutocompleteItem[TAutocompleteKeyField][];
-    onChange?: (value: TAutocompleteItem[]) => void;
-    onValueChange?: (value: TAutocompleteItem[TAutocompleteKeyField][]) => void;
-}
-type NativeAttrs$a<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$a<TAutocompleteItem, TAutocompleteKeyField>>;
-type Props$a<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> = {
-    data: TAutocompleteItem[];
-    keyField?: TAutocompleteKeyField;
-    textField?: keyof TAutocompleteItem;
-    placeholder?: string;
-    filter?: string;
-    loading?: boolean;
-    disabled?: boolean;
-    disclosure?: Disclosure;
-    virtual?: Omit<VirtualizerOptions, 'parentRef'>;
-    startContent?: React.ReactNode;
-    endContent?: React.ReactNode;
-    onItemSelect?: (item: TAutocompleteItem) => void;
-    onFilterChange?: (value: string) => void;
-    renderItem?: (item: TAutocompleteItem, props: ListItemProps) => React.ReactNode;
-} & (AutocompleteSingleProps<TAutocompleteItem, TAutocompleteKeyField> | AutocompleteMultipleProps<TAutocompleteItem, TAutocompleteKeyField>);
+type AutocompleteItem = Record<string, any>;
+type AutocompleteKeyField<TAutocompleteItem> = keyof TAutocompleteItem;
+interface AutocompleteSingleProps<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> {
+    isMultiple?: false;
+    value: TAutocompleteItem[TAutocompleteKeyField] | null;
+    onChange?: (value: TAutocompleteItem | null) => void;
+    onValueChange?: (value: TAutocompleteItem[TAutocompleteKeyField] | null) => void;
+}
+interface AutocompleteMultipleProps<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> {
+    isMultiple: true;
+    value: TAutocompleteItem[TAutocompleteKeyField][];
+    onChange?: (value: TAutocompleteItem[]) => void;
+    onValueChange?: (value: TAutocompleteItem[TAutocompleteKeyField][]) => void;
+}
+type NativeAttrs$a<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$a<TAutocompleteItem, TAutocompleteKeyField>>;
+type Props$a<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> = {
+    data: TAutocompleteItem[];
+    keyField?: TAutocompleteKeyField;
+    textField?: keyof TAutocompleteItem;
+    placeholder?: string;
+    filter?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    disclosure?: Disclosure;
+    virtual?: Omit<VirtualizerOptions, 'parentRef'>;
+    startContent?: React.ReactNode;
+    endContent?: React.ReactNode;
+    onItemSelect?: (item: TAutocompleteItem) => void;
+    onFilterChange?: (value: string) => void;
+    renderItem?: (item: TAutocompleteItem, props: ListItemProps) => React.ReactNode;
+} & (AutocompleteSingleProps<TAutocompleteItem, TAutocompleteKeyField> | AutocompleteMultipleProps<TAutocompleteItem, TAutocompleteKeyField>);
 type AutocompleteProps<TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends AutocompleteKeyField<TAutocompleteItem> = 'key'> = Props$a<TAutocompleteItem, TAutocompleteKeyField> & NativeAttrs$a<TAutocompleteItem, TAutocompleteKeyField>;
 
 declare const Autocomplete: <TAutocompleteItem extends AutocompleteItem, TAutocompleteKeyField extends keyof TAutocompleteItem = "key">(props: AutocompleteProps<TAutocompleteItem, TAutocompleteKeyField>) => react_jsx_runtime.JSX.Element;
 
-interface BackdropProps extends React.HTMLAttributes<HTMLDivElement> {
-    isOpen: boolean;
-    onClose(): void;
-}
+interface BackdropProps extends React.HTMLAttributes<HTMLDivElement> {
+    isOpen: boolean;
+    onClose(): void;
+}
 declare const Backdrop: react.ForwardRefExoticComponent<BackdropProps & react.RefAttributes<HTMLDivElement>>;
 
 type BadgePlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 
-interface Props$9 {
-    /**
-     * The placement of the badge relative to its content.
-     */
-    placement?: BadgePlacement;
-    /**
-     * The content to display within the badge.
-     */
-    content?: React.ReactNode;
-}
-type NativeAttrs$9 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9>;
-type BadgeProps = Props$9 & NativeAttrs$9;
+interface Props$9 {
+    /**
+     * The placement of the badge relative to its content.
+     */
+    placement?: BadgePlacement;
+    /**
+     * The content to display within the badge.
+     */
+    content?: React.ReactNode;
+}
+type NativeAttrs$9 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$9>;
+type BadgeProps = Props$9 & NativeAttrs$9;
 declare const Badge: React.FC<BadgeProps>;
 
-type ButtonVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain';
-type ButtonColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
+type ButtonVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain';
+type ButtonColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
 type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 
-interface Props$8 {
-    /**
-     * The HTML element type or React component to render as the button.
-     */
-    as?: React.ElementType;
-    /**
-     * The variant style of the button.
-     */
-    variant?: ButtonVariant;
-    /**
-     * The color of the button.
-     */
-    color?: ButtonColor;
-    /**
-     * The size of the button.
-     */
-    size?: ButtonSize;
-    /**
-     * Content to display as an icon within the button. Typically an icon component.
-     */
-    iconOnly?: React.ReactNode;
-    /**
-     * Content to display at the start of the button, before the button's text.
-     */
-    startContent?: React.ReactNode;
-    /**
-     * Content to display at the end of the button, after the button's text.
-     */
-    endContent?: React.ReactNode;
-    block?: boolean;
-    /**
-     * Whether the button is in a loading state.
-     */
-    loading?: boolean;
-    /**
-     * Whether the button is disabled.
-     */
-    disabled?: boolean;
-}
-type NativeAttrs$8 = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$8>;
-type ButtonProps = Props$8 & NativeAttrs$8;
+interface Props$8 {
+    /**
+     * The HTML element type or React component to render as the button.
+     */
+    as?: React.ElementType;
+    /**
+     * The variant style of the button.
+     */
+    variant?: ButtonVariant;
+    /**
+     * The color of the button.
+     */
+    color?: ButtonColor;
+    /**
+     * The size of the button.
+     */
+    size?: ButtonSize;
+    /**
+     * Content to display as an icon within the button. Typically an icon component.
+     */
+    iconOnly?: React.ReactNode;
+    /**
+     * Content to display at the start of the button, before the button's text.
+     */
+    startContent?: React.ReactNode;
+    /**
+     * Content to display at the end of the button, after the button's text.
+     */
+    endContent?: React.ReactNode;
+    block?: boolean;
+    /**
+     * Whether the button is in a loading state.
+     */
+    loading?: boolean;
+    /**
+     * Whether the button is disabled.
+     */
+    disabled?: boolean;
+}
+type NativeAttrs$8 = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$8>;
+type ButtonProps = Props$8 & NativeAttrs$8;
 declare const Button: react.ForwardRefExoticComponent<Props$8 & NativeAttrs$8 & react.RefAttributes<HTMLButtonElement>>;
 
-interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
-    as?: React.ElementType;
-}
+interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
+    as?: React.ElementType;
+}
 declare const Card: react.ForwardRefExoticComponent<CardProps & react.RefAttributes<HTMLDivElement>>;
 
-interface CardHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
-    as?: React.ElementType;
-    title: string;
-    subtitle?: string;
-    startContent?: React.ReactNode;
-    endContent?: React.ReactNode;
-}
+interface CardHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    as?: React.ElementType;
+    title: string;
+    subtitle?: string;
+    startContent?: React.ReactNode;
+    endContent?: React.ReactNode;
+}
 declare const CardHeader: react.ForwardRefExoticComponent<CardHeaderProps & react.RefAttributes<HTMLDivElement>>;
 
-type ChipVariant = 'filled' | 'outlined' | 'text';
-type ChipColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
+type ChipVariant = 'filled' | 'outlined' | 'text';
+type ChipColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
 type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 
-interface Props$7 {
-    /**
-     * The HTML element type or React component to render as the chip.
-     */
-    as?: React.ElementType;
-    /**
-     * The variant style of the chip.
-     */
-    variant?: ChipVariant;
-    /**
-     * The color of the chip.
-     */
-    color?: ChipColor;
-    /**
-     * The size of the chip.
-     */
-    size?: ChipSize;
-}
-type NativeAttrs$7 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7>;
-type ChipProps = Props$7 & NativeAttrs$7;
+interface Props$7 {
+    /**
+     * The HTML element type or React component to render as the chip.
+     */
+    as?: React.ElementType;
+    /**
+     * The variant style of the chip.
+     */
+    variant?: ChipVariant;
+    /**
+     * The color of the chip.
+     */
+    color?: ChipColor;
+    /**
+     * The size of the chip.
+     */
+    size?: ChipSize;
+}
+type NativeAttrs$7 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$7>;
+type ChipProps = Props$7 & NativeAttrs$7;
 declare const Chip: react.ForwardRefExoticComponent<Props$7 & NativeAttrs$7 & react.RefAttributes<HTMLDivElement>>;
 
-interface CollapseProps {
-    children: React.ReactNode;
-    isOpen?: boolean;
-    onOpen?: () => void;
-    onClose?: () => void;
-    onToggle?: () => void;
-}
+interface CollapseProps {
+    children: React.ReactNode;
+    isOpen?: boolean;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onToggle?: () => void;
+}
 declare const Collapse: React.FC<CollapseProps>;
 
-interface CollapseContentProps {
-    children: React.ReactNode;
-}
+interface CollapseContentProps {
+    children: React.ReactNode;
+}
 declare const CollapseContent: React.FC<CollapseContentProps>;
 
-interface CollapseContextValue {
-    collapseRef: React.MutableRefObject<HTMLDivElement | null>;
-    isOpen: boolean;
-    heightAuto: boolean;
-    onOpen: () => void;
-    onClose: () => void;
-    onToggle: () => void;
-}
-declare const CollapseContext: react.Context<CollapseContextValue | null>;
+interface CollapseContextValue {
+    collapseRef: React.MutableRefObject<HTMLDivElement | null>;
+    isOpen: boolean;
+    heightAuto: boolean;
+    onOpen: () => void;
+    onClose: () => void;
+    onToggle: () => void;
+}
+declare const CollapseContext: react.Context<CollapseContextValue | null>;
 declare const useCollapse: () => CollapseContextValue;
 
-interface CollapseTriggerProps {
-    children: react__default.ReactNode;
-}
+interface CollapseTriggerProps {
+    children: react__default.ReactNode;
+}
 declare const CollapseTrigger: react__default.ForwardRefExoticComponent<CollapseTriggerProps & react__default.RefAttributes<unknown>>;
 
-type DrawerSize = 'sm' | 'md' | 'lg';
+type DrawerSize = 'sm' | 'md' | 'lg';
 type DrawerPosition = 'top' | 'left' | 'right' | 'bottom';
 
-interface DrawerProps extends React.HTMLAttributes<HTMLDivElement> {
-    isOpen: boolean;
-    size?: DrawerSize;
-    position?: DrawerPosition;
-    onClose: () => void;
-    onAfterClose?: () => void;
-}
+interface DrawerProps extends React.HTMLAttributes<HTMLDivElement> {
+    isOpen: boolean;
+    size?: DrawerSize;
+    position?: DrawerPosition;
+    onClose: () => void;
+    onAfterClose?: () => void;
+}
 declare const Drawer: react.ForwardRefExoticComponent<DrawerProps & react.RefAttributes<HTMLDivElement>>;
 
-interface IconProps {
-    children: React.ReactNode;
-    color?: 'primary' | 'secondary';
-    size?: 'sm' | 'md' | 'lg';
-}
+interface IconProps {
+    children: React.ReactNode;
+    color?: 'primary' | 'secondary';
+    size?: 'sm' | 'md' | 'lg';
+}
 declare const Icon: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<unknown>>;
 
-interface Props$6 {
-    /**
-     * The HTML element type or React component to render as the menu item.
-     */
-    as?: React.ElementType;
-    /**
-     * The value associated with the menu item.
-     */
-    value?: any;
-    /**
-     * The title to display for the menu item.
-     */
-    title: string;
-    /**
-     * Optional icon to display with the menu item.
-     */
-    icon?: React.ReactNode;
-    /**
-     * The nesting level of the menu item, for hierarchical menus.
-     */
-    level?: number;
-    /**
-     * Whether the item is disabled.
-     */
-    disabled?: boolean;
-}
-type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6 | 'items'>;
-type MenuItemProps = Props$6 & NativeAttrs$6;
+interface Props$6 {
+    /**
+     * The HTML element type or React component to render as the menu item.
+     */
+    as?: React.ElementType;
+    /**
+     * The value associated with the menu item.
+     */
+    value?: any;
+    /**
+     * The title to display for the menu item.
+     */
+    title: string;
+    /**
+     * Optional icon to display with the menu item.
+     */
+    icon?: React.ReactNode;
+    /**
+     * The nesting level of the menu item, for hierarchical menus.
+     */
+    level?: number;
+    /**
+     * Whether the item is disabled.
+     */
+    disabled?: boolean;
+}
+type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6 | 'items'>;
+type MenuItemProps = Props$6 & NativeAttrs$6;
 declare const MenuItem: react.ForwardRefExoticComponent<Props$6 & NativeAttrs$6 & react.RefAttributes<HTMLDivElement>>;
 
-type MenuSubmenuProps = Omit<MenuItemProps, 'items'> & {
-    items?: MenuItemType[];
-};
+type MenuSubmenuProps = Omit<MenuItemProps, 'items'> & {
+    items?: MenuItemType[];
+};
 declare const MenuSubmenu: React.FC<MenuSubmenuProps>;
 
-type MenuGroupItemType = (MenuItemProps & {
-    type?: 'item';
-}) | (MenuSubmenuProps & {
-    type?: 'submenu';
-});
-type MenuGroupProps = Omit<MenuItemProps, 'items'> & {
-    items?: MenuGroupItemType[];
-};
+type MenuGroupItemType = (MenuItemProps & {
+    type?: 'item';
+}) | (MenuSubmenuProps & {
+    type?: 'submenu';
+});
+type MenuGroupProps = Omit<MenuItemProps, 'items'> & {
+    items?: MenuGroupItemType[];
+};
 declare const MenuGroup: React.FC<MenuGroupProps>;
 
-type MenuItemType = (MenuGroupProps & {
-    type?: 'group';
-}) | (MenuSubmenuProps & {
-    type?: 'submenu';
-}) | (MenuItemProps & {
-    type?: 'item';
-});
-interface Props$5 {
-    /**
-     * The currently selected value of the menu.
-     */
-    value?: any[];
-    /**
-     * The default value of the menu when initially rendered.
-     */
-    defaultValue?: any[];
-    /**
-     * An array of values that represent open submenus in the menu.
-     */
-    openValues?: any[];
-    /**
-     * The expand mode of the menu, which can be 'single' or 'multiple'.
-     */
-    expandMode?: 'single' | 'multiple';
-    /**
-     * The nav mode of the menu, which can be 'manual' or 'automatic'.
-     * Search for the last level of the menu and validate if the value matches.
-     */
-    navMode?: 'manual' | 'automatic';
-    /**
-     * A callback function called when the selected values of the menu change.
-     */
-    onChange?: (value: any[]) => void;
-    /**
-     * A callback function called when submenus are opened.
-     */
-    onOpen?: (values: any[]) => void;
-    /**
-     * A callback function called when a menu item is selected.
-     * @param {MenuItemProps} props - The properties of the selected menu item.
-     */
-    onItemSelect?: (props: MenuItemProps) => void;
-}
-type NativeAttrs$5 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5 | 'items'>;
-type MenuProps = Props$5 & NativeAttrs$5 & {
-    items?: MenuItemType[];
-};
+type MenuItemType = (MenuGroupProps & {
+    type?: 'group';
+}) | (MenuSubmenuProps & {
+    type?: 'submenu';
+}) | (MenuItemProps & {
+    type?: 'item';
+});
+interface Props$5 {
+    /**
+     * The currently selected value of the menu.
+     */
+    value?: any[];
+    /**
+     * The default value of the menu when initially rendered.
+     */
+    defaultValue?: any[];
+    /**
+     * An array of values that represent open submenus in the menu.
+     */
+    openValues?: any[];
+    /**
+     * The expand mode of the menu, which can be 'single' or 'multiple'.
+     */
+    expandMode?: 'single' | 'multiple';
+    /**
+     * The nav mode of the menu, which can be 'manual' or 'automatic'.
+     * Search for the last level of the menu and validate if the value matches.
+     */
+    navMode?: 'manual' | 'automatic';
+    /**
+     * A callback function called when the selected values of the menu change.
+     */
+    onChange?: (value: any[]) => void;
+    /**
+     * A callback function called when submenus are opened.
+     */
+    onOpen?: (values: any[]) => void;
+    /**
+     * A callback function called when a menu item is selected.
+     * @param {MenuItemProps} props - The properties of the selected menu item.
+     */
+    onItemSelect?: (props: MenuItemProps) => void;
+}
+type NativeAttrs$5 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5 | 'items'>;
+type MenuProps = Props$5 & NativeAttrs$5 & {
+    items?: MenuItemType[];
+};
 declare const Menu: React.FC<MenuProps>;
 
-interface MenuContextValue {
-    value: any;
-    originalValue: any;
-    openValues: any[];
-    expandMode: 'single' | 'multiple';
-    navMode: 'manual' | 'automatic';
-    onChange: (value: any) => void;
-    onOpen: (values: any) => void;
-    onItemSelect: (props: MenuItemProps) => void;
-}
-declare const MenuContext: react.Context<MenuContextValue | null>;
+interface MenuContextValue {
+    value: any;
+    originalValue: any;
+    openValues: any[];
+    expandMode: 'single' | 'multiple';
+    navMode: 'manual' | 'automatic';
+    onChange: (value: any) => void;
+    onOpen: (values: any) => void;
+    onItemSelect: (props: MenuItemProps) => void;
+}
+declare const MenuContext: react.Context<MenuContextValue | null>;
 declare const useMenu: () => MenuContextValue;
 
-declare const MenuValueContext: react.Context<string[]>;
+declare const MenuValueContext: react.Context<string[]>;
 declare const useMenuItemValue: () => string[];
 
 declare const getOpenValuesByPathname: (pathname: string) => string[];
 
-type AccordionProps = React.HTMLAttributes<HTMLDivElement>;
+type AccordionProps = React.HTMLAttributes<HTMLDivElement>;
 declare const Accordion: react.ForwardRefExoticComponent<AccordionProps & react.RefAttributes<HTMLDivElement>>;
 
-interface AccordionItemContextValue {
-    value: string;
-}
-declare const useAccordionItem: () => AccordionItemContextValue;
-type AccordionItemProps = React.HTMLAttributes<HTMLDivElement> & {
-    value?: any;
-};
-declare const AccordionItem: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & {
-    value?: any;
+interface AccordionItemContextValue {
+    value: string;
+}
+declare const useAccordionItem: () => AccordionItemContextValue;
+type AccordionItemProps = React.HTMLAttributes<HTMLDivElement> & {
+    value?: any;
+};
+declare const AccordionItem: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & {
+    value?: any;
 } & react.RefAttributes<HTMLDivElement>>;
 
-type AccordionHeaderProps = React.HTMLAttributes<HTMLDivElement> & {
-    title: string;
-    subtitle?: string;
-    startContent?: React.ReactNode;
-    endContent?: React.ReactNode;
-};
-declare const AccordionHeader: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & {
-    title: string;
-    subtitle?: string | undefined;
-    startContent?: React.ReactNode;
-    endContent?: React.ReactNode;
+type AccordionHeaderProps = React.HTMLAttributes<HTMLDivElement> & {
+    title: string;
+    subtitle?: string;
+    startContent?: React.ReactNode;
+    endContent?: React.ReactNode;
+};
+declare const AccordionHeader: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & {
+    title: string;
+    subtitle?: string | undefined;
+    startContent?: React.ReactNode;
+    endContent?: React.ReactNode;
 } & react.RefAttributes<HTMLDivElement>>;
 
-type AccordionPanelProps = React.HTMLAttributes<HTMLDivElement>;
+type AccordionPanelProps = React.HTMLAttributes<HTMLDivElement>;
 declare const AccordionPanel: react.ForwardRefExoticComponent<AccordionPanelProps & react.RefAttributes<HTMLDivElement>>;
 
-type AccordionContentProps = React.HTMLAttributes<HTMLDivElement>;
+type AccordionContentProps = React.HTMLAttributes<HTMLDivElement>;
 declare const AccordionContent: react.ForwardRefExoticComponent<AccordionContentProps & react.RefAttributes<HTMLDivElement>>;
 
-interface PortalProps {
-    children: React.ReactNode;
-    container?: Element;
-}
+interface PortalProps {
+    children: React.ReactNode;
+    container?: Element;
+}
 declare const Portal: react.ForwardRefExoticComponent<PortalProps & react.RefAttributes<HTMLDivElement>>;
 
-interface Props$4 {
-    /**
-     * The HTML element type or React component to render as the tab.
-     */
-    as?: React.ElementType;
-    /**
-     * The value associated with the tab.
-     */
-    value?: any;
-    /**
-     * Whether the tab can be closed.
-     */
-    closable?: boolean;
-    /**
-     * Whether the tab is disabled.
-     */
-    disabled?: boolean;
-    /**
-     * Content to display at the start of the tab, before the tab's text.
-     */
-    startContent?: React.ReactNode;
-    /**
-     * Content to display at the end of the tab, after the tab's text.
-     */
-    endContent?: React.ReactNode;
-}
-type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
-type TabProps = Props$4 & NativeAttrs$4;
-declare const Tab: react.ForwardRefExoticComponent<Props$4 & NativeAttrs$4 & {
-    children?: react.ReactNode;
+interface Props$4 {
+    /**
+     * The HTML element type or React component to render as the tab.
+     */
+    as?: React.ElementType;
+    /**
+     * The value associated with the tab.
+     */
+    value?: any;
+    /**
+     * Whether the tab can be closed.
+     */
+    closable?: boolean;
+    /**
+     * Whether the tab is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * Content to display at the start of the tab, before the tab's text.
+     */
+    startContent?: React.ReactNode;
+    /**
+     * Content to display at the end of the tab, after the tab's text.
+     */
+    endContent?: React.ReactNode;
+}
+type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
+type TabProps = Props$4 & NativeAttrs$4;
+declare const Tab: react.ForwardRefExoticComponent<Props$4 & NativeAttrs$4 & {
+    children?: react.ReactNode;
 } & react.RefAttributes<HTMLDivElement>>;
 
 type TabsAlignmet = 'start' | 'center' | 'end' | 'stretch';
 
-interface Props$3 {
-    /**
-     * The currently selected value of the tabs.
-     */
-    value?: any;
-    /**
-     * The default value of the tabs when initially rendered.
-     */
-    defaultValue?: any;
-    /**
-     * The alignment of the tabs.
-     */
-    alignment?: TabsAlignmet;
-    /**
-     * A callback function called when the selected tab value changes.
-     */
-    onChange?: (value: any) => void;
-    /**
-     * A callback function called when a tab is closed.
-     */
-    onClose?: (value: any) => void;
-}
-type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3>;
-type TabsProps = Props$3 & NativeAttrs$3;
+interface Props$3 {
+    /**
+     * The currently selected value of the tabs.
+     */
+    value?: any;
+    /**
+     * The default value of the tabs when initially rendered.
+     */
+    defaultValue?: any;
+    /**
+     * The alignment of the tabs.
+     */
+    alignment?: TabsAlignmet;
+    /**
+     * A callback function called when the selected tab value changes.
+     */
+    onChange?: (value: any) => void;
+    /**
+     * A callback function called when a tab is closed.
+     */
+    onClose?: (value: any) => void;
+}
+type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3>;
+type TabsProps = Props$3 & NativeAttrs$3;
 declare const Tabs: React.FC<TabsProps>;
 
 type ToolbarSize = 'auto' | 'sm' | 'md' | 'lg';
 
-interface ToolbarProps extends React.HTMLAttributes<HTMLDivElement> {
-    size?: ToolbarSize;
-    title?: string;
-    subtitle?: string;
-    startContent?: React.ReactNode;
-    endContent?: React.ReactNode;
-    startAction?: React.ReactNode;
-    endAction?: React.ReactNode;
-}
+interface ToolbarProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: ToolbarSize;
+    title?: string;
+    subtitle?: string;
+    startContent?: React.ReactNode;
+    endContent?: React.ReactNode;
+    startAction?: React.ReactNode;
+    endAction?: React.ReactNode;
+}
 declare const Toolbar: React.FC<ToolbarProps>;
 
-interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
-    nodeRef?: React.MutableRefObject<HTMLElement | null>;
-    name: string;
-    isOpen: boolean;
-    enter?: number;
-    leave?: number;
-    mountOnEnter?: boolean;
-    unmountOnExit?: boolean;
-    onExited?: () => void;
-}
+interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
+    nodeRef?: React.MutableRefObject<HTMLElement | null>;
+    name: string;
+    isOpen: boolean;
+    enter?: number;
+    leave?: number;
+    mountOnEnter?: boolean;
+    unmountOnExit?: boolean;
+    onExited?: () => void;
+}
 declare const Transition: react.ForwardRefExoticComponent<TransitionProps & react.RefAttributes<HTMLElement>>;
 
-interface ScrollAreaProps {
-    children: React.ReactNode;
-    autoHide?: boolean;
-    style?: React.CSSProperties;
-}
+interface ScrollAreaProps {
+    children: React.ReactNode;
+    autoHide?: boolean;
+    style?: React.CSSProperties;
+}
 declare const ScrollArea: react.ForwardRefExoticComponent<ScrollAreaProps & react.RefAttributes<HTMLDivElement>>;
 
-interface Props$2 {
-    inputRef?: React.RefObject<HTMLInputElement>;
-    startContent?: React.ReactNode;
-    endContent?: React.ReactNode;
-}
-type NativeAttrs$2 = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$2>;
-type TextInputProps = Props$2 & NativeAttrs$2;
+interface Props$2 {
+    inputRef?: React.RefObject<HTMLInputElement>;
+    startContent?: React.ReactNode;
+    endContent?: React.ReactNode;
+}
+type NativeAttrs$2 = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$2>;
+type TextInputProps = Props$2 & NativeAttrs$2;
 declare const TextInput: react.ForwardRefExoticComponent<Props$2 & NativeAttrs$2 & react.RefAttributes<HTMLInputElement>>;
 
-interface Props$1 {
-    name?: string;
-    value?: string;
-    defaultValue?: string;
-    checked?: boolean;
-    defaultChecked?: boolean;
-    disabled?: boolean;
-    onChange?: (value: string) => void;
-    onCheckedChange?: (checked: boolean) => void;
-}
-type NativeAttrs$1 = Omit<React.LabelHTMLAttributes<HTMLLabelElement>, keyof Props$1>;
-type SwitchProps = Props$1 & NativeAttrs$1;
+interface Props$1 {
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    onChange?: (value: string) => void;
+    onCheckedChange?: (checked: boolean) => void;
+}
+type NativeAttrs$1 = Omit<React.LabelHTMLAttributes<HTMLLabelElement>, keyof Props$1>;
+type SwitchProps = Props$1 & NativeAttrs$1;
 declare const Switch: react.ForwardRefExoticComponent<Props$1 & NativeAttrs$1 & react.RefAttributes<HTMLLabelElement>>;
 
-type SelectItem = Record<string, any>;
-type SelectKeyField<TSelectItem> = keyof TSelectItem;
-interface SelectSingleProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> {
-    isMultiple?: false;
-    value: TSelectItem[TSelectKeyField] | null;
-    onChange?: (value: TSelectItem | null) => void;
-    onValueChange?: (value: TSelectItem[TSelectKeyField] | null) => void;
-}
-interface SelectMultipleProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> {
-    isMultiple: true;
-    value: TSelectItem[TSelectKeyField][];
-    onChange?: (value: TSelectItem[]) => void;
-    onValueChange?: (value: TSelectItem[TSelectKeyField][]) => void;
-}
-type NativeAttrs<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props<TSelectItem, TSelectKeyField>>;
-type Props<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = {
-    data: TSelectItem[];
-    keyField?: TSelectKeyField;
-    textField?: keyof TSelectItem;
-    placeholder?: string;
-    loading?: boolean;
-    disabled?: boolean;
-    disclosure?: Disclosure;
-    virtual?: Omit<VirtualizerOptions, 'parentRef'>;
-    startContent?: React.ReactNode;
-    endContent?: React.ReactNode;
-    onItemSelect?: (item: TSelectItem) => void;
-    renderItem?: (item: TSelectItem, props: ListItemProps) => React.ReactNode;
-} & (SelectSingleProps<TSelectItem, TSelectKeyField> | SelectMultipleProps<TSelectItem, TSelectKeyField>);
+type SelectItem = Record<string, any>;
+type SelectKeyField<TSelectItem> = keyof TSelectItem;
+interface SelectSingleProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> {
+    isMultiple?: false;
+    value: TSelectItem[TSelectKeyField] | null;
+    onChange?: (value: TSelectItem | null) => void;
+    onValueChange?: (value: TSelectItem[TSelectKeyField] | null) => void;
+}
+interface SelectMultipleProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> {
+    isMultiple: true;
+    value: TSelectItem[TSelectKeyField][];
+    onChange?: (value: TSelectItem[]) => void;
+    onValueChange?: (value: TSelectItem[TSelectKeyField][]) => void;
+}
+type NativeAttrs<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props<TSelectItem, TSelectKeyField>>;
+type Props<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = {
+    data: TSelectItem[];
+    keyField?: TSelectKeyField;
+    textField?: keyof TSelectItem;
+    placeholder?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    disclosure?: Disclosure;
+    virtual?: Omit<VirtualizerOptions, 'parentRef'>;
+    startContent?: React.ReactNode;
+    endContent?: React.ReactNode;
+    onItemSelect?: (item: TSelectItem) => void;
+    renderItem?: (item: TSelectItem, props: ListItemProps) => React.ReactNode;
+} & (SelectSingleProps<TSelectItem, TSelectKeyField> | SelectMultipleProps<TSelectItem, TSelectKeyField>);
 type SelectProps<TSelectItem extends SelectItem, TSelectKeyField extends SelectKeyField<TSelectItem> = 'key'> = Props<TSelectItem, TSelectKeyField> & NativeAttrs<TSelectItem, TSelectKeyField>;
 
 declare const Select: <TSelectItem extends SelectItem, TSelectKeyField extends keyof TSelectItem = "key">(props: SelectProps<TSelectItem, TSelectKeyField>) => react_jsx_runtime.JSX.Element;
 
-interface FieldProps extends React.HTMLAttributes<HTMLDivElement> {
-    label: string;
-}
+interface FieldProps extends React.HTMLAttributes<HTMLDivElement> {
+    label: string;
+}
 declare const Field: react.ForwardRefExoticComponent<FieldProps & react.RefAttributes<HTMLDivElement>>;
 
 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;
+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;
+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;
 
 export { Accordion, AccordionContent, AccordionContentProps, AccordionHeader, AccordionHeaderProps, AccordionItem, AccordionItemProps, AccordionPanel, AccordionPanelProps, AccordionProps, Autocomplete, AutocompleteItem, AutocompleteKeyField, AutocompleteMultipleProps, AutocompleteProps, AutocompleteSingleProps, Backdrop, BackdropProps, Badge, BadgeProps, Button, ButtonColor, ButtonProps, ButtonSize, ButtonVariant, Card, CardHeader, CardHeaderProps, CardProps, Chip, ChipProps, Collapse, CollapseContent, CollapseContentProps, CollapseContext, CollapseContextValue, CollapseProps, CollapseTrigger, CollapseTriggerProps, Disclosure, Drawer, DrawerPosition, DrawerProps, DrawerSize, Field, FieldProps, Icon, IconProps, InfiniteData, List, ListGroup, ListGroupProps, ListItem, ListItemProps, ListProps, Menu, MenuContext, MenuContextValue, MenuGroup, MenuGroupItemType, MenuGroupProps, MenuItem, MenuItemProps, MenuItemType, MenuProps, MenuSubmenu, MenuSubmenuProps, MenuValueContext, Portal, PortalProps, QueryFunction, QueryOptions, QueryStatus, ReactRef, Resize, ScrollAlignment, ScrollArea, ScrollAreaProps, ScrollBehavior, ScrollToOptions, Select, SelectItem, SelectKeyField, SelectMultipleProps, SelectProps, SelectSingleProps, Switch, SwitchProps, Tab, TabProps, Tabs, TabsAlignmet, TabsProps, TextInput, TextInputProps, Toolbar, ToolbarProps, ToolbarSize, Transition, TransitionProps, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseResizeObserverOptions, VirtualItem, Virtualizer, VirtualizerOptions, assignRef, clsx, getOpenValuesByPathname, hasResizeObserver, mergeRefs, scrollToItem, useAccordionItem, useCollapse, useDebounce, useDisclosure, useEffectEvent, useElementSize, useInfiniteQuery, useLocalStorage, useMenu, useMenuItemValue, useOnClickOutside, usePrevious, useResizeObserver, useStep, useValueEffect, useVirtualizer };