@true-tech-team/react-components 0.0.9 → 0.0.10

package/lib/components/display/Accordion/index.d.ts

@@ -2,5 +2,5 @@ export { Accordion, default } from './Accordion';
 export type { AccordionProps, AccordionIconPosition } from './Accordion';
 export { AccordionContainer } from './AccordionContainer';
 export type { AccordionContainerProps, AccordionControlsPosition } from './AccordionContainer';
-export { AccordionContext, useAccordionContext, useAccordionContextStrict } from './AccordionContext';
+export { AccordionContext, useAccordionContext, useAccordionContextStrict, } from './AccordionContext';
 export type { AccordionContextValue, AccordionMode } from './AccordionContext';

package/lib/components/display/Table/TableRow.d.ts

@@ -2,7 +2,7 @@ interface TableRowProps<T = Record<string, unknown>> {
     row: T;
     rowIndex: number;
 }
-export declare function TableRow<T extends Record<string, unknown>>({ row, rowIndex, }: TableRowProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function TableRow<T extends Record<string, unknown>>({ row, rowIndex }: TableRowProps<T>): import("react/jsx-runtime").JSX.Element;
 export declare namespace TableRow {
     var displayName: string;
 }

package/lib/components/display/Tabs/index.d.ts

@@ -6,6 +6,6 @@ export { Tab } from './Tab';
 export type { TabProps } from './Tab';
 export { TabPanel } from './TabPanel';
 export type { TabPanelProps } from './TabPanel';
-export { TabsContext, useTabsContext, useTabsContextStrict, } from './TabsContext';
+export { TabsContext, useTabsContext, useTabsContextStrict } from './TabsContext';
 export type { TabsContextValue, TabsVariant } from './TabsContext';
 export { default } from './Tabs';

package/lib/components/dnd/KanbanBoard/index.d.ts

@@ -1,4 +1,4 @@
-export { KanbanBoard, type KanbanBoardProps, type KanbanCardData, type KanbanColumnData } from './KanbanBoard';
+export { KanbanBoard, type KanbanBoardProps, type KanbanCardData, type KanbanColumnData, } from './KanbanBoard';
 export { KanbanColumn, type KanbanColumnProps } from './KanbanColumn';
 export { KanbanCard, type KanbanCardProps, type KanbanCardRenderProps } from './KanbanCard';
 export { KanbanBoardContext, useKanbanBoardContext, useKanbanBoardContextOptional, type KanbanBoardContextValue, type CardMoveEvent, } from './KanbanBoardContext';

package/lib/components/filters/index.d.ts

@@ -31,7 +31,7 @@
  * ```
  */
 export type { FilterType, FilterValue, FilterValueWithMeta, FilterOption, FilterOptionsLoader, FilterOptionsLoaderParams, FilterOptionsLoadResult, FilterDependency, FilterDependencyAction, FilterDefinition, FilterGroup, FilterState, FilterActions, FilterContextValue, FilterOptionsState, NumberRangeValue, DateRangeValue, SelectFilterConfig, MultiSelectFilterConfig, MultiSelectDisplayMode, TextFilterConfig, NumberFilterConfig, NumberRangeFilterConfig, NumberRangeDisplayMode, DateFilterConfig, DateRangeFilterConfig, DateRangePreset, RatingFilterConfig, ListSelectFilterConfig, FilterTypeConfig, FilterProviderProps, FilterFieldProps, FilterSectionProps, ActiveFiltersProps, FilterLayoutProps, FilterSidebarProps, FilterBarProps, FilterPopoverProps, FilterModalProps, FilterAccordionProps, } from './types';
-export { FilterContext, useFilterContext, useFilterContextStrict, } from './FilterContext';
+export { FilterContext, useFilterContext, useFilterContextStrict } from './FilterContext';
 export { useFilter, useFilterDependencies, useFilterOptions, getDependencyValues, clearOptionsCache, } from './hooks';
 export type { UseFilterOptions, UseFilterReturn, UseFilterDependenciesOptions, UseFilterDependenciesReturn, UseFilterOptionsOptions, UseFilterOptionsReturn, } from './hooks';
 export { FilterProvider } from './core/FilterProvider';
@@ -40,4 +40,4 @@ export { FilterSection } from './core/FilterSection';
 export { ActiveFilters } from './core/ActiveFilters';
 export { SelectFilter, MultiSelectFilter, CheckboxFilter, ToggleFilter, TextFilter, DateFilter, DateRangeFilter, NumberFilter, NumberRangeFilter, RatingFilter, ListSelectFilter, } from './fields';
 export type { SelectFilterProps, MultiSelectFilterProps, CheckboxFilterProps, ToggleFilterProps, TextFilterProps, DateFilterProps, DateRangeFilterProps, NumberFilterProps, NumberRangeFilterProps, RatingFilterProps, ListSelectFilterProps, } from './fields';
-export { FilterSidebar, FilterBar, FilterPopover, FilterModal, FilterAccordion, } from './layouts';
+export { FilterSidebar, FilterBar, FilterPopover, FilterModal, FilterAccordion } from './layouts';

package/lib/components/inputs/Input/index.d.ts

@@ -1,3 +1,3 @@
 export { Input } from './Input';
-export type { InputProps, ValidationResult, FormatMask, ValidationTiming, InputType } from './Input';
+export type { InputProps, ValidationResult, FormatMask, ValidationTiming, InputType, } from './Input';
 export { default } from './Input';

package/lib/components/overlays/Alert/AlertProvider.d.ts

@@ -34,7 +34,7 @@ export interface AlertProviderProps {
  * };
  * ```
  */
-export declare function AlertProvider({ children, defaultAlertProps, }: AlertProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function AlertProvider({ children, defaultAlertProps }: AlertProviderProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace AlertProvider {
     var displayName: string;
 }

package/lib/components/overlays/Alert/index.d.ts

@@ -5,7 +5,7 @@ export { Alert } from './Alert';
 export type { AlertProps } from './Alert';
 export { AlertProvider } from './AlertProvider';
 export type { AlertProviderProps } from './AlertProvider';
-export { AlertContext, useAlertContext, useAlertContextStrict, } from './AlertContext';
-export type { AlertContextValue, AlertQueueItem, } from './AlertContext';
-export { ALERT_PRESETS, getAlertPreset, } from './AlertPresets';
-export type { AlertVariant, AlertPreset, } from './AlertPresets';
+export { AlertContext, useAlertContext, useAlertContextStrict } from './AlertContext';
+export type { AlertContextValue, AlertQueueItem } from './AlertContext';
+export { ALERT_PRESETS, getAlertPreset } from './AlertPresets';
+export type { AlertVariant, AlertPreset } from './AlertPresets';

package/lib/components/overlays/Dialog/DialogProvider.d.ts

@@ -24,7 +24,7 @@ export interface DialogProviderProps {
  * </DialogProvider>
  * ```
  */
-export declare function DialogProvider({ children, defaultDialogProps, }: DialogProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function DialogProvider({ children, defaultDialogProps }: DialogProviderProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace DialogProvider {
     var displayName: string;
 }

package/lib/components/overlays/Dialog/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * Dialog component exports
  */
-export { Dialog, DialogHeader, DialogBody, DialogFooter, } from './Dialog';
+export { Dialog, DialogHeader, DialogBody, DialogFooter } from './Dialog';
 export type { DialogProps, DialogSize, DialogHeaderProps, DialogBodyProps, DialogFooterProps, } from './Dialog';
 export { DialogProvider } from './DialogProvider';
 export type { DialogProviderProps } from './DialogProvider';
-export { DialogContext, useDialogContext, useDialogContextStrict, } from './DialogContext';
-export type { DialogContextValue, DialogStackItem, } from './DialogContext';
+export { DialogContext, useDialogContext, useDialogContextStrict } from './DialogContext';
+export type { DialogContextValue, DialogStackItem } from './DialogContext';

package/lib/components/overlays/Toast/index.d.ts

@@ -2,10 +2,10 @@
  * Toast component exports
  */
 export { Toast } from './Toast';
-export type { ToastProps, ToastPosition, ToastVariant, ToastAnimationState, } from './Toast';
+export type { ToastProps, ToastPosition, ToastVariant, ToastAnimationState } from './Toast';
 export { ToastContainer } from './ToastContainer';
 export type { ToastContainerProps } from './ToastContainer';
 export { ToastProvider } from './ToastProvider';
 export type { ToastProviderProps } from './ToastProvider';
-export { ToastContext, useToastContext, useToastContextStrict, } from './ToastContext';
+export { ToastContext, useToastContext, useToastContextStrict } from './ToastContext';
 export type { ToastContextValue, ToastData, ToastInstance, PromiseToastOptions, } from './ToastContext';

package/lib/hooks/index.d.ts

@@ -5,7 +5,7 @@ export { useClickOutside } from './useClickOutside';
 export { useEscapeKey } from './useEscapeKey';
 export { useFocusTrap } from './useFocusTrap';
 export { usePopoverPosition } from './usePopoverPosition';
-export type { UsePopoverPositionOptions, UsePopoverPositionReturn, } from './usePopoverPosition';
+export type { UsePopoverPositionOptions, UsePopoverPositionReturn } from './usePopoverPosition';
 export { useHover } from './useHover';
 export type { UseHoverOptions, UseHoverReturn, HoverProps } from './useHover';
 export { useDebounce } from './useDebounce';
@@ -19,3 +19,18 @@ export { useAsyncToast } from './useAsyncToast';
 export type { UseAsyncToastReturn, AsyncToastConfig } from './useAsyncToast';
 export { useResizeObserver } from './useResizeObserver';
 export type { UseResizeObserverOptions, UseResizeObserverReturn } from './useResizeObserver';
+export { useUrlState, urlStateSerializers } from './useUrlState';
+export type { UseUrlStateOptions, UseUrlStateReturn, UrlStateSerializer } from './useUrlState';
+export { useIntersectionObserver } from './useIntersectionObserver';
+export type { UseIntersectionObserverOptions, UseIntersectionObserverReturn, } from './useIntersectionObserver';
+export { useLocalStorage } from './useLocalStorage';
+export type { UseLocalStorageOptions, UseLocalStorageReturn, LocalStorageSerializer, } from './useLocalStorage';
+export { useMediaQuery } from './useMediaQuery';
+export type { UseMediaQueryOptions, UseMediaQueryReturn } from './useMediaQuery';
+export { usePrevious } from './usePrevious';
+export { useClipboard } from './useClipboard';
+export type { UseClipboardOptions, UseClipboardReturn } from './useClipboard';
+export { useTimeout } from './useTimeout';
+export type { UseTimeoutOptions, UseTimeoutReturn } from './useTimeout';
+export { useInterval } from './useInterval';
+export type { UseIntervalOptions, UseIntervalReturn } from './useInterval';

package/lib/hooks/useClipboard/index.d.ts

@@ -0,0 +1,2 @@
+export { useClipboard, default } from './useClipboard';
+export type { UseClipboardOptions, UseClipboardReturn } from './useClipboard';

package/lib/hooks/useClipboard/useClipboard.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Options for clipboard hook
+ */
+export interface UseClipboardOptions {
+    /**
+     * Duration to show success state (ms)
+     * @default 2000
+     */
+    successDuration?: number;
+    /**
+     * Callback on successful copy
+     */
+    onSuccess?: (text: string) => void;
+    /**
+     * Callback on copy error
+     */
+    onError?: (error: Error) => void;
+}
+/**
+ * Return type for clipboard hook
+ */
+export interface UseClipboardReturn {
+    /**
+     * Copy text to clipboard
+     */
+    copy: (text: string) => Promise<boolean>;
+    /**
+     * Whether copy was recently successful
+     */
+    copied: boolean;
+    /**
+     * Error if copy failed
+     */
+    error: Error | null;
+    /**
+     * Reset copied state
+     */
+    reset: () => void;
+}
+/**
+ * Hook for copying text to clipboard with feedback
+ *
+ * @example
+ * ```tsx
+ * function CopyButton({ text }: { text: string }) {
+ *   const { copy, copied } = useClipboard();
+ *
+ *   return (
+ *     <Button onClick={() => copy(text)}>
+ *       {copied ? 'Copied!' : 'Copy'}
+ *     </Button>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With callbacks
+ * const { copy, copied, error } = useClipboard({
+ *   successDuration: 3000,
+ *   onSuccess: () => toast.success('Copied!'),
+ *   onError: (err) => toast.error(err.message),
+ * });
+ * ```
+ */
+export declare function useClipboard(options?: UseClipboardOptions): UseClipboardReturn;
+export default useClipboard;

package/lib/hooks/useIntersectionObserver/index.d.ts

@@ -0,0 +1,2 @@
+export { useIntersectionObserver, default } from './useIntersectionObserver';
+export type { UseIntersectionObserverOptions, UseIntersectionObserverReturn, } from './useIntersectionObserver';

package/lib/hooks/useIntersectionObserver/useIntersectionObserver.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Options for intersection observer hook
+ */
+export interface UseIntersectionObserverOptions {
+    /**
+     * Element that is used as the viewport for checking visibility
+     * @default null (browser viewport)
+     */
+    root?: Element | null;
+    /**
+     * Margin around the root element
+     * @default '0px'
+     */
+    rootMargin?: string;
+    /**
+     * Threshold(s) at which to trigger callback (0-1)
+     * @default 0
+     */
+    threshold?: number | number[];
+    /**
+     * Callback when intersection changes
+     */
+    onChange?: (entry: IntersectionObserverEntry) => void;
+    /**
+     * Whether to disconnect after first intersection
+     * Useful for lazy loading
+     * @default false
+     */
+    triggerOnce?: boolean;
+    /**
+     * Whether the observer is disabled
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Initial value for isIntersecting before observation starts
+     * @default false
+     */
+    initialIsIntersecting?: boolean;
+}
+/**
+ * Return type for intersection observer hook
+ */
+export interface UseIntersectionObserverReturn {
+    /**
+     * Ref callback to attach to observed element
+     */
+    ref: (node: Element | null) => void;
+    /**
+     * Whether element is currently intersecting
+     */
+    isIntersecting: boolean;
+    /**
+     * The full IntersectionObserverEntry (null before first observation)
+     */
+    entry: IntersectionObserverEntry | null;
+    /**
+     * The observed element
+     */
+    element: Element | null;
+}
+/**
+ * Hook that observes element intersection using IntersectionObserver
+ *
+ * @example
+ * ```tsx
+ * // Basic visibility detection
+ * const { ref, isIntersecting } = useIntersectionObserver();
+ *
+ * return (
+ *   <div ref={ref}>
+ *     {isIntersecting ? 'Visible!' : 'Not visible'}
+ *   </div>
+ * );
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Lazy loading with triggerOnce
+ * const { ref, isIntersecting } = useIntersectionObserver({
+ *   triggerOnce: true,
+ *   rootMargin: '100px',
+ * });
+ *
+ * return (
+ *   <div ref={ref}>
+ *     {isIntersecting ? <img src={src} /> : <Skeleton />}
+ *   </div>
+ * );
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Multiple thresholds for scroll animations
+ * const { ref, entry } = useIntersectionObserver({
+ *   threshold: [0, 0.25, 0.5, 0.75, 1],
+ * });
+ *
+ * const opacity = entry?.intersectionRatio ?? 0;
+ * ```
+ */
+export declare function useIntersectionObserver(options?: UseIntersectionObserverOptions): UseIntersectionObserverReturn;
+export default useIntersectionObserver;

package/lib/hooks/useInterval/index.d.ts

@@ -0,0 +1,2 @@
+export { useInterval, default } from './useInterval';
+export type { UseIntervalOptions, UseIntervalReturn } from './useInterval';

package/lib/hooks/useInterval/useInterval.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Options for interval hook
+ */
+export interface UseIntervalOptions {
+    /**
+     * Callback to execute on each interval
+     */
+    callback: () => void;
+    /**
+     * Interval in milliseconds (null to pause/disable)
+     */
+    delay: number | null;
+    /**
+     * Whether to run callback immediately on start
+     * @default false
+     */
+    immediate?: boolean;
+}
+/**
+ * Return type for interval hook
+ */
+export interface UseIntervalReturn {
+    /**
+     * Reset the interval (restart timing)
+     */
+    reset: () => void;
+    /**
+     * Clear the interval (stop)
+     */
+    clear: () => void;
+}
+/**
+ * Declarative interval hook with cleanup
+ *
+ * @example
+ * ```tsx
+ * // Auto-refresh data
+ * function Dashboard() {
+ *   const [data, setData] = useState(null);
+ *
+ *   useInterval({
+ *     callback: async () => {
+ *       const fresh = await fetchData();
+ *       setData(fresh);
+ *     },
+ *     delay: 30000, // Every 30 seconds
+ *     immediate: true, // Fetch immediately on mount
+ *   });
+ *
+ *   return <DataDisplay data={data} />;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Countdown timer
+ * function Countdown({ seconds }: { seconds: number }) {
+ *   const [remaining, setRemaining] = useState(seconds);
+ *
+ *   useInterval({
+ *     callback: () => setRemaining(r => r - 1),
+ *     delay: remaining > 0 ? 1000 : null, // Stop at 0
+ *   });
+ *
+ *   return <span>{remaining}s</span>;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Pausable animation
+ * const [isPaused, setIsPaused] = useState(false);
+ * const [frame, setFrame] = useState(0);
+ *
+ * const { reset } = useInterval({
+ *   callback: () => setFrame(f => f + 1),
+ *   delay: isPaused ? null : 16, // ~60fps when not paused
+ * });
+ * ```
+ */
+export declare function useInterval(options: UseIntervalOptions): UseIntervalReturn;
+export default useInterval;

package/lib/hooks/useLocalStorage/index.d.ts

@@ -0,0 +1,2 @@
+export { useLocalStorage, default } from './useLocalStorage';
+export type { UseLocalStorageOptions, UseLocalStorageReturn, LocalStorageSerializer, } from './useLocalStorage';

package/lib/hooks/useLocalStorage/useLocalStorage.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Serializer for localStorage values
+ */
+export interface LocalStorageSerializer<T> {
+    /**
+     * Serialize value to string
+     */
+    serialize: (value: T) => string;
+    /**
+     * Deserialize string to value
+     */
+    deserialize: (value: string) => T;
+}
+/**
+ * Options for localStorage hook
+ */
+export interface UseLocalStorageOptions<T> {
+    /**
+     * Custom serializer/deserializer
+     * @default JSON.stringify/parse
+     */
+    serializer?: LocalStorageSerializer<T>;
+    /**
+     * Sync value across browser tabs
+     * @default true
+     */
+    syncTabs?: boolean;
+}
+/**
+ * Return type for localStorage hook
+ */
+export type UseLocalStorageReturn<T> = [
+    /** Current value */
+    T,
+    /** Setter function (like useState) */
+    (value: T | ((prev: T) => T)) => void,
+    /** Remove from localStorage */
+    () => void
+];
+/**
+ * Hook that persists state to localStorage with cross-tab synchronization
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * const [theme, setTheme] = useLocalStorage('theme', 'light');
+ *
+ * // With object
+ * const [user, setUser, clearUser] = useLocalStorage<User | null>('user', null);
+ *
+ * // Disable cross-tab sync
+ * const [draft, setDraft] = useLocalStorage('draft', '', { syncTabs: false });
+ * ```
+ */
+export declare function useLocalStorage<T>(key: string, defaultValue: T, options?: UseLocalStorageOptions<T>): UseLocalStorageReturn<T>;
+export default useLocalStorage;

package/lib/hooks/useMediaQuery/index.d.ts

@@ -0,0 +1,2 @@
+export { useMediaQuery, default } from './useMediaQuery';
+export type { UseMediaQueryOptions, UseMediaQueryReturn } from './useMediaQuery';

package/lib/hooks/useMediaQuery/useMediaQuery.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Options for media query hook
+ */
+export interface UseMediaQueryOptions {
+    /**
+     * Default value for SSR or when media query can't be evaluated
+     * @default false
+     */
+    defaultValue?: boolean;
+    /**
+     * Callback when media query match changes
+     */
+    onChange?: (matches: boolean) => void;
+}
+/**
+ * Return type for media query hook
+ */
+export interface UseMediaQueryReturn {
+    /**
+     * Whether the media query currently matches
+     */
+    matches: boolean;
+}
+/**
+ * Hook that reacts to CSS media query changes
+ *
+ * @example
+ * ```tsx
+ * // Responsive breakpoints
+ * const { matches: isMobile } = useMediaQuery('(max-width: 768px)');
+ * const { matches: isTablet } = useMediaQuery('(min-width: 769px) and (max-width: 1024px)');
+ * const { matches: isDesktop } = useMediaQuery('(min-width: 1025px)');
+ *
+ * // User preferences
+ * const { matches: prefersDark } = useMediaQuery('(prefers-color-scheme: dark)');
+ * const { matches: prefersReducedMotion } = useMediaQuery('(prefers-reduced-motion: reduce)');
+ *
+ * // With callback
+ * const { matches } = useMediaQuery('(max-width: 768px)', {
+ *   onChange: (isMobile) => console.log('Mobile:', isMobile),
+ * });
+ * ```
+ */
+export declare function useMediaQuery(query: string, options?: UseMediaQueryOptions): UseMediaQueryReturn;
+export default useMediaQuery;

package/lib/hooks/usePopoverPosition/index.d.ts

@@ -1,2 +1,2 @@
 export { usePopoverPosition } from './usePopoverPosition';
-export type { UsePopoverPositionOptions, UsePopoverPositionReturn, } from './usePopoverPosition';
+export type { UsePopoverPositionOptions, UsePopoverPositionReturn } from './usePopoverPosition';

package/lib/hooks/usePrevious/index.d.ts

@@ -0,0 +1 @@
+export { usePrevious, default } from './usePrevious';

package/lib/hooks/usePrevious/usePrevious.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Hook that returns the previous value of a state or prop
+ *
+ * @example
+ * ```tsx
+ * function Counter({ count }: { count: number }) {
+ *   const prevCount = usePrevious(count);
+ *
+ *   return (
+ *     <div>
+ *       Current: {count}, Previous: {prevCount ?? 'N/A'}
+ *       {prevCount !== undefined && count > prevCount && ' (increased)'}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function UserProfile({ userId }: { userId: string }) {
+ *   const prevUserId = usePrevious(userId);
+ *
+ *   useEffect(() => {
+ *     if (prevUserId && prevUserId !== userId) {
+ *       // User changed, reset form or fetch new data
+ *       resetForm();
+ *     }
+ *   }, [userId, prevUserId]);
+ *
+ *   return <Profile userId={userId} />;
+ * }
+ * ```
+ */
+export declare function usePrevious<T>(value: T): T | undefined;
+export default usePrevious;

package/lib/hooks/useTimeout/index.d.ts

@@ -0,0 +1,2 @@
+export { useTimeout, default } from './useTimeout';
+export type { UseTimeoutOptions, UseTimeoutReturn } from './useTimeout';

package/lib/hooks/useTimeout/useTimeout.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Options for timeout hook
+ */
+export interface UseTimeoutOptions {
+    /**
+     * Callback to execute after delay
+     */
+    callback: () => void;
+    /**
+     * Delay in milliseconds (null to pause/disable)
+     */
+    delay: number | null;
+}
+/**
+ * Return type for timeout hook
+ */
+export interface UseTimeoutReturn {
+    /**
+     * Reset the timeout (restart from beginning)
+     */
+    reset: () => void;
+    /**
+     * Clear the timeout (stop without executing)
+     */
+    clear: () => void;
+}
+/**
+ * Declarative timeout hook with cleanup
+ *
+ * @example
+ * ```tsx
+ * // Auto-hide notification
+ * function Notification({ message, onClose }: Props) {
+ *   useTimeout({
+ *     callback: onClose,
+ *     delay: 5000,
+ *   });
+ *
+ *   return <div>{message}</div>;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Conditional timeout
+ * const [showHint, setShowHint] = useState(false);
+ *
+ * useTimeout({
+ *   callback: () => setShowHint(true),
+ *   delay: isNewUser ? 3000 : null, // null disables
+ * });
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With controls
+ * const { reset, clear } = useTimeout({
+ *   callback: () => setIdle(true),
+ *   delay: 30000,
+ * });
+ *
+ * // Reset on user activity
+ * useEffect(() => {
+ *   window.addEventListener('mousemove', reset);
+ *   return () => window.removeEventListener('mousemove', reset);
+ * }, [reset]);
+ * ```
+ */
+export declare function useTimeout(options: UseTimeoutOptions): UseTimeoutReturn;
+export default useTimeout;

package/lib/hooks/useUrlState/index.d.ts

@@ -0,0 +1,2 @@
+export { useUrlState, urlStateSerializers, default } from './useUrlState';
+export type { UseUrlStateOptions, UseUrlStateReturn, UrlStateSerializer } from './useUrlState';