@unifiedsoftware/react-ui 1.0.18 → 1.0.19

package/dist/index.d.ts

@@ -10,7 +10,7 @@ declare const Backdrop: react.ForwardRefExoticComponent<BackdropProps & react.Re
 
 type BadgePlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 
-interface Props$6 {
+interface Props$8 {
     /**
      * The placement of the badge relative to its content.
      */
@@ -20,15 +20,15 @@ interface Props$6 {
      */
     content?: React.ReactNode;
 }
-type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
-type BadgeProps = Props$6 & NativeAttrs$6;
+type NativeAttrs$8 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$8>;
+type BadgeProps = Props$8 & NativeAttrs$8;
 declare const Badge: React.FC<BadgeProps>;
 
-type ButtonVariant = 'filled' | 'outlined' | 'flat' | 'text';
+type ButtonVariant = 'filled' | 'outlined' | 'flat' | 'text' | 'plain';
 type ButtonColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
 type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 
-interface Props$5 {
+interface Props$7 {
     /**
      * The HTML element type or React component to render as the button.
      */
@@ -67,9 +67,9 @@ interface Props$5 {
      */
     disabled?: boolean;
 }
-type NativeAttrs$5 = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$5>;
-type ButtonProps = Props$5 & NativeAttrs$5;
-declare const Button: react.ForwardRefExoticComponent<Props$5 & NativeAttrs$5 & react.RefAttributes<HTMLButtonElement>>;
+type NativeAttrs$7 = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$7>;
+type ButtonProps = Props$7 & NativeAttrs$7;
+declare const Button: react.ForwardRefExoticComponent<Props$7 & NativeAttrs$7 & react.RefAttributes<HTMLButtonElement>>;
 
 interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
     as?: React.ElementType;
@@ -89,7 +89,7 @@ type ChipVariant = 'filled' | 'outlined' | 'text';
 type ChipColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
 type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 
-interface Props$4 {
+interface Props$6 {
     /**
      * The HTML element type or React component to render as the chip.
      */
@@ -107,9 +107,9 @@ interface Props$4 {
      */
     size?: ChipSize;
 }
-type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
-type ChipProps = Props$4 & NativeAttrs$4;
-declare const Chip: react.ForwardRefExoticComponent<Props$4 & NativeAttrs$4 & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
+type ChipProps = Props$6 & NativeAttrs$6;
+declare const Chip: react.ForwardRefExoticComponent<Props$6 & NativeAttrs$6 & react.RefAttributes<HTMLDivElement>>;
 
 interface CollapseProps {
     children: React.ReactNode;
@@ -160,7 +160,7 @@ interface IconProps {
 }
 declare const Icon: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<unknown>>;
 
-interface Props$3 {
+interface Props$5 {
     /**
      * The HTML element type or React component to render as the menu item.
      */
@@ -186,9 +186,9 @@ interface Props$3 {
      */
     disabled?: boolean;
 }
-type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3 | 'items'>;
-type MenuItemProps = Props$3 & NativeAttrs$3;
-declare const MenuItem: react.ForwardRefExoticComponent<Props$3 & NativeAttrs$3 & react.RefAttributes<HTMLDivElement>>;
+type NativeAttrs$5 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$5 | 'items'>;
+type MenuItemProps = Props$5 & NativeAttrs$5;
+declare const MenuItem: react.ForwardRefExoticComponent<Props$5 & NativeAttrs$5 & react.RefAttributes<HTMLDivElement>>;
 
 type MenuSubmenuProps = Omit<MenuItemProps, 'items'> & {
     items?: MenuItemType[];
@@ -212,7 +212,7 @@ type MenuItemType = (MenuGroupProps & {
 }) | (MenuItemProps & {
     type?: 'item';
 });
-interface Props$2 {
+interface Props$4 {
     /**
      * The currently selected value of the menu.
      */
@@ -248,8 +248,8 @@ interface Props$2 {
      */
     onItemSelect?: (props: MenuItemProps) => void;
 }
-type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2 | 'items'>;
-type MenuProps = Props$2 & NativeAttrs$2 & {
+type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4 | 'items'>;
+type MenuProps = Props$4 & NativeAttrs$4 & {
     items?: MenuItemType[];
 };
 declare const Menu: React.FC<MenuProps>;
@@ -307,10 +307,11 @@ declare const AccordionContent: react.ForwardRefExoticComponent<AccordionContent
 
 interface PortalProps {
     children: React.ReactNode;
+    container?: Element;
 }
-declare const Portal: react.ForwardRefExoticComponent<PortalProps & react.RefAttributes<react.Component<any, {}, any>>>;
+declare const Portal: react.ForwardRefExoticComponent<PortalProps & react.RefAttributes<HTMLDivElement>>;
 
-interface Props$1 {
+interface Props$3 {
     /**
      * The HTML element type or React component to render as the tab.
      */
@@ -328,15 +329,15 @@ interface Props$1 {
      */
     disabled?: boolean;
 }
-type NativeAttrs$1 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$1>;
-type TabProps = Props$1 & NativeAttrs$1;
-declare const Tab: react.ForwardRefExoticComponent<Props$1 & NativeAttrs$1 & {
+type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3>;
+type TabProps = Props$3 & NativeAttrs$3;
+declare const Tab: react.ForwardRefExoticComponent<Props$3 & NativeAttrs$3 & {
     children?: react.ReactNode;
 } & react.RefAttributes<HTMLDivElement>>;
 
 type TabsAlignmet = 'start' | 'center' | 'end' | 'stretch';
 
-interface Props {
+interface Props$2 {
     /**
      * The currently selected value of the tabs.
      */
@@ -358,8 +359,8 @@ interface Props {
      */
     onClose?: (value: any) => void;
 }
-type NativeAttrs = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props>;
-type TabsProps = Props & NativeAttrs;
+type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2>;
+type TabsProps = Props$2 & NativeAttrs$2;
 declare const Tabs: React.FC<TabsProps>;
 
 type ToolbarSize = 'auto' | 'sm' | 'md' | 'lg';
@@ -385,11 +386,22 @@ interface TransitionProps extends React.HTMLAttributes<HTMLElement> {
 }
 declare const Transition: react.ForwardRefExoticComponent<TransitionProps & react.RefAttributes<HTMLElement>>;
 
-interface ScrollAreaProps extends React.HTMLAttributes<HTMLDivElement> {
-    direction?: 'vertical' | 'horizontal';
+interface ScrollAreaProps {
+    children: React.ReactNode;
+    height?: number;
+    style?: React.CSSProperties;
 }
 declare const ScrollArea: react.ForwardRefExoticComponent<ScrollAreaProps & react.RefAttributes<HTMLDivElement>>;
 
+interface Props$1 {
+    inputRef?: React.RefObject<HTMLInputElement>;
+    startContent?: React.ReactNode;
+    endContent?: React.ReactNode;
+}
+type NativeAttrs$1 = Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof Props$1>;
+type TextInputProps = Props$1 & NativeAttrs$1;
+declare const TextInput: react.ForwardRefExoticComponent<Props$1 & NativeAttrs$1 & react.RefAttributes<HTMLInputElement>>;
+
 type SelectItem = {
     key: any;
     text: string;
@@ -402,7 +414,7 @@ type SelectState = {
     skip: number;
     filter: string;
 };
-interface VirtualScrollerProps$1 {
+interface VirtualScrollerProps {
     pageSize?: number;
 }
 type SelectBaseProps<TSelectItem = SelectItem> = {
@@ -413,7 +425,7 @@ type SelectBaseProps<TSelectItem = SelectItem> = {
     textField?: string;
     filterable?: boolean;
     filter?: string;
-    virtual?: VirtualScrollerProps$1;
+    virtual?: VirtualScrollerProps;
     disabled?: boolean;
     loading?: boolean;
     className?: string;
@@ -443,55 +455,98 @@ type SwitchProps = {
 } & Omit<React.InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange'>;
 declare const Switch: React.FC<SwitchProps>;
 
-type MultiSelectItem = {
-    value: any;
-    label: string;
-} | any;
-type MultiSelectData<TMultiSelectItem = MultiSelectItem> = {
-    items: TMultiSelectItem[];
-    total: number;
-};
-type MultiSelectState = {
-    skip: number;
-    filter: string;
-};
-interface VirtualScrollerProps {
-    pageSize?: number;
+declare global {
+    interface WindowEventMap {
+        'local-storage': CustomEvent;
+    }
 }
-type MultiSelectBaseProps<TMultiSelectItem = MultiSelectItem> = {
-    data: MultiSelectData<TMultiSelectItem>;
-    value?: TMultiSelectItem[];
-    placeholder?: string;
-    keyField?: string;
-    textField?: string;
-    filterable?: boolean;
-    filter?: string;
-    virtual?: VirtualScrollerProps;
-    disabled?: boolean;
-    loading?: boolean;
-    className?: string;
-    onFilterChange?: (filter: string) => void;
-    onChange: (value: TMultiSelectItem[]) => void;
-};
-type MultiSelectClientProps<TMultiSelectItem = MultiSelectItem> = {
-    filterMode: 'client';
+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.
+ */
+declare const usePrevious: (value: any) => undefined;
+
+interface Disclosure {
+    isOpen: boolean;
+    onOpen: () => void;
+    onClose: () => void;
+    onToggle: () => void;
+}
+declare function useDisclosure({ defaultValue }?: {
+    defaultValue?: boolean;
+}): Disclosure;
+
+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:
+ */
+declare const useStep: (maxStep: number) => [number, Helpers];
+
+declare function useDebounce<T>(value: T, delay?: number): T;
+
+declare enum QueryStatus {
+    IDLE = 0,
+    LOADING = 1,
+    SUCCESS = 2,
+    ERROR = 3
+}
+interface QueryOptions {
     page?: number;
-    pageSize?: number;
-    onPageChange?: (page: number) => void;
-} & MultiSelectBaseProps<TMultiSelectItem>;
-type MultiSelectServerProps<TMultiSelectItem = MultiSelectItem> = {
-    filterMode: 'server';
-    onDataChange: (data: MultiSelectData) => void;
-    getData: (state: MultiSelectState) => Promise<MultiSelectData<TMultiSelectItem>>;
-} & MultiSelectBaseProps<TMultiSelectItem>;
-type MultiSelectProps<TMultiSelectItem = MultiSelectItem> = MultiSelectClientProps<TMultiSelectItem> | MultiSelectServerProps<TMultiSelectItem>;
+}
+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 const MultiSelect: (props: MultiSelectProps) => react_jsx_runtime.JSX.Element;
+declare function useInfiniteQuery<TData = unknown, TError = unknown>(options: UseInfiniteQueryOptions<TData>, deps?: React.DependencyList): UseInfiniteQueryResult<TData, TError>;
 
-interface FieldProps extends React.HTMLAttributes<HTMLDivElement> {
-    label: string;
+interface Resize {
+    width: number;
+    height: number;
 }
-declare const Field: react.ForwardRefExoticComponent<FieldProps & react.RefAttributes<HTMLDivElement>>;
+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 ListProps extends React.HTMLAttributes<HTMLDivElement> {
     as?: React.ElementType;
@@ -501,12 +556,17 @@ declare const List: react.ForwardRefExoticComponent<ListProps & react.RefAttribu
 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>>;
 
@@ -527,58 +587,61 @@ declare const ListGroup: react.ForwardRefExoticComponent<ListItemProps & {
     onToggle?: (() => void) | undefined;
 } & react.RefAttributes<HTMLDivElement>>;
 
-declare global {
-    interface WindowEventMap {
-        'local-storage': CustomEvent;
-    }
+type ComboboxItem = Record<string, any>;
+type ComboboxKeyField<TComboboxItem> = keyof TComboboxItem;
+interface VirtualProps {
+    count?: number;
+    hasNextPage?: boolean;
+    isFetchingNextPage?: boolean;
+    onFetchNextPage?: () => Promise<void> | void;
+    estimateSize: (index: number) => number;
 }
-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.
- */
-declare const usePrevious: (value: any) => undefined;
+interface ComboboxSingleProps<TComboboxItem extends ComboboxItem, TComboboxKeyField extends ComboboxKeyField<TComboboxItem> = 'key'> {
+    isMultiple?: false;
+    value: TComboboxItem[TComboboxKeyField] | undefined;
+    onChange?: (value: TComboboxItem | undefined) => void;
+    onValueChange?: (value: TComboboxItem[TComboboxKeyField] | undefined) => void;
+}
+interface ComboboxMultipleProps<TComboboxItem extends ComboboxItem, TComboboxKeyField extends ComboboxKeyField<TComboboxItem> = 'key'> {
+    isMultiple: true;
+    value: TComboboxItem[TComboboxKeyField][];
+    onChange?: (value: TComboboxItem[]) => void;
+    onValueChange?: (value: TComboboxItem[TComboboxKeyField][]) => void;
+}
+type NativeAttrs<TComboboxItem extends ComboboxItem, TComboboxKeyField extends ComboboxKeyField<TComboboxItem> = 'key'> = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props<TComboboxItem, TComboboxKeyField>>;
+type Props<TComboboxItem extends ComboboxItem, TComboboxKeyField extends ComboboxKeyField<TComboboxItem> = 'key'> = {
+    data: TComboboxItem[];
+    keyField?: TComboboxKeyField;
+    textField?: keyof TComboboxItem;
+    placeholder?: string;
+    filterable?: boolean;
+    filter?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    disclosure?: Disclosure;
+    virtual?: VirtualProps;
+    onItemSelect?: (item: TComboboxItem) => void;
+    onFilterChange?: (value: string) => void;
+    renderItem?: (item: TComboboxItem, props: ListItemProps) => React.ReactNode;
+} & (ComboboxSingleProps<TComboboxItem, TComboboxKeyField> | ComboboxMultipleProps<TComboboxItem, TComboboxKeyField>);
+type ComboboxProps<TComboboxItem extends ComboboxItem, TComboboxKeyField extends ComboboxKeyField<TComboboxItem> = 'key'> = Props<TComboboxItem, TComboboxKeyField> & NativeAttrs<TComboboxItem, TComboboxKeyField>;
 
-declare const useDisclosure: ({ defaultValue }?: {
-    defaultValue?: boolean | undefined;
-}) => {
-    isOpen: boolean;
-    onOpen: () => void;
-    onClose: () => void;
-    onToggle: () => void;
-};
+declare const Combobox: <TComboboxItem extends ComboboxItem, TComboboxKeyField extends keyof TComboboxItem = "key">(props: ComboboxProps<TComboboxItem, TComboboxKeyField>) => react_jsx_runtime.JSX.Element;
 
-interface Helpers {
-    goToNextStep: () => void;
-    goToPrevStep: () => void;
-    reset: () => void;
-    canGoToNextStep: boolean;
-    canGoToPrevStep: boolean;
-    setStep: Dispatch<SetStateAction<number>>;
+interface FieldProps extends React.HTMLAttributes<HTMLDivElement> {
+    label: string;
 }
-/**
- * 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 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;
 declare function clsx(...inputs: ClassValue[]): string;
 
-declare const scrollToItem: (parentElement: Element, currentElement: Element) => 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, Backdrop, BackdropProps, Badge, BadgeProps, Button, ButtonColor, ButtonProps, ButtonSize, ButtonVariant, Card, CardHeader, CardHeaderProps, CardProps, Chip, ChipProps, Collapse, CollapseContent, CollapseContentProps, CollapseContext, CollapseContextValue, CollapseProps, CollapseTrigger, CollapseTriggerProps, Drawer, DrawerPosition, DrawerProps, DrawerSize, Field, FieldProps, Icon, IconProps, List, ListGroup, ListGroupProps, ListItem, ListItemProps, ListProps, Menu, MenuContext, MenuContextValue, MenuGroup, MenuGroupItemType, MenuGroupProps, MenuItem, MenuItemProps, MenuItemType, MenuProps, MenuSubmenu, MenuSubmenuProps, MenuValueContext, MultiSelect, MultiSelectData, MultiSelectItem, MultiSelectProps, MultiSelectState, Portal, PortalProps, ScrollArea, ScrollAreaProps, Select, SelectData, SelectItem, SelectProps, SelectState, Switch, SwitchProps, Tab, TabProps, Tabs, TabsAlignmet, TabsProps, Toolbar, ToolbarProps, ToolbarSize, Transition, TransitionProps, clsx, getOpenValuesByPathname, scrollToItem, useAccordionItem, useCollapse, useDisclosure, useLocalStorage, useMenu, useMenuItemValue, usePrevious, useStep };
+export { Accordion, AccordionContent, AccordionContentProps, AccordionHeader, AccordionHeaderProps, AccordionItem, AccordionItemProps, AccordionPanel, AccordionPanelProps, AccordionProps, Backdrop, BackdropProps, Badge, BadgeProps, Button, ButtonColor, ButtonProps, ButtonSize, ButtonVariant, Card, CardHeader, CardHeaderProps, CardProps, Chip, ChipProps, Collapse, CollapseContent, CollapseContentProps, CollapseContext, CollapseContextValue, CollapseProps, CollapseTrigger, CollapseTriggerProps, Combobox, ComboboxItem, ComboboxKeyField, ComboboxMultipleProps, ComboboxProps, ComboboxSingleProps, 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, ScrollArea, ScrollAreaProps, Select, SelectData, SelectItem, SelectProps, SelectState, Switch, SwitchProps, Tab, TabProps, Tabs, TabsAlignmet, TabsProps, TextInput, TextInputProps, Toolbar, ToolbarProps, ToolbarSize, Transition, TransitionProps, UseInfiniteQueryOptions, UseInfiniteQueryResult, assignRef, clsx, getOpenValuesByPathname, mergeRefs, scrollToItem, useAccordionItem, useCollapse, useDebounce, useDisclosure, useElementSize, useInfiniteQuery, useLocalStorage, useMenu, useMenuItemValue, useOnClickOutside, usePrevious, useStep };