@reactive-vscode/vueuse 0.4.0 → 1.0.0-beta.1

package/dist/index.d.ts

@@ -1,18 +1,24 @@
+import { ComponentInternalInstance } from '@reactive-vscode/reactivity';
 import { ComputedGetter } from '@reactive-vscode/reactivity';
 import { ComputedRef } from '@reactive-vscode/reactivity';
+import { getCurrentInstance } from '@reactive-vscode/reactivity';
+import { inject } from '@reactive-vscode/reactivity';
+import { InjectionKey } from '@reactive-vscode/reactivity';
 import { MaybeRef } from '@reactive-vscode/reactivity';
 import { MaybeRefOrGetter } from '@reactive-vscode/reactivity';
+import { MultiWatchSources } from '@reactive-vscode/reactivity';
 import { Ref } from '@reactive-vscode/reactivity';
 import { ShallowRef } from '@reactive-vscode/reactivity';
 import { ShallowUnwrapRef as ShallowUnwrapRef_2 } from '@reactive-vscode/reactivity';
 import { ToRef } from '@reactive-vscode/reactivity';
 import { ToRefs } from '@reactive-vscode/reactivity';
-import { toValue as toValue_2 } from '@reactive-vscode/reactivity';
 import { UnwrapNestedRefs } from '@reactive-vscode/reactivity';
 import { UnwrapRef } from '@reactive-vscode/reactivity';
-import * as vue from '@reactive-vscode/reactivity';
+import * as vue0 from '@reactive-vscode/reactivity';
 import { WatchCallback } from '@reactive-vscode/reactivity';
+import { WatchHandle } from '@reactive-vscode/reactivity';
 import { WatchOptions } from '@reactive-vscode/reactivity';
+import { WatchOptionsBase } from '@reactive-vscode/reactivity';
 import { WatchSource } from '@reactive-vscode/reactivity';
 import { WatchStopHandle } from '@reactive-vscode/reactivity';
 import { WritableComputedOptions } from '@reactive-vscode/reactivity';
@@ -30,12 +36,15 @@ export declare interface AfterFetchContext<T = any> {
  */
 export declare type AnyFn = (...args: any[]) => any;
 
-export declare type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+export declare type ArgumentsType<T$1> = T$1 extends ((...args: infer U) => any) ? U : never;
 
-export declare type Arrayable<T> = T[] | T;
+export declare type Arrayable<T$1> = T$1[] | T$1;
 
 export declare const assert: (condition: boolean, ...infos: any[]) => void;
 
+/** @deprecated use `computedAsync` instead */
+export declare const asyncComputed: typeof computedAsync;
+
 /**
  * Handle overlapping async evaluations.
  *
@@ -66,23 +75,26 @@ export declare interface AsyncComputedOptions<Lazy = boolean> {
      * Possible values: `pre`, `post`, `sync`
      *
      * It works in the same way as the flush option in watch and watch effect in vue reactivity
-     * @default 'pre'
+     * @default 'sync'
      */
-    flush?: 'pre' | 'post' | 'sync';
+    flush?: WatchOptionFlush;
     /**
      * Callback when error is caught.
      */
     onError?: (e: unknown) => void;
 }
 
-export declare type Awaitable<T> = Promise<T> | T;
+/** @deprecated use `refAutoReset` instead */
+export declare const autoResetRef: typeof refAutoReset;
+
+export declare type Awaitable<T$1> = Promise<T$1> | T$1;
 
 /**
  * Compatible with versions below TypeScript 4.5 Awaited
  */
-declare type Awaited_2<T> = T extends null | undefined ? T : T extends object & {
+declare type Awaited_2<T$1> = T$1 extends null | undefined ? T$1 : T$1 extends object & {
     then: (onfulfilled: infer F, ...args: infer _) => any;
-} ? F extends ((value: infer V, ...args: infer _) => any) ? Awaited_2<V> : never : T;
+} ? F extends ((value: infer V, ...args: infer _) => any) ? Awaited_2<V> : never : T$1;
 export { Awaited_2 as Awaited }
 
 export declare interface BeforeFetchContext {
@@ -117,14 +129,7 @@ declare interface BrowserLocationState {
 
 export declare const bypassFilter: EventFilter;
 
-/**
- * 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
- */
-
-declare 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);
+declare type Callback<T$1> = IsAny<T$1> extends true ? (...param: any) => void : ([T$1] extends [void] ? (...param: unknown[]) => void : [T$1] extends [any[]] ? (...param: T$1) => void : (...param: [T$1, ...unknown[]]) => void);
 
 export declare const camelize: (str: string) => string;
 
@@ -144,30 +149,46 @@ declare type Combination = 'overwrite' | 'chain';
  * @param initialState           The initial state, used until the first evaluation finishes
  * @param optionsOrRef           Additional options or a ref passed to receive the updates of the async evaluation
  */
-declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: T, optionsOrRef: AsyncComputedOptions<true>): ComputedRef<T>;
+export declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: T, optionsOrRef: AsyncComputedOptions<true>): ComputedRef<T>;
 
-declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: undefined, optionsOrRef: AsyncComputedOptions<true>): ComputedRef<T | undefined>;
+export declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: undefined, optionsOrRef: AsyncComputedOptions<true>): ComputedRef<T | undefined>;
 
-declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: T, optionsOrRef?: Ref<boolean> | AsyncComputedOptions): Ref<T>;
+export declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: T, optionsOrRef?: Ref<boolean> | AsyncComputedOptions): Ref<T>;
 
-declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState?: undefined, optionsOrRef?: Ref<boolean> | AsyncComputedOptions): Ref<T | undefined>;
-export { computedAsync as asyncComputed }
-export { computedAsync }
+export declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState?: undefined, optionsOrRef?: Ref<boolean> | AsyncComputedOptions): Ref<T | undefined>;
 
-declare type ComputedInjectGetter<T, K> = (source: T | undefined, oldValue?: K) => K;
+/**
+ *
+ * @deprecated This function will be removed in future version.
+ *
+ * Note: If you are using Vue 3.4+, you can straight use computed instead.
+ * Because in Vue 3.4+, if computed new value does not change,
+ * computed, effect, watch, watchEffect, render dependencies will not be triggered.
+ * refer: https://github.com/vuejs/core/pull/5912
+ *
+ * @param fn effect function
+ * @param options WatchOptionsBase
+ * @returns readonly shallowRef
+ */
+export declare function computedEager<T$1>(fn: () => T$1, options?: ComputedEagerOptions): ComputedEagerReturn<T$1>;
+
+export declare type ComputedEagerOptions = WatchOptionsBase;
+
+export declare type ComputedEagerReturn<T$1 = any> = Readonly<ShallowRef<T$1>>;
 
-declare type ComputedInjectGetterWithDefault<T, K> = (source: T, oldValue?: K) => K;
+declare type ComputedInjectGetter<T, K$1> = (source: T | undefined, oldValue?: K$1) => K$1;
+
+declare type ComputedInjectGetterWithDefault<T, K$1> = (source: T, oldValue?: K$1) => K$1;
 
 declare type ComputedInjectSetter<T> = (v: T) => void;
 
-export declare interface ComputedRefWithControl<T> extends ComputedRef<T>, ComputedWithControlRefExtra {
-}
+export declare interface ComputedRefWithControl<T$1> extends ComputedRef<T$1>, ComputedWithControlRefExtra {}
 
-declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: ComputedGetter<T>, options?: WatchOptions): ComputedRefWithControl<T>;
+export declare function computedWithControl<T$1>(source: WatchSource | MultiWatchSources, fn: ComputedGetter<T$1>, options?: WatchOptions): ComputedRefWithControl<T$1>;
 
-declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: WritableComputedOptions<T>, options?: WatchOptions): WritableComputedRefWithControl<T>;
-export { computedWithControl }
-export { computedWithControl as controlledComputed }
+export declare function computedWithControl<T$1>(source: WatchSource | MultiWatchSources, fn: WritableComputedOptions<T$1>, options?: WatchOptions): WritableComputedRefWithControl<T$1>;
+
+export declare type ComputedWithControlRef<T$1 = any> = ComputedRefWithControl<T$1> | WritableComputedRefWithControl<T$1>;
 
 export declare interface ComputedWithControlRefExtra {
     /**
@@ -200,7 +221,7 @@ export declare interface ConfigurableFlush {
      *
      * @default 'pre'
      */
-    flush?: WatchOptions['flush'];
+    flush?: WatchOptionFlush;
 }
 
 export declare interface ConfigurableFlushSync {
@@ -210,7 +231,7 @@ export declare interface ConfigurableFlushSync {
      *
      * @default 'sync'
      */
-    flush?: WatchOptions['flush'];
+    flush?: WatchOptionFlush;
 }
 
 declare interface ConfigurableNavigator {
@@ -223,24 +244,25 @@ declare interface ConfigurableWindow {
 
 export declare function containsProp(obj: object, ...props: string[]): boolean;
 
-/**
- * Alias for `refWithControl`
- */
+/** @deprecated use `computedWithControl` instead */
+export declare const controlledComputed: typeof computedWithControl;
+
+/** @deprecated use `refWithControl` instead */
 export declare const controlledRef: typeof refWithControl;
 
-export declare interface ControlledRefOptions<T> {
+export declare interface ControlledRefOptions<T$1> {
     /**
      * Callback function before the ref changing.
      *
      * Returning `false` to dismiss the change.
      */
-    onBeforeChange?: (value: T, oldValue: T) => void | boolean;
+    onBeforeChange?: (value: T$1, oldValue: T$1) => void | boolean;
     /**
      * Callback function after the ref changed
      *
      * This happens synchronously, with less overhead compare to `watch`
      */
-    onChanged?: (value: T, oldValue: T) => void;
+    onChanged?: (value: T$1, oldValue: T$1) => void;
 }
 
 /**
@@ -250,7 +272,7 @@ export declare interface ControlledRefOptions<T> {
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function createEventHook<T = any>(): EventHookReturn<T>;
+export declare function createEventHook<T$1 = any>(): EventHookReturn<T$1>;
 
 export declare function createFetch(config?: CreateFetchOptions): typeof useFetch;
 
@@ -284,9 +306,66 @@ export declare interface CreateFetchOptions {
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function createGlobalState<Fn extends AnyFn>(stateFactory: Fn): CreateGlobalStateReturn<Fn>;
+export declare function createGlobalState<Fn$1 extends AnyFn>(stateFactory: Fn$1): CreateGlobalStateReturn<Fn$1>;
+
+export declare type CreateGlobalStateReturn<Fn$1 extends AnyFn = AnyFn> = Fn$1;
+
+/**
+ * Create global state that can be injected into components.
+ *
+ * @see https://vueuse.org/createInjectionState
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function createInjectionState<Arguments extends Array<any>, Return>(composable: (...args: Arguments) => Return, options?: CreateInjectionStateOptions<Return>): CreateInjectionStateReturn<Arguments, Return>;
+
+export declare interface CreateInjectionStateOptions<Return> {
+    /**
+     * Custom injectionKey for InjectionState
+     */
+    injectionKey?: string | InjectionKey<Return>;
+    /**
+     * Default value for the InjectionState
+     */
+    defaultValue?: Return;
+}
+
+export declare type CreateInjectionStateReturn<Arguments extends Array<any>, Return> = Readonly<[
+/**
+ * Call this function in a provider component to create and provide the state.
+ *
+ * @param args Arguments passed to the composable
+ * @returns The state returned by the composable
+ */
+useProvidingState: (...args: Arguments) => Return,
+/**
+ * Call this function in a consumer component to inject the state.
+ *
+ * @returns The injected state, or `undefined` if not provided and no default value was set.
+ */
+useInjectedState: () => Return | undefined]>;
+
+/** @deprecated use `reactify` instead */
+export declare const createReactiveFn: typeof reactify;
+
+/**
+ * Returns a `deepRef` or `shallowRef` depending on the `deep` param.
+ *
+ * @example createRef(1) // ShallowRef<number>
+ * @example createRef(1, false) // ShallowRef<number>
+ * @example createRef(1, true) // Ref<number>
+ * @example createRef("string") // ShallowRef<string>
+ * @example createRef<"A"|"B">("A", true) // Ref<"A"|"B">
+ *
+ * @param value
+ * @param deep
+ * @returns the `deepRef` or `shallowRef`
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function createRef<T$1 = any, D extends boolean = false>(value: T$1, deep?: D): CreateRefReturn<T$1, D>;
 
-declare type CreateGlobalStateReturn<Fn extends AnyFn = AnyFn> = Fn;
+export declare type CreateRefReturn<T$1 = any, D extends boolean = false> = ShallowOrDeepRef<T$1, D>;
 
 /**
  * Make a composable function usable with multiple Vue instances.
@@ -295,7 +374,7 @@ declare type CreateGlobalStateReturn<Fn extends AnyFn = AnyFn> = Fn;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function createSharedComposable<Fn extends AnyFn>(composable: Fn): SharedComposableReturn<Fn>;
+export declare function createSharedComposable<Fn$1 extends AnyFn>(composable: Fn$1): SharedComposableReturn<Fn$1>;
 
 /**
  * Create singleton promise function
@@ -309,7 +388,7 @@ export declare function createSharedComposable<Fn extends AnyFn>(composable: Fn)
  * await promise() // and be resolved together
  * ```
  */
-export declare function createSingletonPromise<T>(fn: () => Promise<T>): SingletonPromiseReturn<T>;
+export declare function createSingletonPromise<T$1>(fn: () => Promise<T$1>): SingletonPromiseReturn<T$1>;
 
 /**
  * Make a plain function accepting ref and raw values as arguments.
@@ -321,6 +400,12 @@ export declare function createUnrefFn<T extends Function>(fn: T): UnrefFn<T>;
 
 export declare type DateLike = Date | number | string | undefined;
 
+/** @deprecated use `refDebounced` instead */
+export declare const debouncedRef: typeof refDebounced;
+
+/** @deprecated use `watchDebounced` instead */
+export declare const debouncedWatch: typeof watchDebounced;
+
 /**
  * Create an EventFilter that debounce the events
  */
@@ -349,63 +434,63 @@ export declare interface DebounceFilterOptions {
  * UnwrapRef<DeepMaybeRef<T>> === T
  * ```
  */
-export declare type DeepMaybeRef<T> = T extends Ref<infer V> ? MaybeRef<V> : T extends Array<any> | object ? {
-    [K in keyof T]: DeepMaybeRef<T[K]>;
-} : MaybeRef<T>;
+export declare type DeepMaybeRef<T$1> = T$1 extends Ref<infer V> ? MaybeRef<V> : T$1 extends Array<any> | object ? { [K in keyof T$1]: DeepMaybeRef<T$1[K]> } : MaybeRef<T$1>;
 
 declare type Direction = 'ltr' | 'rtl' | 'both';
 
+/** @deprecated use `computedEager` instead */
+export declare const eagerComputed: typeof computedEager;
+
 /**
  * Infers the element type of an array
  */
-export declare type ElementOf<T> = T extends (infer E)[] ? E : never;
+export declare type ElementOf<T$1> = T$1 extends (infer E)[] ? E : never;
 
 /**
  * A = B
  */
-declare type Equal<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+declare type Equal<A$1, B> = [A$1] extends [B] ? ([B] extends [A$1] ? true : false) : false;
 
-declare 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>;
+declare interface EqualType<D extends Direction, L, R$1, O extends keyof Transform<L, R$1> = (D extends 'both' ? 'ltr' | 'rtl' : D)> {
+    transform?: SpecificFieldPartial<Pick<Transform<L, R$1>, O>, O>;
 }
 
-export declare type EventBusEvents<T, P = any> = Set<EventBusListener<T, P>>;
+export declare type EventBusEvents<T, P$1 = any> = Set<EventBusListener<T, P$1>>;
 
 export declare type EventBusIdentifier<T = unknown> = EventBusKey<T> | string | number;
 
-export declare interface EventBusKey<T> extends Symbol {
-}
+export declare interface EventBusKey<T> extends Symbol {}
 
-export declare type EventBusListener<T = unknown, P = any> = (event: T, payload?: P) => void;
+export declare type EventBusListener<T = unknown, P$1 = any> = (event: T, payload?: P$1) => void;
 
 export declare type EventFilter<Args extends any[] = any[], This = any, Invoke extends AnyFn = AnyFn> = (invoke: Invoke, options: FunctionWrapperOptions<Args, This>) => ReturnType<Invoke> | Promisify<ReturnType<Invoke>>;
 
-export declare interface EventHook<T = any> {
-    on: EventHookOn<T>;
-    off: EventHookOff<T>;
-    trigger: EventHookTrigger<T>;
+export declare interface EventHook<T$1 = any> {
+    on: EventHookOn<T$1>;
+    off: EventHookOff<T$1>;
+    trigger: EventHookTrigger<T$1>;
     clear: () => void;
 }
 
-export declare type EventHookOff<T = any> = (fn: Callback<T>) => void;
+export declare type EventHookOff<T$1 = any> = (fn: Callback<T$1>) => void;
 
-export declare type EventHookOn<T = any> = (fn: Callback<T>) => {
+export declare type EventHookOn<T$1 = any> = (fn: Callback<T$1>) => {
     off: () => void;
 };
 
-declare type EventHookReturn<T> = EventHook<T>;
+export declare type EventHookReturn<T$1> = EventHook<T$1>;
 
-export declare type EventHookTrigger<T = any> = (...param: Parameters<Callback<T>>) => Promise<unknown[]>;
+export declare type EventHookTrigger<T$1 = any> = (...param: Parameters<Callback<T$1>>) => Promise<unknown[]>;
 
 /**
  * Overload 1: Unwrap set to false
  */
-export declare function extendRef<R extends Ref<any>, Extend extends object, Options extends ExtendRefOptions<false>>(ref: R, extend: Extend, options?: Options): ShallowUnwrapRef_2<Extend> & R;
+export declare function extendRef<R$1 extends Ref<any>, Extend extends object, Options extends ExtendRefOptions<false>>(ref: R$1, extend: Extend, options?: Options): ShallowUnwrapRef_2<Extend> & R$1;
 
 /**
  * Overload 2: Unwrap unset or set to true
  */
-export declare function extendRef<R extends Ref<any>, Extend extends object, Options extends ExtendRefOptions>(ref: R, extend: Extend, options?: Options): Extend & R;
+export declare function extendRef<R$1 extends Ref<any>, Extend extends object, Options extends ExtendRefOptions>(ref: R$1, extend: Extend, options?: Options): Extend & R$1;
 
 export declare interface ExtendRefOptions<Unwrap extends boolean = boolean> {
     /**
@@ -422,6 +507,8 @@ export declare interface ExtendRefOptions<Unwrap extends boolean = boolean> {
     unwrap?: Unwrap;
 }
 
+export declare type ExtendRefReturn<T$1 = any> = Ref<T$1>;
+
 declare type Falsy = false | void | null | undefined | 0 | 0n | '';
 
 /**
@@ -466,7 +553,7 @@ export declare interface FormatTimeAgoOptions<UnitNames extends string = UseTime
     units?: UseTimeAgoUnit<UnitNames>[];
 }
 
-export declare type FunctionArgs<Args extends any[] = any[], Return = void> = (...args: Args) => Return;
+export declare type FunctionArgs<Args extends any[] = any[], Return = unknown> = (...args: Args) => Return;
 
 export declare interface FunctionWrapperOptions<Args extends any[] = any[], This = any> {
     fn: FunctionArgs<Args, This>;
@@ -481,28 +568,31 @@ export declare interface GeneralEventListener<E = Event> {
 /**
  * Shorthand for accessing `ref.value`
  */
-export declare function get<T>(ref: MaybeRef<T>): T;
+export declare function get<T$1>(ref: MaybeRef<T$1>): T$1;
 
-export declare function get<T, K extends keyof T>(ref: MaybeRef<T>, key: K): T[K];
+export declare function get<T$1, K$1 extends keyof T$1>(ref: MaybeRef<T$1>, key: K$1): T$1[K$1];
 
-export declare function getLifeCycleTarget(target?: any): any;
+export declare function getLifeCycleTarget(target?: ComponentInternalInstance | null): ComponentInternalInstance | null;
 
 export declare const hasOwn: <T extends object, K extends keyof T>(val: T, key: K) => key is K;
 
 export declare const hyphenate: (str: string) => string;
 
-export declare function identity<T>(arg: T): T;
+export declare function identity<T$1>(arg: T$1): T$1;
 
-export declare type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
+export declare type IfAny<T$1, Y, N> = 0 extends (1 & T$1) ? Y : N;
 
-declare type IgnoredPrevAsyncUpdates = () => void;
+/** @deprecated use `watchIgnorable` instead */
+export declare const ignorableWatch: typeof watchIgnorable;
+
+export declare type IgnoredPrevAsyncUpdates = () => void;
 
 export declare type IgnoredUpdater = (updater: () => void) => void;
 
 /**
  * A ⊆ B
  */
-declare type IncludeButNotEqual<A, B> = Equal<A, B> extends true ? false : A extends B ? true : false;
+declare type IncludeButNotEqual<A$1, B> = Equal<A$1, B> extends true ? false : A$1 extends B ? true : false;
 
 /**
  * Increase string a value with unit
@@ -516,53 +606,74 @@ export declare function increaseWithUnit(target: string, delta: number): string;
 
 export declare function increaseWithUnit(target: string | number, delta: number): string | number;
 
+/**
+ * On the basis of `inject`, it is allowed to directly call inject to obtain the value after call provide in the same component.
+ *
+ * @example
+ * ```ts
+ * injectLocal('MyInjectionKey', 1)
+ * const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare const injectLocal: typeof inject;
+
+export declare type InstanceProxy = NonNullable<NonNullable<ReturnType<typeof getCurrentInstance>>['proxy']>;
+
 /**
  * A ∩ B ≠ ∅
  */
-declare type IntersectButNotEqual<A, B> = Equal<A, B> extends true ? false : A & B extends never ? false : true;
+declare type IntersectButNotEqual<A$1, B> = Equal<A$1, B> extends true ? false : A$1 & B extends never ? false : true;
 
-declare type IntersectButNotEqualType<D extends Direction, L, R> = D extends 'both' ? {
-    transform: Transform<L, R>;
+declare type IntersectButNotEqualType<D extends Direction, L, R$1> = D extends 'both' ? {
+    transform: Transform<L, R$1>;
 } : D extends Exclude<Direction, 'both'> ? {
-    transform: Pick<Transform<L, R>, D>;
+    transform: Pick<Transform<L, R$1>, D>;
 } : never;
 
-export declare function invoke<T>(fn: () => T): T;
+export declare function invoke<T$1>(fn: () => T$1): T$1;
 
 /**
  * will return `true` if `T` is `any`, or `false` otherwise
  */
-export declare type IsAny<T> = IfAny<T, true, false>;
+export declare type IsAny<T$1> = IfAny<T$1, true, false>;
 
 export declare const isDef: <T = any>(val?: T) => val is T;
 
-export declare function isDefined<T>(v: ComputedRef<T>): v is ComputedRef<Exclude<T, null | undefined>>;
+export declare function isDefined<T$1>(v: ComputedRef<T$1>): v is ComputedRef<Exclude<T$1, null | undefined>>;
+
+export declare function isDefined<T$1>(v: Ref<T$1>): v is Ref<Exclude<T$1, null | undefined>>;
 
-export declare function isDefined<T>(v: Ref<T>): v is Ref<Exclude<T, null | undefined>>;
+export declare function isDefined<T$1>(v: T$1): v is Exclude<T$1, null | undefined>;
 
-export declare function isDefined<T>(v: T): v is Exclude<T, null | undefined>;
+export declare type IsDefinedReturn = boolean;
 
 export declare const isObject: (val: any) => val is object;
 
-export declare function makeDestructurable<T extends Record<string, unknown>, A extends readonly any[]>(obj: T, arr: A): T & A;
+declare type LocalProvidedKey<T$1> = InjectionKey<T$1> | string | number;
 
-export declare type MapOldSources<T, Immediate> = {
-    [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : never;
-};
+export declare function makeDestructurable<T$1 extends Record<string, unknown>, A$1 extends readonly any[]>(obj: T$1, arr: A$1): T$1 & A$1;
 
-declare type MapQueueTask<T extends any[]> = {
-    [K in keyof T]: UseAsyncQueueTask<T[K]>;
-};
+/**
+ * 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.
+ */
+export declare interface ManualResetRefReturn<T$1> extends Ref<T$1> {
+    reset: Fn;
+}
 
-export declare type MapSources<T> = {
-    [K in keyof T]: T[K] extends WatchSource<infer V> ? V : never;
-};
+export declare type MapOldSources<T$1, Immediate> = { [K in keyof T$1]: T$1[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : never };
 
-export declare type MultiWatchSources = (WatchSource<unknown> | object)[];
+declare type MapQueueTask<T extends any[]> = { [K in keyof T]: UseAsyncQueueTask<T[K]> };
 
-export declare type Mutable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
+export declare type MapSources<T$1> = { [K in keyof T$1]: T$1[K] extends WatchSource<infer V> ? V : never };
+
+export { MultiWatchSources }
+
+export declare type Mutable<T$1> = { -readonly [P in keyof T$1]: T$1[P] };
 
 export declare const noop: () => void;
 
@@ -571,25 +682,25 @@ export declare function normalizeDate(date: DateLike): Date;
 /**
  * A ∩ B = ∅
  */
-declare type NotIntersect<A, B> = Equal<A, B> extends true ? false : A & B extends never ? true : false;
+declare type NotIntersect<A$1, B> = Equal<A$1, B> extends true ? false : A$1 & B extends never ? true : false;
 
-declare type NotIntersectType<D extends Direction, L, R> = IntersectButNotEqualType<D, L, R>;
+declare type NotIntersectType<D extends Direction, L, R$1> = IntersectButNotEqualType<D, L, R$1>;
 
 export declare const notNullish: <T = any>(val?: T | null | undefined) => val is T;
 
 export declare const now: () => number;
 
-export declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
+export declare function objectEntries<T$1 extends object>(obj: T$1): Array<[keyof T$1, T$1[keyof T$1]]>;
 
 /**
  * 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 objectOmit<O extends object, T$1 extends keyof O>(obj: O, keys: T$1[], omitUndefined?: boolean): Omit<O, T$1>;
 
 /**
  * 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>;
+export declare function objectPick<O extends object, T$1 extends keyof O>(obj: O, keys: T$1[], omitUndefined?: boolean): Pick<O, T$1>;
 
 declare type OnCleanup = (cleanupFn: () => void) => void;
 
@@ -626,7 +737,7 @@ export declare function pausableFilter(extendFilter?: EventFilter, options?: Pau
     eventFilter: EventFilter;
 };
 
-declare interface PausableFilterOptions {
+export declare interface PausableFilterOptions {
     /**
      * The initial state
      *
@@ -635,19 +746,38 @@ declare interface PausableFilterOptions {
     initialState?: 'active' | 'paused';
 }
 
+/** @deprecated use `watchPausable` instead */
+export declare const pausableWatch: typeof watchPausable;
+
 declare type PostMessage = typeof Worker.prototype['postMessage'];
 
 export declare function promiseTimeout(ms: number, throwOnTimeout?: boolean, reason?: string): Promise<void>;
 
-export declare type Promisify<T> = Promise<Awaited_2<T>>;
+export declare type Promisify<T$1> = Promise<Awaited_2<T$1>>;
+
+export declare type PromisifyFn<T$1 extends AnyFn> = (...args: ArgumentsType<T$1>) => Promisify<ReturnType<T$1>>;
+
+/**
+ * On the basis of `provide`, it is allowed to directly call inject to obtain the value after call provide in the same component.
+ *
+ * @example
+ * ```ts
+ * provideLocal('MyInjectionKey', 1)
+ * const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
+ * ```
+ */
+export declare function provideLocal<T$1, K$1 = LocalProvidedKey<T$1>>(key: K$1, value: K$1 extends InjectionKey<infer V> ? V : T$1): ProvideLocalReturn;
 
-export declare type PromisifyFn<T extends AnyFn> = (...args: ArgumentsType<T>) => Promisify<ReturnType<T>>;
+export declare type ProvideLocalReturn = void;
+
+/**
+ * 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
+ */
+export declare function pxValue(px: string): number;
 
 export declare const rand: (min: number, max: number) => number;
 
-export declare 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;
+export declare type Reactified<T$1, Computed extends boolean> = T$1 extends ((...args: infer A) => infer R) ? (...args: { [K in keyof A]: Computed extends true ? MaybeRefOrGetter<A[K]> : MaybeRef<A[K]> }) => ComputedRef<R> : never;
 
 /**
  * Converts plain function into a reactive function.
@@ -659,24 +789,20 @@ export declare type Reactified<T, Computed extends boolean> = T extends (...args
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function reactify<T extends AnyFn, K extends boolean = true>(fn: T, options?: ReactifyOptions<K>): ReactifyReturn<T, K>;
-export { reactify as createReactiveFn }
-export { reactify }
+export declare function reactify<T$1 extends AnyFn, K$1 extends boolean = true>(fn: T$1, options?: ReactifyOptions<K$1>): ReactifyReturn<T$1, K$1>;
 
-export declare 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];
-};
+export declare type ReactifyNested<T$1, Keys extends keyof T$1 = keyof T$1, S$1 extends boolean = true> = { [K in Keys]: T$1[K] extends AnyFn ? Reactified<T$1[K], S$1> : T$1[K] };
 
 /**
  * Apply `reactify` to an object
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function reactifyObject<T extends object, Keys extends keyof T>(obj: T, keys?: (keyof T)[]): ReactifyObjectReturn<T, Keys, true>;
+export declare function reactifyObject<T$1 extends object, Keys extends keyof T$1>(obj: T$1, keys?: (keyof T$1)[]): ReactifyObjectReturn<T$1, Keys, true>;
 
-export declare function reactifyObject<T extends object, S extends boolean = true>(obj: T, options?: ReactifyObjectOptions<S>): ReactifyObjectReturn<T, keyof T, S>;
+export declare function reactifyObject<T$1 extends object, S$1 extends boolean = true>(obj: T$1, options?: ReactifyObjectOptions<S$1>): ReactifyObjectReturn<T$1, keyof T$1, S$1>;
 
-export declare interface ReactifyObjectOptions<T extends boolean> extends ReactifyOptions<T> {
+export declare interface ReactifyObjectOptions<T$1 extends boolean> extends ReactifyOptions<T$1> {
     /**
      * Includes names from Object.getOwnPropertyNames
      *
@@ -685,48 +811,46 @@ export declare interface ReactifyObjectOptions<T extends boolean> extends Reacti
     includeOwnProperties?: boolean;
 }
 
-declare type ReactifyObjectReturn<T, Keys extends keyof T, S extends boolean = true> = ReactifyNested<T, Keys, S>;
+export declare type ReactifyObjectReturn<T$1, Keys extends keyof T$1, S$1 extends boolean = true> = ReactifyNested<T$1, Keys, S$1>;
 
-export declare interface ReactifyOptions<T extends boolean> {
+export declare interface ReactifyOptions<T$1 extends boolean> {
     /**
      * Accept passing a function as a reactive getter
      *
      * @default true
      */
-    computedGetter?: T;
+    computedGetter?: T$1;
 }
 
-declare type ReactifyReturn<T extends AnyFn = AnyFn, K extends boolean = true> = Reactified<T, K>;
+export declare type ReactifyReturn<T$1 extends AnyFn = AnyFn, K$1 extends boolean = true> = Reactified<T$1, K$1>;
 
 /**
  * Computed reactive object.
  */
-export declare function reactiveComputed<T extends object>(fn: ComputedGetter<T>): ReactiveComputedReturn<T>;
+export declare function reactiveComputed<T$1 extends object>(fn: ComputedGetter<T$1>): ReactiveComputedReturn<T$1>;
 
-declare type ReactiveComputedReturn<T extends object> = UnwrapNestedRefs<T>;
+export declare type ReactiveComputedReturn<T$1 extends object> = UnwrapNestedRefs<T$1>;
 
-export declare function reactiveOmit<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): ReactiveOmitReturn<T, K>;
+export declare function reactiveOmit<T$1 extends object, K$1 extends keyof T$1>(obj: T$1, ...keys: (K$1 | K$1[])[]): ReactiveOmitReturn<T$1, K$1>;
 
-export declare function reactiveOmit<T extends object>(obj: T, predicate: ReactiveOmitPredicate<T>): ReactiveOmitReturn<T>;
+export declare function reactiveOmit<T$1 extends object>(obj: T$1, predicate: ReactiveOmitPredicate<T$1>): ReactiveOmitReturn<T$1>;
 
-export declare type ReactiveOmitPredicate<T> = (value: T[keyof T], key: keyof T) => boolean;
+export declare type ReactiveOmitPredicate<T$1> = (value: T$1[keyof T$1], key: keyof T$1) => boolean;
 
-declare type ReactiveOmitReturn<T extends object, K extends keyof T | undefined = undefined> = [K] extends [undefined] ? Partial<T> : Omit<T, Extract<K, keyof T>>;
+export declare type ReactiveOmitReturn<T$1 extends object, K$1 extends keyof T$1 | undefined = undefined> = [K$1] extends [undefined] ? Partial<T$1> : Omit<T$1, Extract<K$1, keyof T$1>>;
 
-export declare function reactivePick<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): ReactivePickReturn<T, K>;
+export declare function reactivePick<T$1 extends object, K$1 extends keyof T$1>(obj: T$1, ...keys: (K$1 | K$1[])[]): ReactivePickReturn<T$1, K$1>;
 
-export declare function reactivePick<T extends object>(obj: T, predicate: ReactivePickPredicate<T>): ReactivePickReturn<T, keyof T>;
+export declare function reactivePick<T$1 extends object>(obj: T$1, predicate: ReactivePickPredicate<T$1>): ReactivePickReturn<T$1, keyof T$1>;
 
-export declare type ReactivePickPredicate<T> = (value: T[keyof T], key: keyof T) => boolean;
+export declare type ReactivePickPredicate<T$1> = (value: T$1[keyof T$1], key: keyof T$1) => boolean;
 
-declare type ReactivePickReturn<T extends object, K extends keyof T> = {
-    [S in K]: UnwrapRef<T[S]>;
-};
+export declare type ReactivePickReturn<T$1 extends object, K$1 extends keyof T$1> = { [S in K$1]: UnwrapRef<T$1[S]> };
 
 /**
  * Maybe it's a computed ref, or a readonly value, or a getter function
  */
-export declare type ReadonlyRefOrGetter<T> = ComputedRef<T> | (() => T);
+export declare type ReadonlyRefOrGetter<T$1> = ComputedRef<T$1> | (() => T$1);
 
 /**
  * Create a ref which will be reset to the default value after some time.
@@ -735,30 +859,33 @@ export declare type ReadonlyRefOrGetter<T> = ComputedRef<T> | (() => T);
  * @param defaultValue The value which will be set.
  * @param afterMs      A zero-or-greater delay in milliseconds.
  */
-declare function refAutoReset<T>(defaultValue: MaybeRefOrGetter<T>, afterMs?: MaybeRefOrGetter<number>): RefAutoResetReturn<T>;
-export { refAutoReset as autoResetRef }
-export { refAutoReset }
+export declare function refAutoReset<T$1>(defaultValue: MaybeRefOrGetter<T$1>, afterMs?: MaybeRefOrGetter<number>): RefAutoResetReturn<T$1>;
 
-declare type RefAutoResetReturn<T = any> = Ref<T>;
+export declare type RefAutoResetReturn<T$1 = any> = Ref<T$1>;
 
 /**
  * Debounce updates of a ref.
  *
  * @return A new debounced ref.
  */
-declare function refDebounced<T>(value: Ref<T>, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): RefDebouncedReturn<T>;
-export { refDebounced as debouncedRef }
-export { refDebounced }
-export { refDebounced as useDebounce }
+export declare function refDebounced<T$1>(value: Ref<T$1>, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): RefDebouncedReturn<T$1>;
 
-declare type RefDebouncedReturn<T = any> = Readonly<Ref<T>>;
+export declare type RefDebouncedReturn<T$1 = any> = Readonly<Ref<T$1>>;
 
 /**
  * Apply default value to a ref.
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function refDefault<T>(source: Ref<T | undefined | null>, defaultValue: T): Ref<T>;
+export declare function refDefault<T$1>(source: Ref<T$1 | undefined | null>, defaultValue: T$1): Ref<T$1>;
+
+/**
+ * Create a ref with manual reset functionality.
+ *
+ * @see https://vueuse.org/refManualReset
+ * @param defaultValue The value which will be set.
+ */
+export declare function refManualReset<T$1>(defaultValue: MaybeRefOrGetter<T$1>): ManualResetRefReturn<T$1>;
 
 /**
  * Throttle execution of a function. Especially useful for rate limiting
@@ -769,44 +896,28 @@ export declare function refDefault<T>(source: Ref<T | undefined | null>, default
  * @param trailing if true, update the value again after the delay time is up
  * @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>;
-export { refThrottled }
-export { refThrottled as throttledRef }
-export { refThrottled as useThrottle }
+export declare function refThrottled<T$1 = any>(value: Ref<T$1>, delay?: number, trailing?: boolean, leading?: boolean): RefThrottledReturn<T$1>;
 
-declare type RefThrottledReturn<T = any> = Ref<T>;
+export declare type RefThrottledReturn<T$1 = any> = Ref<T$1>;
 
 /**
  * Fine-grained controls over ref and its reactivity.
  *
  * @__NO_SIDE_EFFECTS__
  */
-export 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>;
+export declare function refWithControl<T$1>(initial: T$1, options?: ControlledRefOptions<T$1>): vue0.ShallowUnwrapRef<{
+    get: (tracking?: boolean) => T$1;
+    set: (value: T$1, triggering?: boolean) => void;
+    untrackedGet: () => T$1;
+    silentSet: (v: T$1) => void;
+    peek: () => T$1;
+    lay: (v: T$1) => void;
+}> & vue0.Ref<T$1, T$1>;
 
 /**
  * A ref that allow to set null or undefined
  */
-export declare type RemovableRef<T> = Omit<Ref<T>, 'value'> & {
-    get value(): T;
-    set value(value: T | null | undefined);
-};
-
-/**
- * @deprecated use `toRef` instead
- */
-export declare const resolveRef: typeof toRef;
-
-/**
- * @deprecated use `toValue` instead
- */
-export declare const resolveUnref: typeof toValue_2;
+export declare type RemovableRef<T$1> = Ref<T$1, T$1 | null | undefined>;
 
 export declare interface Serializer<T> {
     read: (raw: string) => T;
@@ -818,18 +929,18 @@ export declare interface SerializerAsync<T> {
     write: (value: T) => Awaitable<string>;
 }
 
-export declare function set<T>(ref: Ref<T>, value: T): void;
+export declare function set<T$1>(ref: Ref<T$1>, value: T$1): void;
 
-export declare function set<O extends object, K extends keyof O>(target: O, key: K, value: O[K]): void;
+export declare function set<O extends object, K$1 extends keyof O>(target: O, key: K$1, value: O[K$1]): void;
 
-declare type ShallowOrDeepRef<T = any, D extends boolean = false> = D extends true ? Ref<T> : ShallowRef<T>;
+export declare type ShallowOrDeepRef<T$1 = any, D extends boolean = false> = D extends true ? Ref<T$1> : ShallowRef<T$1>;
 
-export declare type ShallowUnwrapRef<T> = T extends Ref<infer P> ? P : T;
+export declare type ShallowUnwrapRef<T$1> = T$1 extends Ref<infer P> ? P : T$1;
 
-declare type SharedComposableReturn<T extends AnyFn = AnyFn> = T;
+export declare type SharedComposableReturn<T$1 extends AnyFn = AnyFn> = T$1;
 
-export declare interface SingletonPromiseReturn<T> {
-    (): Promise<T>;
+export declare interface SingletonPromiseReturn<T$1> {
+    (): Promise<T$1>;
     /**
      * Reset current staled promise.
      * await it to have proper shutdown.
@@ -837,7 +948,7 @@ export declare interface SingletonPromiseReturn<T> {
     reset: () => Promise<void>;
 }
 
-declare type SpecificFieldPartial<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
+declare type SpecificFieldPartial<T$1, K$1 extends keyof T$1> = Partial<Pick<T$1, K$1>> & Omit<T$1, K$1>;
 
 export declare interface Stoppable<StartFnArgs extends any[] = any[]> {
     /**
@@ -854,15 +965,15 @@ export declare interface Stoppable<StartFnArgs extends any[] = any[]> {
     start: (...args: StartFnArgs) => void;
 }
 
-declare 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>;
+declare type StrictIncludeMap<IncludeType extends 'LR' | 'RL', D extends Exclude<Direction, 'both'>, L, R$1> = (Equal<[IncludeType, D], ['LR', 'ltr']> & Equal<[IncludeType, D], ['RL', 'rtl']>) extends true ? {
+    transform?: SpecificFieldPartial<Pick<Transform<L, R$1>, D>, D>;
 } : {
-    transform: Pick<Transform<L, R>, D>;
+    transform: Pick<Transform<L, R$1>, D>;
 };
 
-declare type StrictIncludeType<IncludeType extends 'LR' | 'RL', D extends Direction, L, R> = D extends 'both' ? {
-    transform: SpecificFieldPartial<Transform<L, R>, IncludeType extends 'LR' ? 'ltr' : 'rtl'>;
-} : D extends Exclude<Direction, 'both'> ? StrictIncludeMap<IncludeType, D, L, R> : never;
+declare type StrictIncludeType<IncludeType extends 'LR' | 'RL', D extends Direction, L, R$1> = D extends 'both' ? {
+    transform: SpecificFieldPartial<Transform<L, R$1>, IncludeType extends 'LR' ? 'ltr' : 'rtl'>;
+} : D extends Exclude<Direction, 'both'> ? StrictIncludeMap<IncludeType, D, L, R$1> : never;
 
 /**
  * Two-way refs synchronization.
@@ -873,9 +984,9 @@ declare type StrictIncludeType<IncludeType extends 'LR' | 'RL', D extends Direct
  * 3. L ⊆ R
  * 4. L ∩ R = ∅
  */
-export 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;
+export declare function syncRef<L, R$1, D extends Direction = 'both'>(left: Ref<L>, right: Ref<R$1>, ...[options]: Equal<L, R$1> extends true ? [options?: SyncRefOptions<L, R$1, D>] : [options: SyncRefOptions<L, R$1, D>]): () => void;
 
-export declare type SyncRefOptions<L, R, D extends Direction> = ConfigurableFlushSync & {
+export declare type SyncRefOptions<L, R$1, D extends Direction> = ConfigurableFlushSync & {
     /**
      * Watch deeply
      *
@@ -894,7 +1005,7 @@ export declare type SyncRefOptions<L, R, D extends Direction> = ConfigurableFlus
      * @default 'both'
      */
     direction?: D;
-} & TransformType<D, L, R>;
+} & TransformType<D, L, R$1>;
 
 /**
  * Keep target ref(s) in sync with the source ref
@@ -902,7 +1013,7 @@ export declare type SyncRefOptions<L, R, D extends Direction> = ConfigurableFlus
  * @param source source ref
  * @param targets
  */
-export declare function syncRefs<T>(source: WatchSource<T>, targets: Ref<T> | Ref<T>[], options?: SyncRefsOptions): vue.WatchHandle;
+export declare function syncRefs<T$1>(source: WatchSource<T$1>, targets: Ref<T$1> | Ref<T$1>[], options?: SyncRefsOptions): vue0.WatchHandle;
 
 export declare interface SyncRefsOptions extends ConfigurableFlushSync {
     /**
@@ -919,6 +1030,12 @@ export declare interface SyncRefsOptions extends ConfigurableFlushSync {
     immediate?: boolean;
 }
 
+/** @deprecated use `refThrottled` instead */
+export declare const throttledRef: typeof refThrottled;
+
+/** @deprecated use `watchThrottled` instead */
+export declare const throttledWatch: typeof watchThrottled;
+
 /**
  * Create an EventFilter that throttle the events
  */
@@ -945,6 +1062,17 @@ export declare interface ThrottleFilterOptions {
     rejectOnCancel?: boolean;
 }
 
+/**
+ * Universal timer handle that works in both browser and Node.js environments
+ */
+export declare type TimerHandle = ReturnType<typeof setTimeout> | undefined;
+
+export declare const timestamp: () => number;
+
+export declare function toArray<T$1>(value: T$1 | readonly T$1[]): readonly T$1[];
+
+export declare function toArray<T$1>(value: T$1 | T$1[]): T$1[];
+
 export declare interface ToDataURLOptions extends UseBase64Options {
     /**
      * MIME type
@@ -956,28 +1084,30 @@ export declare interface ToDataURLOptions extends UseBase64Options {
     quality?: any;
 }
 
+export declare type ToggleFn = (value?: boolean) => void;
+
 /**
  * Converts ref to reactive.
  *
  * @see https://vueuse.org/toReactive
  * @param objectRef A ref of object
  */
-export declare function toReactive<T extends object>(objectRef: MaybeRef<T>): UnwrapNestedRefs<T>;
+export declare function toReactive<T$1 extends object>(objectRef: MaybeRef<T$1>): UnwrapNestedRefs<T$1>;
 
 /**
  * Normalize value/ref/getter to `ref` or `computed`.
  */
-export declare function toRef<T>(r: () => T): Readonly<Ref<T>>;
+export declare function toRef<T$1>(r: () => T$1): Readonly<Ref<T$1>>;
 
-export declare function toRef<T>(r: ComputedRef<T>): ComputedRef<T>;
+export declare function toRef<T$1>(r: ComputedRef<T$1>): ComputedRef<T$1>;
 
-export declare function toRef<T>(r: MaybeRefOrGetter<T>): Ref<T>;
+export declare function toRef<T$1>(r: MaybeRefOrGetter<T$1>): Ref<T$1>;
 
-export declare function toRef<T>(r: T): Ref<T>;
+export declare function toRef<T$1>(r: T$1): Ref<T$1>;
 
-export declare function toRef<T extends object, K extends keyof T>(object: T, key: K): ToRef<T[K]>;
+export declare function toRef<T$1 extends object, K$1 extends keyof T$1>(object: T$1, key: K$1): ToRef<T$1[K$1]>;
 
-export declare function toRef<T extends object, K extends keyof T>(object: T, key: K, defaultValue: T[K]): ToRef<Exclude<T[K], undefined>>;
+export declare function toRef<T$1 extends object, K$1 extends keyof T$1>(object: T$1, key: K$1, defaultValue: T$1[K$1]): ToRef<Exclude<T$1[K$1], undefined>>;
 
 /**
  * Extended `toRefs` that also accepts refs of an object.
@@ -986,7 +1116,7 @@ export declare function toRef<T extends object, K extends keyof T>(object: T, ke
  * @param objectRef A ref or normal object or array.
  * @param options Options
  */
-export declare function toRefs<T extends object>(objectRef: MaybeRef<T>, options?: ToRefsOptions): ToRefs<T>;
+export declare function toRefs<T$1 extends object>(objectRef: MaybeRef<T$1>, options?: ToRefsOptions): ToRefs<T$1>;
 
 export declare interface ToRefsOptions {
     /**
@@ -997,30 +1127,55 @@ export declare interface ToRefsOptions {
     replaceRef?: MaybeRefOrGetter<boolean>;
 }
 
+declare interface Transform<L, R$1> {
+    ltr: (left: L) => R$1;
+    rtl: (right: R$1) => L;
+}
+
+declare type TransformType<D extends Direction, L, R$1> = Equal<L, R$1> extends true ? EqualType<D, L, R$1> : IncludeButNotEqual<L, R$1> extends true ? StrictIncludeType<'LR', D, L, R$1> : IncludeButNotEqual<R$1, L> extends true ? StrictIncludeType<'RL', D, L, R$1> : IntersectButNotEqual<L, R$1> extends true ? IntersectButNotEqualType<D, L, R$1> : NotIntersect<L, R$1> extends true ? NotIntersectType<D, L, R$1> : never;
+
 /**
- * Get the value of value/ref/getter.
+ * Call onBeforeMount() if it's inside a component lifecycle, if not, just call the function
  *
- * @deprecated use `toValue` from `vue` instead
+ * @param fn
+ * @param sync if set to false, it will run in the nextTick() of Vue
+ * @param target
  */
-export declare const toValue: typeof toValue_2;
+export declare function tryOnBeforeMount(fn: Fn, sync?: boolean, target?: ComponentInternalInstance | null): void;
 
-declare interface Transform<L, R> {
-    ltr: (left: L) => R;
-    rtl: (right: R) => L;
-}
+/**
+ * Call onBeforeUnmount() if it's inside a component lifecycle, if not, do nothing
+ *
+ * @param fn
+ * @param target
+ */
+export declare function tryOnBeforeUnmount(fn: Fn, target?: ComponentInternalInstance | null): void;
 
-declare 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;
+/**
+ * Call onMounted() if it's inside a component lifecycle, if not, just call the function
+ *
+ * @param fn
+ * @param sync if set to false, it will run in the nextTick() of Vue
+ * @param target
+ */
+export declare function tryOnMounted(fn: Fn, sync?: boolean, target?: ComponentInternalInstance | null): void;
 
 /**
  * Call onScopeDispose() if it's inside an effect scope lifecycle, if not, do nothing
  *
  * @param fn
  */
-export declare function tryOnScopeDispose(fn: Fn): boolean;
+export declare function tryOnScopeDispose(fn: Fn, failSilently?: boolean): boolean;
 
-export declare type UnrefFn<T> = T extends (...args: infer A) => infer R ? (...args: {
-    [K in keyof A]: MaybeRef<A[K]>;
-}) => R : never;
+/**
+ * Call onUnmounted() if it's inside a component lifecycle, if not, do nothing
+ *
+ * @param fn
+ * @param target
+ */
+export declare function tryOnUnmounted(fn: Fn, target?: ComponentInternalInstance | null): void;
+
+export declare type UnrefFn<T> = T extends ((...args: infer A) => infer R) ? (...args: { [K in keyof A]: MaybeRef<A[K]> }) => R : never;
 
 /**
  * Promised one-time watch for changes
@@ -1035,19 +1190,19 @@ export declare type UnrefFn<T> = T extends (...args: infer A) => infer R ? (...a
  * alert('Counter is now larger than 7!')
  * ```
  */
-export declare function until<T extends unknown[]>(r: WatchSource<T> | MaybeRefOrGetter<T>): UntilArrayInstance<T>;
+export declare function until<T$1 extends unknown[]>(r: WatchSource<T$1> | MaybeRefOrGetter<T$1>): UntilArrayInstance<T$1>;
 
-export declare function until<T>(r: WatchSource<T> | MaybeRefOrGetter<T>): UntilValueInstance<T>;
+export declare function until<T$1>(r: WatchSource<T$1> | MaybeRefOrGetter<T$1>): UntilValueInstance<T$1>;
 
-export declare interface UntilArrayInstance<T> extends UntilBaseInstance<T> {
-    readonly not: UntilArrayInstance<T>;
-    toContains: (value: MaybeRefOrGetter<ElementOf<ShallowUnwrapRef<T>>>, options?: UntilToMatchOptions) => Promise<T>;
+export declare interface UntilArrayInstance<T$1> extends UntilBaseInstance<T$1> {
+    readonly not: UntilArrayInstance<T$1>;
+    toContains: (value: MaybeRefOrGetter<ElementOf<ShallowUnwrapRef<T$1>>>, options?: UntilToMatchOptions) => Promise<T$1>;
 }
 
-declare 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>;
+export declare interface UntilBaseInstance<T$1, Not extends boolean = false> {
+    toMatch: (<U extends T$1 = T$1>(condition: (v: T$1) => v is U, options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T$1, U>> : Promise<U>) & ((condition: (v: T$1) => boolean, options?: UntilToMatchOptions) => Promise<T$1>);
+    changed: (options?: UntilToMatchOptions) => Promise<T$1>;
+    changedTimes: (n?: number, options?: UntilToMatchOptions) => Promise<T$1>;
 }
 
 export declare interface UntilToMatchOptions {
@@ -1069,7 +1224,7 @@ export declare interface UntilToMatchOptions {
      *
      * @default 'sync'
      */
-    flush?: WatchOptions['flush'];
+    flush?: WatchOptionFlush;
     /**
      * `deep` option for internal watch
      *
@@ -1078,22 +1233,22 @@ export declare interface UntilToMatchOptions {
     deep?: WatchOptions['deep'];
 }
 
-export declare 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>;
+export declare interface UntilValueInstance<T$1, Not extends boolean = false> extends UntilBaseInstance<T$1, Not> {
+    readonly not: UntilValueInstance<T$1, Not extends true ? false : true>;
+    toBe: <P = T$1>(value: MaybeRefOrGetter<P>, options?: UntilToMatchOptions) => Not extends true ? Promise<T$1> : Promise<P>;
+    toBeTruthy: (options?: UntilToMatchOptions) => Not extends true ? Promise<T$1 & Falsy> : Promise<Exclude<T$1, Falsy>>;
+    toBeNull: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T$1, null>> : Promise<null>;
+    toBeUndefined: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T$1, undefined>> : Promise<undefined>;
+    toBeNaN: (options?: UntilToMatchOptions) => Promise<T$1>;
 }
 
 export declare type UrlParams = Record<string, string[] | string>;
 
-export declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, key?: keyof T, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
+export declare function useArrayDifference<T$1>(list: MaybeRefOrGetter<T$1[]>, values: MaybeRefOrGetter<T$1[]>, key?: keyof T$1, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T$1>;
 
-export declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, compareFn?: (value: T, othVal: T) => boolean, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
+export declare function useArrayDifference<T$1>(list: MaybeRefOrGetter<T$1[]>, values: MaybeRefOrGetter<T$1[]>, compareFn?: (value: T$1, othVal: T$1) => boolean, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T$1>;
 
-declare interface UseArrayDifferenceOptions {
+export declare interface UseArrayDifferenceOptions {
     /**
      * Returns asymmetric difference
      *
@@ -1103,7 +1258,7 @@ declare interface UseArrayDifferenceOptions {
     symmetric?: boolean;
 }
 
-declare type UseArrayDifferenceReturn<T = any> = ComputedRef<T[]>;
+export declare type UseArrayDifferenceReturn<T$1 = any> = ComputedRef<T$1[]>;
 
 /**
  * Reactive `Array.every`
@@ -1116,9 +1271,9 @@ declare type UseArrayDifferenceReturn<T = any> = ComputedRef<T[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayEvery<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayEveryReturn;
+export declare function useArrayEvery<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => unknown): UseArrayEveryReturn;
 
-declare type UseArrayEveryReturn = ComputedRef<boolean>;
+export declare type UseArrayEveryReturn = ComputedRef<boolean>;
 
 /**
  * Reactive `Array.filter`
@@ -1131,11 +1286,11 @@ declare type UseArrayEveryReturn = ComputedRef<boolean>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayFilter<T, S extends T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => element is S): UseArrayFilterReturn<S>;
+export declare function useArrayFilter<T$1, S$1 extends T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: T$1[]) => element is S$1): UseArrayFilterReturn<S$1>;
 
-export declare function useArrayFilter<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => unknown): UseArrayFilterReturn<T>;
+export declare function useArrayFilter<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: T$1[]) => unknown): UseArrayFilterReturn<T$1>;
 
-declare type UseArrayFilterReturn<T = any> = ComputedRef<T[]>;
+export declare type UseArrayFilterReturn<T$1 = any> = ComputedRef<T$1[]>;
 
 /**
  * Reactive `Array.find`
@@ -1148,7 +1303,7 @@ declare type UseArrayFilterReturn<T = any> = ComputedRef<T[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayFind<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindReturn<T>;
+export declare function useArrayFind<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => boolean): UseArrayFindReturn<T$1>;
 
 /**
  * Reactive `Array.findIndex`
@@ -1161,9 +1316,9 @@ export declare function useArrayFind<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayFindIndex<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayFindIndexReturn;
+export declare function useArrayFindIndex<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => unknown): UseArrayFindIndexReturn;
 
-declare type UseArrayFindIndexReturn = ComputedRef<number>;
+export declare type UseArrayFindIndexReturn = ComputedRef<number>;
 
 /**
  * Reactive `Array.findLast`
@@ -1176,11 +1331,11 @@ declare type UseArrayFindIndexReturn = ComputedRef<number>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayFindLast<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindLastReturn<T>;
+export declare function useArrayFindLast<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => boolean): UseArrayFindLastReturn<T$1>;
 
-declare type UseArrayFindLastReturn<T = any> = ComputedRef<T | undefined>;
+export declare type UseArrayFindLastReturn<T$1 = any> = ComputedRef<T$1 | undefined>;
 
-declare type UseArrayFindReturn<T = any> = ComputedRef<T | undefined>;
+export declare type UseArrayFindReturn<T$1 = any> = ComputedRef<T$1 | undefined>;
 
 /**
  * Reactive `Array.includes`
@@ -1191,20 +1346,20 @@ declare type UseArrayFindReturn<T = any> = ComputedRef<T | undefined>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: UseArrayIncludesComparatorFn<T, V>): UseArrayIncludesReturn;
+export declare function useArrayIncludes<T$1, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, value: MaybeRefOrGetter<V$1>, comparator?: UseArrayIncludesComparatorFn<T$1, V$1>): UseArrayIncludesReturn;
 
-export declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: keyof T): UseArrayIncludesReturn;
+export declare function useArrayIncludes<T$1, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, value: MaybeRefOrGetter<V$1>, comparator?: keyof T$1): UseArrayIncludesReturn;
 
-export declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, options?: UseArrayIncludesOptions<T, V>): UseArrayIncludesReturn;
+export declare function useArrayIncludes<T$1, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, value: MaybeRefOrGetter<V$1>, options?: UseArrayIncludesOptions<T$1, V$1>): UseArrayIncludesReturn;
 
-export declare type UseArrayIncludesComparatorFn<T, V> = ((element: T, value: V, index: number, array: MaybeRefOrGetter<T>[]) => boolean);
+export declare type UseArrayIncludesComparatorFn<T$1, V$1> = ((element: T$1, value: V$1, index: number, array: MaybeRefOrGetter<T$1>[]) => boolean);
 
-export declare interface UseArrayIncludesOptions<T, V> {
+export declare interface UseArrayIncludesOptions<T$1, V$1> {
     fromIndex?: number;
-    comparator?: UseArrayIncludesComparatorFn<T, V> | keyof T;
+    comparator?: UseArrayIncludesComparatorFn<T$1, V$1> | keyof T$1;
 }
 
-declare type UseArrayIncludesReturn = ComputedRef<boolean>;
+export declare type UseArrayIncludesReturn = ComputedRef<boolean>;
 
 /**
  * Reactive `Array.join`
@@ -1219,7 +1374,7 @@ declare type UseArrayIncludesReturn = ComputedRef<boolean>;
  */
 export declare function useArrayJoin(list: MaybeRefOrGetter<MaybeRefOrGetter<any>[]>, separator?: MaybeRefOrGetter<string>): UseArrayJoinReturn;
 
-declare type UseArrayJoinReturn = ComputedRef<string>;
+export declare type UseArrayJoinReturn = ComputedRef<string>;
 
 /**
  * Reactive `Array.map`
@@ -1232,9 +1387,9 @@ declare type UseArrayJoinReturn = ComputedRef<string>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayMap<T, U = T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => U): UseArrayMapReturn<U>;
+export declare function useArrayMap<T$1, U$1 = T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: T$1[]) => U$1): UseArrayMapReturn<U$1>;
 
-declare type UseArrayMapReturn<T = any> = ComputedRef<T[]>;
+export declare type UseArrayMapReturn<T$1 = any> = ComputedRef<T$1[]>;
 
 /**
  * Reactive `Array.reduce`
@@ -1247,7 +1402,7 @@ declare type UseArrayMapReturn<T = any> = ComputedRef<T[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayReduce<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<T, T, T>): ComputedRef<T>;
+export declare function useArrayReduce<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, reducer: UseArrayReducer<T$1, T$1, T$1>): UseArrayReduceReturn<T$1>;
 
 /**
  * Reactive `Array.reduce`
@@ -1261,9 +1416,11 @@ export declare function useArrayReduce<T>(list: MaybeRefOrGetter<MaybeRefOrGette
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayReduce<T, U>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<U, T, U>, initialValue: MaybeRefOrGetter<U>): ComputedRef<U>;
+export declare function useArrayReduce<T$1, U$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, reducer: UseArrayReducer<U$1, T$1, U$1>, initialValue: MaybeRefOrGetter<U$1>): UseArrayReduceReturn<U$1>;
+
+export declare type UseArrayReducer<PV, CV, R$1> = (previousValue: PV, currentValue: CV, currentIndex: number) => R$1;
 
-export declare type UseArrayReducer<PV, CV, R> = (previousValue: PV, currentValue: CV, currentIndex: number) => R;
+export declare type UseArrayReduceReturn<T$1 = any> = ComputedRef<T$1>;
 
 /**
  * Reactive `Array.some`
@@ -1276,9 +1433,9 @@ export declare type UseArrayReducer<PV, CV, R> = (previousValue: PV, currentValu
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArraySome<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArraySomeReturn;
+export declare function useArraySome<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => unknown): UseArraySomeReturn;
 
-declare type UseArraySomeReturn = ComputedRef<boolean>;
+export declare type UseArraySomeReturn = ComputedRef<boolean>;
 
 /**
  * reactive unique array
@@ -1289,9 +1446,9 @@ declare type UseArraySomeReturn = ComputedRef<boolean>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayUnique<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, compareFn?: (a: T, b: T, array: T[]) => boolean): UseArrayUniqueReturn<T>;
+export declare function useArrayUnique<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, compareFn?: (a: T$1, b: T$1, array: T$1[]) => boolean): UseArrayUniqueReturn<T$1>;
 
-declare type UseArrayUniqueReturn<T = any> = ComputedRef<T[]>;
+export declare type UseArrayUniqueReturn<T$1 = any> = ComputedRef<T$1[]>;
 
 /**
  * Asynchronous queue task controller.
@@ -1300,9 +1457,7 @@ declare type UseArrayUniqueReturn<T = any> = ComputedRef<T[]>;
  * @param tasks
  * @param options
  */
-export declare function useAsyncQueue<T extends any[], S = MapQueueTask<T>>(tasks: S & Array<UseAsyncQueueTask<any>>, options?: UseAsyncQueueOptions): UseAsyncQueueReturn<{
-    [P in keyof T]: UseAsyncQueueResult<T[P]>;
-}>;
+export declare function useAsyncQueue<T extends any[], S = MapQueueTask<T>>(tasks: S & Array<UseAsyncQueueTask<any>>, options?: UseAsyncQueueOptions): UseAsyncQueueReturn<{ [P in keyof T]: UseAsyncQueueResult<T[P]> }>;
 
 export declare interface UseAsyncQueueOptions {
     /**
@@ -1456,7 +1611,7 @@ export declare interface UseBase64Return {
  * @param options
  *
  */
-export declare function useBroadcastChannel<D, P>(options: UseBroadcastChannelOptions): UseBroadcastChannelReturn<D, P>;
+export declare function useBroadcastChannel<D, P$1>(options: UseBroadcastChannelOptions): UseBroadcastChannelReturn<D, P$1>;
 
 export declare interface UseBroadcastChannelOptions extends ConfigurableWindow {
     /**
@@ -1465,11 +1620,11 @@ export declare interface UseBroadcastChannelOptions extends ConfigurableWindow {
     name: string;
 }
 
-export declare interface UseBroadcastChannelReturn<D, P> {
+export declare interface UseBroadcastChannelReturn<D, P$1> {
     isSupported: ComputedRef<boolean>;
     channel: Ref<BroadcastChannel | undefined>;
     data: Ref<D>;
-    post: (data: P) => void;
+    post: (data: P$1) => void;
     close: () => void;
     error: ShallowRef<Event | null>;
     isClosed: ShallowRef<boolean>;
@@ -1514,8 +1669,7 @@ export declare type UseBrowserLocationReturn = ReturnType<typeof useBrowserLocat
 
 export declare function useCached<T, D extends boolean = true>(refValue: Ref<T>, comparator?: (a: T, b: T) => boolean, options?: UseCachedOptions<D>): UseCachedReturn<T, D>;
 
-declare interface UseCachedOptions<D extends boolean = true> extends ConfigurableDeepRefs<D>, WatchOptions {
-}
+declare interface UseCachedOptions<D extends boolean = true> extends ConfigurableDeepRefs<D>, WatchOptions {}
 
 declare type UseCachedReturn<T = any, D extends boolean = true> = ShallowOrDeepRef<T, D>;
 
@@ -1559,7 +1713,7 @@ export declare interface UseClonedReturn<T> {
  * @param options
  */
 export declare function useCounter(initialValue?: MaybeRef<number>, options?: UseCounterOptions): {
-    count: Readonly<Ref<number, number> | vue.ShallowRef<number, number> | vue.WritableComputedRef<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;
@@ -1567,11 +1721,44 @@ export declare function useCounter(initialValue?: MaybeRef<number>, options?: Us
     reset: (val?: number) => number;
 };
 
-declare interface UseCounterOptions {
+export declare interface UseCounterOptions {
     min?: number;
     max?: number;
 }
 
+export declare 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;
+}
+
 /**
  * Cycle through a list of items
  *
@@ -1634,6 +1821,9 @@ export declare interface UseDateFormatOptions {
 
 export declare type UseDateFormatReturn = ComputedRef<string>;
 
+/** @deprecated use `refDebounced` instead */
+export declare const useDebounce: typeof refDebounced;
+
 /**
  * Shorthand for [useRefHistory](https://vueuse.org/useRefHistory) with debounce filter.
  *
@@ -1657,30 +1847,30 @@ export declare function useDebouncedRefHistory<Raw, Serialized = Raw>(source: Re
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): UseDebounceFnReturn<T>;
+export declare function useDebounceFn<T$1 extends FunctionArgs>(fn: T$1, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): UseDebounceFnReturn<T$1>;
 
-declare type UseDebounceFnReturn<T extends FunctionArgs> = PromisifyFn<T>;
+export declare type UseDebounceFnReturn<T$1 extends FunctionArgs> = PromisifyFn<T$1>;
 
-export declare function useEventBus<T = unknown, P = any>(key: EventBusIdentifier<T>): UseEventBusReturn<T, P>;
+export declare function useEventBus<T = unknown, P$1 = any>(key: EventBusIdentifier<T>): UseEventBusReturn<T, P$1>;
 
-export declare interface UseEventBusReturn<T, P> {
+export declare interface UseEventBusReturn<T, P$1> {
     /**
      * Subscribe to an event. When calling emit, the listeners will execute.
      * @param listener watch listener.
      * @returns a stop function to remove the current callback.
      */
-    on: (listener: EventBusListener<T, P>) => Fn;
+    on: (listener: EventBusListener<T, P$1>) => Fn;
     /**
      * Similar to `on`, but only fires once
      * @param listener watch listener.
      * @returns a stop function to remove the current callback.
      */
-    once: (listener: EventBusListener<T, P>) => Fn;
+    once: (listener: EventBusListener<T, P$1>) => Fn;
     /**
      * Emit an event, the corresponding event listeners will execute.
      * @param event data sent.
      */
-    emit: (event?: T, payload?: P) => void;
+    emit: (event?: T, payload?: P$1) => void;
     /**
      * Remove the corresponding listener.
      * @param listener watch listener.
@@ -1850,7 +2040,7 @@ declare interface UseIdleOptions extends ConfigurableWindow, ConfigurableEventFi
     initialState?: boolean;
 }
 
-declare interface UseIdleReturn {
+declare interface UseIdleReturn extends Stoppable {
     idle: ShallowRef<boolean>;
     lastActive: ShallowRef<number>;
     reset: () => void;
@@ -1897,7 +2087,7 @@ export declare interface UseIntervalFnOptions {
     immediateCallback?: boolean;
 }
 
-declare type UseIntervalFnReturn = Pausable;
+export declare type UseIntervalFnReturn = Pausable;
 
 export declare interface UseIntervalOptions<Controls extends boolean> {
     /**
@@ -1918,6 +2108,8 @@ export declare interface UseIntervalOptions<Controls extends boolean> {
     callback?: (count: number) => void;
 }
 
+export declare type UseIntervalReturn = Readonly<ShallowRef<number>> | Readonly<UseIntervalControls & Pausable>;
+
 /**
  * Records the timestamp of the last change
  *
@@ -1931,6 +2123,8 @@ export declare interface UseLastChangedOptions<Immediate extends boolean, Initia
     initialValue?: InitialValue;
 }
 
+export declare type UseLastChangedReturn = Readonly<ShallowRef<number | null>> | Readonly<ShallowRef<number>>;
+
 /**
  * Track the change history of a ref, also provides undo and redo functionality.
  *
@@ -2060,7 +2254,7 @@ export declare type UseNowReturn = ReturnType<typeof useNow>;
  * @see https://vueuse.org/useObjectUrl
  * @param object
  */
-export declare function useObjectUrl(object: MaybeRefOrGetter<Blob | MediaSource | null | undefined>): Readonly<vue.Ref<string | undefined, string | undefined>>;
+export declare function useObjectUrl(object: MaybeRefOrGetter<Blob | MediaSource | null | undefined>): Readonly<vue0.Ref<string | undefined, string | undefined>>;
 
 export declare function useOffsetPagination(options: Omit<UseOffsetPaginationOptions, 'total'>): UseOffsetPaginationInfinityPageReturn;
 
@@ -2142,7 +2336,7 @@ export declare interface UseRefHistoryOptions<Raw, Serialized = Raw> extends Con
      *
      * @default 'pre'
      */
-    flush?: 'pre' | 'post' | 'sync';
+    flush?: WatchOptionFlush;
     /**
      * Maximum number of history to be kept. Default to unlimited.
      */
@@ -2213,7 +2407,7 @@ export declare interface UseRefHistoryReturn<Raw, Serialized> extends UseManualR
  * @__NO_SIDE_EFFECTS__
  */
 declare function useShare(shareOptions?: MaybeRefOrGetter<UseShareOptions>, options?: ConfigurableNavigator): {
-    isSupported: vue.ComputedRef<boolean>;
+    isSupported: vue0.ComputedRef<boolean>;
     share: (overrideOptions?: MaybeRefOrGetter<UseShareOptions>) => Promise<void>;
 };
 
@@ -2303,8 +2497,8 @@ export declare interface UseStepperReturn<StepName, Steps, Step> {
 }
 
 declare function useTextareaAutosize(options?: UseTextareaAutosizeOptions): {
-    textarea: vue.Ref<HTMLTextAreaElement | null | undefined, HTMLTextAreaElement | null | undefined>;
-    input: vue.Ref<string, string>;
+    textarea: vue0.Ref<HTMLTextAreaElement | null | undefined, HTMLTextAreaElement | null | undefined>;
+    input: vue0.Ref<string, string>;
     triggerResize: () => void;
 };
 
@@ -2314,7 +2508,7 @@ export declare interface UseTextareaAutosizeOptions extends ConfigurableWindow {
     /** Textarea content. */
     input?: MaybeRef<string>;
     /** Watch sources that should trigger a textarea resize. */
-    watch?: WatchSource | Array<WatchSource>;
+    watch?: WatchSource | MultiWatchSources;
     /** Function called when the textarea size changes. */
     onResize?: () => void;
     /** Specify style target to apply the height based on textarea content. If not provided it will use textarea it self.  */
@@ -2325,6 +2519,9 @@ export declare interface UseTextareaAutosizeOptions extends ConfigurableWindow {
 
 export declare type UseTextareaAutosizeReturn = ReturnType<typeof useTextareaAutosize>;
 
+/** @deprecated use `refThrottled` instead */
+export declare const useThrottle: typeof refThrottled;
+
 /**
  * Shorthand for [useRefHistory](https://vueuse.org/useRefHistory) with throttled filter.
  *
@@ -2360,7 +2557,7 @@ export declare type UseThrottledRefHistoryReturn<Raw, Serialized = Raw> = UseRef
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useThrottleFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): PromisifyFn<T>;
+export declare function useThrottleFn<T$1 extends FunctionArgs>(fn: T$1, ms?: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): PromisifyFn<T$1>;
 
 /**
  * Reactive time ago formatter.
@@ -2448,7 +2645,7 @@ export declare interface UseTimeoutFnOptions {
     immediateCallback?: boolean;
 }
 
-declare type UseTimeoutFnReturn<CallbackFn extends AnyFn> = Stoppable<Parameters<CallbackFn> | []>;
+export declare type UseTimeoutFnReturn<CallbackFn extends AnyFn> = Stoppable<Parameters<CallbackFn> | []>;
 
 export declare interface UseTimeoutOptions<Controls extends boolean> extends UseTimeoutFnOptions {
     /**
@@ -2465,6 +2662,10 @@ export declare interface UseTimeoutOptions<Controls extends boolean> extends Use
 
 export declare function useTimeoutPoll(fn: () => Awaitable<void>, interval: MaybeRefOrGetter<number>, options?: UseTimeoutFnOptions): Pausable;
 
+export declare type UseTimeoutReturn = ComputedRef<boolean> | {
+    readonly ready: ComputedRef<boolean>;
+} & Stoppable;
+
 /**
  * Reactive current timestamp.
  *
@@ -2510,15 +2711,22 @@ export declare interface UseTimestampOptions<Controls extends boolean> {
 
 export declare type UseTimestampReturn = ReturnType<typeof useTimestamp>;
 
-export declare function useToggle<Truthy, Falsy, T = Truthy | Falsy>(initialValue: Ref<T>, options?: UseToggleOptions<Truthy, Falsy>): (value?: T) => T;
+/**
+ * @deprecated use UseTimeoutReturn instead
+ */
+export declare type UseTimoutReturn = UseTimeoutReturn;
+
+export declare function useToggle<Truthy, Falsy$1, T$1 = Truthy | Falsy$1>(initialValue: Ref<T$1>, options?: UseToggleOptions<Truthy, Falsy$1>): (value?: T$1) => T$1;
 
-export declare function useToggle<Truthy = true, Falsy = false, T = Truthy | Falsy>(initialValue?: T, options?: UseToggleOptions<Truthy, Falsy>): [ShallowRef<T>, (value?: T) => T];
+export declare function useToggle<Truthy = true, Falsy$1 = false, T$1 = Truthy | Falsy$1>(initialValue?: T$1, options?: UseToggleOptions<Truthy, Falsy$1>): [ShallowRef<T$1>, (value?: T$1) => T$1];
 
-export declare interface UseToggleOptions<Truthy, Falsy> {
+export declare interface UseToggleOptions<Truthy, Falsy$1> {
     truthyValue?: MaybeRefOrGetter<Truthy>;
-    falsyValue?: MaybeRefOrGetter<Falsy>;
+    falsyValue?: MaybeRefOrGetter<Falsy$1>;
 }
 
+export declare type UseToggleReturn = [ShallowRef<boolean>, ToggleFn] | ToggleFn;
+
 /**
  * Reactively convert a string ref to number.
  *
@@ -2660,9 +2868,11 @@ export declare interface UseWebSocketOptions {
         /**
          * Delay for reconnect, in milliseconds
          *
+         * Or you can pass a function to calculate the delay based on the number of retries.
+         *
          * @default 1000
          */
-        delay?: number;
+        delay?: number | ((retries: number) => number);
         /**
          * On maximum retry times reached.
          */
@@ -2736,7 +2946,7 @@ export declare interface UseWebSocketReturn<T> {
  */
 export declare function useWebWorkerFn<T extends (...fnArgs: any[]) => any>(fn: T, options?: UseWebWorkerOptions): {
     workerFn: (...fnArgs: Parameters<T>) => Promise<ReturnType<T>>;
-    workerStatus: vue.ShallowRef<WebWorkerStatus, WebWorkerStatus>;
+    workerStatus: vue0.ShallowRef<WebWorkerStatus, WebWorkerStatus>;
     workerTerminate: (status?: WebWorkerStatus) => void;
 };
 
@@ -2771,13 +2981,13 @@ export declare interface UseWebWorkerReturn<Data = any> {
  *
  * @see https://vueuse.org/watchArray
  */
-export 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;
+export declare function watchArray<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1[]> | T$1[], cb: WatchArrayCallback<T$1[], Immediate extends true ? T$1[] | undefined : T$1[]>, options?: WatchOptions<Immediate>): vue0.WatchHandle;
 
-export declare type WatchArrayCallback<V = any, OV = any> = (value: V, oldValue: OV, added: V, removed: OV, onCleanup: (cleanupFn: () => void) => void) => any;
+export declare type WatchArrayCallback<V$1 = any, OV = any> = (value: V$1, oldValue: OV, added: V$1, removed: OV, onCleanup: (cleanupFn: () => void) => void) => any;
 
-export 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;
+export declare function watchAtMost<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options: WatchAtMostOptions<Immediate>): WatchAtMostReturn;
 
-export 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;
+export declare function watchAtMost<T$1, Immediate extends Readonly<boolean> = false>(sources: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options: WatchAtMostOptions<Immediate>): WatchAtMostReturn;
 
 export declare interface WatchAtMostOptions<Immediate> extends WatchWithFilterOptions<Immediate> {
     count: MaybeRefOrGetter<number>;
@@ -2785,34 +2995,32 @@ export declare interface WatchAtMostOptions<Immediate> extends WatchWithFilterOp
 
 export declare interface WatchAtMostReturn {
     stop: WatchStopHandle;
+    pause: () => void;
+    resume: () => void;
     count: ShallowRef<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;
+export declare function watchDebounced<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: WatchDebouncedOptions<Immediate>): WatchHandle;
 
-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;
+export declare function watchDebounced<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchDebouncedOptions<Immediate>): WatchHandle;
 
-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;
-export { watchDebounced as debouncedWatch }
-export { watchDebounced }
+export declare function watchDebounced<T$1 extends object, Immediate extends Readonly<boolean> = false>(source: T$1, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchDebouncedOptions<Immediate>): WatchHandle;
 
 export declare interface WatchDebouncedOptions<Immediate> extends WatchOptions<Immediate>, DebounceFilterOptions {
     debounce?: MaybeRefOrGetter<number>;
 }
 
-export 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;
+export declare function watchDeep<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(source: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchHandle;
 
-export 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;
+export declare function watchDeep<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchHandle;
 
-export 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;
+export declare function watchDeep<T$1 extends object, Immediate extends Readonly<boolean> = false>(source: T$1, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchHandle;
 
-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;
+export declare function watchIgnorable<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, 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;
+export declare function watchIgnorable<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, 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;
-export { watchIgnorable as ignorableWatch }
-export { watchIgnorable }
+export declare function watchIgnorable<T$1 extends object, Immediate extends Readonly<boolean> = false>(source: T$1, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
 
 export declare interface WatchIgnorableReturn {
     ignoreUpdates: IgnoredUpdater;
@@ -2820,39 +3028,40 @@ export declare interface WatchIgnorableReturn {
     stop: WatchStopHandle;
 }
 
-export declare function watchImmediate<T extends Readonly<WatchSource<unknown>[]>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
+export declare function watchImmediate<T$1 extends Readonly<MultiWatchSources>>(source: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, true>>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
 
-export declare function watchImmediate<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
+export declare function watchImmediate<T$1>(source: WatchSource<T$1>, cb: WatchCallback<T$1, T$1 | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
 
-export declare function watchImmediate<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
+export declare function watchImmediate<T$1 extends object>(source: T$1, cb: WatchCallback<T$1, T$1 | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
 
-export declare function watchOnce<T extends Readonly<WatchSource<unknown>[]>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'once'>): WatchStopHandle;
+export declare function watchOnce<T$1 extends Readonly<MultiWatchSources>>(source: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, true>>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
 
-export declare function watchOnce<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchStopHandle;
+export declare function watchOnce<T$1>(source: WatchSource<T$1>, cb: WatchCallback<T$1, T$1 | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
 
-export declare function watchOnce<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchStopHandle;
+export declare function watchOnce<T$1 extends object>(source: T$1, cb: WatchCallback<T$1, T$1 | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
 
-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;
+export declare type WatchOptionFlush = WatchOptions['flush'];
 
-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;
+/**
+ * @deprecated This function will be removed in future version.
+ */
+export declare function watchPausable<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
+
+export declare function watchPausable<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, 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;
-export { watchPausable as pausableWatch }
-export { watchPausable }
+export declare function watchPausable<T$1 extends object, Immediate extends Readonly<boolean> = false>(source: T$1, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
 
-declare type WatchPausableOptions<Immediate> = WatchWithFilterOptions<Immediate> & PausableFilterOptions;
+export declare type WatchPausableOptions<Immediate> = WatchWithFilterOptions<Immediate> & PausableFilterOptions;
 
 export declare interface WatchPausableReturn extends Pausable {
     stop: WatchStopHandle;
 }
 
-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;
+export declare function watchThrottled<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: WatchThrottledOptions<Immediate>): WatchHandle;
 
-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;
+export declare function watchThrottled<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchThrottledOptions<Immediate>): WatchHandle;
 
-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;
-export { watchThrottled as throttledWatch }
-export { watchThrottled }
+export declare function watchThrottled<T$1 extends object, Immediate extends Readonly<boolean> = false>(source: T$1, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchThrottledOptions<Immediate>): WatchHandle;
 
 export declare interface WatchThrottledOptions<Immediate> extends WatchOptions<Immediate> {
     throttle?: MaybeRefOrGetter<number>;
@@ -2860,27 +3069,26 @@ export declare interface WatchThrottledOptions<Immediate> extends WatchOptions<I
     leading?: boolean;
 }
 
-export declare function watchTriggerable<T extends Readonly<WatchSource<unknown>[]>, FnReturnT>(sources: [...T], cb: WatchTriggerableCallback<MapSources<T>, MapOldSources<T, true>, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
+export declare function watchTriggerable<T$1 extends Readonly<MultiWatchSources>, FnReturnT>(sources: [...T$1], cb: WatchTriggerableCallback<MapSources<T$1>, MapOldSources<T$1, true>, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
 
-export declare function watchTriggerable<T, FnReturnT>(source: WatchSource<T>, cb: WatchTriggerableCallback<T, T | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
+export declare function watchTriggerable<T$1, FnReturnT>(source: WatchSource<T$1>, cb: WatchTriggerableCallback<T$1, T$1 | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
 
-export declare function watchTriggerable<T extends object, FnReturnT>(source: T, cb: WatchTriggerableCallback<T, T | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
+export declare function watchTriggerable<T$1 extends object, FnReturnT>(source: T$1, cb: WatchTriggerableCallback<T$1, T$1 | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
 
-export declare type WatchTriggerableCallback<V = any, OV = any, R = void> = (value: V, oldValue: OV, onCleanup: OnCleanup) => R;
+export declare type WatchTriggerableCallback<V$1 = any, OV = any, R$1 = void> = (value: V$1, oldValue: OV, onCleanup: OnCleanup) => R$1;
 
 export declare interface WatchTriggerableReturn<FnReturnT = void> extends WatchIgnorableReturn {
     /** Execute `WatchCallback` immediately */
     trigger: () => FnReturnT;
 }
 
-export 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;
+export declare function watchWithFilter<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchHandle;
 
-export 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;
+export declare function watchWithFilter<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchWithFilterOptions<Immediate>): WatchHandle;
 
-export 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;
+export declare function watchWithFilter<T$1 extends object, Immediate extends Readonly<boolean> = false>(source: T$1, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchWithFilterOptions<Immediate>): WatchHandle;
 
-declare interface WatchWithFilterOptions<Immediate> extends WatchOptions<Immediate>, ConfigurableEventFilter {
-}
+export declare interface WatchWithFilterOptions<Immediate> extends WatchOptions<Immediate>, ConfigurableEventFilter {}
 
 declare type WebSocketHeartbeatMessage = string | ArrayBuffer | Blob;
 
@@ -2893,7 +3101,7 @@ export declare type WebWorkerStatus = 'PENDING' | 'SUCCESS' | 'RUNNING' | 'ERROR
  *
  * @see https://vueuse.org/whenever
  */
-export declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WheneverOptions): vue.WatchHandle;
+export declare function whenever<T$1>(source: WatchSource<T$1 | false | null | undefined>, cb: WatchCallback<T$1>, options?: WheneverOptions): vue0.WatchHandle;
 
 export declare interface WheneverOptions extends WatchOptions {
     /**
@@ -2908,17 +3116,16 @@ export declare interface WheneverOptions extends WatchOptions {
 
 declare type WindowEventName = keyof WindowEventMap;
 
-export declare interface WritableComputedInjectOptions<T, K> {
-    get: ComputedInjectGetter<T, K>;
-    set: ComputedInjectSetter<K>;
+export declare interface WritableComputedInjectOptions<T, K$1> {
+    get: ComputedInjectGetter<T, K$1>;
+    set: ComputedInjectSetter<K$1>;
 }
 
-export declare interface WritableComputedInjectOptionsWithDefault<T, K> {
-    get: ComputedInjectGetterWithDefault<T, K>;
-    set: ComputedInjectSetter<K>;
+export declare interface WritableComputedInjectOptionsWithDefault<T, K$1> {
+    get: ComputedInjectGetterWithDefault<T, K$1>;
+    set: ComputedInjectSetter<K$1>;
 }
 
-export declare interface WritableComputedRefWithControl<T> extends WritableComputedRef<T>, ComputedWithControlRefExtra {
-}
+export declare interface WritableComputedRefWithControl<T$1> extends WritableComputedRef<T$1>, ComputedWithControlRefExtra {}
 
 export { }