@intlayer/design-system 9.4.3 → 9.5.0

package/dist/types/components/TextArea/ContentEditableTextArea.d.ts

@@ -13,7 +13,7 @@ type UseContentEditableOptions = {
   onChange?: (value: string) => void;
   disabled?: boolean;
 };
-declare const useContentEditable: ({ value, defaultValue, onChange, disabled }: UseContentEditableOptions) => {
+export declare const useContentEditable: ({ value, defaultValue, onChange, disabled }: UseContentEditableOptions) => {
   lines: string[];
   containerRef: RefObject<HTMLDivElement>;
   getText: () => string;
@@ -29,14 +29,14 @@ declare const useContentEditable: ({ value, defaultValue, onChange, disabled }:
   getCursorOffset: () => number;
   caretFromFlatOffset: (flat: number, targetLines: string[]) => CaretPosition;
 };
-type ContentEditableTextAreaHandle = {
+export type ContentEditableTextAreaHandle = {
   getContainer: () => HTMLDivElement | null;
   getText: () => string;
   focus: () => void;
   getCursorOffset: () => number;
   setCursorAtOffset: (offset: number) => void;
 };
-type ContentEditableTextAreaProps = Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> & {
+export type ContentEditableTextAreaProps = Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> & {
   value?: string;
   defaultValue?: string;
   onChange?: (value: string) => void;
@@ -53,7 +53,6 @@ type ContentEditableTextAreaProps = Omit<HTMLAttributes<HTMLDivElement>, 'onChan
   ref?: Ref<ContentEditableTextAreaHandle>;
   dir?: 'ltr' | 'rtl' | 'auto';
 } & Omit<VariantProps<typeof inputVariants>, 'validationStyleEnabled' | 'variant'>;
-declare const ContentEditableTextArea: FC<ContentEditableTextAreaProps>;
+export declare const ContentEditableTextArea: FC<ContentEditableTextAreaProps>;
 //#endregion
-export { ContentEditableTextArea, ContentEditableTextAreaHandle, ContentEditableTextAreaProps, useContentEditable };
 //# sourceMappingURL=ContentEditableTextArea.d.ts.map

package/dist/types/components/TextArea/ContentEditableTextArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContentEditableTextArea.d.ts","names":[],"sources":["../../../../src/components/TextArea/ContentEditableTextArea.tsx"],"mappings":";;;;;KAqBK;EACH;EACA;;KAGG;EACH;EACA;EACA,YAAY;EACZ;;cAoIW,uBAAkB,OAAA,cAAA,UAAA,YAK5B;;;;;EA0S6B,oBAAA,GAAA,WAAW;EApIf,gBAAA,GAAA,cAAc;EAyFlB,YAAA,GAAA,eAAe;EAsBb,cAAA,GAAA,eAAe;EAoGhB,aAAA,GAAA,UAAU;EAKN,iBAAA,GAAA,UAAU;EA3WR,wBAAA;EAuDE,mBAAA,KAAA;EA+DH;EAhBpB,sBAAA,cAAM,0BAEX;;KAgTO;EACV,oBAAoB;EACpB;EACA;EACA;EACA,oBAAoB;;KAGV,+BAA+B,KACzC,eAAe;EAGf;EACA;EACA,YAAY;EACZ;EACA;EACA;EACA;EACA;EACA;EACA,UAAU,kBAAkB;EAC5B;EACA;EACA;EACA,MAAM,IAAI;EACV;IACE,KACA,oBAAoB;cAOX,yBAAyB,GAAG"}
+{"version":3,"file":"ContentEditableTextArea.d.ts","names":[],"sources":["../../../../src/components/TextArea/ContentEditableTextArea.tsx"],"mappings":";;;;;KAqBK;EACH;EACA;;KAGG;EACH;EACA;EACA,YAAY;EACZ;;qBAoIW,uBAAkB,OAAA,cAAA,UAAA,YAK5B;;;;;EA0S6B,oBAAA,GAAA,WAAW;EApIf,gBAAA,GAAA,cAAc;EAyFlB,YAAA,GAAA,eAAe;EAsBb,cAAA,GAAA,eAAe;EAoGhB,aAAA,GAAA,UAAU;EAKN,iBAAA,GAAA,UAAU;EA3WR,wBAAA;EAuDE,mBAAA,KAAA;EA+DH;EAhBpB,sBAAA,cAAM,0BAEX;;YAgTO;EACV,oBAAoB;EACpB;EACA;EACA;EACA,oBAAoB;;YAGV,+BAA+B,KACzC,eAAe;EAGf;EACA;EACA,YAAY;EACZ;EACA;EACA;EACA;EACA;EACA;EACA,UAAU,kBAAkB;EAC5B;EACA;EACA;EACA,MAAM,IAAI;EACV;IACE,KACA,oBAAoB;qBAOX,yBAAyB,GAAG"}

package/dist/types/components/TextArea/TextArea.d.ts

@@ -33,7 +33,7 @@ import { VariantProps } from "class-variance-authority";
  * />
  * ```
  */
-type TextAreaProps = DetailedHTMLProps<DetailedHTMLProps<TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, HTMLTextAreaElement> & {
+export type TextAreaProps = DetailedHTMLProps<DetailedHTMLProps<TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, HTMLTextAreaElement> & {
   /** Enable validation styling based on the variant prop */
   validationStyleEnabled?: boolean;
 } & Omit<VariantProps<typeof inputVariants>, 'validationStyleEnabled' | 'variant'> & {
@@ -82,7 +82,6 @@ type TextAreaProps = DetailedHTMLProps<DetailedHTMLProps<TextareaHTMLAttributes<
  * />
  * ```
  */
-declare const TextArea: FC<TextAreaProps>;
+export declare const TextArea: FC<TextAreaProps>;
 //#endregion
-export { TextArea, TextAreaProps };
 //# sourceMappingURL=TextArea.d.ts.map

package/dist/types/components/TextArea/TextArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextArea.d.ts","names":[],"sources":["../../../../src/components/TextArea/TextArea.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmCY,gBAAgB,kBAC1B,kBACE,uBAAuB,sBACvB,sBAEF;;EAGA;IACE,KACA,oBAAoB;;EAIpB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6CD,UAAU,GAAG"}
+{"version":3,"file":"TextArea.d.ts","names":[],"sources":["../../../../src/components/TextArea/TextArea.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAmCY,gBAAgB,kBAC1B,kBACE,uBAAuB,sBACvB,sBAEF;;EAGA;IACE,KACA,oBAAoB;;EAIpB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6CD,UAAU,GAAG"}

package/dist/types/components/ThemeSwitcherDropDown/DesktopThemeSwitcher.d.ts

@@ -6,7 +6,6 @@ type DesktopThemeSwitcherProps = {
   theme: Modes;
   setTheme: (theme: Modes) => void;
 };
-declare const DesktopThemeSwitcher: FC<DesktopThemeSwitcherProps>;
+export declare const DesktopThemeSwitcher: FC<DesktopThemeSwitcherProps>;
 //#endregion
-export { DesktopThemeSwitcher };
 //# sourceMappingURL=DesktopThemeSwitcher.d.ts.map

package/dist/types/components/ThemeSwitcherDropDown/DesktopThemeSwitcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DesktopThemeSwitcher.d.ts","names":[],"sources":["../../../../src/components/ThemeSwitcherDropDown/DesktopThemeSwitcher.tsx"],"mappings":";;;KAuBK;;EAEH,OAAO;EACP,WAAW,OAAO;;cAGP,sBAAsB,GAAG"}
+{"version":3,"file":"DesktopThemeSwitcher.d.ts","names":[],"sources":["../../../../src/components/ThemeSwitcherDropDown/DesktopThemeSwitcher.tsx"],"mappings":";;;KAuBK;;EAEH,OAAO;EACP,WAAW,OAAO;;qBAGP,sBAAsB,GAAG"}

package/dist/types/components/ThemeSwitcherDropDown/MobileThemeSwitcher.d.ts

@@ -6,7 +6,6 @@ type MobileThemeSwitcherProps = {
   theme: Modes;
   setTheme: (theme: Modes) => void;
 };
-declare const MobileThemeSwitcher: FC<MobileThemeSwitcherProps>;
+export declare const MobileThemeSwitcher: FC<MobileThemeSwitcherProps>;
 //#endregion
-export { MobileThemeSwitcher };
 //# sourceMappingURL=MobileThemeSwitcher.d.ts.map

package/dist/types/components/ThemeSwitcherDropDown/MobileThemeSwitcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MobileThemeSwitcher.d.ts","names":[],"sources":["../../../../src/components/ThemeSwitcherDropDown/MobileThemeSwitcher.tsx"],"mappings":";;;KAOK;;EAEH,OAAO;EACP,WAAW,OAAO;;cAuBP,qBAAqB,GAAG"}
+{"version":3,"file":"MobileThemeSwitcher.d.ts","names":[],"sources":["../../../../src/components/ThemeSwitcherDropDown/MobileThemeSwitcher.tsx"],"mappings":";;;KAOK;;EAEH,OAAO;EACP,WAAW,OAAO;;qBAuBP,qBAAqB,GAAG"}

package/dist/types/components/ThemeSwitcherDropDown/types.d.ts

@@ -1,7 +1,6 @@
 import { Theme } from "../../providers/ThemeProvider.js";
 //#region src/components/ThemeSwitcherDropDown/types.d.ts
 /** Theme a switcher can select — kept as an alias for the provider's type. */
-type Modes = Theme;
+export type Modes = Theme;
 //#endregion
-export { Modes };
 //# sourceMappingURL=types.d.ts.map

package/dist/types/components/ThemeSwitcherDropDown/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../../src/components/ThemeSwitcherDropDown/types.ts"],"mappings":";;;KAGY,QAAQ"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../../src/components/ThemeSwitcherDropDown/types.ts"],"mappings":";;;YAGY,QAAQ"}

package/dist/types/components/Toaster/Toast.d.ts

@@ -2,8 +2,8 @@ import { ComponentProps, FC, ReactElement } from "react";
 import { VariantProps } from "class-variance-authority";
 import * as ToastPrimitives from "@radix-ui/react-toast";
 //#region src/components/Toaster/Toast.d.ts
-declare const ToastProvider: typeof ToastPrimitives;
-declare const ToastViewport: FC<ComponentProps<typeof ToastPrimitives.Viewport>>;
+export declare const ToastProvider: typeof ToastPrimitives;
+export declare const ToastViewport: FC<ComponentProps<typeof ToastPrimitives.Viewport>>;
 /**
  * Toast variant styles using class-variance-authority.
  *
@@ -22,7 +22,7 @@ declare const ToastViewport: FC<ComponentProps<typeof ToastPrimitives.Viewport>>
  * <Toast variant="default">Info message</Toast>
  * ```
  */
-declare const toastVariants: (props?: {
+export declare const toastVariants: (props?: {
   variant?: "default" | "error" | "success";
 } & import("class-variance-authority/types").ClassProp) => string;
 /**
@@ -64,7 +64,7 @@ declare const toastVariants: (props?: {
  * </Toast>
  * ```
  */
-declare const Toast: FC<ComponentProps<typeof ToastPrimitives.Root> & VariantProps<typeof toastVariants>>;
+export declare const Toast: FC<ComponentProps<typeof ToastPrimitives.Root> & VariantProps<typeof toastVariants>>;
 /**
  * ToastAction Component
  *
@@ -101,8 +101,8 @@ declare const Toast: FC<ComponentProps<typeof ToastPrimitives.Root> & VariantPro
  * </ToastAction>
  * ```
  */
-declare const ToastAction: FC<ComponentProps<typeof ToastPrimitives.Action>>;
-declare const ToastClose: FC<ComponentProps<typeof ToastPrimitives.Close>>;
+export declare const ToastAction: FC<ComponentProps<typeof ToastPrimitives.Action>>;
+export declare const ToastClose: FC<ComponentProps<typeof ToastPrimitives.Close>>;
 /**
  * ToastTitle Component
  *
@@ -121,7 +121,7 @@ declare const ToastClose: FC<ComponentProps<typeof ToastPrimitives.Close>>;
  * <ToastTitle>Settings Saved</ToastTitle>
  * ```
  */
-declare const ToastTitle: FC<ComponentProps<typeof ToastPrimitives.Title>>;
+export declare const ToastTitle: FC<ComponentProps<typeof ToastPrimitives.Title>>;
 /**
  * ToastDescription Component
  *
@@ -149,17 +149,16 @@ declare const ToastTitle: FC<ComponentProps<typeof ToastPrimitives.Title>>;
  * </ToastDescription>
  * ```
  */
-declare const ToastDescription: FC<ComponentProps<typeof ToastPrimitives.Description>>;
+export declare const ToastDescription: FC<ComponentProps<typeof ToastPrimitives.Description>>;
 /**
  * Props type for Toast component including all Radix UI Toast.Root props
  * and variant styling options.
  */
-type ToastProps = ComponentProps<typeof Toast>;
+export type ToastProps = ComponentProps<typeof Toast>;
 /**
  * Type for ToastAction elements used in toast configurations.
  * Ensures type safety when passing action elements to toast functions.
  */
-type ToastActionElement = ReactElement<typeof ToastAction>;
+export type ToastActionElement = ReactElement<typeof ToastAction>;
 //#endregion
-export { Toast, ToastAction, ToastActionElement, ToastClose, ToastDescription, ToastProps, ToastProvider, ToastTitle, ToastViewport, toastVariants };
 //# sourceMappingURL=Toast.d.ts.map

package/dist/types/components/Toaster/Toast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Toast.d.ts","names":[],"sources":["../../../../src/components/Toaster/Toast.tsx"],"mappings":";;;;cAQa,sBAAa;cAEb,eAAe,GAC1B,sBAAsB,gBAAgB;;;;;;;;;;;;;;;;;;;cA6B3B,gBAAa;;6CAkBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyCY,OAAO,GAClB,sBAAsB,gBAAgB,QACpC,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8CX,aAAa,GAAG,sBAAsB,gBAAgB;cAatD,YAAY,GAAG,sBAAsB,gBAAgB;;;;;;;;;;;;;;;;;;;cAiCrD,YAAY,GAAG,sBAAsB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCrD,kBAAkB,GAC7B,sBAAsB,gBAAgB;;;;;KAW5B,aAAa,sBAAsB;;;;;KAMnC,qBAAqB,oBAAoB"}
+{"version":3,"file":"Toast.d.ts","names":[],"sources":["../../../../src/components/Toaster/Toast.tsx"],"mappings":";;;;qBAQa,sBAAa;qBAEb,eAAe,GAC1B,sBAAsB,gBAAgB;;;;;;;;;;;;;;;;;;;qBA6B3B,gBAAa;;6CAkBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAyCY,OAAO,GAClB,sBAAsB,gBAAgB,QACpC,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8CX,aAAa,GAAG,sBAAsB,gBAAgB;qBAatD,YAAY,GAAG,sBAAsB,gBAAgB;;;;;;;;;;;;;;;;;;;qBAiCrD,YAAY,GAAG,sBAAsB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqCrD,kBAAkB,GAC7B,sBAAsB,gBAAgB;;;;;YAW5B,aAAa,sBAAsB;;;;;YAMnC,qBAAqB,oBAAoB"}

package/dist/types/components/Toaster/Toaster.d.ts

@@ -41,7 +41,6 @@
  *
  * @returns JSX element rendering the toast viewport and active toasts
  */
-declare const Toaster: () => import("react").JSX.Element;
+export declare const Toaster: () => import("react").JSX.Element;
 //#endregion
-export { Toaster };
 //# sourceMappingURL=Toaster.d.ts.map

package/dist/types/components/Toaster/Toaster.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Toaster.d.ts","names":[],"sources":["../../../../src/components/Toaster/Toaster.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsDa,+BAAO,IAAA"}
+{"version":3,"file":"Toaster.d.ts","names":[],"sources":["../../../../src/components/Toaster/Toaster.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsDa,+BAAO,IAAA"}

package/dist/types/components/Toaster/useToast.d.ts

@@ -95,7 +95,7 @@ type State = {
  * });
  * ```
  */
-declare const reducer: (state: State, action: Action) => State;
+export declare const reducer: (state: State, action: Action) => State;
 /**
  * Toast configuration type for creating new toasts.
  * Omits the 'id' field as it's automatically generated.
@@ -239,5 +239,5 @@ declare const useToast: () => {
   dismiss: (toastId?: string) => void;
 };
 //#endregion
-export { reducer, toast, useToast };
+export { toast, useToast };
 //# sourceMappingURL=useToast.d.ts.map

package/dist/types/components/Toaster/useToast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useToast.d.ts","names":[],"sources":["../../../../src/components/Toaster/useToast.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;KAkCK,eAAe;;EAElB;;EAEA,QAAQ;;EAER,cAAc;;EAEd,SAAS;;;;;;;;aASN;;EAEH;;EAEA;;EAEA;;EAEA;;KAUG;EAEC,MAAM,YAAY;EAClB,OAAO;;EAGP,MAAM,YAAY;EAClB,OAAO,QAAQ;;EAGf,MAAM,YAAY;EAClB,UAAU;;EAGV,MAAM,YAAY;EAClB,UAAU;;KAGX;EACH,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwDG,UAAO,OAAW,OAAK,QAAU,WAAS;;;;;KAsElD,QAAQ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoDZ,aAAK,SAAkB;;;EAGJ,SAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwGnB;EA7RI,QAAA;gBAAA;EA6Sc,UAAA"}
+{"version":3,"file":"useToast.d.ts","names":[],"sources":["../../../../src/components/Toaster/useToast.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;KAkCK,eAAe;;EAElB;;EAEA,QAAQ;;EAER,cAAc;;EAEd,SAAS;;;;;;;;aASN;;EAEH;;EAEA;;EAEA;;EAEA;;KAUG;EAEC,MAAM,YAAY;EAClB,OAAO;;EAGP,MAAM,YAAY;EAClB,OAAO,QAAQ;;EAGf,MAAM,YAAY;EAClB,UAAU;;EAGV,MAAM,YAAY;EAClB,UAAU;;KAGX;EACH,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwDG,UAAO,OAAW,OAAK,QAAU,WAAS;;;;;KAsElD,QAAQ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoDZ,aAAK,SAAkB;;;EAGJ,SAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwGnB;EA7RI,QAAA;gBAAA;EA6Sc,UAAA"}

package/dist/types/components/WithResizer/index.d.ts

@@ -158,7 +158,6 @@ type WithResizerProps = {
  * - Graceful degradation for older browsers
  * - Mobile-first touch interaction handling
  */
-declare const WithResizer: FC<PropsWithChildren<WithResizerProps>>;
+export declare const WithResizer: FC<PropsWithChildren<WithResizerProps>>;
 //#endregion
-export { WithResizer };
 //# sourceMappingURL=index.d.ts.map

package/dist/types/components/WithResizer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/components/WithResizer/index.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6CK;;EAEH;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgHW,aAAa,GAAG,kBAAkB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/components/WithResizer/index.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6CK;;EAEH;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgHW,aAAa,GAAG,kBAAkB"}

package/dist/types/hooks/index.d.ts

@@ -1,10 +1,11 @@
 import { ItemSelectorOrientation, useItemSelector } from "./useItemSelector.js";
-import { SizeType, calculateIsMobile, checkIsIOS, checkIsIphoneOrSafariDevice, checkIsMac, checkIsMobileScreen, checkIsMobileUserAgent, getBreakpointFromSize, useDevice } from "./useDevice.js";
+import { DeviceState, SizeType, calculateIsMobile, checkIsIOS, checkIsIphoneOrSafariDevice, checkIsMac, checkIsMobileScreen, checkIsMobileUserAgent, getBreakpointFromSize, useDevice } from "./useDevice.js";
 import { useGetElementById } from "./useGetElementById.js";
 import { useGetElementOrWindow } from "./useGetElementOrWindow.js";
 import { HorizontalSwipeConfig, HorizontalSwipeHook, useHorizontalSwipe } from "./useHorizontalSwipe.js";
 import { useIsMounted } from "./useIsMounted.js";
 import { useKeyboardDetector } from "./useKeyboardDetector.js";
+import { NO_HIGHLIGHTED_INDEX, UseListKeyboardNavigationProps, useListKeyboardNavigation } from "./useListKeyboardNavigation.js";
 import { usePersistedStore } from "./usePersistedStore.js";
 import { useScreenWidth } from "./useScreenWidth.js";
 import { useScrollBlockage } from "./useScrollBlockage/index.js";
@@ -12,4 +13,4 @@ import { useScrollDetection } from "./useScrollDetection.js";
 import { useScrollY } from "./useScrollY.js";
 import { useSearch } from "./useSearch.js";
 import { StickToBottomRefs, useStickToBottom } from "./useStickToBottom.js";
-export { HorizontalSwipeConfig, HorizontalSwipeHook, ItemSelectorOrientation, SizeType, StickToBottomRefs, calculateIsMobile, checkIsIOS, checkIsIphoneOrSafariDevice, checkIsMac, checkIsMobileScreen, checkIsMobileUserAgent, getBreakpointFromSize, useDevice, useGetElementById, useGetElementOrWindow, useHorizontalSwipe, useIsMounted, useItemSelector, useKeyboardDetector, usePersistedStore, useScreenWidth, useScrollBlockage, useScrollDetection, useScrollY, useSearch, useStickToBottom };
+export { DeviceState, HorizontalSwipeConfig, HorizontalSwipeHook, ItemSelectorOrientation, NO_HIGHLIGHTED_INDEX, SizeType, StickToBottomRefs, UseListKeyboardNavigationProps, calculateIsMobile, checkIsIOS, checkIsIphoneOrSafariDevice, checkIsMac, checkIsMobileScreen, checkIsMobileUserAgent, getBreakpointFromSize, useDevice, useGetElementById, useGetElementOrWindow, useHorizontalSwipe, useIsMounted, useItemSelector, useKeyboardDetector, useListKeyboardNavigation, usePersistedStore, useScreenWidth, useScrollBlockage, useScrollDetection, useScrollY, useSearch, useStickToBottom };

package/dist/types/hooks/useDevice.d.ts

@@ -1,26 +1,36 @@
 //#region src/hooks/useDevice.d.ts
-type SizeType = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
-declare const getBreakpointFromSize: (breakpoint: SizeType | number) => number;
-declare const checkIsMobileUserAgent: () => boolean | undefined;
-declare const checkIsIphoneOrSafariDevice: () => boolean | undefined;
-declare const checkIsIOS: () => boolean | undefined;
-declare const checkIsMac: () => boolean | undefined;
-declare const checkIsMobileScreen: (breakpoint: number) => boolean | undefined;
-type UseDeviceState = {
+export type SizeType = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+export declare const getBreakpointFromSize: (breakpoint: SizeType | number) => number;
+export declare const checkIsMobileUserAgent: () => boolean | undefined;
+export declare const checkIsIphoneOrSafariDevice: () => boolean | undefined;
+export declare const checkIsIOS: () => boolean | undefined;
+export declare const checkIsMac: () => boolean | undefined;
+export declare const checkIsMobileScreen: (breakpoint: number) => boolean | undefined;
+export type DeviceState = {
+  /** Is the screen width within a mobile breakpoint. */
   isMobileScreen: boolean | undefined;
+  /** Is the user agent indicative of a mobile device. */
   isMobileUserAgent: boolean | undefined;
+  /** Combines both checks to determine if the device is mobile. */
   isMobile: boolean | undefined;
+  /** Is the device running iOS (iPhone, iPad, iPod). */
   isIOS: boolean | undefined;
+  /** Is the device a Mac computer (macOS). */
   isMac: boolean | undefined;
 };
-declare const calculateIsMobile: (breakpoint?: SizeType | number) => {
-  isMobileScreen: boolean;
-  isMobileUserAgent: boolean;
-  isMobile: boolean;
-  isIOS: boolean;
-  isMac: boolean;
-};
-declare const useDevice: (breakpoint?: SizeType | number) => UseDeviceState;
+export declare const calculateIsMobile: (breakpoint?: SizeType | number) => DeviceState;
+/**
+ * Reports whether the current device is mobile, and which platform it runs.
+ *
+ * Server renders — including the prerendered HTML both apps ship — resolve to
+ * `undefined`, then settle to the real values in a single commit once the
+ * browser takes over.
+ *
+ * @example
+ * ```tsx
+ * const { isMobile } = useDevice('lg');
+ * ```
+ */
+export declare const useDevice: (breakpoint?: SizeType | number) => DeviceState;
 //#endregion
-export { SizeType, calculateIsMobile, checkIsIOS, checkIsIphoneOrSafariDevice, checkIsMac, checkIsMobileScreen, checkIsMobileUserAgent, getBreakpointFromSize, useDevice };
 //# sourceMappingURL=useDevice.d.ts.map

package/dist/types/hooks/useDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDevice.d.ts","names":[],"sources":["../../../src/hooks/useDevice.ts"],"mappings":";KAIY;cAEC,wBAAqB,YAAgB;cAmBrC;cAYA;cAgBA;cAWA;cAWA,sBAAmB;KAQ3B;EACH;EACA;EACA;EACA;EACA;;cAGW,oBAAiB,aAAgB;;;;;;;cAkBjC,YAAS,aAAgB,sBAAiB"}
+{"version":3,"file":"useDevice.d.ts","names":[],"sources":["../../../src/hooks/useDevice.ts"],"mappings":";YAIY;qBAYC,wBAAqB,YAAgB;qBAKrC;qBAYA;qBAgBA;qBAWA;qBAWA,sBAAmB;YAQpB;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA;;qBAGW,oBAAiB,aAChB,sBACX;;;;;;;;;;;;;qBA6IU,YAAS,aACR,sBACX"}

package/dist/types/hooks/useGetElementById.d.ts

@@ -1,5 +1,4 @@
 //#region src/hooks/useGetElementById.d.ts
-declare const useGetElementById: (id: string) => HTMLElement;
+export declare const useGetElementById: (id: string) => HTMLElement;
 //#endregion
-export { useGetElementById };
 //# sourceMappingURL=useGetElementById.d.ts.map

package/dist/types/hooks/useGetElementById.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useGetElementById.d.ts","names":[],"sources":["../../../src/hooks/useGetElementById.ts"],"mappings":";cAIa,oBAAiB,eAAc"}
+{"version":3,"file":"useGetElementById.d.ts","names":[],"sources":["../../../src/hooks/useGetElementById.ts"],"mappings":";qBAIa,oBAAiB,eAAc"}

package/dist/types/hooks/useGetElementOrWindow.d.ts

@@ -1,5 +1,4 @@
 //#region src/hooks/useGetElementOrWindow.d.ts
-declare const useGetElementOrWindow: (container?: HTMLElement) => HTMLElement;
+export declare const useGetElementOrWindow: (container?: HTMLElement) => HTMLElement;
 //#endregion
-export { useGetElementOrWindow };
 //# sourceMappingURL=useGetElementOrWindow.d.ts.map

package/dist/types/hooks/useGetElementOrWindow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useGetElementOrWindow.d.ts","names":[],"sources":["../../../src/hooks/useGetElementOrWindow.ts"],"mappings":";cAIa,wBAAqB,YAAgB,gBAAW"}
+{"version":3,"file":"useGetElementOrWindow.d.ts","names":[],"sources":["../../../src/hooks/useGetElementOrWindow.ts"],"mappings":";qBAIa,wBAAqB,YAAgB,gBAAW"}

package/dist/types/hooks/useHorizontalSwipe.d.ts

@@ -1,6 +1,6 @@
 import { CSSProperties, PointerEventHandler, RefObject } from "react";
 //#region src/hooks/useHorizontalSwipe.d.ts
-type HorizontalSwipeConfig = {
+export type HorizontalSwipeConfig = {
   onSwipeLeft?: () => void;
   onSwipeRight?: () => void;
   enable?: boolean;
@@ -10,7 +10,7 @@ type HorizontalSwipeConfig = {
   touchAction?: string;
   disableWhenSelectingText?: boolean;
 };
-type HorizontalSwipeHook = {
+export type HorizontalSwipeHook = {
   containerRef: RefObject<HTMLDivElement>;
   isDragging: boolean;
   dragDeltaPct: number;
@@ -23,7 +23,6 @@ type HorizontalSwipeHook = {
     style: CSSProperties;
   };
 };
-declare const useHorizontalSwipe: (config: HorizontalSwipeConfig) => HorizontalSwipeHook;
+export declare const useHorizontalSwipe: (config: HorizontalSwipeConfig) => HorizontalSwipeHook;
 //#endregion
-export { HorizontalSwipeConfig, HorizontalSwipeHook, useHorizontalSwipe };
 //# sourceMappingURL=useHorizontalSwipe.d.ts.map

package/dist/types/hooks/useHorizontalSwipe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useHorizontalSwipe.d.ts","names":[],"sources":["../../../src/hooks/useHorizontalSwipe.ts"],"mappings":";;KAYY;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;KAGU;EACV,cAAc,UAAU;EACxB;EACA;EACA;IACE,KAAK,UAAU;IACf,eAAe,oBAAoB;IACnC,eAAe,oBAAoB;IACnC,aAAa,oBAAoB;IACjC,iBAAiB,oBAAoB;IACrC,OAAO;;;cAIE,qBAAkB,QACrB,0BACP"}
+{"version":3,"file":"useHorizontalSwipe.d.ts","names":[],"sources":["../../../src/hooks/useHorizontalSwipe.ts"],"mappings":";;YAYY;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;YAGU;EACV,cAAc,UAAU;EACxB;EACA;EACA;IACE,KAAK,UAAU;IACf,eAAe,oBAAoB;IACnC,eAAe,oBAAoB;IACnC,aAAa,oBAAoB;IACjC,iBAAiB,oBAAoB;IACrC,OAAO;;;qBAIE,qBAAkB,QACrB,0BACP"}

package/dist/types/hooks/useIsMounted.d.ts

@@ -1,5 +1,4 @@
 //#region src/hooks/useIsMounted.d.ts
-declare const useIsMounted: () => boolean;
+export declare const useIsMounted: () => boolean;
 //#endregion
-export { useIsMounted };
 //# sourceMappingURL=useIsMounted.d.ts.map

package/dist/types/hooks/useIsMounted.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIsMounted.d.ts","names":[],"sources":["../../../src/hooks/useIsMounted.ts"],"mappings":";cAIa"}
+{"version":3,"file":"useIsMounted.d.ts","names":[],"sources":["../../../src/hooks/useIsMounted.ts"],"mappings":";qBAIa"}

package/dist/types/hooks/useItemSelector.d.ts

@@ -1,6 +1,6 @@
 import { RefObject } from "react";
 //#region src/hooks/useItemSelector.d.ts
-type ItemSelectorOrientation = 'horizontal' | 'vertical';
+export type ItemSelectorOrientation = 'horizontal' | 'vertical';
 type HorizontalStyleState = {
   left: number;
   width: number;
@@ -17,7 +17,7 @@ type Options = {
   isHoverable?: boolean;
   orientation?: ItemSelectorOrientation;
 };
-declare const useItemSelector: (optionsRefs: RefObject<HTMLElement[]>, { selector, isHoverable, orientation }?: Options) => {
+export declare const useItemSelector: (optionsRefs: RefObject<HTMLElement[]>, { selector, isHoverable, orientation }?: Options) => {
   choiceIndicatorPosition: StyleState;
   /** Measures immediately. Prefer `scheduleMeasurement`, which does not force a reflow. */
   calculatePosition: () => void;
@@ -25,5 +25,4 @@ declare const useItemSelector: (optionsRefs: RefObject<HTMLElement[]>, { selecto
   orientation: ItemSelectorOrientation;
 };
 //#endregion
-export { ItemSelectorOrientation, useItemSelector };
 //# sourceMappingURL=useItemSelector.d.ts.map

package/dist/types/hooks/useItemSelector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useItemSelector.d.ts","names":[],"sources":["../../../src/hooks/useItemSelector.ts"],"mappings":";;KAWY;KAEP;EACH;EACA;EACA;;KAGG;EACH;EACA;EACA;;KAGG,aAAa,uBAAuB;KAWpC;EACH,YAAY,QAAQ,aAAa;EACjC;EACA,cAAc;;cAGH,kBAAe,aACb,UAAU,kBAAc,UAAA,aAAA,gBAKlC"}
+{"version":3,"file":"useItemSelector.d.ts","names":[],"sources":["../../../src/hooks/useItemSelector.ts"],"mappings":";;YAWY;KAEP;EACH;EACA;EACA;;KAGG;EACH;EACA;EACA;;KAGG,aAAa,uBAAuB;KAWpC;EACH,YAAY,QAAQ,aAAa;EACjC;EACA,cAAc;;qBAGH,kBAAe,aACb,UAAU,kBAAc,UAAA,aAAA,gBAKlC"}

package/dist/types/hooks/useKeyboardDetector.d.ts

@@ -1,8 +1,7 @@
 //#region src/hooks/useKeyboardDetector.d.ts
-declare const useKeyboardDetector: () => {
+export declare const useKeyboardDetector: () => {
   windowHeight: number;
   isKeyboardOpen: boolean;
 };
 //#endregion
-export { useKeyboardDetector };
 //# sourceMappingURL=useKeyboardDetector.d.ts.map

package/dist/types/hooks/useKeyboardDetector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useKeyboardDetector.d.ts","names":[],"sources":["../../../src/hooks/useKeyboardDetector.ts"],"mappings":";cAIa;EAAA;EAAA"}
+{"version":3,"file":"useKeyboardDetector.d.ts","names":[],"sources":["../../../src/hooks/useKeyboardDetector.ts"],"mappings":";qBAIa;EAAA;EAAA"}

package/dist/types/hooks/useListKeyboardNavigation.d.ts

@@ -0,0 +1,31 @@
+import { KeyboardEvent } from "react";
+//#region src/hooks/useListKeyboardNavigation.d.ts
+/** No row is highlighted until the user presses an arrow key. */
+export declare const NO_HIGHLIGHTED_INDEX = -1;
+export type UseListKeyboardNavigationProps<TElement extends HTMLElement> = {
+  /** Number of navigable rows. The highlight wraps around it. */
+  itemCount: number;
+  /**
+   * Activation of the highlighted row on `Enter`. Defaults to clicking the
+   * first link or button the row contains, which reuses whatever navigation
+   * that element already implements.
+   */
+  onActivate?: (index: number, element: TElement) => void;
+};
+/**
+ * Arrow-key navigation over a list whose focus stays elsewhere — typically a
+ * search input filtering the list below it, where moving the DOM focus onto
+ * each row would stop the user from typing.
+ *
+ * The caller renders the highlight itself from `highlightedIndex`, registers
+ * each row through `setItemElement`, and forwards key events of the focused
+ * element to `handleKeyDown`.
+ */
+export declare const useListKeyboardNavigation: <TElement extends HTMLElement>({ itemCount, onActivate }: UseListKeyboardNavigationProps<TElement>) => {
+  highlightedIndex: number;
+  resetHighlight: () => void;
+  setItemElement: (index: number, element: TElement | null) => void;
+  handleKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
+};
+//#endregion
+//# sourceMappingURL=useListKeyboardNavigation.d.ts.map

package/dist/types/hooks/useListKeyboardNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useListKeyboardNavigation.d.ts","names":[],"sources":["../../../src/hooks/useListKeyboardNavigation.ts"],"mappings":";;;qBAWa;YAED,+BAA+B,iBAAiB;;EAE1D;;;;;;EAMA,cAAc,eAAe,SAAS;;;;;;;;;;;qBAwB3B,4BAA6B,iBAAiB,eAAW,WAAA,cAGnE,+BAA+B;;;EActB,iBAAA,eAAM,SAAW;EAOjB,gBAAA,OAAA,cAAc"}

package/dist/types/hooks/usePersistedStore.d.ts

@@ -1,6 +1,5 @@
 import { Dispatch, SetStateAction } from "react";
 //#region src/hooks/usePersistedStore.d.ts
-declare const usePersistedStore: <S>(key: string, initialState?: S | (() => S)) => [S, Dispatch<SetStateAction<S>>, () => void, () => void];
+export declare const usePersistedStore: <S>(key: string, initialState?: S | (() => S)) => [S, Dispatch<SetStateAction<S>>, () => void, () => void];
 //#endregion
-export { usePersistedStore };
 //# sourceMappingURL=usePersistedStore.d.ts.map

package/dist/types/hooks/usePersistedStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePersistedStore.d.ts","names":[],"sources":["../../../src/hooks/usePersistedStore.ts"],"mappings":";;cAWa,oBAAqB,GAAC,aACtB,eACI,WAAW,QACxB,GAAG,SAAS,eAAe"}
+{"version":3,"file":"usePersistedStore.d.ts","names":[],"sources":["../../../src/hooks/usePersistedStore.ts"],"mappings":";;qBAWa,oBAAqB,GAAC,aACtB,eACI,WAAW,QACxB,GAAG,SAAS,eAAe"}

package/dist/types/hooks/useScreenWidth.d.ts

@@ -1,7 +1,6 @@
 //#region src/hooks/useScreenWidth.d.ts
-declare const useScreenWidth: () => {
+export declare const useScreenWidth: () => {
   screenWidth: number;
 };
 //#endregion
-export { useScreenWidth };
 //# sourceMappingURL=useScreenWidth.d.ts.map

package/dist/types/hooks/useScreenWidth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useScreenWidth.d.ts","names":[],"sources":["../../../src/hooks/useScreenWidth.ts"],"mappings":";cAIa;EAAA"}
+{"version":3,"file":"useScreenWidth.d.ts","names":[],"sources":["../../../src/hooks/useScreenWidth.ts"],"mappings":";qBAIa;EAAA"}

package/dist/types/hooks/useScrollBlockage/index.d.ts

@@ -9,9 +9,8 @@ type useScrollBlockageProps = {
   key: string;
   element?: HTMLElement;
 };
-declare const useScrollBlockage: (props?: useScrollBlockageProps | useScrollBlockagePropsReadOnly) => {
+export declare const useScrollBlockage: (props?: useScrollBlockageProps | useScrollBlockagePropsReadOnly) => {
   isScrollBlocked: boolean;
 };
 //#endregion
-export { useScrollBlockage };
 //# sourceMappingURL=index.d.ts.map

package/dist/types/hooks/useScrollBlockage/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/hooks/useScrollBlockage/index.tsx"],"mappings":";KAOK;EACH;EACA;EACA,UAAU;;KAGP;EACH;EACA;EACA,UAAU;;cAKC,oBAAiB,QACpB,yBAAyB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/hooks/useScrollBlockage/index.tsx"],"mappings":";KAOK;EACH;EACA;EACA,UAAU;;KAGP;EACH;EACA;EACA,UAAU;;qBAKC,oBAAiB,QACpB,yBAAyB"}

package/dist/types/hooks/useScrollBlockage/useScrollBlockageStore.d.ts

@@ -13,13 +13,12 @@ declare class ScrollBlockageObservable {
   isElementScrollBlocked: (element: HTMLElement) => boolean;
   private emit;
 }
-declare const scrollBlockageManager: ScrollBlockageObservable;
-declare const useScrollBlockageStore: () => {
+export declare const scrollBlockageManager: ScrollBlockageObservable;
+export declare const useScrollBlockageStore: () => {
   scrollBlockers: Blocker[];
   addBlockage: (blockerName: string, element: HTMLElement) => void;
   removeBlockage: (blockerName: string, element: HTMLElement) => void;
   isElementScrollBlocked: (element: HTMLElement) => boolean;
 };
 //#endregion
-export { scrollBlockageManager, useScrollBlockageStore };
 //# sourceMappingURL=useScrollBlockageStore.d.ts.map

package/dist/types/hooks/useScrollBlockage/useScrollBlockageStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useScrollBlockageStore.d.ts","names":[],"sources":["../../../../src/hooks/useScrollBlockage/useScrollBlockageStore.ts"],"mappings":";KAEK;EACH,SAAS;EACT;;cAGI;UACI;UACA;EAER,YAAS;EAOT,mBAAW;EAIX,cAAW,qBAAuB,SAAW;EAwB7C,iBAAc,qBAAuB,SAAW;EA0BhD,yBAAsB,SAAa;UAI3B;;cAOG,uBAAqB;cAIrB;;EAjEiB,cAAA,qBAAM,SAAW;EAwBd,iBAAA,qBAAM,SAAW;EA0Bb,yBAAA,SAAA"}
+{"version":3,"file":"useScrollBlockageStore.d.ts","names":[],"sources":["../../../../src/hooks/useScrollBlockage/useScrollBlockageStore.ts"],"mappings":";KAEK;EACH,SAAS;EACT;;cAGI;UACI;UACA;EAER,YAAS;EAOT,mBAAW;EAIX,cAAW,qBAAuB,SAAW;EAwB7C,iBAAc,qBAAuB,SAAW;EA0BhD,yBAAsB,SAAa;UAI3B;;qBAOG,uBAAqB;qBAIrB;;EAjEiB,cAAA,qBAAM,SAAW;EAwBd,iBAAA,qBAAM,SAAW;EA0Bb,yBAAA,SAAA"}

package/dist/types/hooks/useScrollDetection.d.ts

@@ -7,10 +7,9 @@ type useScrollDetectionProps = {
   onScrollUp?: (e: WheelEvent) => void;
   element?: HTMLElement;
 };
-declare const useScrollDetection: (props?: useScrollDetectionProps) => {
+export declare const useScrollDetection: (props?: useScrollDetectionProps) => {
   isScrolled: boolean;
   isScrollable: boolean;
 };
 //#endregion
-export { useScrollDetection };
 //# sourceMappingURL=useScrollDetection.d.ts.map

package/dist/types/hooks/useScrollDetection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useScrollDetection.d.ts","names":[],"sources":["../../../src/hooks/useScrollDetection.ts"],"mappings":";KAQK;EACH;EACA;EACA;EACA,gBAAgB,GAAG;EACnB,cAAc,GAAG;EACjB,UAAU;;cAGC,qBAAkB,QAAY"}
+{"version":3,"file":"useScrollDetection.d.ts","names":[],"sources":["../../../src/hooks/useScrollDetection.ts"],"mappings":";KAQK;EACH;EACA;EACA;EACA,gBAAgB,GAAG;EACnB,cAAc,GAAG;EACjB,UAAU;;qBAGC,qBAAkB,QAAY"}

package/dist/types/hooks/useScrollY.d.ts

@@ -17,7 +17,6 @@ type UseScrollYResult = {
  * @example
  * const { scrollPercentage } = useScrollY({ element: contentElement });
  */
-declare const useScrollY: (props?: UseScrollYProps) => UseScrollYResult;
+export declare const useScrollY: (props?: UseScrollYProps) => UseScrollYResult;
 //#endregion
-export { useScrollY };
 //# sourceMappingURL=useScrollY.d.ts.map

package/dist/types/hooks/useScrollY.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useScrollY.d.ts","names":[],"sources":["../../../src/hooks/useScrollY.ts"],"mappings":";KAOK;EACH,UAAU;;KAGP;EACH;EACA;EACA;;;;;;;;;;;;cAmBW,aAAU,QAAY,oBAAkB"}
+{"version":3,"file":"useScrollY.d.ts","names":[],"sources":["../../../src/hooks/useScrollY.ts"],"mappings":";KAOK;EACH,UAAU;;KAGP;EACH;EACA;EACA;;;;;;;;;;;;qBAmBW,aAAU,QAAY,oBAAkB"}

package/dist/types/hooks/useSearch.d.ts

@@ -7,11 +7,10 @@ type UseSearchProps = {
   onSearch?: (value: string) => void;
   onClear?: () => void;
 };
-declare const useSearch: (options?: UseSearchProps) => {
+export declare const useSearch: (options?: UseSearchProps) => {
   setSearch: (value: string) => void;
   search: string;
   hasMinChars: boolean;
 };
 //#endregion
-export { useSearch };
 //# sourceMappingURL=useSearch.d.ts.map

package/dist/types/hooks/useSearch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSearch.d.ts","names":[],"sources":["../../../src/hooks/useSearch.ts"],"mappings":";KAIK;EACH;EACA;EACA;EACA;EACA,YAAY;EACZ;;cAGW,YAAS,UAAc;EAoBR,YAAA"}
+{"version":3,"file":"useSearch.d.ts","names":[],"sources":["../../../src/hooks/useSearch.ts"],"mappings":";KAIK;EACH;EACA;EACA;EACA;EACA,YAAY;EACZ;;qBAGW,YAAS,UAAc;EAoBR,YAAA"}