@vueuse/shared 14.0.0-alpha.0 → 14.0.0-alpha.2

package/{index.d.mts → dist/index.d.ts}

@@ -1,7 +1,7 @@
-import * as vue from 'vue';
-import { WatchOptionsBase, ShallowRef, WatchSource, ComputedGetter, WatchOptions, ComputedRef, WritableComputedOptions, WritableComputedRef, Ref, MaybeRef, MaybeRefOrGetter, InjectionKey, ShallowUnwrapRef as ShallowUnwrapRef$1, inject, UnwrapNestedRefs, UnwrapRef, ToRef, ToRefs, toValue as toValue$1, WatchCallback, WatchStopHandle } from 'vue';
-export { MaybeRef, MaybeRefOrGetter } from 'vue';
+import * as vue0 from "vue";
+import { ComputedGetter, ComputedRef, InjectionKey, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef, ShallowUnwrapRef as ShallowUnwrapRef$1, ToRef, ToRefs, UnwrapNestedRefs, UnwrapRef, WatchCallback, WatchOptions, WatchOptionsBase, WatchSource, WatchStopHandle, WritableComputedOptions, WritableComputedRef, getCurrentInstance, inject } from "vue";
 
+//#region computedEager/index.d.ts
 type ComputedEagerOptions = WatchOptionsBase;
 type ComputedEagerReturn<T = any> = Readonly<ShallowRef<T>>;
 /**
@@ -15,25 +15,29 @@ type ComputedEagerReturn<T = any> = Readonly<ShallowRef<T>>;
  * @returns readonly shallowRef
  */
 declare function computedEager<T>(fn: () => T, options?: ComputedEagerOptions): ComputedEagerReturn<T>;
-
+/** @deprecated use `computedEager` instead */
+declare const eagerComputed: typeof computedEager;
+//#endregion
+//#region computedWithControl/index.d.ts
 interface ComputedWithControlRefExtra {
-    /**
-     * Force update the computed value.
-     */
-    trigger: () => void;
-}
-interface ComputedRefWithControl<T> extends ComputedRef<T>, ComputedWithControlRefExtra {
-}
-interface WritableComputedRefWithControl<T> extends WritableComputedRef<T>, ComputedWithControlRefExtra {
+  /**
+   * Force update the computed value.
+   */
+  trigger: () => void;
 }
+interface ComputedRefWithControl<T> extends ComputedRef<T>, ComputedWithControlRefExtra {}
+interface WritableComputedRefWithControl<T> extends WritableComputedRef<T>, ComputedWithControlRefExtra {}
 type ComputedWithControlRef<T = any> = ComputedRefWithControl<T> | WritableComputedRefWithControl<T>;
 declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: ComputedGetter<T>, options?: WatchOptions): ComputedRefWithControl<T>;
 declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: WritableComputedOptions<T>, options?: WatchOptions): WritableComputedRefWithControl<T>;
-
+/** @deprecated use `computedWithControl` instead */
+declare const controlledComputed: typeof computedWithControl;
+//#endregion
+//#region utils/types.d.ts
 /**
  * Void function
  */
-type Fn = () => void;
+type Fn$1 = () => void;
 /**
  * Any function
  */
@@ -42,8 +46,8 @@ type AnyFn = (...args: any[]) => any;
  * A ref that allow to set null or undefined
  */
 type RemovableRef<T> = Omit<Ref<T>, 'value'> & {
-    get value(): T;
-    set value(value: T | null | undefined);
+  get value(): T;
+  set value(value: T | null | undefined);
 };
 /**
  * Maybe it's a computed ref, or a readonly value, or a getter function
@@ -58,9 +62,7 @@ type ReadonlyRefOrGetter<T> = ComputedRef<T> | (() => T);
  * UnwrapRef<DeepMaybeRef<T>> === T
  * ```
  */
-type DeepMaybeRef<T> = T extends Ref<infer V> ? MaybeRef<V> : T extends Array<any> | object ? {
-    [K in keyof T]: DeepMaybeRef<T[K]>;
-} : MaybeRef<T>;
+type DeepMaybeRef<T> = T extends Ref<infer V> ? MaybeRef<V> : T extends Array<any> | object ? { [K in keyof T]: DeepMaybeRef<T[K]> } : MaybeRef<T>;
 type Arrayable<T> = T[] | T;
 /**
  * Infers the element type of an array
@@ -68,70 +70,64 @@ type Arrayable<T> = T[] | T;
 type ElementOf<T> = T extends (infer E)[] ? E : never;
 type ShallowUnwrapRef<T> = T extends Ref<infer P> ? P : T;
 type Awaitable<T> = Promise<T> | T;
-type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+type ArgumentsType<T> = T extends ((...args: infer U) => any) ? U : never;
 /**
  * Compatible with versions below TypeScript 4.5 Awaited
  */
 type Awaited<T> = T extends null | undefined ? T : T extends object & {
-    then: (onfulfilled: infer F, ...args: infer _) => any;
+  then: (onfulfilled: infer F, ...args: infer _) => any;
 } ? F extends ((value: infer V, ...args: infer _) => any) ? Awaited<V> : never : T;
 type Promisify<T> = Promise<Awaited<T>>;
 type PromisifyFn<T extends AnyFn> = (...args: ArgumentsType<T>) => Promisify<ReturnType<T>>;
 interface Pausable {
-    /**
-     * A ref indicate whether a pausable instance is active
-     */
-    readonly isActive: Readonly<ShallowRef<boolean>>;
-    /**
-     * Temporary pause the effect from executing
-     */
-    pause: Fn;
-    /**
-     * Resume the effects
-     */
-    resume: Fn;
+  /**
+   * A ref indicate whether a pausable instance is active
+   */
+  readonly isActive: Readonly<ShallowRef<boolean>>;
+  /**
+   * Temporary pause the effect from executing
+   */
+  pause: Fn$1;
+  /**
+   * Resume the effects
+   */
+  resume: Fn$1;
 }
 interface Stoppable<StartFnArgs extends any[] = any[]> {
-    /**
-     * A ref indicate whether a stoppable instance is executing
-     */
-    readonly isPending: Readonly<Ref<boolean>>;
-    /**
-     * Stop the effect from executing
-     */
-    stop: Fn;
-    /**
-     * Start the effects
-     */
-    start: (...args: StartFnArgs) => void;
+  /**
+   * A ref indicate whether a stoppable instance is executing
+   */
+  readonly isPending: Readonly<Ref<boolean>>;
+  /**
+   * Stop the effect from executing
+   */
+  stop: Fn$1;
+  /**
+   * Start the effects
+   */
+  start: (...args: StartFnArgs) => void;
 }
 interface ConfigurableFlush {
-    /**
-     * Timing for monitoring changes, refer to WatchOptions for more details
-     *
-     * @default 'pre'
-     */
-    flush?: WatchOptions['flush'];
+  /**
+   * Timing for monitoring changes, refer to WatchOptions for more details
+   *
+   * @default 'pre'
+   */
+  flush?: WatchOptions['flush'];
 }
 interface ConfigurableFlushSync {
-    /**
-     * Timing for monitoring changes, refer to WatchOptions for more details.
-     * Unlike `watch()`, the default is set to `sync`
-     *
-     * @default 'sync'
-     */
-    flush?: WatchOptions['flush'];
+  /**
+   * Timing for monitoring changes, refer to WatchOptions for more details.
+   * Unlike `watch()`, the default is set to `sync`
+   *
+   * @default 'sync'
+   */
+  flush?: WatchOptions['flush'];
 }
 type MultiWatchSources = (WatchSource<unknown> | object)[];
-type MapSources<T> = {
-    [K in keyof T]: T[K] extends WatchSource<infer V> ? V : never;
-};
-type MapOldSources<T, Immediate> = {
-    [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : never;
-};
-type Mutable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
+type MapSources<T> = { [K in keyof T]: T[K] extends WatchSource<infer V> ? V : never };
+type MapOldSources<T, Immediate> = { [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : never };
+type Mutable<T> = { -readonly [P in keyof T]: T[P] };
 type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
 /**
  * will return `true` if `T` is `any`, or `false` otherwise
@@ -141,25 +137,20 @@ type IsAny<T> = IfAny<T, true, false>;
  * Universal timer handle that works in both browser and Node.js environments
  */
 type TimerHandle = ReturnType<typeof setTimeout> | undefined;
-
-/**
- * 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
- */
-
-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);
+type InstanceProxy = NonNullable<NonNullable<ReturnType<typeof getCurrentInstance>>['proxy']>;
+//#endregion
+//#region createEventHook/index.d.ts
+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);
 type EventHookOn<T = any> = (fn: Callback<T>) => {
-    off: () => void;
+  off: () => void;
 };
 type EventHookOff<T = any> = (fn: Callback<T>) => void;
 type EventHookTrigger<T = any> = (...param: Parameters<Callback<T>>) => Promise<unknown[]>;
 interface EventHook<T = any> {
-    on: EventHookOn<T>;
-    off: EventHookOff<T>;
-    trigger: EventHookTrigger<T>;
-    clear: () => void;
+  on: EventHookOn<T>;
+  off: EventHookOff<T>;
+  trigger: EventHookTrigger<T>;
+  clear: () => void;
 }
 type EventHookReturn<T> = EventHook<T>;
 /**
@@ -170,34 +161,35 @@ type EventHookReturn<T> = EventHook<T>;
  * @__NO_SIDE_EFFECTS__
  */
 declare function createEventHook<T = any>(): EventHookReturn<T>;
-
+//#endregion
+//#region utils/filters.d.ts
 type FunctionArgs<Args extends any[] = any[], Return = void> = (...args: Args) => Return;
 interface FunctionWrapperOptions<Args extends any[] = any[], This = any> {
-    fn: FunctionArgs<Args, This>;
-    args: Args;
-    thisArg: This;
+  fn: FunctionArgs<Args, This>;
+  args: Args;
+  thisArg: This;
 }
 type EventFilter<Args extends any[] = any[], This = any, Invoke extends AnyFn = AnyFn> = (invoke: Invoke, options: FunctionWrapperOptions<Args, This>) => ReturnType<Invoke> | Promisify<ReturnType<Invoke>>;
 interface ConfigurableEventFilter {
-    /**
-     * Filter for if events should to be received.
-     *
-     * @see https://vueuse.org/guide/config.html#event-filters
-     */
-    eventFilter?: EventFilter;
+  /**
+   * Filter for if events should to be received.
+   *
+   * @see https://vueuse.org/guide/config.html#event-filters
+   */
+  eventFilter?: EventFilter;
 }
 interface DebounceFilterOptions {
-    /**
-     * The maximum time allowed to be delayed before it's invoked.
-     * In milliseconds.
-     */
-    maxWait?: MaybeRefOrGetter<number>;
-    /**
-     * Whether to reject the last call if it's been cancel.
-     *
-     * @default false
-     */
-    rejectOnCancel?: boolean;
+  /**
+   * The maximum time allowed to be delayed before it's invoked.
+   * In milliseconds.
+   */
+  maxWait?: MaybeRefOrGetter<number>;
+  /**
+   * Whether to reject the last call if it's been cancel.
+   *
+   * @default false
+   */
+  rejectOnCancel?: boolean;
 }
 /**
  * @internal
@@ -209,22 +201,22 @@ declare const bypassFilter: EventFilter;
  */
 declare function debounceFilter(ms: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): EventFilter<any[], any, AnyFn>;
 interface ThrottleFilterOptions {
-    /**
-     * The maximum time allowed to be delayed before it's invoked.
-     */
-    delay: MaybeRefOrGetter<number>;
-    /**
-     * Whether to invoke on the trailing edge of the timeout.
-     */
-    trailing?: boolean;
-    /**
-     * Whether to invoke on the leading edge of the timeout.
-     */
-    leading?: boolean;
-    /**
-     * Whether to reject the last call if it's been cancel.
-     */
-    rejectOnCancel?: boolean;
+  /**
+   * The maximum time allowed to be delayed before it's invoked.
+   */
+  delay: MaybeRefOrGetter<number>;
+  /**
+   * Whether to invoke on the trailing edge of the timeout.
+   */
+  trailing?: boolean;
+  /**
+   * Whether to invoke on the leading edge of the timeout.
+   */
+  leading?: boolean;
+  /**
+   * Whether to reject the last call if it's been cancel.
+   */
+  rejectOnCancel?: boolean;
 }
 /**
  * Create an EventFilter that throttle the events
@@ -232,12 +224,12 @@ interface ThrottleFilterOptions {
 declare function throttleFilter(ms: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): EventFilter;
 declare function throttleFilter(options: ThrottleFilterOptions): EventFilter;
 interface PausableFilterOptions {
-    /**
-     * The initial state
-     *
-     * @default 'active'
-     */
-    initialState?: 'active' | 'paused';
+  /**
+   * The initial state
+   *
+   * @default 'active'
+   */
+  initialState?: 'active' | 'paused';
 }
 /**
  * EventFilter that gives extra controls to pause and resume the filter
@@ -246,18 +238,19 @@ interface PausableFilterOptions {
  * @param options Options to configure the filter
  */
 declare function pausableFilter(extendFilter?: EventFilter, options?: PausableFilterOptions): Pausable & {
-    eventFilter: EventFilter;
+  eventFilter: EventFilter;
 };
-
+//#endregion
+//#region utils/general.d.ts
 declare function promiseTimeout(ms: number, throwOnTimeout?: boolean, reason?: string): Promise<void>;
 declare function identity<T>(arg: T): T;
 interface SingletonPromiseReturn<T> {
-    (): Promise<T>;
-    /**
-     * Reset current staled promise.
-     * await it to have proper shutdown.
-     */
-    reset: () => Promise<void>;
+  (): Promise<T>;
+  /**
+   * Reset current staled promise.
+   * await it to have proper shutdown.
+   */
+  reset: () => Promise<void>;
 }
 /**
  * Create singleton promise function
@@ -298,7 +291,8 @@ declare function objectOmit<O extends object, T extends keyof O>(obj: O, keys: T
 declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
 declare function toArray<T>(value: T | readonly T[]): readonly T[];
 declare function toArray<T>(value: T | T[]): T[];
-
+//#endregion
+//#region utils/is.d.ts
 declare const isClient: boolean;
 declare const isWorker: boolean;
 declare const isDef: <T = any>(val?: T) => val is T;
@@ -312,12 +306,15 @@ declare const noop: () => void;
 declare const rand: (min: number, max: number) => number;
 declare const hasOwn: <T extends object, K extends keyof T>(val: T, key: K) => key is K;
 declare const isIOS: boolean | "";
-
+//#endregion
+//#region utils/port.d.ts
 declare const hyphenate: (str: string) => string;
 declare const camelize: (str: string) => string;
-
+//#endregion
+//#region utils/vue.d.ts
 declare function getLifeCycleTarget(target?: any): any;
-
+//#endregion
+//#region createGlobalState/index.d.ts
 type CreateGlobalStateReturn<Fn extends AnyFn = AnyFn> = Fn;
 /**
  * Keep states in the global scope to be reusable across Vue instances.
@@ -328,16 +325,17 @@ type CreateGlobalStateReturn<Fn extends AnyFn = AnyFn> = Fn;
  * @__NO_SIDE_EFFECTS__
  */
 declare function createGlobalState<Fn extends AnyFn>(stateFactory: Fn): CreateGlobalStateReturn<Fn>;
-
+//#endregion
+//#region createInjectionState/index.d.ts
 interface CreateInjectionStateOptions<Return> {
-    /**
-     * Custom injectionKey for InjectionState
-     */
-    injectionKey?: string | InjectionKey<Return>;
-    /**
-     * Default value for the InjectionState
-     */
-    defaultValue?: Return;
+  /**
+   * Custom injectionKey for InjectionState
+   */
+  injectionKey?: string | InjectionKey<Return>;
+  /**
+   * Default value for the InjectionState
+   */
+  defaultValue?: Return;
 }
 /**
  * Create global state that can be injected into components.
@@ -347,7 +345,8 @@ interface CreateInjectionStateOptions<Return> {
  * @__NO_SIDE_EFFECTS__
  */
 declare function createInjectionState<Arguments extends Array<any>, Return>(composable: (...args: Arguments) => Return, options?: CreateInjectionStateOptions<Return>): readonly [useProvidingState: (...args: Arguments) => Return, useInjectedState: () => Return | undefined];
-
+//#endregion
+//#region createRef/index.d.ts
 type CreateRefReturn<T = any, D extends boolean = false> = ShallowOrDeepRef<T, D>;
 type ShallowOrDeepRef<T = any, D extends boolean = false> = D extends true ? Ref<T> : ShallowRef<T>;
 /**
@@ -366,7 +365,8 @@ type ShallowOrDeepRef<T = any, D extends boolean = false> = D extends true ? Ref
  * @__NO_SIDE_EFFECTS__
  */
 declare function createRef<T = any, D extends boolean = false>(value: T, deep?: D): CreateRefReturn<T, D>;
-
+//#endregion
+//#region createSharedComposable/index.d.ts
 type SharedComposableReturn<T extends AnyFn = AnyFn> = T;
 /**
  * Make a composable function usable with multiple Vue instances.
@@ -376,21 +376,22 @@ type SharedComposableReturn<T extends AnyFn = AnyFn> = T;
  * @__NO_SIDE_EFFECTS__
  */
 declare function createSharedComposable<Fn extends AnyFn>(composable: Fn): SharedComposableReturn<Fn>;
-
+//#endregion
+//#region extendRef/index.d.ts
 type ExtendRefReturn<T = any> = Ref<T>;
 interface ExtendRefOptions<Unwrap extends boolean = boolean> {
-    /**
-     * Is the extends properties enumerable
-     *
-     * @default false
-     */
-    enumerable?: boolean;
-    /**
-     * Unwrap for Ref properties
-     *
-     * @default true
-     */
-    unwrap?: Unwrap;
+  /**
+   * Is the extends properties enumerable
+   *
+   * @default false
+   */
+  enumerable?: boolean;
+  /**
+   * Unwrap for Ref properties
+   *
+   * @default true
+   */
+  unwrap?: Unwrap;
 }
 /**
  * Overload 1: Unwrap set to false
@@ -400,13 +401,15 @@ declare function extendRef<R extends Ref<any>, Extend extends object, Options ex
  * Overload 2: Unwrap unset or set to true
  */
 declare function extendRef<R extends Ref<any>, Extend extends object, Options extends ExtendRefOptions>(ref: R, extend: Extend, options?: Options): Extend & R;
-
+//#endregion
+//#region get/index.d.ts
 /**
  * Shorthand for accessing `ref.value`
  */
 declare function get<T>(ref: MaybeRef<T>): T;
 declare function get<T, K extends keyof T>(ref: MaybeRef<T>, key: K): T[K];
-
+//#endregion
+//#region injectLocal/index.d.ts
 /**
  * On the basis of `inject`, it is allowed to directly call inject to obtain the value after call provide in the same component.
  *
@@ -419,14 +422,20 @@ declare function get<T, K extends keyof T>(ref: MaybeRef<T>, key: K): T[K];
  * @__NO_SIDE_EFFECTS__
  */
 declare const injectLocal: typeof inject;
-
+//#endregion
+//#region isDefined/index.d.ts
 type IsDefinedReturn = boolean;
 declare function isDefined<T>(v: ComputedRef<T>): v is ComputedRef<Exclude<T, null | undefined>>;
 declare function isDefined<T>(v: Ref<T>): v is Ref<Exclude<T, null | undefined>>;
 declare function isDefined<T>(v: T): v is Exclude<T, null | undefined>;
-
+//#endregion
+//#region makeDestructurable/index.d.ts
 declare function makeDestructurable<T extends Record<string, unknown>, A extends readonly any[]>(obj: T, arr: A): T & A;
-
+//#endregion
+//#region provideLocal/map.d.ts
+type LocalProvidedKey<T> = InjectionKey<T> | string | number;
+//#endregion
+//#region provideLocal/index.d.ts
 type ProvideLocalReturn = void;
 /**
  * On the basis of `provide`, it is allowed to directly call inject to obtain the value after call provide in the same component.
@@ -437,19 +446,18 @@ type ProvideLocalReturn = void;
  * const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
  * ```
  */
-declare function provideLocal<T, K = InjectionKey<T> | string | number>(key: K, value: K extends InjectionKey<infer V> ? V : T): ProvideLocalReturn;
-
-type Reactified<T, Computed extends boolean> = T extends (...args: infer A) => infer R ? (...args: {
-    [K in keyof A]: Computed extends true ? MaybeRefOrGetter<A[K]> : MaybeRef<A[K]>;
-}) => ComputedRef<R> : never;
+declare function provideLocal<T, K = LocalProvidedKey<T>>(key: K, value: K extends InjectionKey<infer V> ? V : T): ProvideLocalReturn;
+//#endregion
+//#region reactify/index.d.ts
+type Reactified<T, Computed extends boolean> = T extends ((...args: infer A) => infer R) ? (...args: { [K in keyof A]: Computed extends true ? MaybeRefOrGetter<A[K]> : MaybeRef<A[K]> }) => ComputedRef<R> : never;
 type ReactifyReturn<T extends AnyFn = AnyFn, K extends boolean = true> = Reactified<T, K>;
 interface ReactifyOptions<T extends boolean> {
-    /**
-     * Accept passing a function as a reactive getter
-     *
-     * @default true
-     */
-    computedGetter?: T;
+  /**
+   * Accept passing a function as a reactive getter
+   *
+   * @default true
+   */
+  computedGetter?: T;
 }
 /**
  * Converts plain function into a reactive function.
@@ -462,18 +470,19 @@ interface ReactifyOptions<T extends boolean> {
  * @__NO_SIDE_EFFECTS__
  */
 declare function reactify<T extends AnyFn, K extends boolean = true>(fn: T, options?: ReactifyOptions<K>): ReactifyReturn<T, K>;
-
-type ReactifyNested<T, Keys extends keyof T = keyof T, S extends boolean = true> = {
-    [K in Keys]: T[K] extends AnyFn ? Reactified<T[K], S> : T[K];
-};
+/** @deprecated use `reactify` instead */
+declare const createReactiveFn: typeof reactify;
+//#endregion
+//#region reactifyObject/index.d.ts
+type ReactifyNested<T, Keys extends keyof T = keyof T, S extends boolean = true> = { [K in Keys]: T[K] extends AnyFn ? Reactified<T[K], S> : T[K] };
 type ReactifyObjectReturn<T, Keys extends keyof T, S extends boolean = true> = ReactifyNested<T, Keys, S>;
 interface ReactifyObjectOptions<T extends boolean> extends ReactifyOptions<T> {
-    /**
-     * Includes names from Object.getOwnPropertyNames
-     *
-     * @default true
-     */
-    includeOwnProperties?: boolean;
+  /**
+   * Includes names from Object.getOwnPropertyNames
+   *
+   * @default true
+   */
+  includeOwnProperties?: boolean;
 }
 /**
  * Apply `reactify` to an object
@@ -482,25 +491,27 @@ interface ReactifyObjectOptions<T extends boolean> extends ReactifyOptions<T> {
  */
 declare function reactifyObject<T extends object, Keys extends keyof T>(obj: T, keys?: (keyof T)[]): ReactifyObjectReturn<T, Keys, true>;
 declare function reactifyObject<T extends object, S extends boolean = true>(obj: T, options?: ReactifyObjectOptions<S>): ReactifyObjectReturn<T, keyof T, S>;
-
+//#endregion
+//#region reactiveComputed/index.d.ts
 type ReactiveComputedReturn<T extends object> = UnwrapNestedRefs<T>;
 /**
  * Computed reactive object.
  */
 declare function reactiveComputed<T extends object>(fn: ComputedGetter<T>): ReactiveComputedReturn<T>;
-
+//#endregion
+//#region reactiveOmit/index.d.ts
 type ReactiveOmitReturn<T extends object, K extends keyof T | undefined = undefined> = [K] extends [undefined] ? Partial<T> : Omit<T, Extract<K, keyof T>>;
 type ReactiveOmitPredicate<T> = (value: T[keyof T], key: keyof T) => boolean;
 declare function reactiveOmit<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): ReactiveOmitReturn<T, K>;
 declare function reactiveOmit<T extends object>(obj: T, predicate: ReactiveOmitPredicate<T>): ReactiveOmitReturn<T>;
-
-type ReactivePickReturn<T extends object, K extends keyof T> = {
-    [S in K]: UnwrapRef<T[S]>;
-};
+//#endregion
+//#region reactivePick/index.d.ts
+type ReactivePickReturn<T extends object, K extends keyof T> = { [S in K]: UnwrapRef<T[S]> };
 type ReactivePickPredicate<T> = (value: T[keyof T], key: keyof T) => boolean;
 declare function reactivePick<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): ReactivePickReturn<T, K>;
 declare function reactivePick<T extends object>(obj: T, predicate: ReactivePickPredicate<T>): ReactivePickReturn<T, keyof T>;
-
+//#endregion
+//#region refAutoReset/index.d.ts
 type RefAutoResetReturn<T = any> = Ref<T>;
 /**
  * Create a ref which will be reset to the default value after some time.
@@ -510,7 +521,10 @@ type RefAutoResetReturn<T = any> = Ref<T>;
  * @param afterMs      A zero-or-greater delay in milliseconds.
  */
 declare function refAutoReset<T>(defaultValue: MaybeRefOrGetter<T>, afterMs?: MaybeRefOrGetter<number>): RefAutoResetReturn<T>;
-
+/** @deprecated use `refAutoReset` instead */
+declare const autoResetRef: typeof refAutoReset;
+//#endregion
+//#region refDebounced/index.d.ts
 type RefDebouncedReturn<T = any> = Readonly<Ref<T>>;
 /**
  * Debounce updates of a ref.
@@ -518,14 +532,38 @@ type RefDebouncedReturn<T = any> = Readonly<Ref<T>>;
  * @return A new debounced ref.
  */
 declare function refDebounced<T>(value: Ref<T>, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): RefDebouncedReturn<T>;
-
+/** @deprecated use `refDebounced` instead */
+declare const debouncedRef: typeof refDebounced;
+/** @deprecated use `refDebounced` instead */
+declare const useDebounce: typeof refDebounced;
+//#endregion
+//#region refDefault/index.d.ts
 /**
  * Apply default value to a ref.
  *
  * @__NO_SIDE_EFFECTS__
  */
 declare function refDefault<T>(source: Ref<T | undefined | null>, defaultValue: T): Ref<T>;
-
+//#endregion
+//#region refManualReset/index.d.ts
+/**
+ * Define the shape of a ref that supports manual reset functionality.
+ *
+ * This interface extends the standard `Ref` type from Vue and adds a `reset` method.
+ * The `reset` method allows the ref to be manually reset to its default value.
+ */
+interface ManualResetRefReturn<T> extends Ref<T> {
+  reset: Fn$1;
+}
+/**
+ * Create a ref with manual reset functionality.
+ *
+ * @see https://vueuse.org/refManualReset
+ * @param defaultValue The value which will be set.
+ */
+declare function refManualReset<T>(defaultValue: MaybeRefOrGetter<T>): ManualResetRefReturn<T>;
+//#endregion
+//#region refThrottled/index.d.ts
 type RefThrottledReturn<T = any> = Ref<T>;
 /**
  * Throttle execution of a function. Especially useful for rate limiting
@@ -537,42 +575,47 @@ type RefThrottledReturn<T = any> = Ref<T>;
  * @param leading if true, update the value on the leading edge of the ms timeout
  */
 declare function refThrottled<T = any>(value: Ref<T>, delay?: number, trailing?: boolean, leading?: boolean): RefThrottledReturn<T>;
-
+/** @deprecated use `refThrottled` instead */
+declare const throttledRef: typeof refThrottled;
+/** @deprecated use `refThrottled` instead */
+declare const useThrottle: typeof refThrottled;
+//#endregion
+//#region refWithControl/index.d.ts
 interface ControlledRefOptions<T> {
-    /**
-     * Callback function before the ref changing.
-     *
-     * Returning `false` to dismiss the change.
-     */
-    onBeforeChange?: (value: T, oldValue: T) => void | boolean;
-    /**
-     * Callback function after the ref changed
-     *
-     * This happens synchronously, with less overhead compare to `watch`
-     */
-    onChanged?: (value: T, oldValue: T) => void;
+  /**
+   * Callback function before the ref changing.
+   *
+   * Returning `false` to dismiss the change.
+   */
+  onBeforeChange?: (value: T, oldValue: T) => void | boolean;
+  /**
+   * Callback function after the ref changed
+   *
+   * This happens synchronously, with less overhead compare to `watch`
+   */
+  onChanged?: (value: T, oldValue: T) => void;
 }
 /**
  * Fine-grained controls over ref and its reactivity.
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function refWithControl<T>(initial: T, options?: ControlledRefOptions<T>): vue.ShallowUnwrapRef<{
-    get: (tracking?: boolean) => T;
-    set: (value: T, triggering?: boolean) => void;
-    untrackedGet: () => T;
-    silentSet: (v: T) => void;
-    peek: () => T;
-    lay: (v: T) => void;
-}> & vue.Ref<T, T>;
-/**
- * Alias for `refWithControl`
- */
+declare function refWithControl<T>(initial: T, options?: ControlledRefOptions<T>): vue0.ShallowUnwrapRef<{
+  get: (tracking?: boolean) => T;
+  set: (value: T, triggering?: boolean) => void;
+  untrackedGet: () => T;
+  silentSet: (v: T) => void;
+  peek: () => T;
+  lay: (v: T) => void;
+}> & vue0.Ref<T, T>;
+/** @deprecated use `refWithControl` instead */
 declare const controlledRef: typeof refWithControl;
-
+//#endregion
+//#region set/index.d.ts
 declare function set<T>(ref: Ref<T>, value: T): void;
 declare function set<O extends object, K extends keyof O>(target: O, key: K, value: O[K]): void;
-
+//#endregion
+//#region syncRef/index.d.ts
 type Direction = 'ltr' | 'rtl' | 'both';
 type SpecificFieldPartial<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
 /**
@@ -591,47 +634,47 @@ type IncludeButNotEqual<A, B> = Equal<A, B> extends true ? false : A extends B ?
  * A ∩ B = ∅
  */
 type NotIntersect<A, B> = Equal<A, B> extends true ? false : A & B extends never ? true : false;
-interface EqualType<D extends Direction, L, R, O extends keyof Transform<L, R> = D extends 'both' ? 'ltr' | 'rtl' : D> {
-    transform?: SpecificFieldPartial<Pick<Transform<L, R>, O>, O>;
+interface EqualType<D extends Direction, L, R, O extends keyof Transform<L, R> = (D extends 'both' ? 'ltr' | 'rtl' : D)> {
+  transform?: SpecificFieldPartial<Pick<Transform<L, R>, O>, O>;
 }
 type StrictIncludeMap<IncludeType extends 'LR' | 'RL', D extends Exclude<Direction, 'both'>, L, R> = (Equal<[IncludeType, D], ['LR', 'ltr']> & Equal<[IncludeType, D], ['RL', 'rtl']>) extends true ? {
-    transform?: SpecificFieldPartial<Pick<Transform<L, R>, D>, D>;
+  transform?: SpecificFieldPartial<Pick<Transform<L, R>, D>, D>;
 } : {
-    transform: Pick<Transform<L, R>, D>;
+  transform: Pick<Transform<L, R>, D>;
 };
 type StrictIncludeType<IncludeType extends 'LR' | 'RL', D extends Direction, L, R> = D extends 'both' ? {
-    transform: SpecificFieldPartial<Transform<L, R>, IncludeType extends 'LR' ? 'ltr' : 'rtl'>;
+  transform: SpecificFieldPartial<Transform<L, R>, IncludeType extends 'LR' ? 'ltr' : 'rtl'>;
 } : D extends Exclude<Direction, 'both'> ? StrictIncludeMap<IncludeType, D, L, R> : never;
 type IntersectButNotEqualType<D extends Direction, L, R> = D extends 'both' ? {
-    transform: Transform<L, R>;
+  transform: Transform<L, R>;
 } : D extends Exclude<Direction, 'both'> ? {
-    transform: Pick<Transform<L, R>, D>;
+  transform: Pick<Transform<L, R>, D>;
 } : never;
 type NotIntersectType<D extends Direction, L, R> = IntersectButNotEqualType<D, L, R>;
 interface Transform<L, R> {
-    ltr: (left: L) => R;
-    rtl: (right: R) => L;
+  ltr: (left: L) => R;
+  rtl: (right: R) => L;
 }
 type TransformType<D extends Direction, L, R> = Equal<L, R> extends true ? EqualType<D, L, R> : IncludeButNotEqual<L, R> extends true ? StrictIncludeType<'LR', D, L, R> : IncludeButNotEqual<R, L> extends true ? StrictIncludeType<'RL', D, L, R> : IntersectButNotEqual<L, R> extends true ? IntersectButNotEqualType<D, L, R> : NotIntersect<L, R> extends true ? NotIntersectType<D, L, R> : never;
 type SyncRefOptions<L, R, D extends Direction> = ConfigurableFlushSync & {
-    /**
-     * Watch deeply
-     *
-     * @default false
-     */
-    deep?: boolean;
-    /**
-     * Sync values immediately
-     *
-     * @default true
-     */
-    immediate?: boolean;
-    /**
-     * Direction of syncing. Value will be redefined if you define syncConvertors
-     *
-     * @default 'both'
-     */
-    direction?: D;
+  /**
+   * Watch deeply
+   *
+   * @default false
+   */
+  deep?: boolean;
+  /**
+   * Sync values immediately
+   *
+   * @default true
+   */
+  immediate?: boolean;
+  /**
+   * Direction of syncing. Value will be redefined if you define syncConvertors
+   *
+   * @default 'both'
+   */
+  direction?: D;
 } & TransformType<D, L, R>;
 /**
  * Two-way refs synchronization.
@@ -643,20 +686,21 @@ type SyncRefOptions<L, R, D extends Direction> = ConfigurableFlushSync & {
  * 4. L ∩ R = ∅
  */
 declare function syncRef<L, R, D extends Direction = 'both'>(left: Ref<L>, right: Ref<R>, ...[options]: Equal<L, R> extends true ? [options?: SyncRefOptions<L, R, D>] : [options: SyncRefOptions<L, R, D>]): () => void;
-
+//#endregion
+//#region syncRefs/index.d.ts
 interface SyncRefsOptions extends ConfigurableFlushSync {
-    /**
-     * Watch deeply
-     *
-     * @default false
-     */
-    deep?: boolean;
-    /**
-     * Sync values immediately
-     *
-     * @default true
-     */
-    immediate?: boolean;
+  /**
+   * Watch deeply
+   *
+   * @default false
+   */
+  deep?: boolean;
+  /**
+   * Sync values immediately
+   *
+   * @default true
+   */
+  immediate?: boolean;
 }
 /**
  * Keep target ref(s) in sync with the source ref
@@ -664,8 +708,9 @@ interface SyncRefsOptions extends ConfigurableFlushSync {
  * @param source source ref
  * @param targets
  */
-declare function syncRefs<T>(source: WatchSource<T>, targets: Ref<T> | Ref<T>[], options?: SyncRefsOptions): vue.WatchHandle;
-
+declare function syncRefs<T>(source: WatchSource<T>, targets: Ref<T> | Ref<T>[], options?: SyncRefsOptions): vue0.WatchHandle;
+//#endregion
+//#region toReactive/index.d.ts
 /**
  * Converts ref to reactive.
  *
@@ -673,7 +718,8 @@ declare function syncRefs<T>(source: WatchSource<T>, targets: Ref<T> | Ref<T>[],
  * @param objectRef A ref of object
  */
 declare function toReactive<T extends object>(objectRef: MaybeRef<T>): UnwrapNestedRefs<T>;
-
+//#endregion
+//#region toRef/index.d.ts
 /**
  * Normalize value/ref/getter to `ref` or `computed`.
  */
@@ -683,18 +729,15 @@ declare function toRef<T>(r: MaybeRefOrGetter<T>): Ref<T>;
 declare function toRef<T>(r: T): Ref<T>;
 declare function toRef<T extends object, K extends keyof T>(object: T, key: K): ToRef<T[K]>;
 declare function toRef<T extends object, K extends keyof T>(object: T, key: K, defaultValue: T[K]): ToRef<Exclude<T[K], undefined>>;
-/**
- * @deprecated use `toRef` instead
- */
-declare const resolveRef: typeof toRef;
-
+//#endregion
+//#region toRefs/index.d.ts
 interface ToRefsOptions {
-    /**
-     * Replace the original ref with a copy on property update.
-     *
-     * @default true
-     */
-    replaceRef?: MaybeRefOrGetter<boolean>;
+  /**
+   * Replace the original ref with a copy on property update.
+   *
+   * @default true
+   */
+  replaceRef?: MaybeRefOrGetter<boolean>;
 }
 /**
  * Extended `toRefs` that also accepts refs of an object.
@@ -704,18 +747,8 @@ interface ToRefsOptions {
  * @param options Options
  */
 declare function toRefs<T extends object>(objectRef: MaybeRef<T>, options?: ToRefsOptions): ToRefs<T>;
-
-/**
- * Get the value of value/ref/getter.
- *
- * @deprecated use `toValue` from `vue` instead
- */
-declare const toValue: typeof toValue$1;
-/**
- * @deprecated use `toValue` instead
- */
-declare const resolveUnref: typeof toValue$1;
-
+//#endregion
+//#region tryOnBeforeMount/index.d.ts
 /**
  * Call onBeforeMount() if it's inside a component lifecycle, if not, just call the function
  *
@@ -723,16 +756,18 @@ declare const resolveUnref: typeof toValue$1;
  * @param sync if set to false, it will run in the nextTick() of Vue
  * @param target
  */
-declare function tryOnBeforeMount(fn: Fn, sync?: boolean, target?: any): void;
-
+declare function tryOnBeforeMount(fn: Fn$1, sync?: boolean, target?: any): void;
+//#endregion
+//#region tryOnBeforeUnmount/index.d.ts
 /**
  * Call onBeforeUnmount() if it's inside a component lifecycle, if not, do nothing
  *
  * @param fn
  * @param target
  */
-declare function tryOnBeforeUnmount(fn: Fn, target?: any): void;
-
+declare function tryOnBeforeUnmount(fn: Fn$1, target?: any): void;
+//#endregion
+//#region tryOnMounted/index.d.ts
 /**
  * Call onMounted() if it's inside a component lifecycle, if not, just call the function
  *
@@ -740,67 +775,70 @@ declare function tryOnBeforeUnmount(fn: Fn, target?: any): void;
  * @param sync if set to false, it will run in the nextTick() of Vue
  * @param target
  */
-declare function tryOnMounted(fn: Fn, sync?: boolean, target?: any): void;
-
+declare function tryOnMounted(fn: Fn$1, sync?: boolean, target?: any): void;
+//#endregion
+//#region tryOnScopeDispose/index.d.ts
 /**
  * Call onScopeDispose() if it's inside an effect scope lifecycle, if not, do nothing
  *
  * @param fn
  */
-declare function tryOnScopeDispose(fn: Fn): boolean;
-
+declare function tryOnScopeDispose(fn: Fn$1): boolean;
+//#endregion
+//#region tryOnUnmounted/index.d.ts
 /**
  * Call onUnmounted() if it's inside a component lifecycle, if not, do nothing
  *
  * @param fn
  * @param target
  */
-declare function tryOnUnmounted(fn: Fn, target?: any): void;
-
+declare function tryOnUnmounted(fn: Fn$1, target?: any): void;
+//#endregion
+//#region until/index.d.ts
 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;
-    /**
-     * `flush` option for internal watch
-     *
-     * @default 'sync'
-     */
-    flush?: WatchOptions['flush'];
-    /**
-     * `deep` option for internal watch
-     *
-     * @default 'false'
-     */
-    deep?: WatchOptions['deep'];
+  /**
+   * 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;
+  /**
+   * `flush` option for internal watch
+   *
+   * @default 'sync'
+   */
+  flush?: WatchOptions['flush'];
+  /**
+   * `deep` option for internal watch
+   *
+   * @default 'false'
+   */
+  deep?: WatchOptions['deep'];
 }
 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>;
+  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 | '';
+type Falsy$1 = false | void | null | undefined | 0 | 0n | '';
 interface UntilValueInstance<T, Not extends boolean = false> extends UntilBaseInstance<T, Not> {
-    readonly not: UntilValueInstance<T, Not extends true ? false : true>;
-    toBe: <P = T>(value: MaybeRefOrGetter<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>;
+  readonly not: UntilValueInstance<T, Not extends true ? false : true>;
+  toBe: <P = T>(value: MaybeRefOrGetter<P>, options?: UntilToMatchOptions) => Not extends true ? Promise<T> : Promise<P>;
+  toBeTruthy: (options?: UntilToMatchOptions) => Not extends true ? Promise<T & Falsy$1> : Promise<Exclude<T, Falsy$1>>;
+  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>;
 }
 interface UntilArrayInstance<T> extends UntilBaseInstance<T> {
-    readonly not: UntilArrayInstance<T>;
-    toContains: (value: MaybeRefOrGetter<ElementOf<ShallowUnwrapRef<T>>>, options?: UntilToMatchOptions) => Promise<T>;
+  readonly not: UntilArrayInstance<T>;
+  toContains: (value: MaybeRefOrGetter<ElementOf<ShallowUnwrapRef<T>>>, options?: UntilToMatchOptions) => Promise<T>;
 }
 /**
  * Promised one-time watch for changes
@@ -817,20 +855,22 @@ interface UntilArrayInstance<T> extends UntilBaseInstance<T> {
  */
 declare function until<T extends unknown[]>(r: WatchSource<T> | MaybeRefOrGetter<T>): UntilArrayInstance<T>;
 declare function until<T>(r: WatchSource<T> | MaybeRefOrGetter<T>): UntilValueInstance<T>;
-
+//#endregion
+//#region useArrayDifference/index.d.ts
 interface UseArrayDifferenceOptions {
-    /**
-     * Returns asymmetric difference
-     *
-     * @see https://en.wikipedia.org/wiki/Symmetric_difference
-     * @default false
-     */
-    symmetric?: boolean;
+  /**
+   * Returns asymmetric difference
+   *
+   * @see https://en.wikipedia.org/wiki/Symmetric_difference
+   * @default false
+   */
+  symmetric?: boolean;
 }
 type UseArrayDifferenceReturn<T = any> = ComputedRef<T[]>;
 declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, key?: keyof T, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
 declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, compareFn?: (value: T, othVal: T) => boolean, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
-
+//#endregion
+//#region useArrayEvery/index.d.ts
 type UseArrayEveryReturn = ComputedRef<boolean>;
 /**
  * Reactive `Array.every`
@@ -844,7 +884,8 @@ type UseArrayEveryReturn = ComputedRef<boolean>;
  * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayEvery<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayEveryReturn;
-
+//#endregion
+//#region useArrayFilter/index.d.ts
 type UseArrayFilterReturn<T = any> = ComputedRef<T[]>;
 /**
  * Reactive `Array.filter`
@@ -859,7 +900,8 @@ type UseArrayFilterReturn<T = any> = ComputedRef<T[]>;
  */
 declare function useArrayFilter<T, S extends T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => element is S): UseArrayFilterReturn<S>;
 declare function useArrayFilter<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => unknown): UseArrayFilterReturn<T>;
-
+//#endregion
+//#region useArrayFind/index.d.ts
 type UseArrayFindReturn<T = any> = ComputedRef<T | undefined>;
 /**
  * Reactive `Array.find`
@@ -873,7 +915,8 @@ type UseArrayFindReturn<T = any> = ComputedRef<T | undefined>;
  * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayFind<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindReturn<T>;
-
+//#endregion
+//#region useArrayFindIndex/index.d.ts
 type UseArrayFindIndexReturn = ComputedRef<number>;
 /**
  * Reactive `Array.findIndex`
@@ -887,7 +930,8 @@ type UseArrayFindIndexReturn = ComputedRef<number>;
  * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayFindIndex<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayFindIndexReturn;
-
+//#endregion
+//#region useArrayFindLast/index.d.ts
 type UseArrayFindLastReturn<T = any> = ComputedRef<T | undefined>;
 /**
  * Reactive `Array.findLast`
@@ -901,11 +945,12 @@ type UseArrayFindLastReturn<T = any> = ComputedRef<T | undefined>;
  * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayFindLast<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindLastReturn<T>;
-
+//#endregion
+//#region useArrayIncludes/index.d.ts
 type UseArrayIncludesComparatorFn<T, V> = ((element: T, value: V, index: number, array: MaybeRefOrGetter<T>[]) => boolean);
 interface UseArrayIncludesOptions<T, V> {
-    fromIndex?: number;
-    comparator?: UseArrayIncludesComparatorFn<T, V> | keyof T;
+  fromIndex?: number;
+  comparator?: UseArrayIncludesComparatorFn<T, V> | keyof T;
 }
 type UseArrayIncludesReturn = ComputedRef<boolean>;
 /**
@@ -920,7 +965,8 @@ type UseArrayIncludesReturn = ComputedRef<boolean>;
 declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: UseArrayIncludesComparatorFn<T, V>): UseArrayIncludesReturn;
 declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: keyof T): UseArrayIncludesReturn;
 declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, options?: UseArrayIncludesOptions<T, V>): UseArrayIncludesReturn;
-
+//#endregion
+//#region useArrayJoin/index.d.ts
 type UseArrayJoinReturn = ComputedRef<string>;
 /**
  * Reactive `Array.join`
@@ -934,7 +980,8 @@ type UseArrayJoinReturn = ComputedRef<string>;
  * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayJoin(list: MaybeRefOrGetter<MaybeRefOrGetter<any>[]>, separator?: MaybeRefOrGetter<string>): UseArrayJoinReturn;
-
+//#endregion
+//#region useArrayMap/index.d.ts
 type UseArrayMapReturn<T = any> = ComputedRef<T[]>;
 /**
  * Reactive `Array.map`
@@ -948,7 +995,8 @@ type UseArrayMapReturn<T = any> = ComputedRef<T[]>;
  * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayMap<T, U = T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => U): UseArrayMapReturn<U>;
-
+//#endregion
+//#region useArrayReduce/index.d.ts
 type UseArrayReducer<PV, CV, R> = (previousValue: PV, currentValue: CV, currentIndex: number) => R;
 /**
  * Reactive `Array.reduce`
@@ -975,7 +1023,8 @@ declare function useArrayReduce<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>
  * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayReduce<T, U>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<U, T, U>, initialValue: MaybeRefOrGetter<U>): ComputedRef<U>;
-
+//#endregion
+//#region useArraySome/index.d.ts
 type UseArraySomeReturn = ComputedRef<boolean>;
 /**
  * Reactive `Array.some`
@@ -989,7 +1038,8 @@ type UseArraySomeReturn = ComputedRef<boolean>;
  * @__NO_SIDE_EFFECTS__
  */
 declare function useArraySome<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArraySomeReturn;
-
+//#endregion
+//#region useArrayUnique/index.d.ts
 type UseArrayUniqueReturn<T = any> = ComputedRef<T[]>;
 /**
  * reactive unique array
@@ -1001,42 +1051,43 @@ type UseArrayUniqueReturn<T = any> = ComputedRef<T[]>;
  * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayUnique<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, compareFn?: (a: T, b: T, array: T[]) => boolean): UseArrayUniqueReturn<T>;
-
+//#endregion
+//#region useCounter/index.d.ts
 interface UseCounterOptions {
-    min?: number;
-    max?: number;
+  min?: number;
+  max?: number;
 }
 interface UseCounterReturn {
-    /**
-     * The current value of the counter.
-     */
-    readonly count: Readonly<Ref<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.
-     */
-    get: () => number;
-    /**
-     * Set the counter to a new value.
-     *
-     * @param val The new value of the counter.
-     */
-    set: (val: number) => void;
-    /**
-     * Reset the counter to an initial value.
-     */
-    reset: (val?: number) => number;
+  /**
+   * The current value of the counter.
+   */
+  readonly count: Readonly<Ref<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.
+   */
+  get: () => number;
+  /**
+   * Set the counter to a new value.
+   *
+   * @param val The new value of the counter.
+   */
+  set: (val: number) => void;
+  /**
+   * Reset the counter to an initial value.
+   */
+  reset: (val?: number) => number;
 }
 /**
  * Basic counter with utility functions.
@@ -1046,27 +1097,28 @@ interface UseCounterReturn {
  * @param options
  */
 declare function useCounter(initialValue?: MaybeRef<number>, options?: UseCounterOptions): {
-    count: Readonly<Ref<number, number> | vue.ShallowRef<number, number> | vue.WritableComputedRef<number, number>>;
-    inc: (delta?: number) => number;
-    dec: (delta?: number) => number;
-    get: () => number;
-    set: (val: number) => number;
-    reset: (val?: number) => number;
+  count: Readonly<Ref<number, number> | vue0.ShallowRef<number, number> | vue0.WritableComputedRef<number, number>>;
+  inc: (delta?: number) => number;
+  dec: (delta?: number) => number;
+  get: () => number;
+  set: (val: number) => number;
+  reset: (val?: number) => number;
 };
-
+//#endregion
+//#region useDateFormat/index.d.ts
 type DateLike = Date | number | string | undefined;
 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).
-     */
-    locales?: MaybeRefOrGetter<Intl.LocalesArgument>;
-    /**
-     * A custom function to re-modify the way to display meridiem
-     *
-     */
-    customMeridiem?: (hours: number, minutes: number, isLowercase?: boolean, hasPeriod?: boolean) => string;
+  /**
+   * 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).
+   */
+  locales?: MaybeRefOrGetter<Intl.LocalesArgument>;
+  /**
+   * A custom function to re-modify the way to display meridiem
+   *
+   */
+  customMeridiem?: (hours: number, minutes: number, isLowercase?: boolean, hasPeriod?: boolean) => string;
 }
 declare function formatDate(date: Date, formatStr: string, options?: UseDateFormatOptions): string;
 declare function normalizeDate(date: DateLike): Date;
@@ -1082,7 +1134,8 @@ type UseDateFormatReturn = ComputedRef<string>;
  * @__NO_SIDE_EFFECTS__
  */
 declare function useDateFormat(date: MaybeRefOrGetter<DateLike>, formatStr?: MaybeRefOrGetter<string>, options?: UseDateFormatOptions): UseDateFormatReturn;
-
+//#endregion
+//#region useDebounceFn/index.d.ts
 type UseDebounceFnReturn<T extends FunctionArgs> = PromisifyFn<T>;
 /**
  * Debounce execution of a function.
@@ -1097,28 +1150,29 @@ type UseDebounceFnReturn<T extends FunctionArgs> = PromisifyFn<T>;
  * @__NO_SIDE_EFFECTS__
  */
 declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): UseDebounceFnReturn<T>;
-
+//#endregion
+//#region useInterval/index.d.ts
 interface UseIntervalOptions<Controls extends boolean> {
-    /**
-     * Expose more controls
-     *
-     * @default false
-     */
-    controls?: Controls;
-    /**
-     * Execute the update immediately on calling
-     *
-     * @default true
-     */
-    immediate?: boolean;
-    /**
-     * Callback on every interval
-     */
-    callback?: (count: number) => void;
+  /**
+   * Expose more controls
+   *
+   * @default false
+   */
+  controls?: Controls;
+  /**
+   * Execute the update immediately on calling
+   *
+   * @default true
+   */
+  immediate?: boolean;
+  /**
+   * Callback on every interval
+   */
+  callback?: (count: number) => void;
 }
 interface UseIntervalControls {
-    counter: ShallowRef<number>;
-    reset: () => void;
+  counter: ShallowRef<number>;
+  reset: () => void;
 }
 type UseIntervalReturn = Readonly<ShallowRef<number>> | Readonly<UseIntervalControls & Pausable>;
 /**
@@ -1130,20 +1184,21 @@ type UseIntervalReturn = Readonly<ShallowRef<number>> | Readonly<UseIntervalCont
  */
 declare function useInterval(interval?: MaybeRefOrGetter<number>, options?: UseIntervalOptions<false>): Readonly<ShallowRef<number>>;
 declare function useInterval(interval: MaybeRefOrGetter<number>, options: UseIntervalOptions<true>): Readonly<UseIntervalControls & Pausable>;
-
+//#endregion
+//#region useIntervalFn/index.d.ts
 interface UseIntervalFnOptions {
-    /**
-     * Start the timer immediately
-     *
-     * @default true
-     */
-    immediate?: boolean;
-    /**
-     * Execute the callback immediately after calling `resume`
-     *
-     * @default false
-     */
-    immediateCallback?: boolean;
+  /**
+   * Start the timer immediately
+   *
+   * @default true
+   */
+  immediate?: boolean;
+  /**
+   * Execute the callback immediately after calling `resume`
+   *
+   * @default false
+   */
+  immediateCallback?: boolean;
 }
 type UseIntervalFnReturn = Pausable;
 /**
@@ -1154,10 +1209,11 @@ type UseIntervalFnReturn = Pausable;
  * @param interval
  * @param options
  */
-declare function useIntervalFn(cb: Fn, interval?: MaybeRefOrGetter<number>, options?: UseIntervalFnOptions): UseIntervalFnReturn;
-
+declare function useIntervalFn(cb: Fn$1, interval?: MaybeRefOrGetter<number>, options?: UseIntervalFnOptions): UseIntervalFnReturn;
+//#endregion
+//#region useLastChanged/index.d.ts
 interface UseLastChangedOptions<Immediate extends boolean, InitialValue extends number | null | undefined = undefined> extends WatchOptions<Immediate> {
-    initialValue?: InitialValue;
+  initialValue?: InitialValue;
 }
 type UseLastChangedReturn = Readonly<ShallowRef<number | null>> | Readonly<ShallowRef<number>>;
 /**
@@ -1167,7 +1223,8 @@ type UseLastChangedReturn = Readonly<ShallowRef<number | null>> | Readonly<Shall
  */
 declare function useLastChanged(source: WatchSource, options?: UseLastChangedOptions<false>): Readonly<ShallowRef<number | null>>;
 declare function useLastChanged(source: WatchSource, options: UseLastChangedOptions<true> | UseLastChangedOptions<boolean, number>): Readonly<ShallowRef<number>>;
-
+//#endregion
+//#region useThrottleFn/index.d.ts
 /**
  * Throttle execution of a function. Especially useful for rate limiting
  * execution of handlers on events like resize and scroll.
@@ -1188,20 +1245,21 @@ declare function useLastChanged(source: WatchSource, options: UseLastChangedOpti
  * @__NO_SIDE_EFFECTS__
  */
 declare function useThrottleFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): PromisifyFn<T>;
-
+//#endregion
+//#region useTimeoutFn/index.d.ts
 interface UseTimeoutFnOptions {
-    /**
-     * Start the timer immediately
-     *
-     * @default true
-     */
-    immediate?: boolean;
-    /**
-     * Execute the callback immediately after calling `start`
-     *
-     * @default false
-     */
-    immediateCallback?: boolean;
+  /**
+   * Start the timer immediately
+   *
+   * @default true
+   */
+  immediate?: boolean;
+  /**
+   * Execute the callback immediately after calling `start`
+   *
+   * @default false
+   */
+  immediateCallback?: boolean;
 }
 type UseTimeoutFnReturn<CallbackFn extends AnyFn> = Stoppable<Parameters<CallbackFn> | []>;
 /**
@@ -1212,21 +1270,22 @@ type UseTimeoutFnReturn<CallbackFn extends AnyFn> = Stoppable<Parameters<Callbac
  * @param options
  */
 declare function useTimeoutFn<CallbackFn extends AnyFn>(cb: CallbackFn, interval: MaybeRefOrGetter<number>, options?: UseTimeoutFnOptions): UseTimeoutFnReturn<CallbackFn>;
-
+//#endregion
+//#region useTimeout/index.d.ts
 interface UseTimeoutOptions<Controls extends boolean> extends UseTimeoutFnOptions {
-    /**
-     * Expose more controls
-     *
-     * @default false
-     */
-    controls?: Controls;
-    /**
-     * Callback on timeout
-     */
-    callback?: Fn;
+  /**
+   * Expose more controls
+   *
+   * @default false
+   */
+  controls?: Controls;
+  /**
+   * Callback on timeout
+   */
+  callback?: Fn$1;
 }
 type UseTimoutReturn = ComputedRef<boolean> | {
-    readonly ready: ComputedRef<boolean>;
+  readonly ready: ComputedRef<boolean>;
 } & Stoppable;
 /**
  * Update value after a given time with controls.
@@ -1237,29 +1296,30 @@ type UseTimoutReturn = ComputedRef<boolean> | {
  */
 declare function useTimeout(interval?: MaybeRefOrGetter<number>, options?: UseTimeoutOptions<false>): ComputedRef<boolean>;
 declare function useTimeout(interval: MaybeRefOrGetter<number>, options: UseTimeoutOptions<true>): {
-    ready: ComputedRef<boolean>;
+  ready: ComputedRef<boolean>;
 } & Stoppable;
-
+//#endregion
+//#region useToNumber/index.d.ts
 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;
+  /**
+   * 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;
 }
 /**
  * Reactively convert a string ref to number.
@@ -1267,7 +1327,8 @@ interface UseToNumberOptions {
  * @__NO_SIDE_EFFECTS__
  */
 declare function useToNumber(value: MaybeRefOrGetter<number | string>, options?: UseToNumberOptions): ComputedRef<number>;
-
+//#endregion
+//#region useToString/index.d.ts
 /**
  * Reactively convert a ref to string.
  *
@@ -1276,113 +1337,132 @@ declare function useToNumber(value: MaybeRefOrGetter<number | string>, options?:
  * @__NO_SIDE_EFFECTS__
  */
 declare function useToString(value: MaybeRefOrGetter<unknown>): ComputedRef<string>;
-
+//#endregion
+//#region useToggle/index.d.ts
 type ToggleFn = (value?: boolean) => void;
 type UseToggleReturn = [ShallowRef<boolean>, ToggleFn] | ToggleFn;
 interface UseToggleOptions<Truthy, Falsy> {
-    truthyValue?: MaybeRefOrGetter<Truthy>;
-    falsyValue?: MaybeRefOrGetter<Falsy>;
+  truthyValue?: MaybeRefOrGetter<Truthy>;
+  falsyValue?: MaybeRefOrGetter<Falsy>;
 }
 declare function useToggle<Truthy, Falsy, T = Truthy | Falsy>(initialValue: Ref<T>, options?: UseToggleOptions<Truthy, Falsy>): (value?: T) => T;
 declare function useToggle<Truthy = true, Falsy = false, T = Truthy | Falsy>(initialValue?: T, options?: UseToggleOptions<Truthy, Falsy>): [ShallowRef<T>, (value?: T) => T];
-
+//#endregion
+//#region watchArray/index.d.ts
 declare type WatchArrayCallback<V = any, OV = any> = (value: V, oldValue: OV, added: V, removed: OV, onCleanup: (cleanupFn: () => void) => void) => any;
 /**
  * Watch for an array with additions and removals.
  *
  * @see https://vueuse.org/watchArray
  */
-declare function watchArray<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T[]> | T[], cb: WatchArrayCallback<T[], Immediate extends true ? T[] | undefined : T[]>, options?: WatchOptions<Immediate>): vue.WatchHandle;
-
-interface WatchWithFilterOptions<Immediate> extends WatchOptions<Immediate>, ConfigurableEventFilter {
-}
+declare function watchArray<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T[]> | T[], cb: WatchArrayCallback<T[], Immediate extends true ? T[] | undefined : T[]>, options?: WatchOptions<Immediate>): vue0.WatchHandle;
+//#endregion
+//#region watchWithFilter/index.d.ts
+interface WatchWithFilterOptions<Immediate> extends WatchOptions<Immediate>, ConfigurableEventFilter {}
 declare function watchWithFilter<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchStopHandle;
 declare function watchWithFilter<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchStopHandle;
 declare function watchWithFilter<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchStopHandle;
-
+//#endregion
+//#region watchAtMost/index.d.ts
 interface WatchAtMostOptions<Immediate> extends WatchWithFilterOptions<Immediate> {
-    count: MaybeRefOrGetter<number>;
+  count: MaybeRefOrGetter<number>;
 }
 interface WatchAtMostReturn {
-    stop: WatchStopHandle;
-    count: ShallowRef<number>;
+  stop: WatchStopHandle;
+  count: ShallowRef<number>;
 }
 declare function watchAtMost<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options: WatchAtMostOptions<Immediate>): WatchAtMostReturn;
 declare function watchAtMost<T, Immediate extends Readonly<boolean> = false>(sources: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options: WatchAtMostOptions<Immediate>): WatchAtMostReturn;
-
+//#endregion
+//#region watchDebounced/index.d.ts
 interface WatchDebouncedOptions<Immediate> extends WatchOptions<Immediate>, DebounceFilterOptions {
-    debounce?: MaybeRefOrGetter<number>;
+  debounce?: MaybeRefOrGetter<number>;
 }
 declare function watchDebounced<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchDebouncedOptions<Immediate>): WatchStopHandle;
 declare function watchDebounced<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchDebouncedOptions<Immediate>): WatchStopHandle;
 declare function watchDebounced<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchDebouncedOptions<Immediate>): WatchStopHandle;
-
+/** @deprecated use `watchDebounced` instead */
+declare const debouncedWatch: typeof watchDebounced;
+//#endregion
+//#region watchDeep/index.d.ts
 declare function watchDeep<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchStopHandle;
 declare function watchDeep<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchStopHandle;
 declare function watchDeep<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchStopHandle;
-
+//#endregion
+//#region watchIgnorable/index.d.ts
 type IgnoredUpdater = (updater: () => void) => void;
 type IgnoredPrevAsyncUpdates = () => void;
 interface WatchIgnorableReturn {
-    ignoreUpdates: IgnoredUpdater;
-    ignorePrevAsyncUpdates: IgnoredPrevAsyncUpdates;
-    stop: WatchStopHandle;
+  ignoreUpdates: IgnoredUpdater;
+  ignorePrevAsyncUpdates: IgnoredPrevAsyncUpdates;
+  stop: WatchStopHandle;
 }
 declare function watchIgnorable<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
 declare function watchIgnorable<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
 declare function watchIgnorable<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
-
+/** @deprecated use `watchIgnorable` instead */
+declare const ignorableWatch: typeof watchIgnorable;
+//#endregion
+//#region watchImmediate/index.d.ts
 declare function watchImmediate<T extends Readonly<WatchSource<unknown>[]>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
 declare function watchImmediate<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
 declare function watchImmediate<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
-
+//#endregion
+//#region watchOnce/index.d.ts
 declare function watchOnce<T extends Readonly<WatchSource<unknown>[]>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'once'>): WatchStopHandle;
 declare function watchOnce<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchStopHandle;
 declare function watchOnce<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchStopHandle;
-
+//#endregion
+//#region watchPausable/index.d.ts
 interface WatchPausableReturn extends Pausable {
-    stop: WatchStopHandle;
+  stop: WatchStopHandle;
 }
 type WatchPausableOptions<Immediate> = WatchWithFilterOptions<Immediate> & PausableFilterOptions;
 declare function watchPausable<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
 declare function watchPausable<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
 declare function watchPausable<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
-
+/** @deprecated use `watchPausable` instead */
+declare const pausableWatch: typeof watchPausable;
+//#endregion
+//#region watchThrottled/index.d.ts
 interface WatchThrottledOptions<Immediate> extends WatchOptions<Immediate> {
-    throttle?: MaybeRefOrGetter<number>;
-    trailing?: boolean;
-    leading?: boolean;
+  throttle?: MaybeRefOrGetter<number>;
+  trailing?: boolean;
+  leading?: boolean;
 }
 declare function watchThrottled<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchThrottledOptions<Immediate>): WatchStopHandle;
 declare function watchThrottled<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchThrottledOptions<Immediate>): WatchStopHandle;
 declare function watchThrottled<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchThrottledOptions<Immediate>): WatchStopHandle;
-
+/** @deprecated use `watchThrottled` instead */
+declare const throttledWatch: typeof watchThrottled;
+//#endregion
+//#region watchTriggerable/index.d.ts
 interface WatchTriggerableReturn<FnReturnT = void> extends WatchIgnorableReturn {
-    /** Execute `WatchCallback` immediately */
-    trigger: () => FnReturnT;
+  /** Execute `WatchCallback` immediately */
+  trigger: () => FnReturnT;
 }
 type OnCleanup = (cleanupFn: () => void) => void;
 type WatchTriggerableCallback<V = any, OV = any, R = void> = (value: V, oldValue: OV, onCleanup: OnCleanup) => R;
 declare function watchTriggerable<T extends Readonly<WatchSource<unknown>[]>, FnReturnT>(sources: [...T], cb: WatchTriggerableCallback<MapSources<T>, MapOldSources<T, true>, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
 declare function watchTriggerable<T, FnReturnT>(source: WatchSource<T>, cb: WatchTriggerableCallback<T, T | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
 declare function watchTriggerable<T extends object, FnReturnT>(source: T, cb: WatchTriggerableCallback<T, T | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
-
+//#endregion
+//#region whenever/index.d.ts
 interface WheneverOptions extends WatchOptions {
-    /**
-     * Only trigger once when the condition is met
-     *
-     * Override the `once` option in `WatchOptions`
-     *
-     * @default false
-     */
-    once?: boolean;
+  /**
+   * Only trigger once when the condition is met
+   *
+   * Override the `once` option in `WatchOptions`
+   *
+   * @default false
+   */
+  once?: boolean;
 }
 /**
  * Shorthand for watching value to be truthy
  *
  * @see https://vueuse.org/whenever
  */
-declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WheneverOptions): vue.WatchHandle;
-
-export { assert, refAutoReset as autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createRef, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, computedEager as eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, provideLocal, pxValue, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toArray, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };
-export type { AnyFn, ArgumentsType, Arrayable, Awaitable, Awaited, ComputedEagerOptions, ComputedEagerReturn, ComputedRefWithControl, ComputedWithControlRef, ComputedWithControlRefExtra, ConfigurableEventFilter, ConfigurableFlush, ConfigurableFlushSync, ControlledRefOptions, CreateGlobalStateReturn, CreateInjectionStateOptions, CreateRefReturn, DateLike, DebounceFilterOptions, DeepMaybeRef, ElementOf, EventFilter, EventHook, EventHookOff, EventHookOn, EventHookReturn, EventHookTrigger, ExtendRefOptions, ExtendRefReturn, Fn, FunctionArgs, FunctionWrapperOptions, IfAny, IgnoredPrevAsyncUpdates, IgnoredUpdater, IsAny, IsDefinedReturn, MapOldSources, MapSources, MultiWatchSources, Mutable, Pausable, PausableFilterOptions, Promisify, PromisifyFn, ProvideLocalReturn, Reactified, ReactifyNested, ReactifyObjectOptions, ReactifyObjectReturn, ReactifyOptions, ReactifyReturn, ReactiveComputedReturn, ReactiveOmitPredicate, ReactiveOmitReturn, ReactivePickPredicate, ReactivePickReturn, ReadonlyRefOrGetter, RefAutoResetReturn, RefDebouncedReturn, RefThrottledReturn, RemovableRef, ShallowOrDeepRef, ShallowUnwrapRef, SharedComposableReturn, SingletonPromiseReturn, Stoppable, SyncRefOptions, SyncRefsOptions, ThrottleFilterOptions, TimerHandle, ToRefsOptions, ToggleFn, UntilArrayInstance, UntilBaseInstance, UntilToMatchOptions, UntilValueInstance, UseArrayDifferenceOptions, UseArrayDifferenceReturn, UseArrayEveryReturn, UseArrayFilterReturn, UseArrayFindIndexReturn, UseArrayFindLastReturn, UseArrayFindReturn, UseArrayIncludesComparatorFn, UseArrayIncludesOptions, UseArrayIncludesReturn, UseArrayJoinReturn, UseArrayMapReturn, UseArrayReducer, UseArraySomeReturn, UseArrayUniqueReturn, UseCounterOptions, UseCounterReturn, UseDateFormatOptions, UseDateFormatReturn, UseDebounceFnReturn, UseIntervalControls, UseIntervalFnOptions, UseIntervalFnReturn, UseIntervalOptions, UseIntervalReturn, UseLastChangedOptions, UseLastChangedReturn, UseTimeoutFnOptions, UseTimeoutFnReturn, UseTimeoutOptions, UseTimoutReturn, UseToNumberOptions, UseToggleOptions, UseToggleReturn, WatchArrayCallback, WatchAtMostOptions, WatchAtMostReturn, WatchDebouncedOptions, WatchIgnorableReturn, WatchPausableOptions, WatchPausableReturn, WatchThrottledOptions, WatchTriggerableCallback, WatchTriggerableReturn, WatchWithFilterOptions, WheneverOptions, WritableComputedRefWithControl };
+declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WheneverOptions): vue0.WatchHandle;
+//#endregion
+export { AnyFn, ArgumentsType, Arrayable, Awaitable, Awaited, ComputedEagerOptions, ComputedEagerReturn, ComputedRefWithControl, ComputedWithControlRef, ComputedWithControlRefExtra, ConfigurableEventFilter, ConfigurableFlush, ConfigurableFlushSync, ControlledRefOptions, CreateGlobalStateReturn, CreateInjectionStateOptions, CreateRefReturn, DateLike, DebounceFilterOptions, DeepMaybeRef, ElementOf, EventFilter, EventHook, EventHookOff, EventHookOn, EventHookReturn, EventHookTrigger, ExtendRefOptions, ExtendRefReturn, Fn$1 as Fn, FunctionArgs, FunctionWrapperOptions, IfAny, IgnoredPrevAsyncUpdates, IgnoredUpdater, InstanceProxy, IsAny, IsDefinedReturn, ManualResetRefReturn, MapOldSources, MapSources, MultiWatchSources, Mutable, Pausable, PausableFilterOptions, Promisify, PromisifyFn, ProvideLocalReturn, Reactified, ReactifyNested, ReactifyObjectOptions, ReactifyObjectReturn, ReactifyOptions, ReactifyReturn, ReactiveComputedReturn, ReactiveOmitPredicate, ReactiveOmitReturn, ReactivePickPredicate, ReactivePickReturn, ReadonlyRefOrGetter, RefAutoResetReturn, RefDebouncedReturn, RefThrottledReturn, RemovableRef, ShallowOrDeepRef, ShallowUnwrapRef, SharedComposableReturn, SingletonPromiseReturn, Stoppable, SyncRefOptions, SyncRefsOptions, ThrottleFilterOptions, TimerHandle, ToRefsOptions, ToggleFn, UntilArrayInstance, UntilBaseInstance, UntilToMatchOptions, UntilValueInstance, UseArrayDifferenceOptions, UseArrayDifferenceReturn, UseArrayEveryReturn, UseArrayFilterReturn, UseArrayFindIndexReturn, UseArrayFindLastReturn, UseArrayFindReturn, UseArrayIncludesComparatorFn, UseArrayIncludesOptions, UseArrayIncludesReturn, UseArrayJoinReturn, UseArrayMapReturn, UseArrayReducer, UseArraySomeReturn, UseArrayUniqueReturn, UseCounterOptions, UseCounterReturn, UseDateFormatOptions, UseDateFormatReturn, UseDebounceFnReturn, UseIntervalControls, UseIntervalFnOptions, UseIntervalFnReturn, UseIntervalOptions, UseIntervalReturn, UseLastChangedOptions, UseLastChangedReturn, UseTimeoutFnOptions, UseTimeoutFnReturn, UseTimeoutOptions, UseTimoutReturn, UseToNumberOptions, UseToggleOptions, UseToggleReturn, WatchArrayCallback, WatchAtMostOptions, WatchAtMostReturn, WatchDebouncedOptions, WatchIgnorableReturn, WatchPausableOptions, WatchPausableReturn, WatchThrottledOptions, WatchTriggerableCallback, WatchTriggerableReturn, WatchWithFilterOptions, WheneverOptions, WritableComputedRefWithControl, assert, autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, createReactiveFn, createRef, createSharedComposable, createSingletonPromise, debounceFilter, debouncedRef, debouncedWatch, eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, pausableWatch, promiseTimeout, provideLocal, pxValue, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refManualReset, refThrottled, refWithControl, set, syncRef, syncRefs, throttleFilter, throttledRef, throttledWatch, timestamp, toArray, toReactive, toRef, toRefs, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };