@fictjs/hooks 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,744 @@
+import { Cleanup } from '@fictjs/runtime';
+
+type MountCallback = () => void | Cleanup;
+/**
+ * Register a callback that runs after the current root mounts.
+ *
+ * @fictReturn {}
+ */
+declare function useMount(callback: MountCallback): void;
+
+type UnmountCallback = () => void | Cleanup;
+/**
+ * Register cleanup logic for root disposal.
+ *
+ * @fictReturn {}
+ */
+declare function useUnmount(callback: UnmountCallback): void;
+
+interface UseAsyncStateOptions {
+    immediate?: boolean;
+    resetOnExecute?: boolean;
+    onError?: (error: unknown) => void;
+}
+interface UseAsyncStateReturn<T, Args extends unknown[]> {
+    state: () => T;
+    isLoading: () => boolean;
+    error: () => unknown;
+    execute: (...args: Args) => Promise<T>;
+}
+/**
+ * Lightweight async state manager with race protection.
+ *
+ * @fictReturn { state: 'signal', isLoading: 'signal', error: 'signal' }
+ */
+declare function useAsyncState<T, Args extends unknown[] = []>(executor: (...args: Args) => Promise<T>, initialState: T, options?: UseAsyncStateOptions): UseAsyncStateReturn<T, Args>;
+
+type MaybeAccessor<T> = T | (() => T);
+
+interface UseFetchOptions<T> {
+    immediate?: boolean;
+    initialData?: T | null;
+    fetch?: typeof fetch;
+    parse?: (response: Response) => Promise<T>;
+    onError?: (error: unknown) => void;
+    init?: RequestInit;
+}
+interface UseFetchReturn<T> {
+    data: () => T | null;
+    error: () => unknown;
+    isLoading: () => boolean;
+    status: () => number | null;
+    aborted: () => boolean;
+    execute: (init?: RequestInit) => Promise<T | null>;
+    abort: () => void;
+}
+/**
+ * Fetch helper with loading/error/abort state.
+ *
+ * @fictReturn { data: 'signal', error: 'signal', isLoading: 'signal', status: 'signal', aborted: 'signal' }
+ */
+declare function useFetch<T = unknown>(input: RequestInfo | URL | MaybeAccessor<RequestInfo | URL>, options?: UseFetchOptions<T>): UseFetchReturn<T>;
+
+interface UseRequestOptions<TData, TParams extends unknown[]> {
+    manual?: boolean;
+    defaultParams?: TParams;
+    retryCount?: number;
+    retryInterval?: number;
+    pollingInterval?: number;
+    cacheKey?: string;
+    staleTime?: number;
+    onSuccess?: (data: TData, params: TParams) => void;
+    onError?: (error: unknown, params: TParams) => void;
+    onFinally?: (params: TParams, data?: TData, error?: unknown) => void;
+}
+interface UseRequestReturn<TData, TParams extends unknown[]> {
+    data: () => TData | undefined;
+    error: () => unknown;
+    loading: () => boolean;
+    params: () => TParams | undefined;
+    run: (...params: TParams) => void;
+    runAsync: (...params: TParams) => Promise<TData | undefined>;
+    cancel: () => void;
+    refresh: () => Promise<TData | undefined>;
+    mutate: (value: TData | ((prev: TData | undefined) => TData)) => void;
+}
+/**
+ * Lightweight request manager with retry, polling and cache.
+ *
+ * @fictReturn { data: 'signal', error: 'signal', loading: 'signal', params: 'signal' }
+ */
+declare function useRequest<TData, TParams extends unknown[] = []>(service: (...params: TParams) => Promise<TData>, options?: UseRequestOptions<TData, TParams>): UseRequestReturn<TData, TParams>;
+
+type NavigatorClipboardLike = {
+    clipboard?: {
+        writeText: (text: string) => Promise<void>;
+    };
+};
+interface UseClipboardOptions {
+    navigator?: NavigatorClipboardLike | null;
+    document?: Document | null;
+    window?: Window | null;
+    copiedDuring?: number;
+}
+interface UseClipboardReturn {
+    text: () => string;
+    copied: () => boolean;
+    isSupported: () => boolean;
+    copy: (value: string) => Promise<boolean>;
+}
+/**
+ * Clipboard write helper with copied state.
+ *
+ * @fictReturn { text: 'signal', copied: 'signal', isSupported: 'signal' }
+ */
+declare function useClipboard(options?: UseClipboardOptions): UseClipboardReturn;
+
+interface RefLike<T> {
+    current: T | null | undefined;
+}
+type MaybeRefOrAccessor<T> = T | null | undefined | RefLike<T> | (() => T | null | undefined);
+type MaybeTarget<T> = MaybeRefOrAccessor<T> | MaybeAccessor<MaybeRefOrAccessor<T>>;
+type MaybeElement = MaybeTarget<Element>;
+type IgnoreTarget = MaybeElement | string;
+
+interface UseClickOutsideOptions {
+    window?: Window | null;
+    document?: Document | null;
+    ignore?: IgnoreTarget | IgnoreTarget[];
+    capture?: boolean;
+}
+interface UseClickOutsideControls {
+    start: () => void;
+    stop: () => void;
+    active: () => boolean;
+    trigger: (event?: Event) => void;
+}
+/**
+ * Trigger handler when pointer interaction happens outside target elements.
+ *
+ * @fictReturn { active: 'signal' }
+ */
+declare function useClickOutside(target: MaybeElement | MaybeElement[], handler: (event: Event) => void, options?: UseClickOutsideOptions): UseClickOutsideControls;
+
+type EventName = string | string[];
+interface UseEventListenerOptions extends AddEventListenerOptions {
+    immediate?: boolean;
+}
+
+interface UseEventListenerControls {
+    start: () => void;
+    stop: () => void;
+    active: () => boolean;
+}
+/**
+ * Bind event listeners with automatic teardown.
+ *
+ * @fictReturn { active: 'signal' }
+ */
+declare function useEventListener<E extends Event = Event>(target: MaybeTarget<EventTarget> | Array<MaybeTarget<EventTarget>>, event: EventName | MaybeAccessor<EventName>, handler: (event: E) => void, options?: UseEventListenerOptions): UseEventListenerControls;
+
+interface UseFocusWithinOptions {
+    initialValue?: boolean;
+}
+interface UseFocusWithinReturn {
+    focused: () => boolean;
+}
+/**
+ * Track whether focus is currently inside a target element.
+ *
+ * @fictReturn { focused: 'signal' }
+ */
+declare function useFocusWithin(target: MaybeElement, options?: UseFocusWithinOptions): UseFocusWithinReturn;
+
+interface UseHoverOptions {
+    initialValue?: boolean;
+}
+interface UseHoverReturn {
+    hovered: () => boolean;
+}
+/**
+ * Track hover state for an element target.
+ *
+ * @fictReturn { hovered: 'signal' }
+ */
+declare function useHover(target: MaybeElement, options?: UseHoverOptions): UseHoverReturn;
+
+type KeyEventName = 'keydown' | 'keyup' | 'keypress';
+type KeyFilter = string | string[] | ((event: KeyboardEvent) => boolean);
+interface UseKeyPressOptions {
+    target?: MaybeTarget<EventTarget> | Array<MaybeTarget<EventTarget>> | null;
+    events?: KeyEventName | KeyEventName[];
+    exactMatch?: boolean;
+    passive?: boolean;
+    capture?: boolean;
+    preventDefault?: boolean;
+    immediate?: boolean;
+}
+/**
+ * Listen to keyboard events with key-filter matching.
+ *
+ * @fictReturn { active: 'signal' }
+ */
+declare function useKeyPress(filter: KeyFilter, handler: (event: KeyboardEvent) => void, options?: UseKeyPressOptions): UseEventListenerControls;
+
+type Procedure = (...args: unknown[]) => void;
+interface ControlledFn<T extends Procedure> {
+    run: (...args: Parameters<T>) => void;
+    cancel: () => void;
+    flush: () => void;
+    pending: () => boolean;
+}
+interface DebounceOptions {
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+}
+interface ThrottleOptions {
+    leading?: boolean;
+    trailing?: boolean;
+}
+
+type UseDebounceFnOptions = DebounceOptions;
+/**
+ * Debounced function wrapper with lifecycle-aware cleanup.
+ *
+ * @fictReturn {}
+ */
+declare function useDebounceFn<T extends Procedure>(fn: T, wait: number, options?: UseDebounceFnOptions): ControlledFn<T>;
+
+interface UseIntervalFnControls {
+    run: () => void;
+    cancel: () => void;
+    flush: () => void;
+    pending: () => boolean;
+}
+/**
+ * Create a managed interval with pause and resume controls.
+ *
+ * @fictReturn { pending: 'signal' }
+ */
+declare function useIntervalFn(callback: () => void, interval: number | MaybeAccessor<number>): UseIntervalFnControls;
+
+interface UseRafFnOptions {
+    immediate?: boolean;
+    window?: Window | null;
+}
+interface UseRafFnReturn {
+    active: () => boolean;
+    start: () => void;
+    stop: () => void;
+}
+/**
+ * requestAnimationFrame loop helper.
+ *
+ * @fictReturn { active: 'signal' }
+ */
+declare function useRafFn(callback: (delta: number, timestamp: number) => void, options?: UseRafFnOptions): UseRafFnReturn;
+
+type UseThrottleFnOptions = ThrottleOptions;
+/**
+ * Throttled function wrapper with lifecycle-aware cleanup.
+ *
+ * @fictReturn {}
+ */
+declare function useThrottleFn<T extends Procedure>(fn: T, wait: number, options?: UseThrottleFnOptions): ControlledFn<T>;
+
+interface UseTimeoutFnControls {
+    run: () => void;
+    cancel: () => void;
+    flush: () => void;
+    pending: () => boolean;
+}
+/**
+ * Schedule a callback with timeout controls.
+ *
+ * @fictReturn { pending: 'signal' }
+ */
+declare function useTimeoutFn(callback: () => void, delay: number | MaybeAccessor<number>): UseTimeoutFnControls;
+
+interface Serializer<T> {
+    read: (raw: string) => T;
+    write: (value: T) => string;
+}
+interface UseStorageOptions<T> {
+    window?: Window;
+    listenToStorageChanges?: boolean;
+    writeDefaults?: boolean;
+    serializer?: Serializer<T>;
+    onError?: (error: unknown) => void;
+}
+interface UseStorageReturn<T> {
+    value: () => T;
+    set: (next: T | ((prev: T) => T)) => void;
+    remove: () => void;
+}
+
+/**
+ * localStorage-backed state.
+ *
+ * @fictReturn { value: 'signal' }
+ */
+declare function useLocalStorage<T>(key: string, initial: T, options?: UseStorageOptions<T>): UseStorageReturn<T>;
+
+/**
+ * sessionStorage-backed state.
+ *
+ * @fictReturn { value: 'signal' }
+ */
+declare function useSessionStorage<T>(key: string, initial: T, options?: UseStorageOptions<T>): UseStorageReturn<T>;
+
+interface UseStorageHookOptions<T> extends UseStorageOptions<T> {
+    storage?: Storage | null;
+}
+/**
+ * Generic storage-backed state.
+ *
+ * @fictReturn { value: 'signal' }
+ */
+declare function useStorage<T>(key: string, initial: T, options?: UseStorageHookOptions<T>): UseStorageReturn<T>;
+
+interface UseIntersectionObserverOptions extends Omit<IntersectionObserverInit, 'root'> {
+    window?: Window | null;
+    root?: MaybeTarget<Element>;
+}
+interface UseIntersectionObserverReturn {
+    entries: () => IntersectionObserverEntry[];
+    isSupported: () => boolean;
+    start: () => void;
+    stop: () => void;
+    active: () => boolean;
+}
+/**
+ * Observe element intersection changes.
+ *
+ * @fictReturn { entries: 'signal', isSupported: 'signal', active: 'signal' }
+ */
+declare function useIntersectionObserver(target: MaybeElement | MaybeElement[], callback?: (entries: IntersectionObserverEntry[], observer: IntersectionObserver) => void, options?: UseIntersectionObserverOptions): UseIntersectionObserverReturn;
+
+interface UseMutationObserverOptions extends MutationObserverInit {
+    window?: Window | null;
+}
+interface UseMutationObserverReturn {
+    records: () => MutationRecord[];
+    isSupported: () => boolean;
+    active: () => boolean;
+    start: () => void;
+    stop: () => void;
+}
+/**
+ * Observe DOM mutations for target elements.
+ *
+ * @fictReturn { records: 'signal', isSupported: 'signal', active: 'signal' }
+ */
+declare function useMutationObserver(target: MaybeElement | MaybeElement[], callback?: (records: MutationRecord[], observer: MutationObserver) => void, options?: UseMutationObserverOptions): UseMutationObserverReturn;
+
+interface UseResizeObserverOptions {
+    box?: ResizeObserverBoxOptions;
+    window?: Window | null;
+}
+interface UseResizeObserverReturn {
+    entries: () => ResizeObserverEntry[];
+    isSupported: () => boolean;
+    active: () => boolean;
+    start: () => void;
+    stop: () => void;
+}
+/**
+ * Observe element resize changes.
+ *
+ * @fictReturn { entries: 'signal', isSupported: 'signal', active: 'signal' }
+ */
+declare function useResizeObserver(target: MaybeElement | MaybeElement[], callback?: (entries: ResizeObserverEntry[], observer: ResizeObserver) => void, options?: UseResizeObserverOptions): UseResizeObserverReturn;
+
+interface UseCounterOptions {
+    min?: number;
+    max?: number;
+}
+interface UseCounterReturn {
+    count: () => number;
+    set: (next: number) => void;
+    inc: (delta?: number) => void;
+    dec: (delta?: number) => void;
+    reset: () => void;
+}
+/**
+ * Number state helper with optional min/max bounds.
+ *
+ * @fictReturn { count: 'signal' }
+ */
+declare function useCounter(initial?: number, options?: UseCounterOptions): UseCounterReturn;
+
+/**
+ * Track the previous value of a reactive source.
+ *
+ * @fictReturn 'signal'
+ */
+declare function usePrevious<T>(value: T | MaybeAccessor<T>): () => T | undefined;
+
+interface UseToggleReturn {
+    value: () => boolean;
+    toggle: () => void;
+    set: (next: boolean) => void;
+    setTrue: () => void;
+    setFalse: () => void;
+}
+/**
+ * Boolean state helper.
+ *
+ * @fictReturn { value: 'signal' }
+ */
+declare function useToggle(initial?: boolean): UseToggleReturn;
+
+interface VirtualItem<T> {
+    index: number;
+    data: T;
+    start: number;
+    end: number;
+}
+interface UseVirtualListOptions {
+    itemHeight: number;
+    containerHeight: number | MaybeAccessor<number>;
+    overscan?: number;
+    initialScrollTop?: number;
+}
+interface UseVirtualListReturn<T> {
+    list: () => VirtualItem<T>[];
+    totalHeight: () => number;
+    start: () => number;
+    end: () => number;
+    scrollTop: () => number;
+    setScrollTop: (value: number) => void;
+    scrollTo: (index: number) => void;
+    onScroll: (event: Event) => void;
+}
+/**
+ * Fixed-height virtual list state helper.
+ *
+ * @fictReturn { list: 'memo', totalHeight: 'memo', start: 'memo', end: 'memo', scrollTop: 'signal' }
+ */
+declare function useVirtualList<T>(source: T[] | MaybeAccessor<T[]>, options: UseVirtualListOptions): UseVirtualListReturn<T>;
+
+interface UseDocumentVisibilityOptions {
+    document?: Document | null;
+    initialVisibility?: DocumentVisibilityState;
+}
+interface UseDocumentVisibilityReturn {
+    visibility: () => DocumentVisibilityState;
+    hidden: () => boolean;
+}
+/**
+ * Track page visibility state.
+ *
+ * @fictReturn { visibility: 'signal', hidden: 'memo' }
+ */
+declare function useDocumentVisibility(options?: UseDocumentVisibilityOptions): UseDocumentVisibilityReturn;
+
+interface UseMediaQueryOptions {
+    window?: Window | null;
+    initialValue?: boolean;
+}
+interface UseMediaQueryReturn {
+    matches: () => boolean;
+    query: () => string;
+    isSupported: () => boolean;
+}
+/**
+ * Reactive media query matching state.
+ *
+ * @fictReturn { matches: 'signal', query: 'signal', isSupported: 'signal' }
+ */
+declare function useMediaQuery(mediaQuery: string | MaybeAccessor<string>, options?: UseMediaQueryOptions): UseMediaQueryReturn;
+
+interface NetworkConnectionLike extends EventTarget {
+    downlink?: number;
+    effectiveType?: string;
+    rtt?: number;
+    saveData?: boolean;
+    type?: string;
+}
+interface NavigatorWithConnection extends Navigator {
+    connection?: NetworkConnectionLike;
+    mozConnection?: NetworkConnectionLike;
+    webkitConnection?: NetworkConnectionLike;
+}
+interface UseNetworkOptions {
+    window?: Window | null;
+    navigator?: NavigatorWithConnection | null;
+}
+interface UseNetworkReturn {
+    online: () => boolean;
+    downlink: () => number | null;
+    effectiveType: () => string | null;
+    rtt: () => number | null;
+    saveData: () => boolean;
+    type: () => string | null;
+    isSupported: () => boolean;
+}
+/**
+ * Reactive network status state.
+ *
+ * @fictReturn { online: 'signal', downlink: 'signal', effectiveType: 'signal', rtt: 'signal', saveData: 'signal', type: 'signal', isSupported: 'signal' }
+ */
+declare function useNetwork(options?: UseNetworkOptions): UseNetworkReturn;
+
+interface ScrollPosition {
+    x: number;
+    y: number;
+}
+interface UseScrollOptions {
+    target?: MaybeTarget<Element | Document | Window> | null;
+    window?: Window | null;
+    initialX?: number;
+    initialY?: number;
+    shouldUpdate?: (next: ScrollPosition, prev: ScrollPosition) => boolean;
+    passive?: boolean;
+    capture?: boolean;
+}
+interface UseScrollReturn {
+    x: () => number;
+    y: () => number;
+}
+/**
+ * Track scroll position for window, document or element targets.
+ *
+ * @fictReturn { x: 'signal', y: 'signal' }
+ */
+declare function useScroll(options?: UseScrollOptions): UseScrollReturn;
+
+interface PermissionNavigator {
+    permissions?: {
+        query: (permissionDesc: PermissionDescriptor) => Promise<PermissionStatus>;
+    };
+}
+type PermissionInput = PermissionDescriptor | string;
+interface UsePermissionOptions {
+    navigator?: PermissionNavigator | null;
+    initialState?: PermissionState;
+    immediate?: boolean;
+}
+interface UsePermissionReturn {
+    state: () => PermissionState;
+    isSupported: () => boolean;
+    query: () => Promise<PermissionStatus | null>;
+}
+/**
+ * Reactive Permissions API helper.
+ *
+ * @fictReturn { state: 'signal', isSupported: 'signal' }
+ */
+declare function usePermission(permission: PermissionInput | MaybeAccessor<PermissionInput>, options?: UsePermissionOptions): UsePermissionReturn;
+
+interface GeolocationNavigator {
+    geolocation?: {
+        watchPosition: (success: PositionCallback, error?: PositionErrorCallback, options?: PositionOptions) => number;
+        clearWatch: (watchId: number) => void;
+    };
+}
+interface GeolocationCoordsState {
+    accuracy: number;
+    latitude: number;
+    longitude: number;
+    altitude: number | null;
+    altitudeAccuracy: number | null;
+    heading: number | null;
+    speed: number | null;
+}
+interface UseGeolocationOptions extends PositionOptions {
+    navigator?: GeolocationNavigator | null;
+    immediate?: boolean;
+}
+interface UseGeolocationReturn {
+    isSupported: () => boolean;
+    coords: () => GeolocationCoordsState;
+    locatedAt: () => number | null;
+    error: () => GeolocationPositionError | null;
+    active: () => boolean;
+    resume: () => void;
+    pause: () => void;
+}
+/**
+ * Reactive Geolocation API wrapper.
+ *
+ * @fictReturn { isSupported: 'signal', coords: 'signal', locatedAt: 'signal', error: 'signal', active: 'signal' }
+ */
+declare function useGeolocation(options?: UseGeolocationOptions): UseGeolocationReturn;
+
+declare const DEFAULT_IDLE_EVENTS: readonly ["mousemove", "mousedown", "resize", "keydown", "touchstart", "wheel", "pointerdown"];
+interface UseIdleOptions {
+    timeout?: number;
+    window?: Window | null;
+    document?: Document | null;
+    events?: Array<(typeof DEFAULT_IDLE_EVENTS)[number] | string>;
+    listenForVisibilityChange?: boolean;
+    immediate?: boolean;
+    initialState?: boolean;
+}
+interface UseIdleReturn {
+    idle: () => boolean;
+    lastActive: () => number | null;
+    isSupported: () => boolean;
+    active: () => boolean;
+    reset: () => void;
+    pause: () => void;
+    resume: () => void;
+}
+/**
+ * Track user idle state using activity events + timer.
+ *
+ * @fictReturn { idle: 'signal', lastActive: 'signal', isSupported: 'signal', active: 'signal' }
+ */
+declare function useIdle(options?: UseIdleOptions): UseIdleReturn;
+
+interface UseSizeOptions {
+    window?: Window | null;
+    box?: ResizeObserverBoxOptions;
+    initialWidth?: number;
+    initialHeight?: number;
+    initialTop?: number;
+    initialLeft?: number;
+    initialX?: number;
+    initialY?: number;
+    immediate?: boolean;
+}
+interface UseSizeReturn {
+    width: () => number;
+    height: () => number;
+    top: () => number;
+    left: () => number;
+    x: () => number;
+    y: () => number;
+    isSupported: () => boolean;
+    active: () => boolean;
+    update: () => void;
+    start: () => void;
+    stop: () => void;
+}
+/**
+ * Track element size/position reactively.
+ *
+ * @fictReturn { width: 'signal', height: 'signal', top: 'signal', left: 'signal', x: 'signal', y: 'signal', isSupported: 'signal', active: 'signal' }
+ */
+declare function useSize(target: MaybeElement | null, options?: UseSizeOptions): UseSizeReturn;
+
+type WebSocketStatus = 'CONNECTING' | 'OPEN' | 'CLOSING' | 'CLOSED';
+interface UseWebSocketReconnectOptions {
+    retries?: number;
+    delay?: number | ((attempt: number) => number);
+}
+type SerializablePayload = string | ArrayBufferLike | Blob | ArrayBufferView;
+type WebSocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send' | 'close' | 'readyState' | 'binaryType' | 'OPEN' | 'CONNECTING' | 'CLOSING' | 'CLOSED'>;
+type WebSocketConstructor = new (url: string | URL, protocols?: string | string[]) => WebSocketLike;
+interface UseWebSocketOptions<TIncoming = unknown, TOutgoing = SerializablePayload> {
+    window?: Window | null;
+    webSocket?: WebSocketConstructor | null;
+    protocols?: string | string[];
+    immediate?: boolean;
+    autoReconnect?: boolean | UseWebSocketReconnectOptions;
+    binaryType?: BinaryType;
+    initialData?: TIncoming | null;
+    serialize?: (payload: TOutgoing) => SerializablePayload;
+    deserialize?: (event: MessageEvent) => TIncoming;
+    onOpen?: (event: Event) => void;
+    onMessage?: (data: TIncoming, event: MessageEvent) => void;
+    onError?: (event: Event) => void;
+    onClose?: (event: CloseEvent) => void;
+}
+interface UseWebSocketReturn<TIncoming = unknown, TOutgoing = SerializablePayload> {
+    data: () => TIncoming | null;
+    error: () => Event | null;
+    status: () => WebSocketStatus;
+    isSupported: () => boolean;
+    reconnectCount: () => number;
+    open: () => boolean;
+    close: (code?: number, reason?: string) => void;
+    reconnect: () => boolean;
+    send: (payload: TOutgoing) => boolean;
+}
+/**
+ * Reactive WebSocket connection helper.
+ *
+ * @fictReturn { data: 'signal', error: 'signal', status: 'signal', isSupported: 'signal', reconnectCount: 'signal' }
+ */
+declare function useWebSocket<TIncoming = unknown, TOutgoing = SerializablePayload>(url: MaybeAccessor<string | URL | null | undefined>, options?: UseWebSocketOptions<TIncoming, TOutgoing>): UseWebSocketReturn<TIncoming, TOutgoing>;
+
+interface UseWindowSizeOptions {
+    window?: Window | null;
+    initialWidth?: number;
+    initialHeight?: number;
+}
+interface UseWindowSizeReturn {
+    width: () => number;
+    height: () => number;
+}
+/**
+ * Reactive window size state.
+ *
+ * @fictReturn { width: 'signal', height: 'signal' }
+ */
+declare function useWindowSize(options?: UseWindowSizeOptions): UseWindowSizeReturn;
+
+interface UseWindowScrollOptions extends Omit<UseScrollOptions, 'target'> {
+    window?: Window | null;
+}
+/**
+ * Track scroll position for window only.
+ *
+ * @fictReturn { x: 'signal', y: 'signal' }
+ */
+declare function useWindowScroll(options?: UseWindowScrollOptions): UseScrollReturn;
+
+interface UseTitleOptions {
+    document?: Document | null;
+    restoreOnUnmount?: boolean;
+}
+interface UseTitleReturn {
+    title: () => string;
+}
+/**
+ * Reactive document title helper.
+ *
+ * @fictReturn { title: 'signal' }
+ */
+declare function useTitle(value: string | MaybeAccessor<string>, options?: UseTitleOptions): UseTitleReturn;
+
+interface UseFullscreenOptions {
+    target?: MaybeElement | null;
+    document?: Document | null;
+    autoExit?: boolean;
+}
+interface UseFullscreenReturn {
+    isSupported: () => boolean;
+    isFullscreen: () => boolean;
+    enter: () => Promise<boolean>;
+    exit: () => Promise<boolean>;
+    toggle: () => Promise<boolean>;
+}
+/**
+ * Fullscreen API wrapper for target elements.
+ *
+ * @fictReturn { isSupported: 'signal', isFullscreen: 'signal' }
+ */
+declare function useFullscreen(options?: UseFullscreenOptions): UseFullscreenReturn;
+
+export { type GeolocationCoordsState, type KeyEventName, type KeyFilter, type MountCallback, type PermissionInput, type ScrollPosition, type UnmountCallback, type UseAsyncStateOptions, type UseAsyncStateReturn, type UseClickOutsideControls, type UseClickOutsideOptions, type UseClipboardOptions, type UseClipboardReturn, type UseCounterOptions, type UseCounterReturn, type UseDebounceFnOptions, type UseDocumentVisibilityOptions, type UseDocumentVisibilityReturn, type UseEventListenerControls, type UseFetchOptions, type UseFetchReturn, type UseFocusWithinOptions, type UseFocusWithinReturn, type UseFullscreenOptions, type UseFullscreenReturn, type UseGeolocationOptions, type UseGeolocationReturn, type UseHoverOptions, type UseHoverReturn, type UseIdleOptions, type UseIdleReturn, type UseIntersectionObserverOptions, type UseIntersectionObserverReturn, type UseIntervalFnControls, type UseKeyPressOptions, type UseMediaQueryOptions, type UseMediaQueryReturn, type UseMutationObserverOptions, type UseMutationObserverReturn, type UseNetworkOptions, type UseNetworkReturn, type UsePermissionOptions, type UsePermissionReturn, type UseRafFnOptions, type UseRafFnReturn, type UseRequestOptions, type UseRequestReturn, type UseResizeObserverOptions, type UseResizeObserverReturn, type UseScrollOptions, type UseScrollReturn, type UseSizeOptions, type UseSizeReturn, type UseStorageHookOptions, type UseThrottleFnOptions, type UseTimeoutFnControls, type UseTitleOptions, type UseTitleReturn, type UseToggleReturn, type UseVirtualListOptions, type UseVirtualListReturn, type UseWebSocketOptions, type UseWebSocketReconnectOptions, type UseWebSocketReturn, type UseWindowScrollOptions, type UseWindowSizeOptions, type UseWindowSizeReturn, type VirtualItem, type WebSocketStatus, useAsyncState, useClickOutside, useClipboard, useCounter, useDebounceFn, useDocumentVisibility, useEventListener, useFetch, useFocusWithin, useFullscreen, useGeolocation, useHover, useIdle, useIntersectionObserver, useIntervalFn, useKeyPress, useLocalStorage, useMediaQuery, useMount, useMutationObserver, useNetwork, usePermission, usePrevious, useRafFn, useRequest, useResizeObserver, useScroll, useSessionStorage, useSize, useStorage, useThrottleFn, useTimeoutFn, useTitle, useToggle, useUnmount, useVirtualList, useWebSocket, useWindowScroll, useWindowSize };