@exyconn/common 1.0.0 → 2.0.0

package/dist/index-BLltj-zN.d.ts

@@ -0,0 +1,1236 @@
+import { ApiResponse, HttpClientOptions, PaginatedResponse, createHttpClient, isForbidden, isNotFound, isServerError, isStatusError, isSuccess, isUnauthorized, parseError, parseFullResponse, parseResponse, withAbortSignal, withFormData, withTimeout } from './client/http/index.js';
+import { ClientLogger, ClientLoggerConfig, LogLevel, clientLogger, createClientLogger } from './client/logger/index.js';
+import { ApiUrlBuilder, ApiUrlConfig, EventEmitter, NpmRegistryResponse, PackageCheckResult, PackageJson, PackageVersion, addDays, appEvents, camelToKebab, capitalize, capitalizeWords, checkPackage, copyToClipboard, createApiEndpoints, createApiUrlBuilder, createEmptyPaginationMeta, createErrorResponse, createEventEmitter, createSuccessResponse, endOfDay, formatDate, formatDateForInput, formatDateTime, formatDateTimeForInput, formatPackageCheckResult, formatRelativeTime, generateNcuCommand, getErrorMessage, getNextPage, getPrevPage, getResponseData, hasData, hasMorePages, isClipboardAvailable, isErrorResponse, isFuture, isPast, isSuccessResponse, isToday, kebabToCamel, packageCheck, readFromClipboard, slugify, slugifyUnique, startOfDay, truncate, truncateWords, unslugify } from './client/utils/index.js';
+import { RefObject } from 'react';
+
+interface UseToggleReturn {
+    /** Current boolean value */
+    value: boolean;
+    /** Toggle the value */
+    toggle: () => void;
+    /** Set to true */
+    setTrue: () => void;
+    /** Set to false */
+    setFalse: () => void;
+    /** Set to specific value */
+    setValue: (value: boolean) => void;
+}
+/**
+ * Hook to manage boolean state with toggle functionality
+ * @param initialValue - Initial boolean value (default: false)
+ */
+declare function useToggle(initialValue?: boolean): UseToggleReturn;
+
+interface UseCounterOptions {
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Step value for increment/decrement */
+    step?: number;
+}
+interface UseCounterReturn {
+    /** Current count value */
+    count: number;
+    /** Increment by step */
+    increment: () => void;
+    /** Decrement by step */
+    decrement: () => void;
+    /** Set to specific value */
+    set: (value: number) => void;
+    /** Reset to initial value */
+    reset: () => void;
+}
+/**
+ * Hook to manage numeric counter with min/max bounds
+ * @param initialValue - Initial counter value (default: 0)
+ * @param options - Configuration options
+ */
+declare function useCounter(initialValue?: number, options?: UseCounterOptions): UseCounterReturn;
+
+/**
+ * Hook that returns a default value when state is null or undefined
+ * @param initialValue - Initial value (can be null/undefined)
+ * @param defaultValue - Default value to use when state is null/undefined
+ */
+declare function useDefault<T>(initialValue: T | null | undefined, defaultValue: T): [T, (value: T | null | undefined) => void];
+
+/**
+ * Hook to get the previous value of a state or prop
+ * @param value - Current value to track
+ * @param initialValue - Optional initial previous value
+ */
+declare function usePrevious<T>(value: T, initialValue?: T): T | undefined;
+
+type ObjectStateUpdate<T> = Partial<T> | ((prevState: T) => Partial<T>);
+interface UseObjectStateReturn<T extends object> {
+    /** Current state object */
+    state: T;
+    /** Update state with partial object (merges with existing) */
+    setState: (update: ObjectStateUpdate<T>) => void;
+    /** Reset to initial state */
+    resetState: () => void;
+    /** Set a single property */
+    setProperty: <K extends keyof T>(key: K, value: T[K]) => void;
+    /** Remove a property (sets to undefined) */
+    removeProperty: <K extends keyof T>(key: K) => void;
+}
+/**
+ * Hook to manage object state with partial updates
+ * @param initialState - Initial state object
+ */
+declare function useObjectState<T extends object>(initialState: T): UseObjectStateReturn<T>;
+
+interface UseHistoryStateReturn<T> {
+    /** Current state value */
+    state: T;
+    /** Set new state (adds to history) */
+    setState: (value: T | ((prev: T) => T)) => void;
+    /** Undo to previous state */
+    undo: () => void;
+    /** Redo to next state */
+    redo: () => void;
+    /** Clear all history and reset to current or initial */
+    clear: (value?: T) => void;
+    /** Can undo? */
+    canUndo: boolean;
+    /** Can redo? */
+    canRedo: boolean;
+    /** Full history array */
+    history: T[];
+    /** Current position in history */
+    pointer: number;
+    /** Go to specific position in history */
+    go: (index: number) => void;
+}
+interface UseHistoryStateOptions {
+    /** Maximum history length (default: 100) */
+    maxLength?: number;
+}
+/**
+ * Hook to manage state with undo/redo functionality
+ * @param initialValue - Initial state value
+ * @param options - Configuration options
+ */
+declare function useHistoryState<T>(initialValue: T, options?: UseHistoryStateOptions): UseHistoryStateReturn<T>;
+
+interface UseQueueReturn<T> {
+    /** Current queue items */
+    queue: T[];
+    /** Add item to end of queue */
+    enqueue: (item: T) => void;
+    /** Add multiple items to end of queue */
+    enqueueAll: (items: T[]) => void;
+    /** Remove and return first item */
+    dequeue: () => T | undefined;
+    /** Peek at first item without removing */
+    peek: () => T | undefined;
+    /** Clear the queue */
+    clear: () => void;
+    /** Queue size */
+    size: number;
+    /** Is queue empty? */
+    isEmpty: boolean;
+    /** First item in queue */
+    first: T | undefined;
+    /** Last item in queue */
+    last: T | undefined;
+}
+/**
+ * Hook to manage a FIFO queue
+ * @param initialValue - Initial queue items (default: [])
+ */
+declare function useQueue<T>(initialValue?: T[]): UseQueueReturn<T>;
+
+interface UseListReturn<T> {
+    /** Current list items */
+    list: T[];
+    /** Set entire list */
+    set: (newList: T[]) => void;
+    /** Add item to end */
+    push: (item: T) => void;
+    /** Add item to beginning */
+    unshift: (item: T) => void;
+    /** Remove item at index */
+    removeAt: (index: number) => void;
+    /** Remove first matching item */
+    remove: (item: T) => void;
+    /** Remove items matching predicate */
+    removeWhere: (predicate: (item: T) => boolean) => void;
+    /** Update item at index */
+    updateAt: (index: number, item: T) => void;
+    /** Update item at index with function */
+    updateWhere: (predicate: (item: T) => boolean, updater: (item: T) => T) => void;
+    /** Insert item at index */
+    insertAt: (index: number, item: T) => void;
+    /** Move item from one index to another */
+    move: (fromIndex: number, toIndex: number) => void;
+    /** Clear the list */
+    clear: () => void;
+    /** Reset to initial value */
+    reset: () => void;
+    /** Filter items */
+    filter: (predicate: (item: T) => boolean) => void;
+    /** Sort items */
+    sort: (compareFn?: (a: T, b: T) => number) => void;
+    /** Reverse items */
+    reverse: () => void;
+    /** List size */
+    size: number;
+    /** Is list empty? */
+    isEmpty: boolean;
+    /** First item */
+    first: T | undefined;
+    /** Last item */
+    last: T | undefined;
+}
+/**
+ * Hook to manage array/list with utility methods
+ * @param initialValue - Initial list items (default: [])
+ */
+declare function useList<T>(initialValue?: T[]): UseListReturn<T>;
+
+interface UseMapReturn<K, V> {
+    /** Current map */
+    map: Map<K, V>;
+    /** Get value by key */
+    get: (key: K) => V | undefined;
+    /** Set key-value pair */
+    set: (key: K, value: V) => void;
+    /** Set multiple entries */
+    setAll: (entries: Iterable<[K, V]>) => void;
+    /** Check if key exists */
+    has: (key: K) => boolean;
+    /** Delete by key */
+    remove: (key: K) => void;
+    /** Delete multiple keys */
+    removeAll: (keys: K[]) => void;
+    /** Clear the map */
+    clear: () => void;
+    /** Reset to initial value */
+    reset: () => void;
+    /** Map size */
+    size: number;
+    /** All keys */
+    keys: K[];
+    /** All values */
+    values: V[];
+    /** All entries */
+    entries: [K, V][];
+    /** Is map empty? */
+    isEmpty: boolean;
+}
+/**
+ * Hook to manage Map state with utility methods
+ * @param initialValue - Initial entries (default: [])
+ */
+declare function useMap<K, V>(initialValue?: Iterable<[K, V]>): UseMapReturn<K, V>;
+
+interface UseSetReturn<T> {
+    /** Current set */
+    set: Set<T>;
+    /** Add item to set */
+    add: (item: T) => void;
+    /** Add multiple items */
+    addAll: (items: Iterable<T>) => void;
+    /** Check if item exists */
+    has: (item: T) => boolean;
+    /** Remove item from set */
+    remove: (item: T) => void;
+    /** Remove multiple items */
+    removeAll: (items: Iterable<T>) => void;
+    /** Toggle item (add if not exists, remove if exists) */
+    toggle: (item: T) => void;
+    /** Clear the set */
+    clear: () => void;
+    /** Reset to initial value */
+    reset: () => void;
+    /** Set size */
+    size: number;
+    /** All values as array */
+    values: T[];
+    /** Is set empty? */
+    isEmpty: boolean;
+}
+/**
+ * Hook to manage Set state with utility methods
+ * @param initialValue - Initial items (default: [])
+ */
+declare function useSet<T>(initialValue?: Iterable<T>): UseSetReturn<T>;
+
+/**
+ * Debounce a value with configurable delay
+ * @param value - Value to debounce
+ * @param delay - Delay in milliseconds (default: 500)
+ */
+declare function useDebounce<T>(value: T, delay?: number): T;
+
+/**
+ * Throttle a value with configurable interval
+ * @param value - Value to throttle
+ * @param interval - Minimum interval between updates in milliseconds (default: 500)
+ */
+declare function useThrottle<T>(value: T, interval?: number): T;
+
+interface UseTimeoutReturn {
+    /** Reset the timeout */
+    reset: () => void;
+    /** Clear/cancel the timeout */
+    clear: () => void;
+}
+/**
+ * Hook to manage setTimeout declaratively
+ * @param callback - Function to call after timeout
+ * @param delay - Delay in milliseconds (null to disable)
+ */
+declare function useTimeout(callback: () => void, delay: number | null): UseTimeoutReturn;
+
+/**
+ * Run a callback on an interval
+ * @param callback - Function to call on each interval
+ * @param delay - Interval delay in ms (null to pause)
+ */
+declare function useInterval(callback: () => void, delay: number | null): void;
+
+/**
+ * Hook to run interval conditionally
+ * @param callback - Function to call on each interval
+ * @param delay - Interval delay in milliseconds
+ * @param when - Condition to run the interval
+ * @param immediate - Run callback immediately when condition becomes true
+ */
+declare function useIntervalWhen(callback: () => void, delay: number, when: boolean, immediate?: boolean): void;
+
+/**
+ * Hook to run callback at random intervals
+ * @param callback - Function to call on each interval
+ * @param minDelay - Minimum delay in milliseconds
+ * @param maxDelay - Maximum delay in milliseconds
+ * @param enabled - Whether the interval is enabled (default: true)
+ */
+declare function useRandomInterval(callback: () => void, minDelay: number, maxDelay: number, enabled?: boolean): void;
+
+interface UseCountdownOptions {
+    /** Interval in milliseconds (default: 1000) */
+    interval?: number;
+    /** Callback when countdown reaches zero */
+    onComplete?: () => void;
+    /** Auto-start the countdown (default: false) */
+    autoStart?: boolean;
+}
+interface UseCountdownReturn {
+    /** Current countdown value in milliseconds */
+    count: number;
+    /** Start the countdown */
+    start: () => void;
+    /** Pause the countdown */
+    pause: () => void;
+    /** Resume the countdown */
+    resume: () => void;
+    /** Reset to initial value */
+    reset: (newCount?: number) => void;
+    /** Is countdown running? */
+    isRunning: boolean;
+    /** Is countdown complete? */
+    isComplete: boolean;
+    /** Formatted time { days, hours, minutes, seconds } */
+    formatted: {
+        days: number;
+        hours: number;
+        minutes: number;
+        seconds: number;
+    };
+}
+/**
+ * Hook to manage countdown timer
+ * @param initialCount - Initial countdown value in milliseconds
+ * @param options - Configuration options
+ */
+declare function useCountdown(initialCount: number, options?: UseCountdownOptions): UseCountdownReturn;
+
+interface UseContinuousRetryOptions {
+    /** Maximum number of retry attempts (default: Infinity) */
+    maxAttempts?: number;
+    /** Delay between retries in milliseconds (default: 1000) */
+    delay?: number;
+    /** Whether to use exponential backoff (default: false) */
+    exponentialBackoff?: boolean;
+    /** Maximum delay when using exponential backoff (default: 30000) */
+    maxDelay?: number;
+    /** Auto-start retrying (default: true) */
+    autoStart?: boolean;
+}
+interface UseContinuousRetryReturn {
+    /** Number of attempts made */
+    attempts: number;
+    /** Last error encountered */
+    error: Error | null;
+    /** Is currently retrying? */
+    isRetrying: boolean;
+    /** Has succeeded? */
+    isSuccess: boolean;
+    /** Has reached max attempts? */
+    isMaxAttempts: boolean;
+    /** Start/restart retrying */
+    start: () => void;
+    /** Stop retrying */
+    stop: () => void;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Hook to continuously retry a function until success
+ * @param callback - Async function to retry (return true for success, false for retry)
+ * @param options - Configuration options
+ */
+declare function useContinuousRetry(callback: () => Promise<boolean> | boolean, options?: UseContinuousRetryOptions): UseContinuousRetryReturn;
+
+interface WindowSize {
+    width: number;
+    height: number;
+}
+/**
+ * Track window dimensions with resize updates
+ * @param debounceMs - Debounce resize events (default: 100ms)
+ */
+declare function useWindowSize(debounceMs?: number): WindowSize;
+
+interface WindowScrollPosition {
+    /** Horizontal scroll position */
+    x: number;
+    /** Vertical scroll position */
+    y: number;
+    /** Scroll direction (up, down, left, right, or null) */
+    direction: 'up' | 'down' | 'left' | 'right' | null;
+    /** Is scrolling? */
+    isScrolling: boolean;
+}
+interface UseWindowScrollReturn extends WindowScrollPosition {
+    /** Scroll to position */
+    scrollTo: (options: ScrollToOptions) => void;
+    /** Scroll to top */
+    scrollToTop: (behavior?: ScrollBehavior) => void;
+    /** Scroll to bottom */
+    scrollToBottom: (behavior?: ScrollBehavior) => void;
+}
+/**
+ * Hook to track and control window scroll position
+ */
+declare function useWindowScroll(): UseWindowScrollReturn;
+
+interface UseDocumentTitleOptions {
+    /** Restore previous title on unmount (default: true) */
+    restoreOnUnmount?: boolean;
+    /** Title template, use %s for title placeholder */
+    template?: string;
+}
+/**
+ * Hook to set document title
+ * @param title - Document title
+ * @param options - Configuration options
+ */
+declare function useDocumentTitle(title: string, options?: UseDocumentTitleOptions): void;
+
+interface UsePageTitleOptions {
+    /** Suffix to append to the title (e.g., organization name) */
+    suffix?: string;
+    /** Separator between title and suffix (default: ' | ') */
+    separator?: string;
+    /** Whether to restore original title on unmount (default: true) */
+    restoreOnUnmount?: boolean;
+}
+/**
+ * Set the document title with optional suffix
+ * @param title - Page title
+ * @param options - Configuration options
+ */
+declare function usePageTitle(title: string, options?: UsePageTitleOptions): void;
+
+/**
+ * Hook to dynamically change favicon
+ * @param href - URL of the favicon image
+ * @param restoreOnUnmount - Whether to restore original favicon on unmount (default: true)
+ */
+declare function useFavicon(href: string, restoreOnUnmount?: boolean): void;
+
+interface UseVisibilityChangeReturn {
+    /** Is document visible? */
+    isVisible: boolean;
+    /** Visibility state ('visible', 'hidden', 'prerender') */
+    visibilityState: DocumentVisibilityState;
+    /** Time when visibility last changed */
+    lastChanged: Date | null;
+}
+/**
+ * Hook to track document visibility state
+ * @param onVisibilityChange - Optional callback when visibility changes
+ */
+declare function useVisibilityChange(onVisibilityChange?: (isVisible: boolean) => void): UseVisibilityChangeReturn;
+
+interface UsePageLeaveOptions {
+    /** Show confirmation dialog on page leave (default: false) */
+    showConfirmation?: boolean;
+    /** Custom confirmation message (browser may override) */
+    confirmationMessage?: string;
+}
+/**
+ * Hook to detect when user is leaving the page
+ * @param onLeave - Callback when user attempts to leave
+ * @param options - Configuration options
+ */
+declare function usePageLeave(onLeave?: () => void, options?: UsePageLeaveOptions): void;
+
+/**
+ * Hook to lock body scroll
+ * @param locked - Whether scroll should be locked (default: true)
+ */
+declare function useLockBodyScroll(locked?: boolean): void;
+
+/**
+ * Hook to check if rendering on client side
+ * Useful for SSR/SSG environments
+ */
+declare function useIsClient(): boolean;
+
+/**
+ * Hook to check if it's the first render
+ */
+declare function useIsFirstRender(): boolean;
+
+type EventMap = WindowEventMap & DocumentEventMap & HTMLElementEventMap;
+/**
+ * Hook to attach event listeners declaratively
+ * @param eventName - Name of the event to listen for
+ * @param handler - Event handler function
+ * @param element - Target element (default: window)
+ * @param options - AddEventListener options
+ */
+declare function useEventListener<K extends keyof EventMap>(eventName: K, handler: (event: EventMap[K]) => void, element?: HTMLElement | Window | Document | null, options?: boolean | AddEventListenerOptions): void;
+
+interface UseKeyPressOptions {
+    /** Target element (default: document) */
+    target?: HTMLElement | Document | Window | null;
+    /** Event type: 'keydown' | 'keyup' | 'keypress' */
+    event?: 'keydown' | 'keyup' | 'keypress';
+    /** Prevent default behavior */
+    preventDefault?: boolean;
+    /** Stop event propagation */
+    stopPropagation?: boolean;
+}
+interface UseKeyPressReturn {
+    /** Is the key currently pressed? */
+    pressed: boolean;
+    /** Event object from last press */
+    event: KeyboardEvent | null;
+}
+/**
+ * Hook to detect key press
+ * @param targetKey - Key to detect (e.g., 'Enter', 'Escape', 'a')
+ * @param callback - Optional callback when key is pressed
+ * @param options - Configuration options
+ */
+declare function useKeyPress(targetKey: string | string[], callback?: (event: KeyboardEvent) => void, options?: UseKeyPressOptions): UseKeyPressReturn;
+
+interface UseHoverReturn<T extends HTMLElement = HTMLElement> {
+    /** Ref to attach to the target element */
+    ref: React.RefObject<T | null>;
+    /** Is element being hovered? */
+    isHovered: boolean;
+    /** Bind props to spread on element */
+    bind: {
+        onMouseEnter: () => void;
+        onMouseLeave: () => void;
+    };
+}
+/**
+ * Hook to detect hover state
+ * @param onHoverChange - Optional callback when hover state changes
+ */
+declare function useHover<T extends HTMLElement = HTMLElement>(onHoverChange?: (isHovered: boolean) => void): UseHoverReturn<T>;
+
+type EventType = 'mousedown' | 'mouseup' | 'touchstart' | 'touchend';
+/**
+ * Hook to detect clicks outside of an element
+ * @param callback - Function to call when click outside occurs
+ * @param events - Event types to listen for (default: ['mousedown', 'touchstart'])
+ */
+declare function useClickAway<T extends HTMLElement = HTMLElement>(callback: (event: MouseEvent | TouchEvent) => void, events?: EventType[]): React.RefObject<T | null>;
+
+/**
+ * useOnClickOutside Hook
+ * Detect clicks outside of a referenced element
+ */
+
+type Handler = (event: MouseEvent | TouchEvent) => void;
+/**
+ * Detect clicks outside of a referenced element
+ * @param ref - React ref to the element
+ * @param handler - Callback when click outside occurs
+ * @param enabled - Whether the hook is enabled (default: true)
+ */
+declare function useOnClickOutside<T extends HTMLElement = HTMLElement>(ref: RefObject<T>, handler: Handler, enabled?: boolean): void;
+
+interface UseLongPressOptions {
+    /** Threshold in milliseconds (default: 400) */
+    threshold?: number;
+    /** Callback on long press */
+    onLongPress?: (event: React.MouseEvent | React.TouchEvent) => void;
+    /** Callback on regular click */
+    onClick?: (event: React.MouseEvent | React.TouchEvent) => void;
+    /** Callback when press starts */
+    onStart?: (event: React.MouseEvent | React.TouchEvent) => void;
+    /** Callback when press ends */
+    onFinish?: (event: React.MouseEvent | React.TouchEvent) => void;
+    /** Callback when press is cancelled */
+    onCancel?: (event: React.MouseEvent | React.TouchEvent) => void;
+}
+interface UseLongPressReturn {
+    /** Is currently pressing? */
+    isPressed: boolean;
+    /** Is long press achieved? */
+    isLongPress: boolean;
+    /** Bind props to spread on element */
+    bind: {
+        onMouseDown: (e: React.MouseEvent) => void;
+        onMouseUp: (e: React.MouseEvent) => void;
+        onMouseLeave: (e: React.MouseEvent) => void;
+        onTouchStart: (e: React.TouchEvent) => void;
+        onTouchEnd: (e: React.TouchEvent) => void;
+    };
+}
+/**
+ * Hook to detect long press gesture
+ * @param options - Configuration options
+ */
+declare function useLongPress(options?: UseLongPressOptions): UseLongPressReturn;
+
+interface MousePosition {
+    /** X position relative to viewport */
+    x: number;
+    /** Y position relative to viewport */
+    y: number;
+    /** X position relative to page */
+    pageX: number;
+    /** Y position relative to page */
+    pageY: number;
+    /** X position relative to element (if ref provided) */
+    elementX: number;
+    /** Y position relative to element (if ref provided) */
+    elementY: number;
+    /** Is mouse within element bounds? */
+    isInElement: boolean;
+}
+interface UseMouseOptions {
+    /** Whether to track (default: true) */
+    enabled?: boolean;
+}
+interface UseMouseReturn<T extends HTMLElement = HTMLElement> extends MousePosition {
+    /** Ref to attach to element for relative positioning */
+    ref: React.RefObject<T | null>;
+}
+/**
+ * Hook to track mouse position
+ * @param options - Configuration options
+ */
+declare function useMouse<T extends HTMLElement = HTMLElement>(options?: UseMouseOptions): UseMouseReturn<T>;
+
+interface UseCopyToClipboardReturn {
+    /** Copy text to clipboard */
+    copy: (text: string) => Promise<boolean>;
+    /** Whether copy was successful (resets after timeout) */
+    copied: boolean;
+    /** Error message if copy failed */
+    error: string | null;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Copy text to clipboard with feedback
+ * @param resetDelay - Time in ms before copied state resets (default: 2000)
+ */
+declare function useCopyToClipboard(resetDelay?: number): UseCopyToClipboardReturn;
+
+/**
+ * Track a media query match
+ * @param query - CSS media query string (e.g., '(min-width: 768px)')
+ */
+declare function useMediaQuery(query: string): boolean;
+declare const useIsMobile: () => boolean;
+declare const useIsTablet: () => boolean;
+declare const useIsDesktop: () => boolean;
+declare const useIsMobileOrTablet: () => boolean;
+
+interface OrientationState {
+    /** Device orientation angle */
+    angle: number;
+    /** Orientation type */
+    type: OrientationType;
+    /** Is portrait? */
+    isPortrait: boolean;
+    /** Is landscape? */
+    isLandscape: boolean;
+}
+/**
+ * Hook to track device/screen orientation
+ */
+declare function useOrientation(): OrientationState;
+
+interface BatteryState {
+    /** Is battery API supported? */
+    isSupported: boolean;
+    /** Is device charging? */
+    charging: boolean;
+    /** Time until fully charged (seconds), Infinity if not charging */
+    chargingTime: number;
+    /** Time until discharged (seconds), Infinity if charging */
+    dischargingTime: number;
+    /** Battery level (0 to 1) */
+    level: number;
+    /** Battery percentage (0 to 100) */
+    percentage: number;
+}
+/**
+ * Hook to track battery status
+ */
+declare function useBattery(): BatteryState;
+
+interface NetworkState {
+    /** Is online? */
+    online: boolean;
+    /** Is offline? */
+    offline: boolean;
+    /** Connection downlink speed (Mbps) */
+    downlink?: number;
+    /** Effective connection type */
+    effectiveType?: 'slow-2g' | '2g' | '3g' | '4g';
+    /** Round-trip time (ms) */
+    rtt?: number;
+    /** Is data saver enabled? */
+    saveData?: boolean;
+    /** Connection type */
+    type?: string;
+    /** Time when status last changed */
+    since?: Date;
+}
+/**
+ * Hook to track network status
+ */
+declare function useNetworkState(): NetworkState;
+
+interface UseIdleOptions {
+    /** Idle timeout in milliseconds (default: 60000 = 1 minute) */
+    timeout?: number;
+    /** Events to consider as activity */
+    events?: string[];
+    /** Initial idle state */
+    initialState?: boolean;
+    /** Callback when user becomes idle */
+    onIdle?: () => void;
+    /** Callback when user becomes active */
+    onActive?: () => void;
+}
+interface UseIdleReturn {
+    /** Is user idle? */
+    isIdle: boolean;
+    /** Last active timestamp */
+    lastActive: Date;
+    /** Reset idle timer */
+    reset: () => void;
+    /** Start tracking */
+    start: () => void;
+    /** Stop tracking */
+    stop: () => void;
+}
+/**
+ * Hook to detect user idle state
+ * @param options - Configuration options
+ */
+declare function useIdle(options?: UseIdleOptions): UseIdleReturn;
+
+interface GeolocationState {
+    /** Is loading? */
+    loading: boolean;
+    /** Error message */
+    error: string | null;
+    /** Latitude */
+    latitude: number | null;
+    /** Longitude */
+    longitude: number | null;
+    /** Accuracy in meters */
+    accuracy: number | null;
+    /** Altitude in meters */
+    altitude: number | null;
+    /** Altitude accuracy in meters */
+    altitudeAccuracy: number | null;
+    /** Heading in degrees */
+    heading: number | null;
+    /** Speed in m/s */
+    speed: number | null;
+    /** Timestamp */
+    timestamp: number | null;
+}
+interface UseGeolocationOptions {
+    /** Enable high accuracy mode */
+    enableHighAccuracy?: boolean;
+    /** Maximum age of cached position (ms) */
+    maximumAge?: number;
+    /** Timeout for getting position (ms) */
+    timeout?: number;
+    /** Watch position continuously */
+    watch?: boolean;
+}
+interface UseGeolocationReturn extends GeolocationState {
+    /** Refresh position */
+    refresh: () => void;
+    /** Is geolocation supported? */
+    isSupported: boolean;
+}
+/**
+ * Hook to track geolocation
+ * @param options - Configuration options
+ */
+declare function useGeolocation(options?: UseGeolocationOptions): UseGeolocationReturn;
+
+interface UsePreferredLanguageReturn {
+    /** Primary preferred language */
+    language: string;
+    /** All preferred languages */
+    languages: readonly string[];
+}
+/**
+ * Hook to get user's preferred language
+ */
+declare function usePreferredLanguage(): UsePreferredLanguageReturn;
+
+type ThemeMode = 'light' | 'dark';
+/**
+ * Detect and track system color scheme preference
+ * @returns Current theme mode based on system preference
+ */
+declare function useThemeDetector(): ThemeMode;
+
+type SetValue<T> = T | ((prevValue: T) => T);
+interface UseLocalStorageOptions<T> {
+    /** Serialize function (default: JSON.stringify) */
+    serializer?: (value: T) => string;
+    /** Deserialize function (default: JSON.parse) */
+    deserializer?: (value: string) => T;
+    /** Enable cross-tab synchronization (default: true) */
+    syncTabs?: boolean;
+    /** Enable logging (default: false) */
+    debug?: boolean;
+}
+/**
+ * Hook to persist state in localStorage with cross-tab sync
+ * @param key - localStorage key
+ * @param initialValue - initial/fallback value
+ * @param options - configuration options
+ */
+declare function useLocalStorage<T>(key: string, initialValue: T, options?: UseLocalStorageOptions<T>): [T, (value: SetValue<T>) => void, () => void];
+
+interface UseSessionStorageOptions<T> {
+    /** Serialize function (default: JSON.stringify) */
+    serializer?: (value: T) => string;
+    /** Deserialize function (default: JSON.parse) */
+    deserializer?: (value: string) => T;
+    /** Enable logging (default: false) */
+    debug?: boolean;
+}
+/**
+ * Hook to persist state in sessionStorage
+ * @param key - sessionStorage key
+ * @param initialValue - initial/fallback value
+ * @param options - configuration options
+ */
+declare function useSessionStorage<T>(key: string, initialValue: T, options?: UseSessionStorageOptions<T>): [T, (value: SetValue<T>) => void, () => void];
+
+interface UseFetchOptions<T> extends Omit<RequestInit, 'body'> {
+    /** Request body (will be JSON.stringify'd if object) */
+    body?: BodyInit | object | null;
+    /** Skip initial fetch */
+    skip?: boolean;
+    /** Transform response data */
+    transform?: (data: unknown) => T;
+    /** Retry count on failure */
+    retries?: number;
+    /** Retry delay in ms */
+    retryDelay?: number;
+    /** Cache key (default: url) */
+    cacheKey?: string;
+    /** Cache time in ms */
+    cacheTime?: number;
+    /** Callback on success */
+    onSuccess?: (data: T) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+interface UseFetchReturn<T> {
+    /** Response data */
+    data: T | null;
+    /** Is loading? */
+    loading: boolean;
+    /** Error */
+    error: Error | null;
+    /** Refetch data */
+    refetch: () => Promise<T | null>;
+    /** Abort current request */
+    abort: () => void;
+    /** Is fetching? (includes refetch) */
+    isFetching: boolean;
+    /** HTTP status code */
+    status: number | null;
+}
+/**
+ * Hook for data fetching with caching and retry support
+ * @param url - URL to fetch
+ * @param options - Fetch options
+ */
+declare function useFetch<T = unknown>(url: string | null, options?: UseFetchOptions<T>): UseFetchReturn<T>;
+
+type ScriptStatus = 'idle' | 'loading' | 'ready' | 'error';
+interface UseScriptOptions {
+    /** Should load script immediately (default: true) */
+    shouldLoad?: boolean;
+    /** Remove script on unmount (default: false) */
+    removeOnUnmount?: boolean;
+    /** Script attributes */
+    attributes?: Record<string, string>;
+}
+interface UseScriptReturn {
+    /** Script loading status */
+    status: ScriptStatus;
+    /** Is script ready? */
+    ready: boolean;
+    /** Is loading? */
+    loading: boolean;
+    /** Has error? */
+    error: boolean;
+    /** Load script manually */
+    load: () => void;
+    /** Remove script */
+    remove: () => void;
+}
+/**
+ * Hook to dynamically load external scripts
+ * @param src - Script source URL
+ * @param options - Configuration options
+ */
+declare function useScript(src: string, options?: UseScriptOptions): UseScriptReturn;
+
+interface RenderInfo {
+    /** Component name (if provided) */
+    name: string;
+    /** Total render count */
+    renders: number;
+    /** Time since last render (ms) */
+    sinceLastRender: number;
+    /** Timestamp of last render */
+    timestamp: number;
+}
+/**
+ * Hook to track render information for debugging
+ * @param componentName - Optional component name for identification
+ */
+declare function useRenderInfo(componentName?: string): RenderInfo;
+
+/**
+ * Hook to count component renders
+ */
+declare function useRenderCount(): number;
+
+interface UseLoggerOptions {
+    /** Log props changes */
+    logProps?: boolean;
+    /** Log lifecycle events */
+    logLifecycle?: boolean;
+    /** Custom logger function */
+    logger?: (...args: unknown[]) => void;
+}
+/**
+ * Hook to log component lifecycle and changes
+ * @param componentName - Name of the component
+ * @param props - Props to track changes
+ * @param options - Configuration options
+ */
+declare function useLogger(componentName: string, props?: Record<string, unknown>, options?: UseLoggerOptions): void;
+
+interface Dimensions {
+    /** Element width */
+    width: number;
+    /** Element height */
+    height: number;
+    /** Top position relative to viewport */
+    top: number;
+    /** Left position relative to viewport */
+    left: number;
+    /** Bottom position relative to viewport */
+    bottom: number;
+    /** Right position relative to viewport */
+    right: number;
+    /** X position (same as left) */
+    x: number;
+    /** Y position (same as top) */
+    y: number;
+}
+interface UseMeasureReturn<T extends HTMLElement = HTMLElement> {
+    /** Ref to attach to element */
+    ref: React.RefCallback<T>;
+    /** Element dimensions */
+    dimensions: Dimensions;
+    /** Manually trigger measurement */
+    measure: () => void;
+}
+/**
+ * Hook to measure element dimensions
+ */
+declare function useMeasure<T extends HTMLElement = HTMLElement>(): UseMeasureReturn<T>;
+
+interface UseIntersectionObserverOptions {
+    /** Root element (default: viewport) */
+    root?: Element | null;
+    /** Root margin (default: '0px') */
+    rootMargin?: string;
+    /** Intersection threshold(s) (default: 0) */
+    threshold?: number | number[];
+    /** Freeze after first intersection */
+    freezeOnceVisible?: boolean;
+    /** Initial visibility state */
+    initialIsIntersecting?: boolean;
+    /** Callback when intersection changes */
+    onChange?: (isIntersecting: boolean, entry: IntersectionObserverEntry) => void;
+}
+interface UseIntersectionObserverReturn<T extends Element = Element> {
+    /** Ref to attach to element */
+    ref: React.RefCallback<T>;
+    /** Is element intersecting? */
+    isIntersecting: boolean;
+    /** Full intersection entry */
+    entry: IntersectionObserverEntry | null;
+}
+/**
+ * Hook to observe element intersection with viewport
+ * @param options - IntersectionObserver options
+ */
+declare function useIntersectionObserver<T extends Element = Element>(options?: UseIntersectionObserverOptions): UseIntersectionObserverReturn<T>;
+
+type SnackbarSeverity = 'success' | 'error' | 'warning' | 'info';
+interface SnackbarState {
+    open: boolean;
+    message: string;
+    severity: SnackbarSeverity;
+    autoHideDuration?: number;
+}
+interface UseSnackbarReturn {
+    /** Current snackbar state */
+    state: SnackbarState;
+    /** Show snackbar with message */
+    show: (message: string, severity?: SnackbarSeverity, duration?: number) => void;
+    /** Show success snackbar */
+    success: (message: string, duration?: number) => void;
+    /** Show error snackbar */
+    error: (message: string, duration?: number) => void;
+    /** Show warning snackbar */
+    warning: (message: string, duration?: number) => void;
+    /** Show info snackbar */
+    info: (message: string, duration?: number) => void;
+    /** Close snackbar */
+    close: () => void;
+}
+/**
+ * Manage snackbar/toast notification state
+ * @param defaultDuration - Default auto-hide duration in ms
+ */
+declare function useSnackbar(defaultDuration?: number): UseSnackbarReturn;
+
+declare const index_ApiResponse: typeof ApiResponse;
+declare const index_ApiUrlBuilder: typeof ApiUrlBuilder;
+declare const index_ApiUrlConfig: typeof ApiUrlConfig;
+type index_BatteryState = BatteryState;
+declare const index_ClientLogger: typeof ClientLogger;
+declare const index_ClientLoggerConfig: typeof ClientLoggerConfig;
+type index_Dimensions = Dimensions;
+declare const index_EventEmitter: typeof EventEmitter;
+type index_GeolocationState = GeolocationState;
+declare const index_HttpClientOptions: typeof HttpClientOptions;
+declare const index_LogLevel: typeof LogLevel;
+type index_MousePosition = MousePosition;
+type index_NetworkState = NetworkState;
+declare const index_NpmRegistryResponse: typeof NpmRegistryResponse;
+type index_ObjectStateUpdate<T> = ObjectStateUpdate<T>;
+type index_OrientationState = OrientationState;
+declare const index_PackageCheckResult: typeof PackageCheckResult;
+declare const index_PackageJson: typeof PackageJson;
+declare const index_PackageVersion: typeof PackageVersion;
+declare const index_PaginatedResponse: typeof PaginatedResponse;
+type index_RenderInfo = RenderInfo;
+type index_ScriptStatus = ScriptStatus;
+type index_SetValue<T> = SetValue<T>;
+type index_SnackbarSeverity = SnackbarSeverity;
+type index_SnackbarState = SnackbarState;
+type index_ThemeMode = ThemeMode;
+type index_UseContinuousRetryOptions = UseContinuousRetryOptions;
+type index_UseContinuousRetryReturn = UseContinuousRetryReturn;
+type index_UseCopyToClipboardReturn = UseCopyToClipboardReturn;
+type index_UseCountdownOptions = UseCountdownOptions;
+type index_UseCountdownReturn = UseCountdownReturn;
+type index_UseCounterOptions = UseCounterOptions;
+type index_UseCounterReturn = UseCounterReturn;
+type index_UseDocumentTitleOptions = UseDocumentTitleOptions;
+type index_UseFetchOptions<T> = UseFetchOptions<T>;
+type index_UseFetchReturn<T> = UseFetchReturn<T>;
+type index_UseGeolocationOptions = UseGeolocationOptions;
+type index_UseGeolocationReturn = UseGeolocationReturn;
+type index_UseHistoryStateOptions = UseHistoryStateOptions;
+type index_UseHistoryStateReturn<T> = UseHistoryStateReturn<T>;
+type index_UseHoverReturn<T extends HTMLElement = HTMLElement> = UseHoverReturn<T>;
+type index_UseIdleOptions = UseIdleOptions;
+type index_UseIdleReturn = UseIdleReturn;
+type index_UseIntersectionObserverOptions = UseIntersectionObserverOptions;
+type index_UseIntersectionObserverReturn<T extends Element = Element> = UseIntersectionObserverReturn<T>;
+type index_UseKeyPressOptions = UseKeyPressOptions;
+type index_UseKeyPressReturn = UseKeyPressReturn;
+type index_UseListReturn<T> = UseListReturn<T>;
+type index_UseLocalStorageOptions<T> = UseLocalStorageOptions<T>;
+type index_UseLoggerOptions = UseLoggerOptions;
+type index_UseLongPressOptions = UseLongPressOptions;
+type index_UseLongPressReturn = UseLongPressReturn;
+type index_UseMapReturn<K, V> = UseMapReturn<K, V>;
+type index_UseMeasureReturn<T extends HTMLElement = HTMLElement> = UseMeasureReturn<T>;
+type index_UseMouseOptions = UseMouseOptions;
+type index_UseMouseReturn<T extends HTMLElement = HTMLElement> = UseMouseReturn<T>;
+type index_UseObjectStateReturn<T extends object> = UseObjectStateReturn<T>;
+type index_UsePageLeaveOptions = UsePageLeaveOptions;
+type index_UsePageTitleOptions = UsePageTitleOptions;
+type index_UsePreferredLanguageReturn = UsePreferredLanguageReturn;
+type index_UseQueueReturn<T> = UseQueueReturn<T>;
+type index_UseScriptOptions = UseScriptOptions;
+type index_UseScriptReturn = UseScriptReturn;
+type index_UseSessionStorageOptions<T> = UseSessionStorageOptions<T>;
+type index_UseSetReturn<T> = UseSetReturn<T>;
+type index_UseSnackbarReturn = UseSnackbarReturn;
+type index_UseTimeoutReturn = UseTimeoutReturn;
+type index_UseToggleReturn = UseToggleReturn;
+type index_UseVisibilityChangeReturn = UseVisibilityChangeReturn;
+type index_UseWindowScrollReturn = UseWindowScrollReturn;
+type index_WindowScrollPosition = WindowScrollPosition;
+type index_WindowSize = WindowSize;
+declare const index_addDays: typeof addDays;
+declare const index_appEvents: typeof appEvents;
+declare const index_camelToKebab: typeof camelToKebab;
+declare const index_capitalize: typeof capitalize;
+declare const index_capitalizeWords: typeof capitalizeWords;
+declare const index_checkPackage: typeof checkPackage;
+declare const index_clientLogger: typeof clientLogger;
+declare const index_copyToClipboard: typeof copyToClipboard;
+declare const index_createApiEndpoints: typeof createApiEndpoints;
+declare const index_createApiUrlBuilder: typeof createApiUrlBuilder;
+declare const index_createClientLogger: typeof createClientLogger;
+declare const index_createEmptyPaginationMeta: typeof createEmptyPaginationMeta;
+declare const index_createErrorResponse: typeof createErrorResponse;
+declare const index_createEventEmitter: typeof createEventEmitter;
+declare const index_createHttpClient: typeof createHttpClient;
+declare const index_createSuccessResponse: typeof createSuccessResponse;
+declare const index_endOfDay: typeof endOfDay;
+declare const index_formatDate: typeof formatDate;
+declare const index_formatDateForInput: typeof formatDateForInput;
+declare const index_formatDateTime: typeof formatDateTime;
+declare const index_formatDateTimeForInput: typeof formatDateTimeForInput;
+declare const index_formatPackageCheckResult: typeof formatPackageCheckResult;
+declare const index_formatRelativeTime: typeof formatRelativeTime;
+declare const index_generateNcuCommand: typeof generateNcuCommand;
+declare const index_getErrorMessage: typeof getErrorMessage;
+declare const index_getNextPage: typeof getNextPage;
+declare const index_getPrevPage: typeof getPrevPage;
+declare const index_getResponseData: typeof getResponseData;
+declare const index_hasData: typeof hasData;
+declare const index_hasMorePages: typeof hasMorePages;
+declare const index_isClipboardAvailable: typeof isClipboardAvailable;
+declare const index_isErrorResponse: typeof isErrorResponse;
+declare const index_isForbidden: typeof isForbidden;
+declare const index_isFuture: typeof isFuture;
+declare const index_isNotFound: typeof isNotFound;
+declare const index_isPast: typeof isPast;
+declare const index_isServerError: typeof isServerError;
+declare const index_isStatusError: typeof isStatusError;
+declare const index_isSuccess: typeof isSuccess;
+declare const index_isSuccessResponse: typeof isSuccessResponse;
+declare const index_isToday: typeof isToday;
+declare const index_isUnauthorized: typeof isUnauthorized;
+declare const index_kebabToCamel: typeof kebabToCamel;
+declare const index_packageCheck: typeof packageCheck;
+declare const index_parseError: typeof parseError;
+declare const index_parseFullResponse: typeof parseFullResponse;
+declare const index_parseResponse: typeof parseResponse;
+declare const index_readFromClipboard: typeof readFromClipboard;
+declare const index_slugify: typeof slugify;
+declare const index_slugifyUnique: typeof slugifyUnique;
+declare const index_startOfDay: typeof startOfDay;
+declare const index_truncate: typeof truncate;
+declare const index_truncateWords: typeof truncateWords;
+declare const index_unslugify: typeof unslugify;
+declare const index_useBattery: typeof useBattery;
+declare const index_useClickAway: typeof useClickAway;
+declare const index_useContinuousRetry: typeof useContinuousRetry;
+declare const index_useCopyToClipboard: typeof useCopyToClipboard;
+declare const index_useCountdown: typeof useCountdown;
+declare const index_useCounter: typeof useCounter;
+declare const index_useDebounce: typeof useDebounce;
+declare const index_useDefault: typeof useDefault;
+declare const index_useDocumentTitle: typeof useDocumentTitle;
+declare const index_useEventListener: typeof useEventListener;
+declare const index_useFavicon: typeof useFavicon;
+declare const index_useFetch: typeof useFetch;
+declare const index_useGeolocation: typeof useGeolocation;
+declare const index_useHistoryState: typeof useHistoryState;
+declare const index_useHover: typeof useHover;
+declare const index_useIdle: typeof useIdle;
+declare const index_useIntersectionObserver: typeof useIntersectionObserver;
+declare const index_useInterval: typeof useInterval;
+declare const index_useIntervalWhen: typeof useIntervalWhen;
+declare const index_useIsClient: typeof useIsClient;
+declare const index_useIsDesktop: typeof useIsDesktop;
+declare const index_useIsFirstRender: typeof useIsFirstRender;
+declare const index_useIsMobile: typeof useIsMobile;
+declare const index_useIsMobileOrTablet: typeof useIsMobileOrTablet;
+declare const index_useIsTablet: typeof useIsTablet;
+declare const index_useKeyPress: typeof useKeyPress;
+declare const index_useList: typeof useList;
+declare const index_useLocalStorage: typeof useLocalStorage;
+declare const index_useLockBodyScroll: typeof useLockBodyScroll;
+declare const index_useLogger: typeof useLogger;
+declare const index_useLongPress: typeof useLongPress;
+declare const index_useMap: typeof useMap;
+declare const index_useMeasure: typeof useMeasure;
+declare const index_useMediaQuery: typeof useMediaQuery;
+declare const index_useMouse: typeof useMouse;
+declare const index_useNetworkState: typeof useNetworkState;
+declare const index_useObjectState: typeof useObjectState;
+declare const index_useOnClickOutside: typeof useOnClickOutside;
+declare const index_useOrientation: typeof useOrientation;
+declare const index_usePageLeave: typeof usePageLeave;
+declare const index_usePageTitle: typeof usePageTitle;
+declare const index_usePreferredLanguage: typeof usePreferredLanguage;
+declare const index_usePrevious: typeof usePrevious;
+declare const index_useQueue: typeof useQueue;
+declare const index_useRandomInterval: typeof useRandomInterval;
+declare const index_useRenderCount: typeof useRenderCount;
+declare const index_useRenderInfo: typeof useRenderInfo;
+declare const index_useScript: typeof useScript;
+declare const index_useSessionStorage: typeof useSessionStorage;
+declare const index_useSet: typeof useSet;
+declare const index_useSnackbar: typeof useSnackbar;
+declare const index_useThemeDetector: typeof useThemeDetector;
+declare const index_useThrottle: typeof useThrottle;
+declare const index_useTimeout: typeof useTimeout;
+declare const index_useToggle: typeof useToggle;
+declare const index_useVisibilityChange: typeof useVisibilityChange;
+declare const index_useWindowScroll: typeof useWindowScroll;
+declare const index_useWindowSize: typeof useWindowSize;
+declare const index_withAbortSignal: typeof withAbortSignal;
+declare const index_withFormData: typeof withFormData;
+declare const index_withTimeout: typeof withTimeout;
+declare namespace index {
+  export { index_ApiResponse as ApiResponse, index_ApiUrlBuilder as ApiUrlBuilder, index_ApiUrlConfig as ApiUrlConfig, type index_BatteryState as BatteryState, index_ClientLogger as ClientLogger, index_ClientLoggerConfig as ClientLoggerConfig, type index_Dimensions as Dimensions, index_EventEmitter as EventEmitter, type index_GeolocationState as GeolocationState, index_HttpClientOptions as HttpClientOptions, index_LogLevel as LogLevel, type index_MousePosition as MousePosition, type index_NetworkState as NetworkState, index_NpmRegistryResponse as NpmRegistryResponse, type index_ObjectStateUpdate as ObjectStateUpdate, type index_OrientationState as OrientationState, index_PackageCheckResult as PackageCheckResult, index_PackageJson as PackageJson, index_PackageVersion as PackageVersion, index_PaginatedResponse as PaginatedResponse, type index_RenderInfo as RenderInfo, type index_ScriptStatus as ScriptStatus, type index_SetValue as SetValue, type index_SnackbarSeverity as SnackbarSeverity, type index_SnackbarState as SnackbarState, type index_ThemeMode as ThemeMode, type index_UseContinuousRetryOptions as UseContinuousRetryOptions, type index_UseContinuousRetryReturn as UseContinuousRetryReturn, type index_UseCopyToClipboardReturn as UseCopyToClipboardReturn, type index_UseCountdownOptions as UseCountdownOptions, type index_UseCountdownReturn as UseCountdownReturn, type index_UseCounterOptions as UseCounterOptions, type index_UseCounterReturn as UseCounterReturn, type index_UseDocumentTitleOptions as UseDocumentTitleOptions, type index_UseFetchOptions as UseFetchOptions, type index_UseFetchReturn as UseFetchReturn, type index_UseGeolocationOptions as UseGeolocationOptions, type index_UseGeolocationReturn as UseGeolocationReturn, type index_UseHistoryStateOptions as UseHistoryStateOptions, type index_UseHistoryStateReturn as UseHistoryStateReturn, type index_UseHoverReturn as UseHoverReturn, type index_UseIdleOptions as UseIdleOptions, type index_UseIdleReturn as UseIdleReturn, type index_UseIntersectionObserverOptions as UseIntersectionObserverOptions, type index_UseIntersectionObserverReturn as UseIntersectionObserverReturn, type index_UseKeyPressOptions as UseKeyPressOptions, type index_UseKeyPressReturn as UseKeyPressReturn, type index_UseListReturn as UseListReturn, type index_UseLocalStorageOptions as UseLocalStorageOptions, type index_UseLoggerOptions as UseLoggerOptions, type index_UseLongPressOptions as UseLongPressOptions, type index_UseLongPressReturn as UseLongPressReturn, type index_UseMapReturn as UseMapReturn, type index_UseMeasureReturn as UseMeasureReturn, type index_UseMouseOptions as UseMouseOptions, type index_UseMouseReturn as UseMouseReturn, type index_UseObjectStateReturn as UseObjectStateReturn, type index_UsePageLeaveOptions as UsePageLeaveOptions, type index_UsePageTitleOptions as UsePageTitleOptions, type index_UsePreferredLanguageReturn as UsePreferredLanguageReturn, type index_UseQueueReturn as UseQueueReturn, type index_UseScriptOptions as UseScriptOptions, type index_UseScriptReturn as UseScriptReturn, type index_UseSessionStorageOptions as UseSessionStorageOptions, type index_UseSetReturn as UseSetReturn, type index_UseSnackbarReturn as UseSnackbarReturn, type index_UseTimeoutReturn as UseTimeoutReturn, type index_UseToggleReturn as UseToggleReturn, type index_UseVisibilityChangeReturn as UseVisibilityChangeReturn, type index_UseWindowScrollReturn as UseWindowScrollReturn, type index_WindowScrollPosition as WindowScrollPosition, type index_WindowSize as WindowSize, index_addDays as addDays, index_appEvents as appEvents, index_camelToKebab as camelToKebab, index_capitalize as capitalize, index_capitalizeWords as capitalizeWords, index_checkPackage as checkPackage, index_clientLogger as clientLogger, index_copyToClipboard as copyToClipboard, index_createApiEndpoints as createApiEndpoints, index_createApiUrlBuilder as createApiUrlBuilder, index_createClientLogger as createClientLogger, index_createEmptyPaginationMeta as createEmptyPaginationMeta, index_createErrorResponse as createErrorResponse, index_createEventEmitter as createEventEmitter, index_createHttpClient as createHttpClient, index_createSuccessResponse as createSuccessResponse, index_endOfDay as endOfDay, index_formatDate as formatDate, index_formatDateForInput as formatDateForInput, index_formatDateTime as formatDateTime, index_formatDateTimeForInput as formatDateTimeForInput, index_formatPackageCheckResult as formatPackageCheckResult, index_formatRelativeTime as formatRelativeTime, index_generateNcuCommand as generateNcuCommand, index_getErrorMessage as getErrorMessage, index_getNextPage as getNextPage, index_getPrevPage as getPrevPage, index_getResponseData as getResponseData, index_hasData as hasData, index_hasMorePages as hasMorePages, index_isClipboardAvailable as isClipboardAvailable, index_isErrorResponse as isErrorResponse, index_isForbidden as isForbidden, index_isFuture as isFuture, index_isNotFound as isNotFound, index_isPast as isPast, index_isServerError as isServerError, index_isStatusError as isStatusError, index_isSuccess as isSuccess, index_isSuccessResponse as isSuccessResponse, index_isToday as isToday, index_isUnauthorized as isUnauthorized, index_kebabToCamel as kebabToCamel, index_packageCheck as packageCheck, index_parseError as parseError, index_parseFullResponse as parseFullResponse, index_parseResponse as parseResponse, index_readFromClipboard as readFromClipboard, index_slugify as slugify, index_slugifyUnique as slugifyUnique, index_startOfDay as startOfDay, index_truncate as truncate, index_truncateWords as truncateWords, index_unslugify as unslugify, index_useBattery as useBattery, index_useClickAway as useClickAway, index_useContinuousRetry as useContinuousRetry, index_useCopyToClipboard as useCopyToClipboard, index_useCountdown as useCountdown, index_useCounter as useCounter, index_useDebounce as useDebounce, index_useDefault as useDefault, index_useDocumentTitle as useDocumentTitle, index_useEventListener as useEventListener, index_useFavicon as useFavicon, index_useFetch as useFetch, index_useGeolocation as useGeolocation, index_useHistoryState as useHistoryState, index_useHover as useHover, index_useIdle as useIdle, index_useIntersectionObserver as useIntersectionObserver, index_useInterval as useInterval, index_useIntervalWhen as useIntervalWhen, index_useIsClient as useIsClient, index_useIsDesktop as useIsDesktop, index_useIsFirstRender as useIsFirstRender, index_useIsMobile as useIsMobile, index_useIsMobileOrTablet as useIsMobileOrTablet, index_useIsTablet as useIsTablet, index_useKeyPress as useKeyPress, index_useList as useList, index_useLocalStorage as useLocalStorage, index_useLockBodyScroll as useLockBodyScroll, index_useLogger as useLogger, index_useLongPress as useLongPress, index_useMap as useMap, index_useMeasure as useMeasure, index_useMediaQuery as useMediaQuery, index_useMouse as useMouse, index_useNetworkState as useNetworkState, index_useObjectState as useObjectState, index_useOnClickOutside as useOnClickOutside, index_useOrientation as useOrientation, index_usePageLeave as usePageLeave, index_usePageTitle as usePageTitle, index_usePreferredLanguage as usePreferredLanguage, index_usePrevious as usePrevious, index_useQueue as useQueue, index_useRandomInterval as useRandomInterval, index_useRenderCount as useRenderCount, index_useRenderInfo as useRenderInfo, index_useScript as useScript, index_useSessionStorage as useSessionStorage, index_useSet as useSet, index_useSnackbar as useSnackbar, index_useThemeDetector as useThemeDetector, index_useThrottle as useThrottle, index_useTimeout as useTimeout, index_useToggle as useToggle, index_useVisibilityChange as useVisibilityChange, index_useWindowScroll as useWindowScroll, index_useWindowSize as useWindowSize, index_withAbortSignal as withAbortSignal, index_withFormData as withFormData, index_withTimeout as withTimeout };
+}
+
+export { useIntersectionObserver as $, useLockBodyScroll as A, useIsClient as B, useIsFirstRender as C, useEventListener as D, useKeyPress as E, useHover as F, useClickAway as G, useOnClickOutside as H, useLongPress as I, useMouse as J, useCopyToClipboard as K, useMediaQuery as L, useOrientation as M, useBattery as N, useNetworkState as O, useIdle as P, useGeolocation as Q, usePreferredLanguage as R, useThemeDetector as S, useLocalStorage as T, useSessionStorage as U, useFetch as V, useScript as W, useRenderInfo as X, useRenderCount as Y, useLogger as Z, useMeasure as _, useCounter as a, type UseSnackbarReturn as a$, useSnackbar as a0, type UseToggleReturn as a1, type UseCounterOptions as a2, type UseCounterReturn as a3, type ObjectStateUpdate as a4, type UseObjectStateReturn as a5, type UseHistoryStateReturn as a6, type UseHistoryStateOptions as a7, type UseQueueReturn as a8, type UseListReturn as a9, useIsMobileOrTablet as aA, type OrientationState as aB, type BatteryState as aC, type NetworkState as aD, type UseIdleOptions as aE, type UseIdleReturn as aF, type GeolocationState as aG, type UseGeolocationOptions as aH, type UseGeolocationReturn as aI, type UsePreferredLanguageReturn as aJ, type ThemeMode as aK, type SetValue as aL, type UseLocalStorageOptions as aM, type UseSessionStorageOptions as aN, type UseFetchOptions as aO, type UseFetchReturn as aP, type ScriptStatus as aQ, type UseScriptOptions as aR, type UseScriptReturn as aS, type RenderInfo as aT, type UseLoggerOptions as aU, type Dimensions as aV, type UseMeasureReturn as aW, type UseIntersectionObserverOptions as aX, type UseIntersectionObserverReturn as aY, type SnackbarSeverity as aZ, type SnackbarState as a_, type UseMapReturn as aa, type UseSetReturn as ab, type UseTimeoutReturn as ac, type UseCountdownOptions as ad, type UseCountdownReturn as ae, type UseContinuousRetryOptions as af, type UseContinuousRetryReturn as ag, type WindowSize as ah, type WindowScrollPosition as ai, type UseWindowScrollReturn as aj, type UseDocumentTitleOptions as ak, type UsePageTitleOptions as al, type UseVisibilityChangeReturn as am, type UsePageLeaveOptions as an, type UseKeyPressOptions as ao, type UseKeyPressReturn as ap, type UseHoverReturn as aq, type UseLongPressOptions as ar, type UseLongPressReturn as as, type MousePosition as at, type UseMouseOptions as au, type UseMouseReturn as av, type UseCopyToClipboardReturn as aw, useIsMobile as ax, useIsTablet as ay, useIsDesktop as az, useDefault as b, usePrevious as c, useObjectState as d, useHistoryState as e, useQueue as f, useList as g, useMap as h, index as i, useSet as j, useDebounce as k, useThrottle as l, useTimeout as m, useInterval as n, useIntervalWhen as o, useRandomInterval as p, useCountdown as q, useContinuousRetry as r, useWindowSize as s, useWindowScroll as t, useToggle as u, useDocumentTitle as v, usePageTitle as w, useFavicon as x, useVisibilityChange as y, usePageLeave as z };