@reause/shared 0.1.2

package/dist/index.d.ts

@@ -0,0 +1,2713 @@
+import { Context, Dispatch, PropsWithChildren, ReactNode, Ref, RefObject, SetStateAction } from "react";
+//#region createEventHook/index.d.ts
+/**
+ * Utility for creating event hooks — React port of VueUse's `createEventHook`.
+ *
+ * Map from @vueuse/shared `createEventHook`
+ * Mapping notes:
+ * - VueUse auto-disposes listeners through the Vue effect scope
+ *   (`tryOnScopeDispose`); React has no scope equivalent, so that call is
+ *   dropped. Clean up manually with the `{ off }` object returned by `on`
+ *   (e.g. in an effect cleanup), or bind the hook with `useListener(on, cb)`
+ *   for automatic cleanup on unmount.
+ * - `trigger` matches upstream error semantics: a synchronous throw inside
+ *   one listener propagates out of `trigger` and aborts the remaining
+ *   listeners (upstream has no per-listener guard); rejections from async
+ *   listeners still surface on the promise returned by `trigger`.
+ *
+ * The source code for this function was inspired by vue-apollo's `useEventHook` util
+ * https://github.com/vuejs/vue-apollo/blob/v4/packages/vue-apollo-composable/src/util/useEventHook.ts
+ *
+ * @see https://vueuse.org/createEventHook
+ *
+ * @example
+ * const resultEvent = createEventHook<Response>()
+ * useListener(resultEvent.on, (response) => { console.log(response) })
+ * resultEvent.trigger(response)
+ */
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+type Callback<T> = IsAny<T> extends true ? (...param: any) => void : ([T] extends [void] ? (...param: unknown[]) => void : [T] extends [any[]] ? (...param: T) => void : (...param: [T, ...unknown[]]) => void);
+export type EventHookOn<T = any> = (fn: Callback<T>) => {
+  off: () => void;
+};
+export type EventHookOff<T = any> = (fn: Callback<T>) => void;
+export type EventHookTrigger<T = any> = (...param: Parameters<Callback<T>>) => Promise<unknown[]>;
+export interface EventHook<T = any> {
+  on: EventHookOn<T>;
+  off: EventHookOff<T>;
+  trigger: EventHookTrigger<T>;
+  clear: () => void;
+}
+export type EventHookReturn<T> = EventHook<T>;
+/**
+ * Utility for creating event hooks
+ *
+ * @see https://vueuse.org/createEventHook
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function createEventHook<T = any>(): EventHookReturn<T>;
+//#endregion
+//#region createGlobalState/index.d.ts
+export type GlobalStateInitAction<State> = State | (() => State);
+export type GlobalStateSetAction<State> = State | ((prev: State) => State);
+export type GlobalStateSetter<State> = (update: GlobalStateSetAction<State>) => void;
+/**
+ * Keep state in the global scope, reusable across React components — React
+ * port of VueUse's `createGlobalState`, with the parameter following
+ * react-use's `createGlobalState`.
+ *
+ * Map from @vueuse/shared `createGlobalState`
+ * Mapping: upstream runs the factory inside a detached `effectScope(true)`
+ * once and returns the reactive object, so every caller shares the same refs
+ * and `computed`s. React has no `effectScope` and no reactive `ref`, so the
+ * port keeps the state in a module-level external store (a per-factory closure
+ * holding the value plus a `Set` of listeners) and every consumer reads it
+ * through `useSyncExternalStore`. The store is never disposed or reset, so
+ * state survives unmount exactly like upstream's detached scope.
+ *
+ * The parameter follows react-use `createGlobalState`: it is the **initial
+ * state** — a plain value, or a zero-arg function computing it. It is resolved
+ * exactly once, at `createGlobalState` call time (module scope), mirroring
+ * react-use's `store.state = initialState instanceof Function ? initialState()
+ * : initialState`; the initializer therefore never runs during a component
+ * render, and the returned hook takes no arguments. This differs from upstream
+ * VueUse, where the factory receives the arguments of the first hook call.
+ *
+ * Deviations from upstream:
+ * - module-level external store instead of `effectScope(true)` — the scope's
+ *   only job was keeping the state alive outside any component; a module-level
+ *   closure does that without a scope, and `useSyncExternalStore` makes every
+ *   consumer re-render on change.
+ * - the returned hook yields the tuple `[state, setState]` instead of the
+ *   factory's object of refs (`{ count, doubleCount, increment }`): §2B of the
+ *   naming rules — a state-like writable hook returns `[value, setValue]`.
+ *   Derive computed values inside the consumer from `state`, and expose
+ *   actions through the factory's returned state or a plain function.
+ * - the parameter is react-use's initial state (value or zero-arg initializer)
+ *   instead of upstream's variadic factory (see above).
+ *
+ * The tuple is memoized on the snapshot, so its identity is stable across
+ * renders for a given state (effect deps / memoized children keyed on the
+ * tuple do not churn); `setState` is a single function shared by every
+ * consumer, like react-use's `store.setState`.
+ *
+ * ```ts
+ * const useGlobalState = createGlobalState(() => 0)
+ *
+ * function Counter() {
+ *   const [count, setCount] = useGlobalState()
+ *   return <button onClick={() => setCount(prev => prev + 1)}>{count}</button>
+ * }
+ * ```
+ *
+ * @see https://vueuse.org/createGlobalState
+ * @see https://github.com/streamich/react-use/blob/master/src/factory/createGlobalState.ts
+ * @param initialState The initial state — a plain value or a zero-arg function
+ * computing it; resolved exactly once, at `createGlobalState` call time.
+ */
+export declare function createGlobalState<State = unknown>(initialState: GlobalStateInitAction<State>): () => [State, GlobalStateSetter<State>];
+export declare function createGlobalState<State = undefined>(): () => [State, GlobalStateSetter<State>];
+//#endregion
+//#region createInjectionState/index.d.ts
+export interface CreateInjectionStateOptions<Return> {
+  /**
+   * Custom injectionKey for InjectionState — the React equivalent of
+   * upstream's string/symbol key. React keys a context by object identity, so
+   * pass a `createContext(...)` instance; consumers may then read it directly
+   * with `useContext`.
+   */
+  injectionKey?: Context<Return | undefined>;
+  /**
+   * Default value used by `useInjectedState` when no provider is rendered
+   * above the consumer. Implemented natively through `createContext`; when a
+   * custom `injectionKey` is supplied, that context's own default is used
+   * instead.
+   */
+  defaultValue?: Return;
+}
+export type CreateInjectionStateProvider<Props extends object, ProvideReturn = ReactNode> = (props: PropsWithChildren<Props>) => ProvideReturn;
+export type CreateInjectionStateReturn<Props extends object, ProvideReturn, InjectReturn> = Readonly<[
+/**
+ * Render this component to create and provide the state to its descendants.
+ */
+Provider: CreateInjectionStateProvider<Props, ProvideReturn>,
+/**
+ * Call this hook in a consumer component to inject the state.
+ */
+useInjectedState: () => InjectReturn]>;
+/**
+ * Create a state that can be injected into descendant components — React port
+ * of VueUse's `createInjectionState`.
+ *
+ * Map from @vueuse/shared `createInjectionState`
+ * Mapping: React has no provide/inject pair, so the providing side becomes a
+ * component and the state travels through a React Context created by the
+ * factory (or supplied through `options.injectionKey`). Slot 0 of the returned
+ * tuple is `Provider` — render it (it may wrap children) and the composable
+ * runs during its render, exactly once per render, with the props passed to
+ * it. Slot 1 is `useInjectedState`, which reads the nearest `Provider` above
+ * the calling component with `useContext`.
+ * Because JSX can only pass a single props object, the factory receives one
+ * object — upstream's `(initialValue: number) => ...` becomes
+ * `({ initialValue }: { initialValue: number }) => ...`.
+ *
+ * The second type parameter (`ProvideReturn`) is upstream's
+ * `useProvidingState` return slot, which in this port is the provider
+ * component's render output (`ReactNode`).
+ *
+ * Deviations from upstream:
+ * - `options.injectionKey` takes a React `Context` instead of a string/symbol
+ *   key: React keys a context by object identity, so the factory's own
+ *   `Context` is the default key and a custom context can be shared with a
+ *   plain `useContext`.
+ * - The providing side is a component (`Provider`) rather than a callable
+ *   `useProvidingState`: React cannot provide during a hook call of the same
+ *   component that consumes it.
+ * - The factory takes a single props object instead of variadic arguments.
+ * - `children` is a reserved prop: it is consumed by `Provider` for rendering
+ *   and is not forwarded to the factory.
+ *
+ * @see https://vueuse.org/createInjectionState
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * const [CounterStoreProvider, useCounterStore] = createInjectionState(
+ *   ({ initialValue }: { initialValue: number }) => {
+ *     const [count, setCount] = useState(initialValue)
+ *     return { count, inc: () => setCount(c => c + 1) }
+ *   },
+ * )
+ *
+ * function Counter() {
+ *   const { count, inc } = useCounterStore()!
+ *   return <button onClick={inc}>{count}</button>
+ * }
+ *
+ * <CounterStoreProvider initialValue={0}>
+ *   <Counter />
+ * </CounterStoreProvider>
+ */
+export declare function createInjectionState<Props extends object, Return>(composable: (props: Props) => Return, options: {
+  defaultValue: Return;
+} & CreateInjectionStateOptions<Return>): CreateInjectionStateReturn<Props, ReactNode, Return>;
+export declare function createInjectionState<Props extends object, Return>(composable: (props: Props) => Return, options?: CreateInjectionStateOptions<Return>): CreateInjectionStateReturn<Props, ReactNode, Return | undefined>;
+//#endregion
+//#region createSharedHook/index.d.ts
+/**
+ * Make a composable function usable with multiple React components.
+ *
+ * Map from @vueuse/shared `createSharedComposable`
+ * Mapping: upstream runs the composable once inside a detached
+ * `effectScope(true)`, counts the subscribers and stops the scope when the
+ * last consumer leaves. React has no `effectScope`, so the same lifetime is
+ * expressed by an external store held in the closure of one
+ * `createSharedHook` call — the `state` snapshot, a `Set` of `listeners`, the
+ * `refCount` and the optional `cleanup` — which every consumer reads through
+ * `useSyncExternalStore`.
+ *
+ * The shared instance is created by the **first consumer to render** (the
+ * "creator"): it runs the wrapped hook on every one of its renders — the
+ * wrapped hook is therefore free to use React hooks internally — assigning
+ * the result to `state`, and `useLayoutEffect` publishes the latest value to
+ * every other consumer after commit. Every later consumer never calls the
+ * wrapped hook (both call patterns are stable per consumer, so the hook order
+ * never changes across renders); it just reads the published snapshot. The
+ * creator assigns `state` *before* `useSyncExternalStore` reads its snapshot
+ * in the same render, so every consumer — creator included — receives the
+ * shared value on its very first render, never `undefined`.
+ *
+ * The creator deliberately **does not register a store listener**: it already
+ * re-renders on its own state changes (the wrapped hook's setters belong to
+ * its component) and re-publishes afterwards, so a notification would only
+ * re-render it from its own publish. `useSyncExternalStore` requires the
+ * snapshot to stay reference-stable between real changes ("the result of
+ * getSnapshot should be cached"): every creator render assigns a fresh
+ * reference, so a subscribed creator would see "the store changed" forever and
+ * loop. The creator still counts toward `refCount`, so teardown timing is
+ * exact — it just never receives notifications.
+ *
+ * Deviations from upstream:
+ * - upstream runs the composable exactly once, with the first caller's
+ *   arguments; here the creator re-runs the wrapped hook on every one of its
+ *   renders (React hooks cannot be called outside a render), so while the
+ *   creator stays mounted the shared value keeps tracking its latest render.
+ * - **frozen after the creator unmounts**: the wrapped hook's setters belong
+ *   to the creator's component, so if the creator unmounts while other
+ *   consumers remain mounted, the shared value stops updating — it freezes at
+ *   the last published value. The instance itself lives on until the last
+ *   consumer unmounts (upstream lifetime parity).
+ * - `getServerSnapshot` returns the same snapshot as the client: server
+ *   rendering yields the uninitialized value, the client fills it in after
+ *   hydration, and `useSyncExternalStore` handles the mismatch.
+ * - Teardown has no `tryOnScopeDispose` to hook into, so the optional
+ *   `cleanup` argument is called — and the state dropped — when the last
+ *   consumer unmounts; a later mount starts a fresh instance, exactly like
+ *   upstream's `scope.stop()` followed by `state = undefined`.
+ *
+ * ```tsx
+ * const useSharedMouse = createSharedHook(useMouse)
+ *
+ * // CompA — const { x, y } = useSharedMouse()
+ * // CompB — const { x, y } = useSharedMouse() // same state, no new listeners
+ * ```
+ *
+ * @see https://vueuse.org/createSharedComposable
+ * @param hook The composable to share across every consumer of the returned
+ * hook. It runs on every render of the first consumer (the creator).
+ * @param cleanup Called when the last consumer unmounts, before the shared
+ * state is dropped — the place to undo whatever `hook` set up outside React.
+ */
+export declare function createSharedHook<Fn extends (...args: any[]) => any>(hook: Fn, cleanup?: () => void): (...args: Parameters<Fn>) => ReturnType<Fn>;
+//#endregion
+//#region isDefined/index.d.ts
+export type IsDefinedReturn = boolean;
+/**
+ * Non-nullish checking type guard for ref-like objects.
+ *
+ * Map from @vueuse/shared `isDefined`
+ * Mapping: upstream narrows a Vue `Ref` / `ComputedRef` itself; this port
+ * operates on React ref-like objects (`{ current }`) and narrows `.current`
+ * to `Exclude<T, null | undefined>` — upstream's `Ref` and `ComputedRef`
+ * overloads collapse into the single ref-like overload below. The
+ * plain-value overload keeps upstream parity at the type level, so bare
+ * values can be guarded with the same call. At runtime a ref-like is
+ * detected via `isRefLike` (mirroring upstream's `unref`), so both shapes
+ * share one check — with one edge: a plain object that happens to look like
+ * a ref (`{ current: undefined }`) is unwrapped and judged by `.current`
+ * (upstream `unref` only unwraps Vue refs, so the same object would be
+ * `true` there).
+ *
+ * @__NO_SIDE_EFFECTS__
+ * @example
+ * const example = useRef(Math.random() ? 'example' : undefined) // RefObject<string | undefined>
+ *
+ * if (isDefined(example))
+ *   example.current // string — narrowed by the type guard
+ *
+ * @see https://vueuse.org/shared/isDefined/
+ */
+export declare function isDefined<T>(v: RefObject<T>): v is RefObject<Exclude<T, null | undefined>>;
+export declare function isDefined<T>(v: T): v is Exclude<T, null | undefined>;
+//#endregion
+//#region makeDestructurable/index.d.ts
+/**
+ * Make isomorphic destructurable for object and array at the same time —
+ * React port of VueUse's `makeDestructurable` (a pure utility function, so it
+ * maps 1:1 with no React adaptation). See this blog for the underlying idea:
+ * https://antfu.me/posts/destructuring-with-object-or-array/
+ *
+ * Map from @vueuse/shared `makeDestructurable`
+ * Upstream semantics are kept verbatim: given `(obj, arr)` the returned value
+ * can be destructured as an object (`const { foo, bar } = obj`) or as an array
+ * (`const [foo, bar] = obj`) — the array mode is backed by a non-enumerable
+ * `Symbol.iterator` defined on a shallow clone of `obj` (spread
+ * `{ ...obj }`); `Object.assign` appears only in the no-Symbol SSR fallback.
+ *
+ * @example
+ * const foo = { name: 'foo' }
+ * const bar = 1024
+ * const obj = makeDestructurable({ foo, bar } as const, [foo, bar] as const)
+ * const { foo: f1, bar: b1 } = obj // object destructuring
+ * const [f2, b2] = obj // array destructuring
+ */
+export declare function makeDestructurable<T extends Record<string, unknown>, A extends readonly any[]>(obj: T, arr: A): T & A;
+//#endregion
+//#region utils/index.d.ts
+export declare function promiseTimeout(ms: number, throwOnTimeout?: boolean, reason?: string): Promise<void>;
+export interface SingletonPromiseReturn<T> {
+  (): Promise<T>;
+  /**
+   * Reset current staled promise.
+   * await it to have proper shutdown.
+   */
+  reset: () => Promise<void>;
+}
+/**
+ * Create singleton promise function
+ *
+ * @example
+ * ```
+ * const promise = createSingletonPromise(async () => { ... })
+ *
+ * await promise()
+ * await promise() // all of them will be bind to a single promise instance
+ * await promise() // and be resolved together
+ * ```
+ */
+export declare function createSingletonPromise<T>(fn: () => Promise<T>): SingletonPromiseReturn<T>;
+/**
+ * Increase string a value with unit
+ *
+ * @example '2px' + 1 = '3px'
+ * @example '15em' + (-2) = '13em'
+ */
+export declare function increaseWithUnit(target: number, delta: number): number;
+export declare function increaseWithUnit(target: string, delta: number): string;
+export declare function increaseWithUnit(target: string | number, delta: number): string | number;
+/**
+ * Get a px value for SSR use, do not rely on this method outside of SSR as REM
+ * unit is assumed at 16px, which might not be the case on the client
+ *
+ * @example pxValue('37rem') // 592
+ * @example pxValue('500px') // 500
+ */
+export declare function pxValue(px: string): number;
+/**
+ * Create a new subset object by giving keys
+ */
+export declare function objectPick<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined?: boolean): Pick<O, T>;
+/**
+ * Create a new subset object by omit giving keys
+ */
+export declare function objectOmit<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined?: boolean): Omit<O, T>;
+export declare function toArray<T>(value: T | readonly T[]): readonly T[];
+export declare function toArray<T>(value: T | T[]): T[];
+export declare const isDef: <T = any>(val?: T) => val is T;
+export declare const assert: (condition: boolean, ...infos: any[]) => void;
+export declare const isObject: (val: any) => val is object;
+export declare const now: () => number;
+export declare const timestamp: () => number;
+export declare const clamp: (n: number, min: number, max: number) => number;
+export declare const rand: (min: number, max: number) => number;
+export declare const hasOwn: <T extends object, K extends keyof T>(val: T, key: K) => key is K;
+export declare const isIOS: boolean;
+export declare const hyphenate: (str: string) => string;
+/** A plain value or a React ref. Zero-argument getter values are not supported. */
+export type RefOrValue<T> = T | Ref<T>;
+/** Values accepted by controllable state hooks. */
+export type StateValue<T> = RefOrValue<T> | (() => T) | readonly [T, (value: T | ((prev: T) => T)) => void] | {
+  value: T;
+  onChange?: (value: T) => void;
+};
+/**
+ * Allow a custom `window` instance, e.g. working with iframes or in testing
+ * environments. Single source of truth — VueUse defines this in shared too.
+ */
+export interface ConfigurableWindow {
+  window?: Window;
+}
+/**
+ * Type guard for React ref objects (`RefObject` — `{ current }` holders).
+ * Callback refs are functions and cannot be read synchronously, so they are
+ * not ref-like.
+ */
+export declare function isRefLike<T>(value: RefOrValue<T> | undefined | null): value is RefObject<T | null>;
+/**
+ * Resolve a plain value or a React ref to its current value — the React
+ * replacement for VueUse's `toValue`. Getters are not supported: pass a
+ * React ref (`useRef`) when the latest value must be read lazily.
+ */
+export declare function toValue<T>(value: StateValue<T>): T;
+export declare function toValue<T>(value: StateValue<T> | undefined | null): T | undefined | null;
+/**
+ * Write a value back through a writable `State<T>` source — a ref-like
+ * `.current`, a `[value, setter]` tuple or a `{ value, onChange }` pair.
+ * Plain values and getters have no write path and are skipped. This is the
+ * write-side counterpart of `toValue`; hooks that push values into a
+ * `State<T>` import it from here rather than re-implementing the branches.
+ */
+export declare function writeState<T>(source: StateValue<T> | undefined | null, value: T): void;
+//#endregion
+//#region useControllableState/index.d.ts
+export type StateTuple<T> = [T, Dispatch<SetStateAction<T>>];
+/** A value, lazy getter, React ref, state tuple, or value/onChange pair. */
+export type State<T> = StateValue<T>;
+export interface UseControllableStateOptions<T> {
+  defaultValue?: T | (() => T);
+  shouldUpdate?: (prev: T, next: T) => boolean;
+  passive?: boolean;
+}
+/**
+ * Combine controlled and uncontrolled state sources.
+ *
+ * `state` is resolved with `toValue` on every render. A tuple
+ * `[value, setter]` or a `{ value, onChange }` pair is always controlled: the
+ * current value is the resolved source and `setValue` writes through to the
+ * tuple setter / `onChange`. With `passive: true` a plain value, getter, or
+ * ref source is uncontrolled — the hook initializes from the source and local
+ * updates persist, and external source changes are synced back (honoring
+ * `shouldUpdate`). With the default `passive: false` such a source is
+ * controlled (the external value wins on every render); `setValue` then has
+ * no channel back to the caller, so it warns instead of silently discarding
+ * the update — pass a tuple, a `{ value, onChange }` pair, or use
+ * `passive: true` to write. `defaultValue` (value or lazy initializer) seeds
+ * the internal state of uncontrolled sources; `shouldUpdate(prev, next)`
+ * guards every commit, including the passive sync.
+ */
+export declare function useControllableState<T>(state: State<T>, options?: UseControllableStateOptions<T>): StateTuple<T>;
+//#endregion
+//#region syncState/index.d.ts
+export type SyncStateDirection = 'both' | 'ltr' | 'rtl';
+export interface SyncStateTransform<L, R> {
+  ltr: (left: L) => R;
+  rtl: (right: R) => L;
+}
+export interface SyncStateOptions<L, R, D extends SyncStateDirection = 'both'> {
+  /**
+   * Timing for syncing, same as watch's `flush` option.
+   *
+   * React note: no React equivalent — effects always run after commit, so
+   * `'sync'` / `'pre'` / `'post'` are accepted for upstream signature
+   * compatibility and all behave identically.
+   *
+   * @default 'sync'
+   */
+  flush?: 'sync' | 'pre' | 'post';
+  /**
+   * Watch deeply.
+   *
+   * React note: no React equivalent — a `.current` write never schedules a
+   * re-render by itself, so nested mutations cannot be observed (only the
+   * value as a whole is compared, via `Object.is`). Accepted for upstream
+   * signature compatibility.
+   *
+   * @default false
+   */
+  deep?: boolean;
+  /**
+   * Sync values immediately (on mount).
+   *
+   * @default true
+   */
+  immediate?: boolean;
+  /**
+   * Direction of syncing.
+   *
+   * @default 'both'
+   */
+  direction?: D;
+  /**
+   * Value convertors applied on the way to the other side: `ltr` maps a left
+   * value before it is written into the right state, `rtl` maps a right
+   * value before it is written into the left state. A missing convertor
+   * falls back to identity.
+   */
+  transform?: Partial<SyncStateTransform<L, R>>;
+}
+/**
+ * Two-way state synchronization — keeps two writable `State<T>` sources in
+ * sync, with optional direction and value transforms.
+ *
+ * Map from @vueuse/shared `syncRef`
+ * (`source/vueuse/packages/shared/syncRef/`), renamed `syncState` for the
+ * React port: the two sides are `State<T>` sources — a `[value, setter]`
+ * tuple, a `{ value, onChange }` pair, a ref-like `{ current }`, a getter or
+ * a plain value — instead of Vue refs. Each side is read with `toValue` and
+ * written back through its writable form (tuple setter / `onChange` /
+ * `.current`); plain values and getters have no write path, so that side is
+ * treated as read-only (the sync becomes one-way for it).
+ *
+ * React Hook adaptation: upstream drives both sides through Vue's reactive
+ * `watchPausable`, pausing all watchers while writing so a side never echoes
+ * its own write back. React has no reactive system, so `syncState` is
+ * implemented as a hook (call it unconditionally at the top of a component).
+ * A `useEffect` that runs after every commit compares each side's resolved
+ * value with the last observed one via `Object.is` and mirrors the changed
+ * side into the other — through the optional `transform` convertors when
+ * given — recording the value it just wrote as already observed on the
+ * receiving side (the React analogue of upstream's pause/resume). Ref-like
+ * `.current` writes are synchronous and need no absorption; writes through a
+ * setter / `onChange` are asynchronous, so until the target's value reflects
+ * the write the stale pre-write value is absorbed and never mistaken for an
+ * external change. Read-only sides (plain values / getters) are never marked
+ * as written, so a changing source keeps propagating. The initial sync
+ * (upstream default `immediate: true`) runs in the mount effect and cascades
+ * ltr before rtl,
+ * matching upstream's watcher creation order. Because the observation happens
+ * post-commit, an external mutation is only adopted on the render that
+ * follows it — the mutation itself never schedules a render, so a bare
+ * `.current` write outside of React is not observed (see the maintainer
+ * notes on reause #40 / #41). The returned `stop` function tears the
+ * synchronization down; the effect also stops doing any work once the owning
+ * component unmounts.
+ *
+ * @example
+ * const [a, setA] = useState('a')
+ * const [b, setB] = useState('b')
+ *
+ * const stop = syncState([a, setA], [b, setB])
+ *
+ * console.log(a) // a
+ *
+ * setB('foo') // then the component re-renders
+ * console.log(a) // foo
+ *
+ * setA('bar') // then the component re-renders
+ * console.log(b) // bar
+ *
+ * stop()
+ */
+export declare function syncState<L, R, D extends SyncStateDirection = 'both'>(left: State<L>, right: State<R>, options?: SyncStateOptions<L, R, D>): () => void;
+//#endregion
+//#region syncStates/index.d.ts
+export interface SyncStatesOptions {
+  /**
+   * Timing for syncing, same as watch's `flush` option.
+   *
+   * React note: there is no React equivalent — effects always run after
+   * commit, so `'sync'` / `'pre'` / `'post'` are accepted for upstream
+   * signature compatibility and all behave identically.
+   *
+   * @default 'sync'
+   */
+  flush?: 'sync' | 'pre' | 'post';
+  /**
+   * Watch deeply.
+   *
+   * React note: no React equivalent — a `.current` write never schedules a
+   * re-render by itself, so nested mutations cannot be observed (only the
+   * source value as a whole is compared, via `Object.is`). Accepted for
+   * upstream signature compatibility.
+   *
+   * @default false
+   */
+  deep?: boolean;
+  /**
+   * Sync values immediately (on mount).
+   *
+   * @default true
+   */
+  immediate?: boolean;
+}
+/**
+ * Keep target state(s) in sync with a source value — React port of VueUse's
+ * `syncRefs`.
+ *
+ * Map from @vueuse/shared `syncRefs`
+ * (`source/vueuse/packages/shared/syncRefs/`), renamed `syncStates` for the
+ * React port: the source is a `State<T>` — a plain value, getter, ref-like,
+ * `[value, setter]` tuple or `{ value, onChange }` pair (upstream:
+ * `WatchSource`) — resolved with `toValue`; the targets are writable
+ * `State<T>` sources written back through their writable form (tuple setter /
+ * `onChange` / `.current`); upstream's `flush` / `deep` / `immediate` options
+ * are kept for signature compatibility.
+ *
+ * React Hook adaptation: upstream syncs through Vue's reactive `watch`, and
+ * React has no reactive system — so `syncStates` is implemented as a hook
+ * (call it unconditionally at the top of a component). Internally a
+ * `useEffect` that runs after every commit compares the resolved source value
+ * with the last observed one via `Object.is`; a change is written through to
+ * all targets. Because the observation happens post-commit, the caller must
+ * re-render (e.g. `setState`) for a new source value to reach the targets —
+ * a bare mutation outside of React is never observed (see the maintainer
+ * notes on reause #40 / #41). The returned `stop` function tears the
+ * synchronization down; the effect also stops doing any work once the owning
+ * component unmounts.
+ *
+ * @example
+ * function Form() {
+ *   const [source, setSource] = useState('hello')
+ *   const [target, setTarget] = useState('target')
+ *
+ *   const stop = syncStates(source, [target, setTarget])
+ *
+ *   // during the first render `target` is still 'target' — the sync effect
+ *   // runs after the commit, so the source reaches the target only once the
+ *   // component has mounted (target === 'hello' afterwards).
+ *   // Calling `setSource('foo')` re-renders and the effect then copies 'foo'
+ *   // into the target state on the following commit.
+ *
+ *   stop()
+ * }
+ */
+export declare function syncStates<T>(source: State<T>, targets: State<T> | State<T>[], options?: SyncStatesOptions): () => void;
+//#endregion
+//#region until/index.d.ts
+export interface UntilToMatchOptions {
+  /**
+   * Milliseconds timeout for promise to resolve/reject if the when condition does not meet.
+   * 0 for never timed out
+   *
+   * @default 0
+   */
+  timeout?: number;
+  /**
+   * Reject the promise when timeout
+   *
+   * @default false
+   */
+  throwOnTimeout?: boolean;
+  /**
+   * `deep` option for the internal watch — kept for API compatibility. The
+   * React poller re-reads the source on every tick, so deep observation is
+   * implicit and this option is effectively a no-op.
+   *
+   * @default false
+   */
+  deep?: boolean;
+}
+export interface UntilBaseInstance<T, Not extends boolean = false> {
+  toMatch: (<U extends T = T>(condition: (v: T) => v is U, options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, U>> : Promise<U>) & ((condition: (v: T) => boolean, options?: UntilToMatchOptions) => Promise<T>);
+  changed: (options?: UntilToMatchOptions) => Promise<T>;
+  changedTimes: (n?: number, options?: UntilToMatchOptions) => Promise<T>;
+}
+type Falsy = false | void | null | undefined | 0 | 0n | '';
+export interface UntilValueInstance<T, Not extends boolean = false> extends UntilBaseInstance<T, Not> {
+  readonly not: UntilValueInstance<T, Not extends true ? false : true>;
+  toBe: <P = T>(value: P, options?: UntilToMatchOptions) => Not extends true ? Promise<T> : Promise<P>;
+  toBeTruthy: (options?: UntilToMatchOptions) => Not extends true ? Promise<T & Falsy> : Promise<Exclude<T, Falsy>>;
+  toBeNull: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, null>> : Promise<null>;
+  toBeUndefined: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, undefined>> : Promise<undefined>;
+  toBeNaN: (options?: UntilToMatchOptions) => Promise<T>;
+}
+type ElementOf<T> = T extends readonly unknown[] ? T[number] : never;
+export interface UntilArrayInstance<T> extends UntilBaseInstance<T> {
+  readonly not: UntilArrayInstance<T>;
+  toContains: (value: ElementOf<T>, options?: UntilToMatchOptions) => Promise<T>;
+}
+/**
+ * Promised one-time watch for changes
+ *
+ * Map from @vueuse/shared `until`
+ * React adaptation: upstream resolves when Vue's reactive `watch` callback
+ * first observes the condition holding; React has no reactive refs or watch,
+ * so this port **polls** the source — a plain value or a zero-argument getter
+ * — at a small fixed interval (the same polling `useFetch` uses for its
+ * `refetch` watch) and resolves the promise the first time the condition
+ * holds. `until` is a **pure function, not a hook** — no React hooks are
+ * involved — so it can be used anywhere a plain promise utility can.
+ *
+ * A plain value is a snapshot: it never changes between polls, so use a getter
+ * when the value may change after `until` was called (`until(() => ref.current)`).
+ * A `Ref` / `{ current }` object is not accepted directly. The `value` passed to
+ * `toBe` / `toContains` is a plain value too.
+ *
+ * @example
+ * let count = 0
+ * void until(() => count).toMatch(v => v > 7).then(() => {
+ *   alert('Counter is now larger than 7!')
+ * })
+ * count = 8 // the next poll resolves
+ *
+ * @see https://vueuse.org/shared/until/
+ */
+export declare function until<T extends unknown[]>(r: () => T): UntilArrayInstance<T>;
+export declare function until<T>(r: () => T): UntilValueInstance<T>;
+export declare function until<T extends unknown[]>(r: T): UntilArrayInstance<T>;
+export declare function until<T>(r: T): UntilValueInstance<T>;
+//#endregion
+//#region useArrayDifference/index.d.ts
+export interface UseArrayDifferenceOptions {
+  /**
+   * Returns asymmetric difference
+   *
+   * @see https://en.wikipedia.org/wiki/Symmetric_difference
+   * @default false
+   */
+  symmetric?: boolean;
+}
+export type UseArrayDifferenceReturn<T = any> = T[];
+export declare function useArrayDifference<T>(list: readonly T[], values: readonly T[], key?: keyof T, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
+export declare function useArrayDifference<T>(list: readonly T[], values: readonly T[], compareFn?: (value: T, othVal: T) => boolean, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
+//#endregion
+//#region useArrayEvery/index.d.ts
+export type UseArrayEveryReturn = boolean;
+/**
+ * React port of VueUse's `useArrayEvery`.
+ *
+ * Map from @vueuse/shared `useArrayEvery`
+ * Mapping: upstream wraps `toValue(list).every(...)` in `computed(() => ...)`
+ * and returns a `ComputedRef`; React has no reactive value tracking, so this
+ * is a plain function recomputed on every render over the plain `list` array
+ * the caller passes. Hold the array in `useState` (or any render-scoped value)
+ * and pass a new array to observe a change — the result recomputes on the next
+ * render. The predicate may return any value (coerced by truthiness, like
+ * `Array.prototype.every`).
+ *
+ * @see https://vueuse.org/shared/useArrayEvery/
+ *
+ * @example
+ * const [list, setList] = useState([0, 2, 4])
+ * useArrayEvery(list, val => val % 2 === 0) // true
+ * setList([0, 2, 5]) // false on the next render
+ *
+ * @param list - the array was called upon.
+ * @param fn - a function to test each element.
+ *
+ * @returns **true** if the `fn` function returns a **truthy** value for every element from the array. Otherwise, **false**.
+ */
+export declare function useArrayEvery<T>(list: readonly T[], fn: (element: T, index: number, array: readonly T[]) => unknown): UseArrayEveryReturn;
+//#endregion
+//#region useArrayFilter/index.d.ts
+export type UseArrayFilterReturn<T = any> = T[];
+/**
+ * Reactive `Array.filter`
+ *
+ * Map from @vueuse/shared `useArrayFilter`
+ * React port of VueUse's `useArrayFilter`.
+ *
+ * Mapping: Vue's `computed` → recompute per render and return a plain array
+ * (no `.value`) over the plain `list` array the caller passes. Pass a
+ * `useState` array directly — the filtered result updates on the next render.
+ *
+ * @see https://vueuse.org/useArrayFilter
+ *
+ * @example
+ * const [list, setList] = useState([0, 1, 2, 3, 4])
+ * const evens = useArrayFilter(list, i => i % 2 === 0) // [0, 2, 4]
+ * setList([1, 2, 3]) // evens === [2] on the next render
+ */
+export declare function useArrayFilter<T, S extends T>(list: readonly T[], fn: (element: T, index: number, array: readonly T[]) => element is S): UseArrayFilterReturn<S>;
+export declare function useArrayFilter<T>(list: readonly T[], fn: (element: T, index: number, array: readonly T[]) => unknown): UseArrayFilterReturn<T>;
+//#endregion
+//#region useArrayFind/index.d.ts
+export type UseArrayFindReturn<T = any> = T | undefined;
+/**
+ * React port of VueUse's `useArrayFind`.
+ *
+ * Map from @vueuse/shared `useArrayFind`
+ * Mapping: upstream wraps `toValue(list).find(...)` in `computed(() => ...)`
+ * and returns a `ComputedRef`; React has no reactive value tracking, so this
+ * is a plain function recomputed on every render over the plain `list` array
+ * the caller passes. Hold the array in `useState` and pass a new array to
+ * observe a change — the first match is returned on the next render.
+ *
+ * @see https://vueuse.org/shared/useArrayFind/
+ *
+ * @example
+ * const [list, setList] = useState([1, -1, 2])
+ * useArrayFind(list, val => val > 0) // 1
+ * setList([3, -1, 2]) // 3 on the next render
+ */
+export declare function useArrayFind<T>(list: readonly T[], fn: (element: T, index: number, array: readonly T[]) => boolean): UseArrayFindReturn<T>;
+//#endregion
+//#region useArrayFindIndex/index.d.ts
+export type UseArrayFindIndexReturn = number;
+/**
+ * React port of VueUse's `useArrayFindIndex`.
+ *
+ * Map from @vueuse/shared `useArrayFindIndex`
+ * Mapping: upstream wraps `toValue(list).findIndex(...)` in `computed(...)`
+ * and accepts a `RefOrValue`; React has no reactive value tracking, so
+ * this is a plain function that recomputes the index on every render — pass
+ * a state array (upstream: reactive array) and re-render with new state to
+ * see the updated result. The return is a plain number, no `.value`.
+ *
+ * @example
+ * const [list, setList] = useState([0, 2, 4, 6, 8])
+ * useArrayFindIndex(list, i => i % 2 === 0) // 0
+ *
+ * setList([1, 3, 5, 7, 9]) // result === -1 on the next render
+ *
+ * @param list - the array was called upon.
+ * @param fn - a function to test each element.
+ *
+ * @returns the index of the first element in the array that passes the test. Otherwise, "-1".
+ */
+export declare function useArrayFindIndex<T>(list: T[], fn: (element: T, index: number, array: T[]) => unknown): UseArrayFindIndexReturn;
+//#endregion
+//#region useArrayFindLast/index.d.ts
+export type UseArrayFindLastReturn<T = any> = T | undefined;
+/**
+ * React port of VueUse's `useArrayFindLast`.
+ *
+ * Map from @vueuse/shared `useArrayFindLast`
+ * Mapping: upstream wraps native `Array.prototype.findLast` (with a loop
+ * fallback for runtimes without it) in `computed(() => ...)` and returns a
+ * `ComputedRef`; React has no reactive value tracking, so this is a plain
+ * function recomputed on every render over the plain `list` array the caller
+ * passes — the loop helper stands in for the native method since the repo
+ * targets lib ES2022. Hold the array in `useState` and pass a new array to
+ * observe a change — the last match is returned on the next render.
+ *
+ * @see https://vueuse.org/shared/useArrayFindLast/
+ *
+ * @example
+ * const [list, setList] = useState([1, -1, 2])
+ * useArrayFindLast(list, val => val > 0) // 2
+ * setList([1, -1, -2]) // 1 on the next render
+ */
+export declare function useArrayFindLast<T>(list: readonly T[], fn: (element: T, index: number, array: readonly T[]) => boolean): UseArrayFindLastReturn<T>;
+//#endregion
+//#region useArrayIncludes/index.d.ts
+export type UseArrayIncludesComparatorFn<T, V> = (element: T, value: V, index: number, array: readonly T[]) => boolean;
+export interface UseArrayIncludesOptions<T, V> {
+  fromIndex?: number;
+  comparator?: UseArrayIncludesComparatorFn<T, V> | keyof T;
+}
+export type UseArrayIncludesReturn = boolean;
+/**
+ * React port of VueUse's `useArrayIncludes`.
+ *
+ * Map from @vueuse/shared `useArrayIncludes`
+ * Mapping: upstream wraps `toValue(list).slice(fromIndex).some(...)` in
+ * `computed(() => ...)` and returns a `ComputedRef`; React has no reactive
+ * value tracking, so this is a plain function recomputed on every render over
+ * the plain `list` array and `value` the caller passes. The default comparator
+ * mirrors `Array.prototype.includes` (strict equality). Hold the array in
+ * `useState` and pass a new array to observe a change.
+ *
+ * @see https://vueuse.org/shared/useArrayIncludes/
+ *
+ * @example
+ * const list = [0, 2, 4]
+ * useArrayIncludes(list, 2) // true
+ * useArrayIncludes(list, 8) // false
+ * useArrayIncludes([{ id: 1 }, { id: 2 }], 2, 'id') // true
+ * useArrayIncludes(list, 0, { fromIndex: 1, comparator: (a, b) => a === b }) // false
+ *
+ * @param list - the array was called upon.
+ * @param value - the value to search for.
+ * @param comparator - a function to compare elements with, a key of the elements to compare by, or an options object with `fromIndex` and `comparator`.
+ *
+ * @returns **true** if the `value` is found in the array. Otherwise, **false**.
+ */
+export declare function useArrayIncludes<T, V = any>(list: readonly T[], value: V, comparator?: UseArrayIncludesComparatorFn<T, V>): UseArrayIncludesReturn;
+export declare function useArrayIncludes<T, V = any>(list: readonly T[], value: V, comparator?: keyof T): UseArrayIncludesReturn;
+export declare function useArrayIncludes<T, V = any>(list: readonly T[], value: V, options?: UseArrayIncludesOptions<T, V>): UseArrayIncludesReturn;
+//#endregion
+//#region useArrayJoin/index.d.ts
+export type UseArrayJoinReturn = string;
+/**
+ * React port of VueUse's `useArrayJoin`.
+ *
+ * Map from @vueuse/shared `useArrayJoin`
+ * Mapping: upstream wraps `toValue(list).map(i => toValue(i)).join(toValue(separator))`
+ * in `computed(...)` and accepts a `RefOrValue`; React has no reactive
+ * value tracking, so this is a plain function that recomputes the join on
+ * every render — pass a state array (upstream: reactive array) and re-render
+ * with new state to see the updated result. The return is a plain string,
+ * no `.value`.
+ *
+ * `list` holds plain values only: the elements are joined with
+ * `Array.prototype.join`, so no per-element unwrap happens (upstream
+ * `toValue`s each element). A function element would be stringified to its
+ * source instead of invoked.
+ *
+ * @example
+ * const [list, setList] = useState(['foo', 0, { prop: 'val' }])
+ * useArrayJoin(list) // 'foo,0,[object Object]'
+ * useArrayJoin(list, '--') // 'foo--0--[object Object]'
+ *
+ * setList([...list, 'bar']) // result === 'foo--0--[object Object]--bar' on the next render
+ *
+ * @param list - the array was called upon.
+ * @param separator - a string to separate each pair of adjacent elements of the array. If omitted, the array elements are separated with a comma (",").
+ *
+ * @returns a string with all array elements joined. If `list.length` is 0, the empty string is returned.
+ */
+export declare function useArrayJoin(list: any[], separator?: string): UseArrayJoinReturn;
+//#endregion
+//#region useArrayMap/index.d.ts
+export type UseArrayMapReturn<T = any> = T[];
+/**
+ * Reactive `Array.map`
+ *
+ * Map from @vueuse/shared `useArrayMap`
+ * React port of VueUse's `useArrayMap`.
+ *
+ * Mapping: Vue's `computed` → recompute per render and return a plain array
+ * (no `.value`) over the plain `list` array the caller passes.
+ * Pass a `useState` array directly — the result updates on the next render.
+ *
+ * @example
+ * const [list, setList] = useState([0, 1, 2, 3, 4])
+ * const result = useArrayMap(list, i => i * 2) // [0, 2, 4, 6, 8]
+ * setList(list.slice(0, -1)) // result: [0, 2, 4, 6] on the next render
+ */
+export declare function useArrayMap<T, U = T>(list: readonly T[], fn: (element: T, index: number, array: readonly T[]) => U): UseArrayMapReturn<U>;
+//#endregion
+//#region useArrayReduce/index.d.ts
+export type UseArrayReducer<PV, CV, R> = (previousValue: PV, currentValue: CV, currentIndex: number) => R;
+export type UseArrayReduceReturn<T = any> = T;
+/**
+ * Reactive `Array.reduce`
+ *
+ * Map from @vueuse/shared `useArrayReduce`
+ * React port of VueUse's `useArrayReduce`.
+ *
+ * Mapping: upstream wraps `toValue(list).reduce(...)` in `computed(() => ...)`
+ * and returns a `ComputedRef`; React has no reactive value tracking, so this
+ * is a plain function recomputed on every render over the plain `list` array
+ * the caller passes. Hold the array in `useState` and pass a new array to
+ * observe a change — the reduced result recomputes on the next render.
+ *
+ * @see https://vueuse.org/shared/useArrayReduce/
+ *
+ * @example
+ * const [list, setList] = useState([1, 2, 3])
+ * useArrayReduce(list, (prev, item) => prev + item) // 6
+ * setList([4, 2, 3]) // 9 on the next render
+ *
+ * @param list - the array was called upon.
+ * @param reducer - a "reducer" function.
+ *
+ * @returns the value that results from running the "reducer" callback function to completion over the entire array.
+ */
+export declare function useArrayReduce<T>(list: readonly T[], reducer: UseArrayReducer<T, T, T>): UseArrayReduceReturn<T>;
+/**
+ * Reactive `Array.reduce`
+ *
+ * @param list - the array was called upon.
+ * @param reducer - a "reducer" function.
+ * @param initialValue - a value (or a React lazy-initializer function, invoked
+ * per evaluation like `useState`) to be initialized the first time when the callback is called.
+ *
+ * @returns the value that results from running the "reducer" callback function to completion over the entire array.
+ */
+export declare function useArrayReduce<T, U>(list: readonly T[], reducer: UseArrayReducer<U, T, U>, initialValue: U | (() => U)): UseArrayReduceReturn<U>;
+//#endregion
+//#region useArraySome/index.d.ts
+export type UseArraySomeReturn = boolean;
+/**
+ * React port of VueUse's `useArraySome`.
+ *
+ * Map from @vueuse/shared `useArraySome`
+ * Mapping: `computed(() => ...)` → recompute on every render — the result is a
+ * plain `boolean` (no `.value`, no caching) computed from the plain `list`
+ * array the caller passes. Hold the array in `useState` and pass a new array
+ * to observe a change; the result recomputes on the next render.
+ *
+ * @see https://vueuse.org/shared/useArraySome/
+ * @param list - the array was called upon.
+ * @param fn - a function to test each element.
+ *
+ * @returns **true** if the `fn` function returns a **truthy** value for any element from the array. Otherwise, **false**.
+ *
+ * @example
+ * const [list, setList] = useState([0, 2, 4, 6, 8])
+ * const result = useArraySome(list, i => i > 10) // false
+ * setList([...list, 11]) // result === true on the next render
+ */
+export declare function useArraySome<T>(list: readonly T[], fn: (element: T, index: number, array: readonly T[]) => unknown): UseArraySomeReturn;
+//#endregion
+//#region useArrayUnique/index.d.ts
+export type UseArrayUniqueReturn<T = any> = T[];
+/**
+ * Reactive `Array.unique`
+ *
+ * Map from @vueuse/shared `useArrayUnique`
+ * React port of VueUse's `useArrayUnique`.
+ *
+ * Mapping: upstream wraps `toValue(list)` in `computed(() => ...)` and returns
+ * a `ComputedRef`; React has no reactive value tracking, so this is a plain
+ * function recomputed on every render over the plain `list` array the caller
+ * passes — the result is a deduped plain array (no `.value`, no caching).
+ * Duplicate detection uses a `Set` of the values (reference identity for
+ * objects) unless a custom `compareFn` is given — same as upstream. Hold the
+ * array in `useState` and pass a new array to observe a change.
+ *
+ * @see https://vueuse.org/shared/useArrayUnique/
+ *
+ * @example
+ * const [list, setList] = useState([0, 2, 2, 4, 4, 4])
+ * const result = useArrayUnique(list) // [0, 2, 4]
+ *
+ * setList([0, 2, 4, 6, 6]) // result === [0, 2, 4, 6] on the next render
+ */
+export declare function useArrayUnique<T>(list: readonly T[], compareFn?: (a: T, b: T, array: readonly T[]) => boolean): UseArrayUniqueReturn<T>;
+//#endregion
+//#region useCounter/index.d.ts
+export interface UseCounterOptions {
+  min?: number;
+  max?: number;
+}
+export interface UseCounterReturn {
+  /**
+   * The current value of the counter.
+   */
+  count: number;
+  /**
+   * Increment the counter.
+   *
+   * @param {number} [delta=1] The number to increment.
+   */
+  inc: (delta?: number) => void;
+  /**
+   * Decrement the counter.
+   *
+   * @param {number} [delta=1] The number to decrement.
+   */
+  dec: (delta?: number) => void;
+  /**
+   * Get the current value of the counter — the latest rendered value (React
+   * state updates are applied on the next render, so a read right after
+   * `inc` / `dec` / `set` still sees the previous value).
+   */
+  get: () => number;
+  /**
+   * Set the counter to a new value (clamped to `[min, max]`).
+   *
+   * @param value The new value of the counter.
+   */
+  set: (value: number) => void;
+  /**
+   * Reset the counter to the initial value — or to `val` when passed, which
+   * also rebases the value future resets restore — and return the new value.
+   *
+   * @param val The value to reset to (defaults to the initial value).
+   */
+  reset: (val?: number) => number;
+}
+/**
+ * React port of VueUse's `useCounter`.
+ *
+ * Map from @vueuse/shared `useCounter`
+ * Mapping: `ref(initialValue)` → `useState`, mutation functions become
+ * stable `useCallback`s; options are kept in refs so callbacks stay stable.
+ *
+ * @example
+ * const { count, inc, dec, set, reset } = useCounter(10, { min: 0, max: 100 })
+ */
+export declare function useCounter(initialValue?: State<number>, options?: UseCounterOptions): UseCounterReturn;
+//#endregion
+//#region useDateFormat/index.d.ts
+export type DateLike = Date | number | string | undefined;
+export interface UseDateFormatOptions {
+  /**
+   * The locale(s) to used for dd/ddd/dddd/MMM/MMMM format
+   *
+   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument).
+   *
+   * A plain locale (or locale array), matching upstream's
+   * `MaybeRefOrGetter<Intl.LocalesArgument>` resolved to its current value.
+   */
+  locales?: Intl.LocalesArgument;
+  /**
+   * A custom function to re-modify the way to display meridiem
+   *
+   */
+  customMeridiem?: (hours: number, minutes: number, isLowercase?: boolean, hasPeriod?: boolean) => string;
+}
+/**
+ * Unwrap the house input convention — a plain value, a ref-like `{ current }`
+ * or a getter function (house replacement for Vue's `toValue` /
+ * `RefOrValue<T>`).
+ */
+export declare function formatDate(date: Date, formatStr: string, options?: UseDateFormatOptions): string;
+export declare function normalizeDate(date: DateLike): Date;
+/**
+ * The return type of `useDateFormat`.
+ *
+ * Upstream (`@vueuse/shared`) declares `ComputedRef<string>`; this React port
+ * returns the formatted string directly — a plain `string` recomputed on every
+ * render / call.
+ */
+export type UseDateFormatReturn = string;
+/**
+ * Get the formatted date according to the string of tokens passed in.
+ *
+ * Map from @vueuse/shared `useDateFormat`.
+ *
+ * React divergence: upstream wraps the result in a Vue `computed` and returns
+ * `ComputedRef<string>` — this port returns a PLAIN STRING. Call it during
+ * render and pass plain values (e.g. your `useState` date); the string is
+ * recomputed on every render with fresh inputs. Do not read `.value` from it.
+ *
+ * Inputs (`date`, `formatStr`, `options.locales`) are plain read-only values
+ * — pass `ref.current` or the state value; a `MaybeRefOrGetter` source must be
+ * resolved by the caller (upstream types them `MaybeRefOrGetter`).
+ *
+ * Supported tokens (mirroring upstream 1:1, default format `HH:mm:ss`):
+ * `Yo YY YYYY` — year · `M Mo MM MMM MMMM` — month (locale-aware short/long
+ * names via `Intl`) · `D Do DD` — day of month · `H Ho HH` — 24-hour clock ·
+ * `h ho hh` — 12-hour clock · `m mo mm` — minutes · `s so ss` — seconds ·
+ * `SSS` — milliseconds (3 digits) · `d dd ddd dddd` — weekday (locale-aware
+ * via `Intl`) · `A AA a aa` — meridiem, customizable via
+ * `options.customMeridiem` · `z zz zzz zzzz` — timezone offset names
+ * (`shortOffset` / `longOffset` via `toLocaleString`). Text wrapped in
+ * brackets (`[...]`) is output literally as an escape sequence.
+ *
+ * @see https://vueuse.org/useDateFormat
+ * @param date - The date to format, can either be a `Date` object, a timestamp, or a string
+ * @param formatStr - The combination of tokens to format the date
+ * @param options - UseDateFormatOptions
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useDateFormat(date: DateLike, formatStr?: string, options?: UseDateFormatOptions): UseDateFormatReturn;
+//#endregion
+//#region useDebounceFn/index.d.ts
+export type FunctionArgs<Args extends any[] = any[], Return = unknown> = (...args: Args) => Return;
+export interface DebounceFilterOptions {
+  /**
+   * The maximum time allowed to be delayed before it's invoked.
+   * In milliseconds.
+   */
+  maxWait?: RefOrValue<number>;
+  /**
+   * Whether to reject the last call if it's been cancelled.
+   *
+   * @default false
+   */
+  rejectOnCancel?: boolean;
+}
+export interface UseDebounceFnReturn<T extends FunctionArgs> {
+  (...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
+  /**
+   * Cancel the pending invocation — the outstanding promise settles
+   * (resolves, or rejects with `rejectOnCancel`) without calling `fn`.
+   */
+  cancel: () => void;
+  /**
+   * Invoke the pending call immediately and settle its promise with the result.
+   */
+  flush: () => void;
+  /**
+   * `true` while a call is waiting to be invoked.
+   *
+   * Note: unlike upstream's reactive readonly ref, this is a plain
+   * (non-reactive) getter — read it imperatively, it does not trigger
+   * re-renders.
+   */
+  readonly isPending: boolean;
+}
+/**
+ * Debounce execution of a function — React port of VueUse's `useDebounceFn`.
+ *
+ * Map from @vueuse/shared `useDebounceFn`
+ * Mapping: upstream builds `createFilterWrapper(debounceFilter(ms, options), fn)`
+ * so every call returns a promise and the wrapper carries `cancel` / `flush` /
+ * `isPending`. This port builds the same wrapper once (`useMemo`) so its
+ * identity is stable across renders; the latest `fn` / `ms` / `options` are
+ * mirrored into refs so every call sees fresh values. `ms` accepts a number or
+ * a ref-like `{ current }` (upstream: `RefOrValue<number>`) and is re-read on
+ * every call. `isPending` becomes a non-reactive getter (React has no reactive
+ * refs); promise settlement mirrors upstream — a regular debounce resolves
+ * with the result, a superseded/canceled call settles with `undefined` (or
+ * rejects with `rejectOnCancel`), and the `maxWait` trailing edge runs the
+ * latest invocation but settles the pending promise without its result.
+ * Pending timers are cleared when the component unmounts (upstream leaves
+ * disposal to the effect scope).
+ *
+ * @example
+ * const debouncedFn = useDebounceFn(() => { ... }, 1000)
+ * debouncedFn()
+ * debouncedFn.cancel()
+ * debouncedFn.flush()
+ */
+export declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: RefOrValue<number>, options?: DebounceFilterOptions): UseDebounceFnReturn<T>;
+//#endregion
+//#region useInterval/index.d.ts
+export interface UseIntervalOptions<Controls extends boolean = false> {
+  /**
+   * Expose more controls
+   *
+   * @default false
+   */
+  controls?: Controls;
+  /**
+   * Start the interval automatically on mount
+   *
+   * @default true
+   */
+  immediate?: boolean;
+  /**
+   * Callback on every interval tick, receives the incremented count
+   */
+  callback?: (count: number) => void;
+  /**
+   * Increment the counter (and fire `callback`) immediately when the interval
+   * starts or `resume` is called
+   *
+   * @default false
+   */
+  immediateCallback?: boolean;
+}
+export interface UseIntervalControls {
+  /**
+   * Current count
+   */
+  counter: number;
+  /**
+   * Reset the counter to `0`
+   */
+  reset: () => void;
+  /**
+   * `true` while the interval is running
+   */
+  isActive: boolean;
+  /**
+   * Stop the interval
+   */
+  pause: () => void;
+  /**
+   * (Re)start the interval
+   */
+  resume: () => void;
+}
+export type UseIntervalReturn = number | UseIntervalControls;
+/**
+ * React port of VueUse's `useInterval`.
+ *
+ * Map from @vueuse/shared `useInterval`
+ * Mapping: upstream wraps `useIntervalFn` and returns a readonly
+ * `ShallowRef<number>`; since `useIntervalFn` is mapped in its own module,
+ * this port inlines the interval logic to stay self-contained — the counter
+ * is a plain `number` state (no `.value`), the setup-time `resume()`
+ * (`immediate`) becomes a mount `useEffect` (guarded against the StrictMode
+ * double-invocation so `immediateCallback` fires only once), and
+ * `tryOnScopeDispose(pause)` becomes the effect cleanup. `{ controls: true }`
+ * exposes `counter` / `reset` plus the `Pausable` controls (`isActive` /
+ * `pause` / `resume`). `interval` accepts a number or a React ref (upstream:
+ * `RefOrValue<number>`); like upstream's reactive watch, a changed interval
+ * live-restarts the timer while it is active (a ref's `.current` mutation is
+ * only picked up on the next render — React has no reactive refs).
+ * `immediateCallback` follows `useIntervalFn`'s semantics (upstream
+ * `useInterval` doesn't forward it). `pause` / `resume` / `reset` are stable
+ * `useCallback`s.
+ *
+ * @example
+ * // count will increase every 200ms
+ * const counter = useInterval(200)
+ *
+ * const { counter, isActive, pause, resume, reset } = useInterval(200, { controls: true })
+ */
+export declare function useInterval(interval?: RefOrValue<number>, options?: UseIntervalOptions<false>): number;
+export declare function useInterval(interval: RefOrValue<number>, options: UseIntervalOptions<true>): UseIntervalControls;
+//#endregion
+//#region useIntervalFn/index.d.ts
+type Fn = () => void;
+export interface UseIntervalFnOptions {
+  /**
+   * Start the timer automatically when the component mounts
+   *
+   * @default true
+   */
+  immediate?: boolean;
+  /**
+   * Execute the callback immediately after calling `resume`
+   *
+   * @default false
+   */
+  immediateCallback?: boolean;
+}
+export interface UseIntervalFnReturn {
+  /**
+   * Whether the timer is currently active
+   */
+  isActive: boolean;
+  /**
+   * Pause the timer
+   */
+  pause: () => void;
+  /**
+   * Resume the timer (restarts it with the current interval)
+   */
+  resume: () => void;
+}
+/**
+ * React port of VueUse's `useIntervalFn` — wrapper for `setInterval` with
+ * controls.
+ *
+ * Map from @vueuse/shared `useIntervalFn`
+ * Mapping: upstream accepts `RefOrValue<number>` for the interval — this
+ * port accepts a plain `number`. `isActive` is a boolean state (upstream: a
+ * readonly shallow ref), also mirrored in a ref so `resume()` can check it
+ * synchronously right after `immediateCallback` fires the callback — the
+ * callback may `pause()` itself ("pause in callback"). The timer is scheduled
+ * in a mount effect (upstream starts synchronously during setup) and cleared
+ * on unmount via effect cleanup; changing the interval while active restarts
+ * the timer (upstream: a `watch` on the interval calls `resume()`). The
+ * callback, interval and options are kept in refs so every tick and restart
+ * uses the newest ones.
+ *
+ * @example
+ * const { isActive, pause, resume } = useIntervalFn(() => { ... }, 1000)
+ */
+export declare function useIntervalFn(cb: Fn, interval?: number, options?: UseIntervalFnOptions): UseIntervalFnReturn;
+//#endregion
+//#region useLastChanged/index.d.ts
+export interface UseLastChangedOptions<InitialValue extends number | null | undefined = undefined> {
+  /**
+   * Value returned before any change has been recorded.
+   *
+   * (Upstream also extends Vue's `WatchOptions` — `immediate` / `deep` /
+   * `flush` / `once` have no React equivalent here, see the mapping note.)
+   *
+   * @default null
+   */
+  initialValue?: InitialValue;
+}
+export type UseLastChangedReturn = number | null;
+/**
+ * React port of VueUse's `useLastChanged`.
+ *
+ * Map from @vueuse/shared `useLastChanged`
+ * Records the timestamp of the last change
+ *
+ * @see https://vueuse.org/shared/useLastChanged
+ */
+export declare function useLastChanged<T>(value: T, options?: UseLastChangedOptions<undefined>): UseLastChangedReturn;
+export declare function useLastChanged<T>(value: T, options: UseLastChangedOptions<number>): number;
+//#endregion
+//#region useListener/index.d.ts
+/**
+ * A listener registration function — the `onXxx` callbacks returned by hooks
+ * such as `useFileDialog`'s `onChange` / `onCancel`. Mirror of upstream
+ * `EventHookOn<T>`.
+ */
+export type ListenerOn<T extends (...args: any[]) => void> = (fn: T) => {
+  off: () => void;
+} | void;
+/**
+ * React port of the `useListener` protocol — bind a callback to an event
+ * registration function returned by a reause hook, with automatic cleanup
+ * on unmount.
+ *
+ * Map from @reause/shared `useListener` (protocol: #129)
+ * Motivation: hooks like `useFileDialog` return `onChange` / `onCancel`
+ * registration functions (upstream `EventHookOn`). In Vue those auto-clean
+ * via the effect scope; in React we need a hook to own that lifecycle.
+ * `useListener` registers `cb` with `on` on mount and, when `on` returns an
+ * `off` function, calls it on unmount, so listeners are cleaned up and
+ * callbacks never fire after the component is gone. (An `on` that returns
+ * nothing provides no cleanup — nothing can be released.) The callback is
+ * kept in a ref, so changing `cb` across renders does not re-register — the
+ * latest callback is used by the already-registered listener. If `on` itself
+ * changes (a new hook instance), the effect re-runs and re-registers.
+ *
+ * @example
+ * const { files, open, onChange } = useFileDialog()
+ * useListener(onChange, (files) => { console.log(files) })
+ */
+export declare function useListener<T extends (...args: any[]) => void>(on: ListenerOn<T>, cb: T): void;
+//#endregion
+//#region useMount/index.d.ts
+/**
+ * React port of react-use's `useMount`.
+ *
+ * Map from react-use `useMount`.
+ * Runs `fn` exactly once after the component mounts.
+ *
+ * @example
+ * useMount(() => {
+ *   trackPageView()
+ * })
+ */
+export declare function useMount(fn: () => void): void;
+//#endregion
+//#region useStateAutoReset/index.d.ts
+export type UseStateAutoResetReturn<T = any> = [T, Dispatch<SetStateAction<T>>];
+/**
+ * A state which will be reset to the default value after some time.
+ *
+ * Map from @vueuse/shared `refAutoReset`
+ * (`source/vueuse/packages/shared/refAutoReset/`). Upstream returns a single
+ * writable Vue ref; per this repo's `useState*` family convention the return
+ * is the React `[value, setValue]` tuple — `value` is the state, `setValue`
+ * is a `useState`-style setter (value or updater form, `Dispatch<SetStateAction>`)
+ * that also (re)schedules a timer to restore `defaultValue` after `afterMs`
+ * milliseconds. `defaultValue` accepts the shared `State<T>` form (plain value,
+ * lazy getter, ref-like object, state tuple, or controlled `{ value, onChange }` pair).
+ * `afterMs` accepts the shared `RefOrValue<number>` form and is resolved with `toValue` at fire time
+ * (upstream: `toValue`); the pending timer is cleared on unmount (upstream:
+ * `tryOnScopeDispose`, timers in the effect scope). The deprecated `autoResetRef`
+ * alias is not ported.
+ *
+ * @param defaultValue The value which will be set.
+ * @param afterMs      A zero-or-greater delay in milliseconds.
+ * @example
+ * const [message, setMessage] = useStateAutoReset('default message', 1000)
+ *
+ * function handleMessage() {
+ *   setMessage('message has set') // resets to 'default message' after 1000ms
+ * }
+ */
+export declare function useStateAutoReset<T = any>(defaultValue: State<T>, afterMs?: RefOrValue<number>): UseStateAutoResetReturn<T>;
+//#endregion
+//#region useStateDebounced/index.d.ts
+export type UseStateDebouncedReturn<T = any> = [value: T, setValue: Dispatch<SetStateAction<T>>, debounced: T];
+/**
+ * Debounce updates of a state value — React port of VueUse's `refDebounced`.
+ *
+ * Map from @vueuse/shared `refDebounced`
+ * Mapping: upstream takes a Vue `Ref<T>` and returns a readonly ref that only
+ * flips to the latest source value once it stops changing for `ms` (a watcher
+ * hands every change to `useDebounceFn`). The naming follows this repo's
+ * `ref* → useState*` rule (`refDebounced` → `useStateDebounced`), the Vue
+ * `Ref<T>` input becomes a plain initial value, and the readonly ref becomes
+ * an extra state slot — so the hook returns the tuple
+ * `[value, setValue, debounced]`:
+ *
+ * ```ts
+ * const [input, setInput, debounced] = useStateDebounced('foo', 1000)
+ *
+ * setInput('bar')
+ * console.log(debounced) // 'foo' — flips to 'bar' once the debounce elapses
+ * ```
+ *
+ * `value` is the source state, `setValue` its setter, and `debounced` lags
+ * behind it by `ms`. Writes settle through a `useDebounceFn` updater, so a
+ * burst of writes collapses into a single trailing update carrying the last
+ * written value. `ms` (and `options.maxWait`) accept a plain number or a
+ * ref-like `{ current }` (upstream: `RefOrValue<number>`) and are re-read on
+ * every write; pending timers are cleared when the component unmounts
+ * (upstream disposes with the effect scope). Note: a write only schedules the
+ * debounce when the value actually changes — writing the same value is
+ * skipped by `useControllableState`'s `Object.is` guard, so the pending timer
+ * is not re-delayed (upstream's `watch` re-delays on every source write, even
+ * unchanged ones).
+ *
+ * @example
+ * ```ts
+ * const [value, setValue, debounced] = useStateDebounced('foo', 1000)
+ * ```
+ */
+export declare function useStateDebounced<T>(value: State<T>, ms?: RefOrValue<number>, options?: DebounceFilterOptions): UseStateDebouncedReturn<T>;
+//#endregion
+//#region useStateDefault/index.d.ts
+export type UseStateDefaultReturn<T = any> = [
+/**
+ * Current value — the source's current value, or `defaultValue` when the
+ * source is `null`/`undefined`.
+ */
+value: T,
+/**
+ * Setter to update the value (value or updater form, like `setState`) —
+ * writes through to a ref-like source's `current`, a state tuple's setter
+ * or a `{ value, onChange }` source's `onChange`.
+ */
+setValue: Dispatch<SetStateAction<T | undefined | null>>];
+/**
+ * Apply default value to a ref-like source — React port of VueUse's
+ * `refDefault` renamed to `useStateDefault` (this repo's naming for the
+ * `ref*` family; upstream's single writable computed ref becomes a tuple).
+ *
+ * Map from @vueuse/shared `refDefault`
+ * Mapping: upstream derives a writable `computed` from a source
+ * `Ref<T | undefined | null>` — it reads `source.value ?? defaultValue` and
+ * writes back to `source.value`. This port accepts a `State<T | undefined |
+ * null>` — a plain value, a ref-like object (`{ current }`, e.g. the first
+ * tuple element of `useStorage`), a getter, a `[value, setter]` tuple or a
+ * `{ value, onChange }` pair — and returns the React tuple
+ * `const [value, setValue] = useStateDefault(raw, 'default')`. `value` is
+ * derived on every render from the source through `toValue` (`source.current
+ * ?? defaultValue`), so it always reflects the source's current value —
+ * including writes made from outside the component; `setValue` resolves the
+ * next value (value or updater form), writes it through to the source (its
+ * `current`, its setter or its `onChange`) and bumps a local version counter
+ * so the derived `value` re-renders. SSR-safe: nothing touches the DOM and the
+ * first server render already shows the default.
+ *
+ * @param source       The `State<T | undefined | null>` source holding the
+ *                     value — read through `toValue` on every render and
+ *                     written back to `current` / the tuple setter /
+ *                     `onChange` on `setValue`.
+ * @param defaultValue The value displayed while the source is `null` or
+ *                     `undefined`.
+ * @return  A tuple `[value, setValue]` — the current value (source value or
+ *          `defaultValue`) and its setter.
+ *
+ * @example
+ * const raw = { current: undefined as string | undefined }
+ * const [value, setValue] = useStateDefault(raw, 'default')
+ *
+ * setValue('hello')
+ * console.log(value) // 'hello' after the next render (React derives at render)
+ *
+ * setValue(undefined)
+ * console.log(value) // 'default' after the next render
+ */
+export declare function useStateDefault<T = any>(source: State<T | undefined | null>, defaultValue: T): UseStateDefaultReturn<T>;
+//#endregion
+//#region useStateManualReset/index.d.ts
+export type UseStateManualResetReturn<T> = [value: T, setValue: Dispatch<SetStateAction<T>>, reset: () => void];
+/**
+ * React port of VueUse's `refManualReset`.
+ *
+ * Map from @vueuse/shared `refManualReset`
+ * (`source/vueuse/packages/shared/refManualReset/`). Create a state with
+ * manual reset functionality — any update can be reverted back to the initial
+ * value with the returned `reset` function.
+ *
+ * Upstream returns a writable Vue `Ref<T>` extended with a `reset` method
+ * (built on `customRef`). Per this repo's naming rules the port is renamed to
+ * `useStateManualReset` and the ref becomes a `[value, setValue, reset]`
+ * tuple: the second element is the plain `useState` setter (value or updater
+ * form), and `reset` restores the default value.
+ *
+ * The state input accepts the shared `State<T>` form: a value, getter, ref-like
+ * object, state tuple, or controlled `{ value, onChange }` object. `reset`
+ * re-reads the input on every call, so plain, getter and ref-like sources
+ * reset to the latest source value (matching upstream's
+ * `value = toValue(defaultValue)`); tuple / `{ value, onChange }` (controlled)
+ * sources have no stored default, so they restore the initial argument value.
+ *
+ * @example
+ * const [message, setMessage, resetMessage] = useStateManualReset('default message')
+ * setMessage('message has set')
+ * resetMessage()
+ * console.log(message) // 'default message'
+ */
+export declare function useStateManualReset<T>(value: State<T>): UseStateManualResetReturn<T>;
+//#endregion
+//#region useStateThrottled/index.d.ts
+export type UseStateThrottledReturn<T = any> = [value: T, setValue: Dispatch<SetStateAction<T>>, throttled: T];
+/**
+ * Throttle changing of a state value — React port of VueUse's `refThrottled`.
+ *
+ * The `value` argument accepts any `State<T>` supported by
+ * `useControllableState`: a plain value, lazy initializer, controlled tuple,
+ * or `{ value, onChange }` source. The returned tuple contains the current
+ * value, its setter, and a throttled mirror.
+ *
+ * A `delay <= 0` short-circuits like upstream (`if (delay <= 0) return value`):
+ * the throttled element is the input itself — no throttling, no timers.
+ *
+ * @param value State source accepted by `useControllableState`.
+ * @param delay Delay in milliseconds between commits (default: 200).
+ * @param trailing Whether to commit the latest value after the window (default: true).
+ * @param leading Whether to commit on the leading edge (default: true).
+ */
+export declare function useStateThrottled<T = any>(value: State<T>, delay?: number, trailing?: boolean, leading?: boolean): UseStateThrottledReturn<T>;
+//#endregion
+//#region useStateWithControl/index.d.ts
+export interface UseStateWithControlOptions<T> {
+  /**
+   * Callback function before the state changing.
+   *
+   * Returning `false` to dismiss the change.
+   */
+  onBeforeChange?: (value: T, oldValue: T) => void | boolean;
+  /**
+   * Callback function after the state changed.
+   *
+   * This happens synchronously, with less overhead compared to an effect.
+   */
+  onChanged?: (value: T, oldValue: T) => void;
+}
+export interface UseStateWithControlControls<T> {
+  /**
+   * Get the current value. The `tracking` argument is accepted for API parity
+   * with upstream but is a no-op in React — there is no reactivity dependency
+   * collection during render.
+   */
+  get: (tracking?: boolean) => T;
+  /**
+   * Set the value with fine-grained control. `triggering` controls whether the
+   * change re-renders the component (defaults to `true`).
+   */
+  set: (value: T, triggering?: boolean) => void;
+  /**
+   * Get the value without tracking in the reactivity system — alias for
+   * `get(false)`.
+   */
+  untrackedGet: () => T;
+  /**
+   * Set the value without triggering the reactivity system — alias for
+   * `set(value, false)`.
+   */
+  silentSet: (value: T) => void;
+  /**
+   * Alias for `untrackedGet()`.
+   */
+  peek: () => T;
+  /**
+   * Alias for `silentSet(value)`.
+   */
+  lay: (value: T) => void;
+  /**
+   * Reset the value back to the initial value passed to the hook.
+   */
+  reset: () => void;
+}
+export type UseStateWithControlReturn<T> = [
+/**
+ * Current value — identical to the `value` a plain `useState` would hold.
+ */
+value: T,
+/**
+ * Setter to update the value (value or updater form, like `setState`).
+ */
+setValue: Dispatch<SetStateAction<T>>,
+/**
+ * Fine-grained controls over the value: `get` / `set` / `peek` / `lay`, the
+ * untracked/silent shorthands, and `reset`.
+ */
+control: UseStateWithControlControls<T>];
+/**
+ * Fine-grained controls over a state and its re-renders — React port of
+ * VueUse's `refWithControl`.
+ *
+ * Map from @vueuse/shared `refWithControl`
+ * (`source/vueuse/packages/shared/refWithControl/`). Upstream returns a single
+ * writable Vue `Ref` extended with `get` / `set` / `untrackedGet` /
+ * `silentSet` / `peek` / `lay`. This port owns the state like a `useState` and
+ * returns the React tuple `const [num, setNum, control] = useStateWithControl(0)`
+ * — the name follows this repo's `ref*` → `useState*` mapping rule. `setNum`
+ * behaves like a normal `setState` (value or updater form — the updater base
+ * is the current internal value, which may be ahead of the rendered value
+ * after a silent write), while `control`
+ * keeps the fine-grained get/set pair: `set(value, false)` (and `lay` /
+ * `silentSet`) updates the value without re-rendering (upstream: without
+ * triggering reactivity), and `peek` / `untrackedGet` read it back — in React
+ * there is no dependency tracking during render, so those are plain aliases
+ * for the current value. `reset()` (a small addition, upstream has no
+ * equivalent) restores the initial value and participates in the change
+ * callbacks (`onBeforeChange` can dismiss it, `onChanged` fires when
+ * accepted). Option names are kept from upstream:
+ * `onBeforeChange` can dismiss a change by returning `false`, and `onChanged`
+ * fires synchronously after an accepted change.
+ *
+ * @param   state    State source: a plain value, getter, ref-like value, state
+ *                   tuple, or `{ value, onChange }` controllable state.
+ * @param   options
+ * @return  A tuple `[value, setValue, control]` — the current value, a
+ *          `setState`-like setter and the fine-grained control object.
+ *
+ * @example
+ * const [num, setNum, control] = useStateWithControl(0)
+ *
+ * setNum(42) // just like a normal useState setter
+ * control.set(30, false) // set the value without re-rendering
+ * control.peek() // get the value without tracking
+ */
+export declare function useStateWithControl<T>(state: State<T>, options?: UseStateWithControlOptions<T>): UseStateWithControlReturn<T>;
+//#endregion
+//#region useThrottleFn/index.d.ts
+export type PromisifyFn<T extends FunctionArgs> = (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
+/**
+ * Throttle execution of a function — React port of VueUse's `useThrottleFn`.
+ * Especially useful for rate limiting execution of handlers on events like
+ * resize and scroll.
+ *
+ * Map from @vueuse/shared `useThrottleFn`
+ * Mapping: upstream builds `createFilterWrapper(throttleFilter(ms, trailing,
+ * leading, rejectOnCancel), fn)` and returns a plain `PromisifyFn<T>` — the
+ * throttled wrapper carries no `cancel` / `flush` / `isPending` (unlike the
+ * debounce filter, upstream's `throttleFilter` is not cancelable), so this
+ * port mirrors that: the return value is the wrapped function and nothing
+ * more. The wrapper is built once (`useMemo`) so its identity is stable
+ * across renders — safe to add/remove in effects; the latest `fn` / `ms` /
+ * `trailing` / `leading` / `rejectOnCancel` are mirrored into refs so every
+ * call sees fresh values (upstream captures the flags once, at filter
+ * creation). `ms` accepts a number or a ref-like `{ current: number }`
+ * (upstream: `RefOrValue<number>`) and is re-read on every call. The
+ * throttle filter logic is inlined (upstream: `utils/filters.ts`
+ * `throttleFilter` — leading/trailing timestamps with a trailing invoke on
+ * window end). The wrapper is cleaned up on unmount: any pending trailing
+ * timer is cleared when the component unmounts — a React hygiene measure;
+ * upstream registers no disposal at all (`@__NO_SIDE_EFFECTS__`), so a
+ * pending call would still fire there after teardown.
+ *
+ * @param   fn             A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
+ *                                    to `callback` when the throttled-function is executed.
+ * @param   ms             A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+ *                                    (default value: 200)
+ *
+ * @param [trailing] if true, call fn again after the time is up (default value: true)
+ *
+ * @param [leading] if true, call fn on the leading edge of the ms timeout (default value: true)
+ *
+ * @param [rejectOnCancel] if true, reject the last call if it's been cancel (default value: false)
+ *
+ * @return  A new, throttled, function.
+ *
+ * @example
+ * const throttledFn = useThrottleFn(() => { ... }, 1000)
+ * throttledFn()
+ */
+export declare function useThrottleFn<T extends FunctionArgs>(fn: T, ms?: RefOrValue<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): PromisifyFn<T>;
+//#endregion
+//#region useTimeout/index.d.ts
+export interface UseTimeoutOptions<Controls extends boolean = false> {
+  /**
+   * Expose more controls
+   *
+   * @default false
+   */
+  controls?: Controls;
+  /**
+   * Callback on timeout
+   */
+  callback?: () => void;
+  /**
+   * Start the timer immediately
+   *
+   * @default true
+   */
+  immediate?: boolean;
+  /**
+   * Execute the callback immediately after calling `start`
+   *
+   * @default false
+   */
+  immediateCallback?: boolean;
+}
+export interface UseTimeoutReturn {
+  /**
+   * `true` once the timeout has fired
+   */
+  ready: boolean;
+  /**
+   * `true` while the timer is armed and waiting
+   */
+  isPending: boolean;
+  /**
+   * (Re)arm the timer
+   */
+  start: () => void;
+  /**
+   * Cancel the pending timer
+   */
+  stop: () => void;
+}
+/**
+ * React port of VueUse's `useTimeout`.
+ *
+ * Map from @vueuse/shared `useTimeout`
+ * Mapping: upstream `useTimeout` wraps `useTimeoutFn` and derives
+ * `ready` as `!isPending`; since `useTimeoutFn` is mapped in its own module,
+ * this port inlines the timer logic to stay self-contained — `ref` →
+ * `useState` for `isPending`, `ready` derived as `!isPending` like upstream,
+ * the setup-time `start()` (immediate) becomes an empty-dependency `useEffect`
+ * on mount, and `tryOnScopeDispose(stop)` becomes the effect cleanup.
+ * `interval` accepts a number or a React ref (upstream: `RefOrValue<number>`);
+ * `start` / `stop` are stable `useCallback`s.
+ *
+ * @example
+ * const ready = useTimeout(1000) // boolean, becomes true after 1s
+ *
+ * const { ready, start, stop } = useTimeout(1000, { controls: true })
+ */
+export declare function useTimeout(interval?: RefOrValue<number>, options?: UseTimeoutOptions<false>): boolean;
+export declare function useTimeout(interval: RefOrValue<number>, options: UseTimeoutOptions<true>): UseTimeoutReturn;
+//#endregion
+//#region useTimeoutFn/index.d.ts
+type AnyFn = (...args: any[]) => any;
+export interface UseTimeoutFnOptions {
+  /**
+   * Start the timer immediately
+   *
+   * @default true
+   */
+  immediate?: boolean;
+  /**
+   * Execute the callback immediately after calling `start`
+   *
+   * @default false
+   */
+  immediateCallback?: boolean;
+}
+export interface UseTimeoutFnReturn<CallbackFn extends AnyFn> {
+  isPending: boolean;
+  stop: () => void;
+  start: (...args: Parameters<CallbackFn> | []) => void;
+}
+/**
+ * React port of VueUse's `useTimeoutFn` — wrapper for `setTimeout` with
+ * controls.
+ *
+ * Map from @vueuse/shared `useTimeoutFn`
+ * Mapping: upstream accepts `RefOrValue<number>` for the interval — this
+ * port accepts a plain `number`. `isPending` becomes a boolean state
+ * (upstream: a readonly shallow ref) that starts `false` and is set inside
+ * the mount effect — like upstream's `shallowRef(false)` + `isClient` gate,
+ * the server render does not report pending. `immediateCallback` runs the
+ * callback synchronously on `start` (before the timer is armed). The timer
+ * is scheduled in a mount effect (upstream starts synchronously during
+ * setup) and a pending timer is cleared on unmount via effect cleanup. The
+ * latest callback and interval are kept in refs so restarts always use the
+ * newest ones.
+ *
+ * @example
+ * const { isPending, start, stop } = useTimeoutFn(() => { ... }, 3000)
+ */
+export declare function useTimeoutFn<CallbackFn extends AnyFn>(cb: CallbackFn, interval: number, options?: UseTimeoutFnOptions): UseTimeoutFnReturn<CallbackFn>;
+//#endregion
+//#region useToggle/index.d.ts
+export interface UseToggleOptions<Truthy, Falsy> {
+  /**
+   * Custom value for `true`
+   *
+   * @default true
+   */
+  truthyValue?: Truthy;
+  /**
+   * Custom value for `false`
+   *
+   * @default false
+   */
+  falsyValue?: Falsy;
+}
+export type UseToggleReturn<T extends boolean | number | string = boolean> = [T, (value?: T | ((current: T) => T)) => void];
+/**
+ * React port of VueUse's `useToggle` — a toggler between a truthy and a falsy
+ * value, both configurable.
+ *
+ * Map from @vueuse/shared `useToggle`
+ * Mapping: `ref(initialValue)` → `useControllableState(initialValue)`,
+ * `toggle()` → stable `useCallback`; accepts the full `State<T>` input.
+ * `truthyValue` / `falsyValue` are plain values (upstream: `MaybeRefOrGetter` —
+ * reactive refs/getters are not supported, see `RefOrValue`). Upstream's
+ * `toggle` returns the new value synchronously; React state updates are async,
+ * so here `toggle` is `() => void` and the new value is read from `value` on
+ * the next render. Like upstream, a bare `toggle()` flips between
+ * `truthyValue` and `falsyValue`, `toggle(value)` (including an explicit
+ * `undefined`) forces the value, and a function argument is applied as a
+ * functional update (React adaptation).
+ *
+ * @example
+ * const [value, toggle] = useToggle()
+ * toggle()        // false → true
+ * toggle(false)   // force to false
+ *
+ * const [status, toggleStatus] = useToggle('on', { truthyValue: 'on', falsyValue: 'off' })
+ * toggleStatus()  // 'on' → 'off'
+ */
+export declare function useToggle<T extends boolean | number | string = boolean, Truthy = true, Falsy = false>(initialValue?: State<T>, options?: UseToggleOptions<Truthy, Falsy>): UseToggleReturn<T>;
+//#endregion
+//#region useToNumber/index.d.ts
+export interface UseToNumberOptions {
+  /**
+   * Method to use to convert the value to a number.
+   *
+   * Or a custom function for the conversion.
+   *
+   * @default 'parseFloat'
+   */
+  method?: 'parseFloat' | 'parseInt' | ((value: string | number) => number);
+  /**
+   * The base in mathematical numeral systems passed to `parseInt`.
+   * Only works with `method: 'parseInt'`
+   */
+  radix?: number;
+  /**
+   * Replace NaN with zero
+   *
+   * @default false
+   */
+  nanToZero?: boolean;
+}
+/**
+ * React port of VueUse's `useToNumber`.
+ *
+ * Map from @vueuse/shared `useToNumber`
+ * Mapping: `ComputedRef<number>` → plain number recomputed from the current
+ * value on every render (accepts `number | string`); no hook state needed.
+ *
+ * @__NO_SIDE_EFFECTS__
+ * @example
+ * useToNumber('123') // 123
+ * useToNumber('0xFA', { method: 'parseInt', radix: 16 }) // 250
+ */
+export declare function useToNumber(value: number | string, options?: UseToNumberOptions): number;
+//#endregion
+//#region useToString/index.d.ts
+/**
+ * React port of VueUse's `useToString`.
+ *
+ * Map from @vueuse/shared `useToString`
+ * Mapping: VueUse wraps the template-literal coercion in `computed(() => ...)`
+ * and accepts a `MaybeRefOrGetter`; React has no reactive value tracking, so
+ * this is a plain function returning the stringified value directly.
+ *
+ * The `value` param is a PLAIN read-only value — pass `ref.current` or the
+ * state value. Getter inputs are intentionally not supported (getters were
+ * removed repo-wide); unlike upstream, a getter passed here is coerced as-is
+ * (its source text), not invoked.
+ *
+ * @example
+ * useToString(123.345)       // '123.345'
+ * useToString('hi')          // 'hi'
+ * useToString({ foo: 'hi' }) // '[object Object]'
+ */
+export declare function useToString(value: unknown): string;
+//#endregion
+//#region useUnmount/index.d.ts
+/**
+ * React port of react-use's `useUnmount`.
+ *
+ * Map from react-use `useUnmount`
+ * Mapping: react-use's `useUnmount` keeps the callback in a `useRef`,
+ * reassigning it on every render so the newest callback is invoked, and runs
+ * it via an empty-dependency `useEffect` cleanup (react-use's `useEffectOnce`
+ * is just `useEffect(effect, [])`). This port follows the same semantics.
+ *
+ * @example
+ * useUnmount(() => cleanup())
+ */
+export declare function useUnmount(fn: () => any): void;
+//#endregion
+//#region useUpdate/index.d.ts
+/**
+ * React port of react-use's `useUpdate`.
+ *
+ * Map from react-use `useUpdate`
+ * Mapping: `useReducer` with a wrapping counter — the returned function
+ * dispatches an update that forces a re-render and is stable across renders.
+ *
+ * @example
+ * const update = useUpdate()
+ * update() // forces a re-render
+ */
+export declare function useUpdate(): () => void;
+//#endregion
+//#region useWatch/index.d.ts
+export interface UseWatchCallback<T = any> {
+  (value: T, oldValue: T | undefined): void;
+}
+export interface UseWatchOptions {
+  /**
+   * Fire the callback once on mount with the current value.
+   * @default false
+   */
+  immediate?: boolean;
+}
+/**
+ * React port of VueUse's `watch`.
+ *
+ * Map from @vueuse/shared `watch`
+ * Mapping: Vue's reactive dependency tracking becomes a `useEffect` whose
+ * dependency list is the source itself — `[source]` for a single value, the
+ * source's elements for an array source — so the callback re-fires whenever
+ * any watched part changes. The previous value is tracked in a ref updated
+ * by the effect (inlined `usePrevious`), and the callback never fires on the
+ * first render unless `immediate: true`.
+ *
+ * This is the parent of all `useWatch*` variants.
+ *
+ * @example
+ * ```ts
+ * useWatch(count, (value, oldValue) => console.log(value, oldValue))
+ * useWatch([count, name], (value, oldValue) => console.log(value, oldValue))
+ * ```
+ */
+export declare function useWatch<T extends any[]>(source: readonly [...T], callback: UseWatchCallback<[...T]>, options?: UseWatchOptions): void;
+export declare function useWatch<T>(source: T, callback: UseWatchCallback<T>, options?: UseWatchOptions): void;
+//#endregion
+//#region useWatchArray/index.d.ts
+export interface UseWatchArrayCallback<V = any, OV = any> {
+  (value: V, oldValue: OV, added: V, removed: OV): void;
+}
+export interface UseWatchArrayOptions<Immediate extends Readonly<boolean> = false> {
+  /**
+   * Fire the callback once on mount with the current list.
+   * @default false
+   */
+  immediate?: Immediate;
+}
+/**
+ * React port of VueUse's `watchArray` — watch for an array with additions and removals.
+ *
+ * Mapping: built on the house `useWatch` — the list is a plain array value tracked across
+ * renders, `useWatch` handles the change detection, and the previous list is diffed against
+ * the next one with item-identity matching (like upstream) so the callback receives
+ * `(newList, oldList, added, removed)`. The list is wrapped as a single-element watch
+ * source (`[list]`) so `useWatch` tracks it by reference identity instead of spreading a
+ * variable-length list into its dependency list (React requires a constant deps size).
+ *
+ * Divergences from the upstream Vue API:
+ * - `source` is a plain array value — Vue's `WatchSource` forms (ref / getter / reactive)
+ *   have no React equivalent, compute the array during render and pass it directly.
+ * - The list is tracked by reference identity: replacing it with a new array fires the
+ *   callback even when the items are identical (like a Vue ref reassignment), while
+ *   re-renders that keep the same array reference do not fire.
+ * - In-place mutations (`push` / `splice`) do not re-render — produce a new array
+ *   (`setList([...list, item])`) to trigger the watch.
+ * - The upstream `onCleanup` callback parameter is not ported — `useWatch` has no
+ *   watch-cleanup equivalent, use `useEffect` cleanup in the component instead.
+ * - The return value is `void` — upstream returns a stop `WatchHandle`; watching
+ *   ends when the component unmounts.
+ *
+ * @example
+ * ```ts
+ * useWatchArray(list, (newList, oldList, added, removed) => {
+ *   console.log('added:', added, 'removed:', removed)
+ * })
+ * ```
+ */
+export declare function useWatchArray<T, Immediate extends Readonly<boolean> = false>(source: T[], cb: UseWatchArrayCallback<T[], Immediate extends true ? T[] | undefined : T[]>, options?: UseWatchArrayOptions<Immediate>): void;
+//#endregion
+//#region useWatchAtMost/index.d.ts
+export interface UseWatchAtMostOptions {
+  /**
+   * The maximum number of times the callback may fire.
+   */
+  count: number;
+  /**
+   * Fire the callback once on mount with the current value.
+   * @default false
+   */
+  immediate?: boolean;
+}
+export interface UseWatchAtMostReturn {
+  /**
+   * The number of times the callback has fired so far.
+   */
+  count: number;
+  /**
+   * Stop watching before the limit is reached.
+   */
+  stop: () => void;
+  /**
+   * Pause the watch — source changes do not fire the callback nor count
+   * towards the limit until `resume` is called.
+   */
+  pause: () => void;
+  /**
+   * Resume a paused watch.
+   */
+  resume: () => void;
+}
+export declare function useWatchAtMost<T extends any[]>(source: readonly [...T], callback: UseWatchCallback<[...T]>, options: UseWatchAtMostOptions): UseWatchAtMostReturn;
+export declare function useWatchAtMost<T>(source: T, callback: UseWatchCallback<T>, options: UseWatchAtMostOptions): UseWatchAtMostReturn;
+//#endregion
+//#region useWatchDebounced/index.d.ts
+export interface UseWatchDebouncedOptions extends DebounceFilterOptions {
+  /**
+   * Debounce delay in milliseconds. Accepts a plain number or a ref-like
+   * `{ current }` — re-read on every source change.
+   *
+   * @default 0
+   */
+  debounce?: RefOrValue<number>;
+  /**
+   * Fire the callback once on mount with the current value (still debounced).
+   *
+   * @default false
+   */
+  immediate?: boolean;
+}
+/**
+ * Debounced watch — the callback fires only after the source stops changing
+ * for the specified duration — React port of VueUse's `watchDebounced`.
+ *
+ * Map from @vueuse/shared `watchDebounced`
+ * Mapping: upstream is a shorthand for
+ * `watchWithFilter(source, cb, { eventFilter: debounceFilter(debounce, { maxWait }) })`.
+ * This port composes the same pieces from house primitives: `useWatch` tracks
+ * the source across renders (Vue's reactive dependency tracking becomes the
+ * effect dependency list) and hands every change to `useDebounceFn`, which
+ * implements the upstream `debounceFilter` (trailing edge + `maxWait`). Bursts
+ * of changes collapse into a single call carrying the latest `(value, oldValue)`
+ * pair captured at the last change.
+ *
+ * Divergences from upstream:
+ * - Returns `void` — upstream returns a `WatchHandle`; here disposal follows the
+ *   component lifecycle and pending timers are cancelled on unmount (via
+ *   `useDebounceFn`).
+ * - The source is a plain value (or array of values) tracked across renders —
+ *   deep-reactive object sources and `deep` / `flush` watch options don't apply.
+ * - `rejectOnCancel` (inherited from `DebounceFilterOptions`) is forwarded to
+ *   `useDebounceFn` but has no observable effect — watch callbacks return
+ *   nothing, so there is no promise to reject.
+ *
+ * @example
+ * ```ts
+ * useWatchDebounced(input, (value, oldValue) => console.log(value, oldValue), { debounce: 500, maxWait: 1000 })
+ * useWatchDebounced([count, name], (value, oldValue) => console.log(value, oldValue), { debounce: 200 })
+ * ```
+ */
+export declare function useWatchDebounced<T extends any[]>(source: readonly [...T], callback: UseWatchCallback<[...T]>, options?: UseWatchDebouncedOptions): void;
+export declare function useWatchDebounced<T>(source: T, callback: UseWatchCallback<T>, options?: UseWatchDebouncedOptions): void;
+//#endregion
+//#region useWatchDeep/index.d.ts
+/**
+ * Structural equality, mirroring the semantics of test `toEqual`: primitives
+ * are compared with `Object.is`, and `Date`, `RegExp`, `Array`, `Map`, `Set`
+ * and objects (plain or class instances) are compared by contents. Functions
+ * compare by reference, and `Map` keys are matched by reference because key
+ * lookups cannot deep-match, while `Map` values and `Set` items are compared
+ * deeply.
+ *
+ * Shared single source of truth — used by {@link useWatchDeep} and imported
+ * from `@reause/shared` by core hooks that need deep change detection
+ * (e.g. `useCloned`).
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+/**
+ * Deep clone pairing with {@link deepEqual}'s type coverage — `Date`, `RegExp`,
+ * `Array`, `Map`, `Set` and objects (plain or class instances) are copied
+ * structurally, primitives and functions pass through. Used to snapshot a live
+ * value into an isolated baseline for change detection (e.g. `useCloned`'s
+ * source / cloned baselines, which must stay unaffected by in-place mutations).
+ */
+export declare function deepClone<T>(value: T): T;
+/**
+ * React port of VueUse's `watchDeep` — shorthand for watching a value with
+ * `{ deep: true }`. Built on top of {@link useWatch}.
+ *
+ * Map from @vueuse/shared `watchDeep`
+ * Mapping: Vue's deep watcher traverses reactive proxies and fires on in-place
+ * mutation of any nested property. React state is immutable — a nested change
+ * always arrives as a new top-level value — so `useWatchDeep` deep-compares
+ * the newly rendered value against the previously rendered one and invokes the
+ * callback only when they differ deeply. A re-render that replaces the value
+ * with a deep-equal one stays silent (unlike `useWatch`, which fires on every
+ * reference change).
+ *
+ * Documented divergences from Vue's deep watch:
+ * - In-place mutation of a value that is never replaced cannot be observed
+ *   (React immutability) — replace the state instead; the callback then fires
+ *   when the next rendered value deep-differs from the previous one.
+ * - Reassigning the state to a deep-equal value does not fire. Vue's ref-based
+ *   watch fires on every reassignment of the ref, even when deeply equal.
+ *
+ * @example
+ * ```ts
+ * const [obj, setObj] = useState({ foo: { bar: { deep: 5 } } })
+ * useWatchDeep(obj, (value, oldValue) => console.log(value, oldValue))
+ * setObj({ foo: { bar: { deep: 10 } } }) // fires — nested value changed
+ * setObj({ foo: { bar: { deep: 10 } } }) // silent — deep-equal reassignment
+ * ```
+ */
+export declare function useWatchDeep<T extends any[]>(source: readonly [...T], callback: UseWatchCallback<[...T]>, options?: UseWatchOptions): void;
+export declare function useWatchDeep<T>(source: T, callback: UseWatchCallback<T>, options?: UseWatchOptions): void;
+//#endregion
+//#region useWatchIgnorable/index.d.ts
+export type IgnoredUpdater = (updater: () => void) => void;
+export type IgnoredPrevAsyncUpdates = () => void;
+export interface UseWatchIgnorableReturn {
+  /**
+   * Run `updater`, ignoring the watch for the source changes it makes — as
+   * long as no other changes follow, the callback is not fired for that batch.
+   */
+  ignoreUpdates: IgnoredUpdater;
+  /**
+   * Ignore the source changes made since the last time the callback fired —
+   * as long as no other changes follow, the callback is not fired for that
+   * batch.
+   */
+  ignorePrevAsyncUpdates: IgnoredPrevAsyncUpdates;
+  /**
+   * Stop watching — further source changes will not fire the callback.
+   */
+  stop: () => void;
+}
+export interface UseWatchIgnorableOptions {
+  /**
+   * Fire the callback once on mount with the current value.
+   * @default false
+   */
+  immediate?: boolean;
+  /**
+   * Stop the watch after the callback has fired once (upstream: Vue's `once`
+   * watch option). Ignored fires do not count towards the limit.
+   * @default false
+   */
+  once?: boolean;
+}
+/**
+ * Ignorable watch — extended watch that returns `ignoreUpdates(updater)` /
+ * `ignorePrevAsyncUpdates()` / `stop` to ignore particular updates to the
+ * source — React port of VueUse's `watchIgnorable`.
+ * Map from @vueuse/shared watchIgnorable.
+ *
+ * The API follows the maintainer-directed adjustment of issue #263: the
+ * source is the caller's own state value (house `useWatch` source convention)
+ * and the return is the upstream `WatchIgnorableReturn` object shape — this
+ * deliberately overrides the house array-destructure return convention.
+ *
+ * Mapping: upstream counts every source modification with a hidden
+ * `flush: 'sync'` shadow watcher (`syncCounter`), accumulates the changes to
+ * skip in `ignoreCounter`, and skips a trigger only when every counted change
+ * came from `ignoreUpdates` (`ignoreCounter === syncCounter`, both counters
+ * reset together). React offers no way to observe — let alone intercept — the
+ * caller's `setSource`: changes only become visible at the next commit, where
+ * automatic batching has already collapsed consecutive updates into a single
+ * render. The port therefore approximates the counters with a one-shot
+ * "ignore barrier": `ignoreUpdates(updater)` snapshots the latest observed
+ * value, runs `updater` synchronously and arms the barrier; the next change
+ * the watch observes is skipped (upstream skips it too when no other changes
+ * follow) and the flag is consumed either way, so later genuine changes fire
+ * again. `ignorePrevAsyncUpdates()` arms the same barrier for the changes
+ * queued before the call (snapshot-style one-shot skip). A commit that
+ * carries no source change disarms the barrier so a no-op updater cannot
+ * consume a later genuine change.
+ *
+ * Divergences from upstream (React batching):
+ * - Changes made inside `ignoreUpdates` and further changes made afterwards
+ *   in the same synchronous batch collapse into one render, which the barrier
+ *   skips as a whole — upstream would fire the trigger with the latest value.
+ *   Let the updater's batch commit (return from the event handler) before
+ *   making changes that must fire.
+ * - If the updater produces no change and the very next commit carries a
+ *   source change, that change is skipped where upstream would fire it (a
+ *   commit without a source change disarms the barrier).
+ * - The `flush` option is not ported — the callback fires in the effect after
+ *   commit (upstream `flush: 'pre'` timing); where upstream's
+ *   `flush: 'sync'` makes `ignorePrevAsyncUpdates` a no-op, here it always
+ *   applies.
+ * - Upstream's other `WatchWithFilterOptions` members are rejected:
+ *   `deep` (no reactive graph to traverse — the source is compared by
+ *   identity), `flush` (React commits are not configurable), and
+ *   `eventFilter` (no filter pipeline); the option type does not accept them,
+ *   so passing them fails type checking. `once` IS ported — the watch stops
+ *   after the first fired change.
+ * - `stop()` keeps the effect registered but the callback becomes a no-op —
+ *   observable behavior is identical (the callback never fires again).
+ * - The deprecated upstream alias `ignorableWatch` is not ported (house
+ *   `useWatch*` naming convention).
+ *
+ * @example
+ * ```ts
+ * const [source, setSource] = useState('foo')
+ * const { ignoreUpdates } = useWatchIgnorable(source, v => console.log(`Changed to ${v}!`))
+ * setSource('bar') // logs: Changed to bar!
+ * ignoreUpdates(() => setSource('foobar')) // (nothing logged)
+ * ```
+ */
+export declare function useWatchIgnorable<T extends any[]>(source: readonly [...T], callback: UseWatchCallback<[...T]>, options?: UseWatchIgnorableOptions): UseWatchIgnorableReturn;
+export declare function useWatchIgnorable<T>(source: T, callback: UseWatchCallback<T>, options?: UseWatchIgnorableOptions): UseWatchIgnorableReturn;
+//#endregion
+//#region useWatchImmediate/index.d.ts
+/**
+ * Shorthand for watching value with `{ immediate: true }` — React port of
+ * VueUse's `watchImmediate`.
+ *
+ * Map from @vueuse/shared watchImmediate. Upstream is a shorthand for
+ * `watch(source, cb, { ...options, immediate: true })`; this port composes
+ * the same pieces from house primitives: `useWatch` tracks the source across
+ * renders (Vue's reactive dependency tracking becomes the effect dependency
+ * list) and the hardcoded `immediate: true` fires the callback once on mount
+ * with the current value, then again on every subsequent change with
+ * `(value, oldValue)`.
+ *
+ * Divergences from the upstream Vue API:
+ * - Returns `void` — upstream returns a `WatchHandle`; here disposal follows
+ *   the component lifecycle.
+ * - The source is a plain value (or array of values) tracked across renders —
+ *   Vue's `WatchSource` forms (ref / getter / reactive) have no React
+ *   equivalent, compute the value during render and pass it directly.
+ * - The remaining upstream options are not ported — `immediate` is the whole
+ *   point of this shorthand and is always `true`, while `deep` and `flush`
+ *   don't apply (tracking is by `Object.is` identity, like a Vue ref
+ *   reassignment, and effects always run after commit).
+ *
+ * @example
+ * ```ts
+ * // logs on mount ('vue-use') and again on every change ('VueUse', ...)
+ * useWatchImmediate(obj, updated => console.log(updated))
+ * useWatchImmediate([count, name], (value, oldValue) => console.log(value, oldValue))
+ * ```
+ */
+export declare function useWatchImmediate<T extends any[]>(source: readonly [...T], callback: UseWatchCallback<[...T]>): void;
+export declare function useWatchImmediate<T>(source: T, callback: UseWatchCallback<T>): void;
+//#endregion
+//#region useWatchOnce/index.d.ts
+export interface UseWatchOnceReturn {
+  /**
+   * Stop watching before the callback has fired — further source changes are
+   * ignored. Calling it after the callback fired is a no-op.
+   */
+  stop: () => void;
+}
+export declare function useWatchOnce<T extends any[]>(source: readonly [...T], callback: UseWatchCallback<[...T]>, options?: UseWatchOptions): UseWatchOnceReturn;
+export declare function useWatchOnce<T>(source: T, callback: UseWatchCallback<T>, options?: UseWatchOptions): UseWatchOnceReturn;
+//#endregion
+//#region useWatchPausable/index.d.ts
+export interface UseWatchPausableOptions {
+  /**
+   * The initial state of the watcher.
+   *
+   * @default 'active'
+   */
+  initialState?: 'active' | 'paused';
+  /**
+   * Fire the callback once on mount with the current source value (still
+   * subject to the pause state).
+   *
+   * @default false
+   */
+  immediate?: boolean;
+}
+export interface UseWatchPausableReturn {
+  /**
+   * Pause the watcher — source changes will not fire the callback while
+   * paused. Changes made while paused are dropped.
+   */
+  pause: () => void;
+  /**
+   * Resume the watcher — re-activates the callback for future changes. It
+   * does not replay changes made while paused.
+   */
+  resume: () => void;
+  /**
+   * Whether the watcher is currently active.
+   */
+  isActive: boolean;
+  /**
+   * Stop the watcher — the callback never fires again.
+   */
+  stop: () => void;
+}
+/**
+ * Pausable watch — a watched value whose updates can be paused and resumed —
+ * React port of VueUse's `watchPausable`.
+ *
+ * Map from @vueuse/shared watchPausable. Upstream wraps `watchWithFilter` with
+ * `pausableFilter`: while paused the event filter drops invocations, and
+ * `resume()` only re-activates the filter — changes made while paused are
+ * never replayed, so the first change after resuming fires the callback with
+ * the last change's value — the dropped one, if any — as `oldValue`: the
+ * watch's tracked previous value advances through paused changes, matching
+ * upstream, where the filter swallows the invocation but the underlying
+ * watch's `oldValue` still moves. This port keeps those semantics on
+ * house primitives: `useWatch` tracks the source across renders (Vue's
+ * reactive dependency tracking becomes the effect dependency list, firing in
+ * the effect after commit — upstream `flush: 'pre'` timing) and the callback
+ * is skipped whenever the watcher is paused or stopped.
+ *
+ * The API follows the maintainer-directed watch-wrapper convention of issue
+ * #263: the source is the caller's own state value (house `useWatch` source
+ * convention) and the return is the upstream `WatchPausableReturn` object
+ * shape.
+ *
+ * Divergences from upstream:
+ * - `isActive` is a plain boolean state instead of a readonly ref — it updates
+ *   across renders, and `pause()` / `resume()` made in the same batch as a
+ *   source change are still honoured (the pause state is mirrored into a ref
+ *   read by the effect).
+ * - Changes made while paused are dropped — upstream `pausableFilter` defers
+ *   nothing, so `resume()` does not replay them and never fires the callback
+ *   by itself.
+ * - The `deep`, `flush`, `eventFilter` watch options and the `onTrack` /
+ *   `onTrigger` callbacks are not ported — tracking is by `Object.is`
+ *   identity, like a Vue ref reassignment (upstream `WatchPausableOptions` is
+ *   `WatchWithFilterOptions & PausableFilterOptions`; the `pausableFilter`
+ *   half carries no options of its own, so there is no `eventFilterOptions`
+ *   member).
+ * - `stop()` keeps the effect registered but the callback becomes a no-op —
+ *   observable behavior is identical (the callback never fires again), and
+ *   `isActive` is unaffected, like upstream.
+ *
+ * @example
+ * ```ts
+ * const [source, setSource] = useState('foo')
+ * const { pause, resume } = useWatchPausable(source, v => console.log(`Changed to ${v}!`))
+ * setSource('bar') // logs: Changed to bar!
+ * pause()
+ * setSource('foobar') // (nothing logged)
+ * resume()
+ * setSource('hello') // logs: Changed to hello!
+ * ```
+ */
+export declare function useWatchPausable<T extends any[]>(source: readonly [...T], callback: UseWatchCallback<[...T]>, options?: UseWatchPausableOptions): UseWatchPausableReturn;
+export declare function useWatchPausable<T>(source: T, callback: UseWatchCallback<NoInfer<T>>, options?: UseWatchPausableOptions): UseWatchPausableReturn;
+//#endregion
+//#region useWatchThrottled/index.d.ts
+export interface UseWatchThrottledOptions {
+  /**
+   * Throttle interval in milliseconds. Accepts a plain number or a ref-like
+   * `{ current }` — re-read on every source change.
+   *
+   * @default 0
+   */
+  throttle?: RefOrValue<number>;
+  /**
+   * Invoke the callback on the trailing edge of the throttle window.
+   *
+   * @default true
+   */
+  trailing?: boolean;
+  /**
+   * Invoke the callback on the leading edge of the throttle window.
+   *
+   * @default true
+   */
+  leading?: boolean;
+  /**
+   * Fire the callback once on mount with the current value (still throttled).
+   *
+   * @default false
+   */
+  immediate?: boolean;
+}
+/**
+ * Throttled watch — the callback is invoked at most once per specified
+ * duration — React port of VueUse's `watchThrottled`.
+ * Map from @vueuse/shared watchThrottled.
+ *
+ * Mapping: upstream is a shorthand for
+ * `watchWithFilter(source, cb, { eventFilter: throttleFilter(throttle, trailing, leading) })`.
+ * This port composes the same pieces from house primitives: `useWatch` tracks
+ * the source across renders (Vue's reactive dependency tracking becomes the
+ * effect dependency list) and hands every change to `useThrottleFn`, which
+ * implements the upstream `throttleFilter` (leading/trailing edges with a
+ * trailing invoke on window end). Changes inside the throttle window collapse
+ * into a single call carrying the latest `(value, oldValue)` pair captured at
+ * the last change.
+ *
+ * Divergences from upstream:
+ * - Returns `void` — upstream returns a `WatchHandle`; here disposal follows the
+ *   component lifecycle and pending timers are cancelled on unmount (via
+ *   `useThrottleFn`).
+ * - The source is a plain value (or array of values) tracked across renders —
+ *   deep-reactive object sources and `deep` / `flush` watch options don't apply.
+ * - upstream's deprecated `throttledWatch` alias is not ported.
+ *
+ * @example
+ * ```ts
+ * useWatchThrottled(input, (value, oldValue) => console.log(value, oldValue), { throttle: 500 })
+ * useWatchThrottled([count, name], (value, oldValue) => console.log(value, oldValue), { throttle: 200 })
+ * ```
+ */
+export declare function useWatchThrottled<T extends any[]>(source: readonly [...T], callback: UseWatchCallback<[...T]>, options?: UseWatchThrottledOptions): void;
+export declare function useWatchThrottled<T>(source: T, callback: UseWatchCallback<T>, options?: UseWatchThrottledOptions): void;
+//#endregion
+//#region useWatchTriggerable/index.d.ts
+export type OnCleanup = (cleanupFn: () => void) => void;
+export interface UseWatchTriggerableCallback<V = any, OV = any, R = void> {
+  (value: V, oldValue: OV, onCleanup: OnCleanup): R;
+}
+/** Per-element optional old value for array sources (upstream `MapOldSources<T, true>`). */
+export type UseWatchTriggerableOldValues<T extends readonly any[]> = { [K in keyof T]: T[K] | undefined; };
+export interface UseWatchTriggerableReturn<R = void> {
+  /**
+   * Execute the callback immediately with the current source value — the old
+   * value is unknown (`undefined`, per-element for array sources) for a manual
+   * call, and the invocation does not count as a source change: a source
+   * change queued inside the callback is itself ignored.
+   */
+  trigger: () => R;
+  /**
+   * Run `updater`, ignoring the watch for the source changes it makes — as
+   * long as no other changes follow, the callback is not fired for that batch.
+   */
+  ignoreUpdates: IgnoredUpdater;
+  /**
+   * Ignore the source changes made since the last time the callback fired —
+   * as long as no other changes follow, the callback is not fired for that
+   * batch.
+   */
+  ignorePrevAsyncUpdates: () => void;
+  /**
+   * Stop watching — further source changes will not fire the callback.
+   */
+  stop: () => void;
+}
+export interface UseWatchTriggerableOptions {
+  /**
+   * Fire the callback once on mount with the current value.
+   * @default false
+   */
+  immediate?: boolean;
+}
+/**
+ * Watch that can be triggered manually — extended watch that returns
+ * `trigger()` to execute the callback immediately — React port of VueUse's
+ * `watchTriggerable`.
+ * Map from @vueuse/shared watchTriggerable.
+ *
+ * The API follows the maintainer-directed adjustment of issue #263: the
+ * source is the caller's own state value (house `useWatch` source convention)
+ * and the return is the upstream `WatchTriggerableReturn` object shape — this
+ * deliberately overrides the house array-destructure return convention, and
+ * the hook holds no observable state of its own (the internal render tick is
+ * invisible to the caller).
+ *
+ * Mapping: upstream builds on `watchIgnorable`, which counts every source
+ * modification with a hidden `flush: 'sync'` shadow watcher (`syncCounter`),
+ * accumulates the changes to skip in `ignoreCounter`, and skips a trigger
+ * only when every counted change came from `ignoreUpdates`
+ * (`ignoreCounter === syncCounter`); `trigger()` calls the callback with the
+ * current source value wrapped in `ignoreUpdates` so the manual invocation
+ * does not disturb that accounting, and the previously registered `onCleanup`
+ * side effect is cleaned up before every new invocation.
+ *
+ * React sees the caller's changes only at commit — there is no way to observe
+ * (let alone intercept) `setSource`, and automatic batching has already
+ * collapsed consecutive updates into a single render by then. The counters
+ * are therefore approximated with a one-shot "ignore barrier":
+ * `ignoreUpdates(updater)` snapshots the latest observed value, runs `updater`
+ * synchronously and arms the barrier; the next change the watch observes is
+ * skipped (upstream skips it too when no other changes follow) and the flag is
+ * consumed either way, so later genuine changes fire again.
+ * `ignorePrevAsyncUpdates()` arms the same barrier for the changes queued
+ * before the call. The barrier is disarmed again when a commit carries no
+ * source change (the updater produced nothing observable); an internal render
+ * tick guarantees such a commit even when the updater is a no-op `setState`
+ * that React would otherwise bail out of entirely — so a no-op updater can
+ * never consume a later genuine change (upstream counts 0 changes and fires).
+ *
+ * `trigger()` fires synchronously at the call site — it does not wait for
+ * React to commit and is unaffected by batching: it hands the current source
+ * value straight to the callback with the old value `undefined` (upstream
+ * cannot know it either; array sources get a per-element `undefined`) and
+ * returns the callback's return value so async work can be awaited. Like
+ * upstream, the invocation is wrapped in `ignoreUpdates`: a source change
+ * queued by the callback inside `trigger()` is suppressed after its commit
+ * (upstream counts it in `ignoreCounter`), and a callback that makes no
+ * source change is disarmed by the forced commit, so a later genuine change
+ * still fires.
+ *
+ * Divergences from upstream (React batching):
+ * - Changes made inside `ignoreUpdates` and further changes made afterwards
+ *   in the same synchronous batch collapse into one render, which the
+ *   barrier skips as a whole — upstream would fire the callback with the
+ *   latest value. Let the updater's batch commit before making changes that
+ *   must fire.
+ * - The `flush` option is not ported — the callback fires in the effect after
+ *   commit (upstream `flush: 'pre'` timing); `eventFilter` and the other
+ *   `WatchWithFilterOptions` members (`deep`, pause/resume) are not ported —
+ *   only `immediate`.
+ * - `stop()` keeps the effect registered but the callback becomes a no-op —
+ *   observable behavior is identical (the callback never fires again).
+ *
+ * @example
+ * ```ts
+ * const [source, setSource] = useState('foo')
+ * const { trigger, ignoreUpdates } = useWatchTriggerable(source, v => console.log(`Changed to ${v}!`))
+ * setSource('bar') // logs: Changed to bar!
+ * ignoreUpdates(() => setSource('foobar')) // (nothing logged)
+ * trigger() // logs: Changed to foobar! — fired manually with the current value
+ * ```
+ */
+export declare function useWatchTriggerable<T extends any[], R>(source: readonly [...T], callback: UseWatchTriggerableCallback<[...T], UseWatchTriggerableOldValues<[...T]>, R>, options?: UseWatchTriggerableOptions): UseWatchTriggerableReturn<R>;
+export declare function useWatchTriggerable<T, R>(source: T, callback: UseWatchTriggerableCallback<T, T | undefined, R>, options?: UseWatchTriggerableOptions): UseWatchTriggerableReturn<R>;
+//#endregion
+//#region useWatchWithFilter/index.d.ts
+/**
+ * Filter for if events should to be received — the house equivalent of
+ * upstream's `EventFilter` (`@vueuse/shared` `utils/filters.ts`).
+ *
+ * Upstream is generic over the wrapped function
+ * (`EventFilter<Args, This, Invoke>` returning
+ * `ReturnType<Invoke> | Promisify<ReturnType<Invoke>>`); the watch path
+ * discards the wrapped callback's return value, so the contract collapses
+ * to `(invoke: FunctionArgs, options?: Record<string, unknown>) => void`.
+ * The optional second argument mirrors upstream's placeholder
+ * `FunctionWrapperOptions` (e.g. `useMouse` passes `{}`), so a chained
+ * filter reads an object instead of `undefined`.
+ */
+export type EventFilter = (invoke: FunctionArgs, options?: Record<string, unknown>) => void;
+/**
+ * An `EventFilter` that carries cancellation controls (upstream:
+ * `CancelableEventFilter`), as returned by `debounceFilter`.
+ *
+ * `isPending` is a plain (non-reactive) getter — React has no reactive refs,
+ * read it imperatively.
+ */
+export interface CancelableEventFilter extends EventFilter {
+  cancel: () => void;
+  flush: () => void;
+  readonly isPending: boolean;
+}
+export interface UseWatchWithFilterOptions {
+  /**
+   * Filter for if events should to be received (upstream:
+   * `ConfigurableEventFilter`).
+   *
+   * The filter instance is captured once on mount — like upstream, where the
+   * watch options are evaluated once during setup — so an inline
+   * `debounceFilter(300)` is safe; pass a getter-based delay
+   * (`debounceFilter(() => ms)`) when the delay must change over time.
+   *
+   * @default bypassFilter (invoke directly)
+   */
+  eventFilter?: EventFilter;
+  /**
+   * Fire the callback once on mount with the current value (still filtered).
+   * @default false
+   */
+  immediate?: boolean;
+}
+/**
+ * The stop function returned by `useWatchWithFilter` — upstream's
+ * `WatchHandle`, reduced to the stop capability (house `useWatch` has no
+ * stop-handle infrastructure).
+ */
+export type UseWatchWithFilterReturn = () => void;
+/**
+ * Create an EventFilter that debounce the events — in-house port of upstream
+ * `@vueuse/shared` `debounceFilter` (trailing edge + `maxWait`).
+ *
+ * Mapping: same collapsing semantics as upstream (a newer call supersedes the
+ * pending one; the `maxWait` timer survives re-scheduling and forces the call
+ * with the latest `invoke`). Divergences: the promise-settlement plumbing
+ * (`lastRejector` / `rejectOnCancel`) is dropped — the house `EventFilter`
+ * contract returns `void` and the watch path consumes no promise, so
+ * `rejectOnCancel` has no observable effect — and `isPending` is a plain
+ * getter instead of a reactive ref. `ms` accepts a plain number or a React
+ * ref (upstream: `RefOrValue<number>`) and is re-read on every call. Pending
+ * timers are cleared by `cancel()` — the `useWatchWithFilter` hook calls it
+ * on stop / unmount.
+ *
+ * @example
+ * ```ts
+ * useWatchWithFilter(input, callback, { eventFilter: debounceFilter(300, { maxWait: 1000 }) })
+ * ```
+ */
+export declare function debounceFilter(ms?: RefOrValue<number>, options?: DebounceFilterOptions): CancelableEventFilter;
+/**
+ * Create an EventFilter that throttle the events — in-house port of upstream
+ * `@vueuse/shared` `throttleFilter` (leading/trailing edges with a trailing
+ * invoke on window end).
+ *
+ * Mapping: same collapsing semantics as upstream — a call inside the throttle
+ * window re-schedules the trailing timer with the remaining time, collapsing
+ * bursts into one trailing call carrying the latest `invoke`. Divergences:
+ * the promise-settlement plumbing (`rejectOnCancel`, upstream's fourth
+ * parameter) is dropped — the house `EventFilter` contract returns `void` —
+ * and the object options form is not ported (positional
+ * `throttleFilter(ms, trailing, leading)` like the house `useThrottleFn`).
+ * `ms` accepts a plain number or a React ref (upstream:
+ * `RefOrValue<number>`) and is re-read on every call.
+ *
+ * @example
+ * ```ts
+ * useWatchWithFilter(scrollY, callback, { eventFilter: throttleFilter(100, true, false) })
+ * ```
+ */
+export declare function throttleFilter(ms?: RefOrValue<number>, trailing?: boolean, leading?: boolean): EventFilter;
+export declare function useWatchWithFilter<T extends any[]>(source: readonly [...T], callback: UseWatchCallback<[...T]>, options?: UseWatchWithFilterOptions): UseWatchWithFilterReturn;
+export declare function useWatchWithFilter<T>(source: T, callback: UseWatchCallback<T>, options?: UseWatchWithFilterOptions): UseWatchWithFilterReturn;
+//#endregion
+//#region useWhenever/index.d.ts
+export type Truthy<T> = T extends false | null | undefined ? never : T;
+export interface UseWheneverOptions {
+  /**
+   * Fire the callback on mount if the value is already truthy
+   *
+   * @default false
+   */
+  immediate?: boolean;
+  /**
+   * Only trigger once when the condition is met — the watch stops after the
+   * first truthy fire
+   *
+   * @default false
+   */
+  once?: boolean;
+}
+/**
+ * React port of VueUse's `whenever`.
+ *
+ * Map from @vueuse/shared `whenever`
+ * Mapping: upstream `whenever` is Vue's `watch` plus a truthy guard — the
+ * callback runs every time the source CHANGES to a truthy value (a re-render
+ * with the same truthy value never fires). In React this becomes a `useEffect`
+ * watching `[value]`: the initial mount is skipped unless `immediate` (which
+ * fires with `oldValue` `undefined`), later runs fire when the value is truthy
+ * and actually changed, and the previous value is tracked in a ref updated on
+ * every run — mirroring `watch`'s `oldValue`, which advances through falsy
+ * values too. The callback is kept in a ref so re-renders always invoke the
+ * newest one.
+ *
+ * The `once` option stops the watch after the first truthy fire — expressible
+ * in React as a one-shot flag consulted by the effect, mirroring upstream's
+ * `if (options?.once) nextTick(() => stop())`.
+ *
+ * The return value is a `stop` function — upstream's `WatchHandle`, reduced to
+ * the stop capability (house `useWatch` has no stop-handle infrastructure).
+ * `stop()` is also called when the component unmounts.
+ *
+ * The upstream 3-arg callback `(value, oldValue, onInvalidate)` becomes a
+ * 2-arg `(value, oldValue)` in this port — `onInvalidate` (Vue's effect
+ * invalidation registration) has no React equivalent, so it is dropped.
+ *
+ * @see https://vueuse.org/shared/whenever/
+ *
+ * @example
+ * useWhenever(ready, () => console.log(state))
+ * useWhenever(ready, () => console.log(state), { immediate: true })
+ * useWhenever(ready, () => console.log(state), { once: true })
+ */
+export declare function useWhenever<T>(value: T, cb: (value: Truthy<T>, oldValue: T | undefined) => void, options?: UseWheneverOptions): () => void;
+//#endregion
+//#region index.d.ts
+/**
+ * @reause/shared — React port of @vueuse/shared
+ * Shared utilities shared across all reause packages.
+ *
+ * Mapping note: @vueuse/shared exposes pure utilities + composables that
+ * don't depend on the renderer. In the React world those become either
+ * plain functions (no hook) or hooks without rendering logic.
+ */
+export declare const isClient: boolean;
+export declare function noop(): void;
+//#endregion