@vueuse/shared 14.0.0-alpha.1 → 14.0.0-alpha.3

package/dist/index.d.ts

@@ -1,10 +1,13 @@
 import * as vue0 from "vue";
-import { ComputedGetter, ComputedRef, InjectionKey, MaybeRef, MaybeRef as MaybeRef$1, MaybeRefOrGetter, MaybeRefOrGetter as MaybeRefOrGetter$1, Ref, ShallowRef, ShallowUnwrapRef as ShallowUnwrapRef$1, ToRef, ToRefs, UnwrapNestedRefs, UnwrapRef, WatchCallback, WatchOptions, WatchOptionsBase, WatchSource, WatchStopHandle, WritableComputedOptions, WritableComputedRef, inject, toValue as toValue$1 } from "vue";
+import { ComputedGetter, ComputedRef, InjectionKey, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef, ShallowUnwrapRef as ShallowUnwrapRef$1, ToRef, ToRefs, UnwrapNestedRefs, UnwrapRef, WatchCallback, WatchHandle, WatchOptions, WatchOptionsBase, WatchSource, WatchStopHandle, WritableComputedOptions, WritableComputedRef, getCurrentInstance, inject } from "vue";
 
 //#region computedEager/index.d.ts
 type ComputedEagerOptions = WatchOptionsBase;
 type ComputedEagerReturn<T = any> = Readonly<ShallowRef<T>>;
 /**
+ *
+ * @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.
@@ -15,6 +18,8 @@ type ComputedEagerReturn<T = any> = Readonly<ShallowRef<T>>;
  * @returns readonly shallowRef
  */
 declare function computedEager<T>(fn: () => T, options?: ComputedEagerOptions): ComputedEagerReturn<T>;
+/** @deprecated use `computedEager` instead */
+declare const eagerComputed: typeof computedEager;
 //#endregion
 //#region computedWithControl/index.d.ts
 interface ComputedWithControlRefExtra {
@@ -28,6 +33,8 @@ interface WritableComputedRefWithControl<T> extends WritableComputedRef<T>, Comp
 type ComputedWithControlRef<T = any> = ComputedRefWithControl<T> | WritableComputedRefWithControl<T>;
 declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: ComputedGetter<T>, options?: WatchOptions): ComputedRefWithControl<T>;
 declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: WritableComputedOptions<T>, options?: WatchOptions): WritableComputedRefWithControl<T>;
+/** @deprecated use `computedWithControl` instead */
+declare const controlledComputed: typeof computedWithControl;
 //#endregion
 //#region utils/types.d.ts
 /**
@@ -103,13 +110,14 @@ interface Stoppable<StartFnArgs extends any[] = any[]> {
    */
   start: (...args: StartFnArgs) => void;
 }
+type WatchOptionFlush = WatchOptions['flush'];
 interface ConfigurableFlush {
   /**
    * Timing for monitoring changes, refer to WatchOptions for more details
    *
    * @default 'pre'
    */
-  flush?: WatchOptions['flush'];
+  flush?: WatchOptionFlush;
 }
 interface ConfigurableFlushSync {
   /**
@@ -118,7 +126,7 @@ interface ConfigurableFlushSync {
    *
    * @default 'sync'
    */
-  flush?: WatchOptions['flush'];
+  flush?: WatchOptionFlush;
 }
 type MultiWatchSources = (WatchSource<unknown> | object)[];
 type MapSources<T> = { [K in keyof T]: T[K] extends WatchSource<infer V> ? V : never };
@@ -133,6 +141,7 @@ type IsAny<T> = IfAny<T, true, false>;
  * Universal timer handle that works in both browser and Node.js environments
  */
 type TimerHandle = ReturnType<typeof setTimeout> | undefined;
+type InstanceProxy = NonNullable<NonNullable<ReturnType<typeof getCurrentInstance>>['proxy']>;
 //#endregion
 //#region createEventHook/index.d.ts
 type Callback<T> = IsAny<T> extends true ? (...param: any) => void : ([T] extends [void] ? (...param: unknown[]) => void : [T] extends [any[]] ? (...param: T) => void : (...param: [T, ...unknown[]]) => void);
@@ -178,7 +187,7 @@ interface DebounceFilterOptions {
    * The maximum time allowed to be delayed before it's invoked.
    * In milliseconds.
    */
-  maxWait?: MaybeRefOrGetter$1<number>;
+  maxWait?: MaybeRefOrGetter<number>;
   /**
    * Whether to reject the last call if it's been cancel.
    *
@@ -194,12 +203,12 @@ declare const bypassFilter: EventFilter;
 /**
  * Create an EventFilter that debounce the events
  */
-declare function debounceFilter(ms: MaybeRefOrGetter$1<number>, options?: DebounceFilterOptions): EventFilter<any[], any, AnyFn>;
+declare function debounceFilter(ms: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): EventFilter<any[], any, AnyFn>;
 interface ThrottleFilterOptions {
   /**
    * The maximum time allowed to be delayed before it's invoked.
    */
-  delay: MaybeRefOrGetter$1<number>;
+  delay: MaybeRefOrGetter<number>;
   /**
    * Whether to invoke on the trailing edge of the timeout.
    */
@@ -216,7 +225,7 @@ interface ThrottleFilterOptions {
 /**
  * Create an EventFilter that throttle the events
  */
-declare function throttleFilter(ms: MaybeRefOrGetter$1<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): EventFilter;
+declare function throttleFilter(ms: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): EventFilter;
 declare function throttleFilter(options: ThrottleFilterOptions): EventFilter;
 interface PausableFilterOptions {
   /**
@@ -401,8 +410,8 @@ declare function extendRef<R extends Ref<any>, Extend extends object, Options ex
 /**
  * Shorthand for accessing `ref.value`
  */
-declare function get<T>(ref: MaybeRef$1<T>): T;
-declare function get<T, K extends keyof T>(ref: MaybeRef$1<T>, key: K): T[K];
+declare function get<T>(ref: MaybeRef<T>): T;
+declare function get<T, K extends keyof T>(ref: MaybeRef<T>, key: K): T[K];
 //#endregion
 //#region injectLocal/index.d.ts
 /**
@@ -427,6 +436,9 @@ declare function isDefined<T>(v: T): v is Exclude<T, null | undefined>;
 //#region makeDestructurable/index.d.ts
 declare function makeDestructurable<T extends Record<string, unknown>, A extends readonly any[]>(obj: T, arr: A): T & A;
 //#endregion
+//#region provideLocal/map.d.ts
+type LocalProvidedKey<T> = InjectionKey<T> | string | number;
+//#endregion
 //#region provideLocal/index.d.ts
 type ProvideLocalReturn = void;
 /**
@@ -438,10 +450,10 @@ type ProvideLocalReturn = void;
  * const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
  * ```
  */
-declare function provideLocal<T, K = InjectionKey<T> | string | number>(key: K, value: K extends InjectionKey<infer V> ? V : T): ProvideLocalReturn;
+declare function provideLocal<T, K = LocalProvidedKey<T>>(key: K, value: K extends InjectionKey<infer V> ? V : T): ProvideLocalReturn;
 //#endregion
 //#region reactify/index.d.ts
-type Reactified<T, Computed extends boolean> = T extends ((...args: infer A) => infer R) ? (...args: { [K in keyof A]: Computed extends true ? MaybeRefOrGetter$1<A[K]> : MaybeRef$1<A[K]> }) => ComputedRef<R> : never;
+type Reactified<T, Computed extends boolean> = T extends ((...args: infer A) => infer R) ? (...args: { [K in keyof A]: Computed extends true ? MaybeRefOrGetter<A[K]> : MaybeRef<A[K]> }) => ComputedRef<R> : never;
 type ReactifyReturn<T extends AnyFn = AnyFn, K extends boolean = true> = Reactified<T, K>;
 interface ReactifyOptions<T extends boolean> {
   /**
@@ -462,6 +474,8 @@ interface ReactifyOptions<T extends boolean> {
  * @__NO_SIDE_EFFECTS__
  */
 declare function reactify<T extends AnyFn, K extends boolean = true>(fn: T, options?: ReactifyOptions<K>): ReactifyReturn<T, K>;
+/** @deprecated use `reactify` instead */
+declare const createReactiveFn: typeof reactify;
 //#endregion
 //#region reactifyObject/index.d.ts
 type ReactifyNested<T, Keys extends keyof T = keyof T, S extends boolean = true> = { [K in Keys]: T[K] extends AnyFn ? Reactified<T[K], S> : T[K] };
@@ -510,7 +524,9 @@ type RefAutoResetReturn<T = any> = Ref<T>;
  * @param defaultValue The value which will be set.
  * @param afterMs      A zero-or-greater delay in milliseconds.
  */
-declare function refAutoReset<T>(defaultValue: MaybeRefOrGetter$1<T>, afterMs?: MaybeRefOrGetter$1<number>): RefAutoResetReturn<T>;
+declare function refAutoReset<T>(defaultValue: MaybeRefOrGetter<T>, afterMs?: MaybeRefOrGetter<number>): RefAutoResetReturn<T>;
+/** @deprecated use `refAutoReset` instead */
+declare const autoResetRef: typeof refAutoReset;
 //#endregion
 //#region refDebounced/index.d.ts
 type RefDebouncedReturn<T = any> = Readonly<Ref<T>>;
@@ -519,7 +535,11 @@ type RefDebouncedReturn<T = any> = Readonly<Ref<T>>;
  *
  * @return A new debounced ref.
  */
-declare function refDebounced<T>(value: Ref<T>, ms?: MaybeRefOrGetter$1<number>, options?: DebounceFilterOptions): RefDebouncedReturn<T>;
+declare function refDebounced<T>(value: Ref<T>, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): RefDebouncedReturn<T>;
+/** @deprecated use `refDebounced` instead */
+declare const debouncedRef: typeof refDebounced;
+/** @deprecated use `refDebounced` instead */
+declare const useDebounce: typeof refDebounced;
 //#endregion
 //#region refDefault/index.d.ts
 /**
@@ -529,6 +549,24 @@ declare function refDebounced<T>(value: Ref<T>, ms?: MaybeRefOrGetter$1<number>,
  */
 declare function refDefault<T>(source: Ref<T | undefined | null>, defaultValue: T): Ref<T>;
 //#endregion
+//#region refManualReset/index.d.ts
+/**
+ * Define the shape of a ref that supports manual reset functionality.
+ *
+ * This interface extends the standard `Ref` type from Vue and adds a `reset` method.
+ * The `reset` method allows the ref to be manually reset to its default value.
+ */
+interface ManualResetRefReturn<T> extends Ref<T> {
+  reset: Fn$1;
+}
+/**
+ * Create a ref with manual reset functionality.
+ *
+ * @see https://vueuse.org/refManualReset
+ * @param defaultValue The value which will be set.
+ */
+declare function refManualReset<T>(defaultValue: MaybeRefOrGetter<T>): ManualResetRefReturn<T>;
+//#endregion
 //#region refThrottled/index.d.ts
 type RefThrottledReturn<T = any> = Ref<T>;
 /**
@@ -541,6 +579,10 @@ type RefThrottledReturn<T = any> = Ref<T>;
  * @param leading if true, update the value on the leading edge of the ms timeout
  */
 declare function refThrottled<T = any>(value: Ref<T>, delay?: number, trailing?: boolean, leading?: boolean): RefThrottledReturn<T>;
+/** @deprecated use `refThrottled` instead */
+declare const throttledRef: typeof refThrottled;
+/** @deprecated use `refThrottled` instead */
+declare const useThrottle: typeof refThrottled;
 //#endregion
 //#region refWithControl/index.d.ts
 interface ControlledRefOptions<T> {
@@ -570,9 +612,7 @@ declare function refWithControl<T>(initial: T, options?: ControlledRefOptions<T>
   peek: () => T;
   lay: (v: T) => void;
 }> & vue0.Ref<T, T>;
-/**
- * Alias for `refWithControl`
- */
+/** @deprecated use `refWithControl` instead */
 declare const controlledRef: typeof refWithControl;
 //#endregion
 //#region set/index.d.ts
@@ -681,7 +721,7 @@ declare function syncRefs<T>(source: WatchSource<T>, targets: Ref<T> | Ref<T>[],
  * @see https://vueuse.org/toReactive
  * @param objectRef A ref of object
  */
-declare function toReactive<T extends object>(objectRef: MaybeRef$1<T>): UnwrapNestedRefs<T>;
+declare function toReactive<T extends object>(objectRef: MaybeRef<T>): UnwrapNestedRefs<T>;
 //#endregion
 //#region toRef/index.d.ts
 /**
@@ -689,14 +729,10 @@ declare function toReactive<T extends object>(objectRef: MaybeRef$1<T>): UnwrapN
  */
 declare function toRef<T>(r: () => T): Readonly<Ref<T>>;
 declare function toRef<T>(r: ComputedRef<T>): ComputedRef<T>;
-declare function toRef<T>(r: MaybeRefOrGetter$1<T>): Ref<T>;
+declare function toRef<T>(r: MaybeRefOrGetter<T>): Ref<T>;
 declare function toRef<T>(r: T): Ref<T>;
 declare function toRef<T extends object, K extends keyof T>(object: T, key: K): ToRef<T[K]>;
 declare function toRef<T extends object, K extends keyof T>(object: T, key: K, defaultValue: T[K]): ToRef<Exclude<T[K], undefined>>;
-/**
- * @deprecated use `toRef` instead
- */
-declare const resolveRef: typeof toRef;
 //#endregion
 //#region toRefs/index.d.ts
 interface ToRefsOptions {
@@ -705,7 +741,7 @@ interface ToRefsOptions {
    *
    * @default true
    */
-  replaceRef?: MaybeRefOrGetter$1<boolean>;
+  replaceRef?: MaybeRefOrGetter<boolean>;
 }
 /**
  * Extended `toRefs` that also accepts refs of an object.
@@ -714,19 +750,7 @@ interface ToRefsOptions {
  * @param objectRef A ref or normal object or array.
  * @param options Options
  */
-declare function toRefs<T extends object>(objectRef: MaybeRef$1<T>, options?: ToRefsOptions): ToRefs<T>;
-//#endregion
-//#region toValue/index.d.ts
-/**
- * Get the value of value/ref/getter.
- *
- * @deprecated use `toValue` from `vue` instead
- */
-declare const toValue: typeof toValue$1;
-/**
- * @deprecated use `toValue` instead
- */
-declare const resolveUnref: typeof toValue$1;
+declare function toRefs<T extends object>(objectRef: MaybeRef<T>, options?: ToRefsOptions): ToRefs<T>;
 //#endregion
 //#region tryOnBeforeMount/index.d.ts
 /**
@@ -794,7 +818,7 @@ interface UntilToMatchOptions {
    *
    * @default 'sync'
    */
-  flush?: WatchOptions['flush'];
+  flush?: WatchOptionFlush;
   /**
    * `deep` option for internal watch
    *
@@ -810,7 +834,7 @@ interface UntilBaseInstance<T, Not extends boolean = false> {
 type Falsy$1 = false | void | null | undefined | 0 | 0n | '';
 interface UntilValueInstance<T, Not extends boolean = false> extends UntilBaseInstance<T, Not> {
   readonly not: UntilValueInstance<T, Not extends true ? false : true>;
-  toBe: <P = T>(value: MaybeRefOrGetter$1<P>, options?: UntilToMatchOptions) => Not extends true ? Promise<T> : Promise<P>;
+  toBe: <P = T>(value: MaybeRefOrGetter<P>, options?: UntilToMatchOptions) => Not extends true ? Promise<T> : Promise<P>;
   toBeTruthy: (options?: UntilToMatchOptions) => Not extends true ? Promise<T & Falsy$1> : Promise<Exclude<T, Falsy$1>>;
   toBeNull: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, null>> : Promise<null>;
   toBeUndefined: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, undefined>> : Promise<undefined>;
@@ -818,7 +842,7 @@ interface UntilValueInstance<T, Not extends boolean = false> extends UntilBaseIn
 }
 interface UntilArrayInstance<T> extends UntilBaseInstance<T> {
   readonly not: UntilArrayInstance<T>;
-  toContains: (value: MaybeRefOrGetter$1<ElementOf<ShallowUnwrapRef<T>>>, options?: UntilToMatchOptions) => Promise<T>;
+  toContains: (value: MaybeRefOrGetter<ElementOf<ShallowUnwrapRef<T>>>, options?: UntilToMatchOptions) => Promise<T>;
 }
 /**
  * Promised one-time watch for changes
@@ -833,8 +857,8 @@ interface UntilArrayInstance<T> extends UntilBaseInstance<T> {
  * alert('Counter is now larger than 7!')
  * ```
  */
-declare function until<T extends unknown[]>(r: WatchSource<T> | MaybeRefOrGetter$1<T>): UntilArrayInstance<T>;
-declare function until<T>(r: WatchSource<T> | MaybeRefOrGetter$1<T>): UntilValueInstance<T>;
+declare function until<T extends unknown[]>(r: WatchSource<T> | MaybeRefOrGetter<T>): UntilArrayInstance<T>;
+declare function until<T>(r: WatchSource<T> | MaybeRefOrGetter<T>): UntilValueInstance<T>;
 //#endregion
 //#region useArrayDifference/index.d.ts
 interface UseArrayDifferenceOptions {
@@ -847,8 +871,8 @@ interface UseArrayDifferenceOptions {
   symmetric?: boolean;
 }
 type UseArrayDifferenceReturn<T = any> = ComputedRef<T[]>;
-declare function useArrayDifference<T>(list: MaybeRefOrGetter$1<T[]>, values: MaybeRefOrGetter$1<T[]>, key?: keyof T, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
-declare function useArrayDifference<T>(list: MaybeRefOrGetter$1<T[]>, values: MaybeRefOrGetter$1<T[]>, compareFn?: (value: T, othVal: T) => boolean, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
+declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, key?: keyof T, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
+declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, compareFn?: (value: T, othVal: T) => boolean, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
 //#endregion
 //#region useArrayEvery/index.d.ts
 type UseArrayEveryReturn = ComputedRef<boolean>;
@@ -863,7 +887,7 @@ type UseArrayEveryReturn = ComputedRef<boolean>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayEvery<T>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter$1<T>[]) => unknown): UseArrayEveryReturn;
+declare function useArrayEvery<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayEveryReturn;
 //#endregion
 //#region useArrayFilter/index.d.ts
 type UseArrayFilterReturn<T = any> = ComputedRef<T[]>;
@@ -878,8 +902,8 @@ type UseArrayFilterReturn<T = any> = ComputedRef<T[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayFilter<T, S extends T>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, fn: (element: T, index: number, array: T[]) => element is S): UseArrayFilterReturn<S>;
-declare function useArrayFilter<T>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, fn: (element: T, index: number, array: T[]) => unknown): UseArrayFilterReturn<T>;
+declare function useArrayFilter<T, S extends T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => element is S): UseArrayFilterReturn<S>;
+declare function useArrayFilter<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => unknown): UseArrayFilterReturn<T>;
 //#endregion
 //#region useArrayFind/index.d.ts
 type UseArrayFindReturn<T = any> = ComputedRef<T | undefined>;
@@ -894,7 +918,7 @@ type UseArrayFindReturn<T = any> = ComputedRef<T | undefined>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayFind<T>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter$1<T>[]) => boolean): UseArrayFindReturn<T>;
+declare function useArrayFind<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindReturn<T>;
 //#endregion
 //#region useArrayFindIndex/index.d.ts
 type UseArrayFindIndexReturn = ComputedRef<number>;
@@ -909,7 +933,7 @@ type UseArrayFindIndexReturn = ComputedRef<number>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayFindIndex<T>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter$1<T>[]) => unknown): UseArrayFindIndexReturn;
+declare function useArrayFindIndex<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayFindIndexReturn;
 //#endregion
 //#region useArrayFindLast/index.d.ts
 type UseArrayFindLastReturn<T = any> = ComputedRef<T | undefined>;
@@ -924,10 +948,10 @@ type UseArrayFindLastReturn<T = any> = ComputedRef<T | undefined>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayFindLast<T>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter$1<T>[]) => boolean): UseArrayFindLastReturn<T>;
+declare function useArrayFindLast<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindLastReturn<T>;
 //#endregion
 //#region useArrayIncludes/index.d.ts
-type UseArrayIncludesComparatorFn<T, V> = ((element: T, value: V, index: number, array: MaybeRefOrGetter$1<T>[]) => boolean);
+type UseArrayIncludesComparatorFn<T, V> = ((element: T, value: V, index: number, array: MaybeRefOrGetter<T>[]) => boolean);
 interface UseArrayIncludesOptions<T, V> {
   fromIndex?: number;
   comparator?: UseArrayIncludesComparatorFn<T, V> | keyof T;
@@ -942,9 +966,9 @@ type UseArrayIncludesReturn = ComputedRef<boolean>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, value: MaybeRefOrGetter$1<V>, comparator?: UseArrayIncludesComparatorFn<T, V>): UseArrayIncludesReturn;
-declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, value: MaybeRefOrGetter$1<V>, comparator?: keyof T): UseArrayIncludesReturn;
-declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, value: MaybeRefOrGetter$1<V>, options?: UseArrayIncludesOptions<T, V>): UseArrayIncludesReturn;
+declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: UseArrayIncludesComparatorFn<T, V>): UseArrayIncludesReturn;
+declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: keyof T): UseArrayIncludesReturn;
+declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, options?: UseArrayIncludesOptions<T, V>): UseArrayIncludesReturn;
 //#endregion
 //#region useArrayJoin/index.d.ts
 type UseArrayJoinReturn = ComputedRef<string>;
@@ -959,7 +983,7 @@ type UseArrayJoinReturn = ComputedRef<string>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayJoin(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<any>[]>, separator?: MaybeRefOrGetter$1<string>): UseArrayJoinReturn;
+declare function useArrayJoin(list: MaybeRefOrGetter<MaybeRefOrGetter<any>[]>, separator?: MaybeRefOrGetter<string>): UseArrayJoinReturn;
 //#endregion
 //#region useArrayMap/index.d.ts
 type UseArrayMapReturn<T = any> = ComputedRef<T[]>;
@@ -974,7 +998,7 @@ type UseArrayMapReturn<T = any> = ComputedRef<T[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayMap<T, U = T>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, fn: (element: T, index: number, array: T[]) => U): UseArrayMapReturn<U>;
+declare function useArrayMap<T, U = T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => U): UseArrayMapReturn<U>;
 //#endregion
 //#region useArrayReduce/index.d.ts
 type UseArrayReducer<PV, CV, R> = (previousValue: PV, currentValue: CV, currentIndex: number) => R;
@@ -989,7 +1013,7 @@ type UseArrayReducer<PV, CV, R> = (previousValue: PV, currentValue: CV, currentI
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayReduce<T>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, reducer: UseArrayReducer<T, T, T>): ComputedRef<T>;
+declare function useArrayReduce<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<T, T, T>): ComputedRef<T>;
 /**
  * Reactive `Array.reduce`
  *
@@ -1002,7 +1026,7 @@ declare function useArrayReduce<T>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayReduce<T, U>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, reducer: UseArrayReducer<U, T, U>, initialValue: MaybeRefOrGetter$1<U>): ComputedRef<U>;
+declare function useArrayReduce<T, U>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<U, T, U>, initialValue: MaybeRefOrGetter<U>): ComputedRef<U>;
 //#endregion
 //#region useArraySome/index.d.ts
 type UseArraySomeReturn = ComputedRef<boolean>;
@@ -1017,7 +1041,7 @@ type UseArraySomeReturn = ComputedRef<boolean>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArraySome<T>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter$1<T>[]) => unknown): UseArraySomeReturn;
+declare function useArraySome<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArraySomeReturn;
 //#endregion
 //#region useArrayUnique/index.d.ts
 type UseArrayUniqueReturn<T = any> = ComputedRef<T[]>;
@@ -1030,7 +1054,7 @@ type UseArrayUniqueReturn<T = any> = ComputedRef<T[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayUnique<T>(list: MaybeRefOrGetter$1<MaybeRefOrGetter$1<T>[]>, compareFn?: (a: T, b: T, array: T[]) => boolean): UseArrayUniqueReturn<T>;
+declare function useArrayUnique<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, compareFn?: (a: T, b: T, array: T[]) => boolean): UseArrayUniqueReturn<T>;
 //#endregion
 //#region useCounter/index.d.ts
 interface UseCounterOptions {
@@ -1076,7 +1100,7 @@ interface UseCounterReturn {
  * @param [initialValue]
  * @param options
  */
-declare function useCounter(initialValue?: MaybeRef$1<number>, options?: UseCounterOptions): {
+declare function useCounter(initialValue?: MaybeRef<number>, options?: UseCounterOptions): {
   count: Readonly<Ref<number, number> | vue0.ShallowRef<number, number> | vue0.WritableComputedRef<number, number>>;
   inc: (delta?: number) => number;
   dec: (delta?: number) => number;
@@ -1093,7 +1117,7 @@ interface UseDateFormatOptions {
    *
    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument).
    */
-  locales?: MaybeRefOrGetter$1<Intl.LocalesArgument>;
+  locales?: MaybeRefOrGetter<Intl.LocalesArgument>;
   /**
    * A custom function to re-modify the way to display meridiem
    *
@@ -1113,7 +1137,7 @@ type UseDateFormatReturn = ComputedRef<string>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useDateFormat(date: MaybeRefOrGetter$1<DateLike>, formatStr?: MaybeRefOrGetter$1<string>, options?: UseDateFormatOptions): UseDateFormatReturn;
+declare function useDateFormat(date: MaybeRefOrGetter<DateLike>, formatStr?: MaybeRefOrGetter<string>, options?: UseDateFormatOptions): UseDateFormatReturn;
 //#endregion
 //#region useDebounceFn/index.d.ts
 type UseDebounceFnReturn<T extends FunctionArgs> = PromisifyFn<T>;
@@ -1129,7 +1153,7 @@ type UseDebounceFnReturn<T extends FunctionArgs> = PromisifyFn<T>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter$1<number>, options?: DebounceFilterOptions): UseDebounceFnReturn<T>;
+declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): UseDebounceFnReturn<T>;
 //#endregion
 //#region useInterval/index.d.ts
 interface UseIntervalOptions<Controls extends boolean> {
@@ -1162,8 +1186,8 @@ type UseIntervalReturn = Readonly<ShallowRef<number>> | Readonly<UseIntervalCont
  * @param interval
  * @param options
  */
-declare function useInterval(interval?: MaybeRefOrGetter$1<number>, options?: UseIntervalOptions<false>): Readonly<ShallowRef<number>>;
-declare function useInterval(interval: MaybeRefOrGetter$1<number>, options: UseIntervalOptions<true>): Readonly<UseIntervalControls & Pausable>;
+declare function useInterval(interval?: MaybeRefOrGetter<number>, options?: UseIntervalOptions<false>): Readonly<ShallowRef<number>>;
+declare function useInterval(interval: MaybeRefOrGetter<number>, options: UseIntervalOptions<true>): Readonly<UseIntervalControls & Pausable>;
 //#endregion
 //#region useIntervalFn/index.d.ts
 interface UseIntervalFnOptions {
@@ -1189,7 +1213,7 @@ type UseIntervalFnReturn = Pausable;
  * @param interval
  * @param options
  */
-declare function useIntervalFn(cb: Fn$1, interval?: MaybeRefOrGetter$1<number>, options?: UseIntervalFnOptions): UseIntervalFnReturn;
+declare function useIntervalFn(cb: Fn$1, interval?: MaybeRefOrGetter<number>, options?: UseIntervalFnOptions): UseIntervalFnReturn;
 //#endregion
 //#region useLastChanged/index.d.ts
 interface UseLastChangedOptions<Immediate extends boolean, InitialValue extends number | null | undefined = undefined> extends WatchOptions<Immediate> {
@@ -1224,7 +1248,7 @@ declare function useLastChanged(source: WatchSource, options: UseLastChangedOpti
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useThrottleFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter$1<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): PromisifyFn<T>;
+declare function useThrottleFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): PromisifyFn<T>;
 //#endregion
 //#region useTimeoutFn/index.d.ts
 interface UseTimeoutFnOptions {
@@ -1249,7 +1273,7 @@ type UseTimeoutFnReturn<CallbackFn extends AnyFn> = Stoppable<Parameters<Callbac
  * @param interval
  * @param options
  */
-declare function useTimeoutFn<CallbackFn extends AnyFn>(cb: CallbackFn, interval: MaybeRefOrGetter$1<number>, options?: UseTimeoutFnOptions): UseTimeoutFnReturn<CallbackFn>;
+declare function useTimeoutFn<CallbackFn extends AnyFn>(cb: CallbackFn, interval: MaybeRefOrGetter<number>, options?: UseTimeoutFnOptions): UseTimeoutFnReturn<CallbackFn>;
 //#endregion
 //#region useTimeout/index.d.ts
 interface UseTimeoutOptions<Controls extends boolean> extends UseTimeoutFnOptions {
@@ -1274,8 +1298,8 @@ type UseTimoutReturn = ComputedRef<boolean> | {
  * @param interval
  * @param options
  */
-declare function useTimeout(interval?: MaybeRefOrGetter$1<number>, options?: UseTimeoutOptions<false>): ComputedRef<boolean>;
-declare function useTimeout(interval: MaybeRefOrGetter$1<number>, options: UseTimeoutOptions<true>): {
+declare function useTimeout(interval?: MaybeRefOrGetter<number>, options?: UseTimeoutOptions<false>): ComputedRef<boolean>;
+declare function useTimeout(interval: MaybeRefOrGetter<number>, options: UseTimeoutOptions<true>): {
   ready: ComputedRef<boolean>;
 } & Stoppable;
 //#endregion
@@ -1306,7 +1330,7 @@ interface UseToNumberOptions {
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useToNumber(value: MaybeRefOrGetter$1<number | string>, options?: UseToNumberOptions): ComputedRef<number>;
+declare function useToNumber(value: MaybeRefOrGetter<number | string>, options?: UseToNumberOptions): ComputedRef<number>;
 //#endregion
 //#region useToString/index.d.ts
 /**
@@ -1316,14 +1340,14 @@ declare function useToNumber(value: MaybeRefOrGetter$1<number | string>, options
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useToString(value: MaybeRefOrGetter$1<unknown>): ComputedRef<string>;
+declare function useToString(value: MaybeRefOrGetter<unknown>): ComputedRef<string>;
 //#endregion
 //#region useToggle/index.d.ts
 type ToggleFn = (value?: boolean) => void;
 type UseToggleReturn = [ShallowRef<boolean>, ToggleFn] | ToggleFn;
 interface UseToggleOptions<Truthy, Falsy> {
-  truthyValue?: MaybeRefOrGetter$1<Truthy>;
-  falsyValue?: MaybeRefOrGetter$1<Falsy>;
+  truthyValue?: MaybeRefOrGetter<Truthy>;
+  falsyValue?: MaybeRefOrGetter<Falsy>;
 }
 declare function useToggle<Truthy, Falsy, T = Truthy | Falsy>(initialValue: Ref<T>, options?: UseToggleOptions<Truthy, Falsy>): (value?: T) => T;
 declare function useToggle<Truthy = true, Falsy = false, T = Truthy | Falsy>(initialValue?: T, options?: UseToggleOptions<Truthy, Falsy>): [ShallowRef<T>, (value?: T) => T];
@@ -1339,16 +1363,18 @@ declare function watchArray<T, Immediate extends Readonly<boolean> = false>(sour
 //#endregion
 //#region watchWithFilter/index.d.ts
 interface WatchWithFilterOptions<Immediate> extends WatchOptions<Immediate>, ConfigurableEventFilter {}
-declare function watchWithFilter<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchStopHandle;
-declare function watchWithFilter<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchStopHandle;
-declare function watchWithFilter<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchStopHandle;
+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>): WatchHandle;
+declare function watchWithFilter<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchHandle;
+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>): WatchHandle;
 //#endregion
 //#region watchAtMost/index.d.ts
 interface WatchAtMostOptions<Immediate> extends WatchWithFilterOptions<Immediate> {
-  count: MaybeRefOrGetter$1<number>;
+  count: MaybeRefOrGetter<number>;
 }
 interface WatchAtMostReturn {
   stop: WatchStopHandle;
+  pause: () => void;
+  resume: () => void;
   count: ShallowRef<number>;
 }
 declare function watchAtMost<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options: WatchAtMostOptions<Immediate>): WatchAtMostReturn;
@@ -1356,16 +1382,18 @@ declare function watchAtMost<T, Immediate extends Readonly<boolean> = false>(sou
 //#endregion
 //#region watchDebounced/index.d.ts
 interface WatchDebouncedOptions<Immediate> extends WatchOptions<Immediate>, DebounceFilterOptions {
-  debounce?: MaybeRefOrGetter$1<number>;
+  debounce?: MaybeRefOrGetter<number>;
 }
-declare function watchDebounced<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchDebouncedOptions<Immediate>): WatchStopHandle;
-declare function watchDebounced<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchDebouncedOptions<Immediate>): WatchStopHandle;
-declare function watchDebounced<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchDebouncedOptions<Immediate>): WatchStopHandle;
+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>): 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>): 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>): WatchHandle;
+/** @deprecated use `watchDebounced` instead */
+declare const debouncedWatch: typeof watchDebounced;
 //#endregion
 //#region watchDeep/index.d.ts
-declare function watchDeep<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchStopHandle;
-declare function watchDeep<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchStopHandle;
-declare function watchDeep<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchStopHandle;
+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'>): WatchHandle;
+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'>): WatchHandle;
+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'>): WatchHandle;
 //#endregion
 //#region watchIgnorable/index.d.ts
 type IgnoredUpdater = (updater: () => void) => void;
@@ -1378,35 +1406,44 @@ interface WatchIgnorableReturn {
 declare function watchIgnorable<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
 declare function watchIgnorable<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
 declare function watchIgnorable<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
+/** @deprecated use `watchIgnorable` instead */
+declare const ignorableWatch: typeof watchIgnorable;
 //#endregion
 //#region watchImmediate/index.d.ts
-declare function watchImmediate<T extends Readonly<WatchSource<unknown>[]>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
-declare function watchImmediate<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
-declare function watchImmediate<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
+declare function watchImmediate<T extends Readonly<WatchSource<unknown>[]>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
+declare function watchImmediate<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
+declare function watchImmediate<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
 //#endregion
 //#region watchOnce/index.d.ts
-declare function watchOnce<T extends Readonly<WatchSource<unknown>[]>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'once'>): WatchStopHandle;
-declare function watchOnce<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchStopHandle;
-declare function watchOnce<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchStopHandle;
+declare function watchOnce<T extends Readonly<WatchSource<unknown>[]>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
+declare function watchOnce<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
+declare function watchOnce<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
 //#endregion
 //#region watchPausable/index.d.ts
 interface WatchPausableReturn extends Pausable {
   stop: WatchStopHandle;
 }
 type WatchPausableOptions<Immediate> = WatchWithFilterOptions<Immediate> & PausableFilterOptions;
+/**
+ * @deprecated This function will be removed in future version.
+ */
 declare function watchPausable<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
 declare function watchPausable<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
 declare function watchPausable<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
+/** @deprecated use `watchPausable` instead */
+declare const pausableWatch: typeof watchPausable;
 //#endregion
 //#region watchThrottled/index.d.ts
 interface WatchThrottledOptions<Immediate> extends WatchOptions<Immediate> {
-  throttle?: MaybeRefOrGetter$1<number>;
+  throttle?: MaybeRefOrGetter<number>;
   trailing?: boolean;
   leading?: boolean;
 }
-declare function watchThrottled<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchThrottledOptions<Immediate>): WatchStopHandle;
-declare function watchThrottled<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchThrottledOptions<Immediate>): WatchStopHandle;
-declare function watchThrottled<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchThrottledOptions<Immediate>): WatchStopHandle;
+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>): 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>): 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>): WatchHandle;
+/** @deprecated use `watchThrottled` instead */
+declare const throttledWatch: typeof watchThrottled;
 //#endregion
 //#region watchTriggerable/index.d.ts
 interface WatchTriggerableReturn<FnReturnT = void> extends WatchIgnorableReturn {
@@ -1437,4 +1474,4 @@ interface WheneverOptions extends WatchOptions {
  */
 declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WheneverOptions): vue0.WatchHandle;
 //#endregion
-export { AnyFn, ArgumentsType, Arrayable, Awaitable, Awaited, ComputedEagerOptions, ComputedEagerReturn, ComputedRefWithControl, ComputedWithControlRef, ComputedWithControlRefExtra, ConfigurableEventFilter, ConfigurableFlush, ConfigurableFlushSync, ControlledRefOptions, CreateGlobalStateReturn, CreateInjectionStateOptions, CreateRefReturn, DateLike, DebounceFilterOptions, DeepMaybeRef, ElementOf, EventFilter, EventHook, EventHookOff, EventHookOn, EventHookReturn, EventHookTrigger, ExtendRefOptions, ExtendRefReturn, Fn$1 as Fn, FunctionArgs, FunctionWrapperOptions, IfAny, IgnoredPrevAsyncUpdates, IgnoredUpdater, IsAny, IsDefinedReturn, MapOldSources, MapSources, type MaybeRef, type MaybeRefOrGetter, MultiWatchSources, Mutable, Pausable, PausableFilterOptions, Promisify, PromisifyFn, ProvideLocalReturn, Reactified, ReactifyNested, ReactifyObjectOptions, ReactifyObjectReturn, ReactifyOptions, ReactifyReturn, ReactiveComputedReturn, ReactiveOmitPredicate, ReactiveOmitReturn, ReactivePickPredicate, ReactivePickReturn, ReadonlyRefOrGetter, RefAutoResetReturn, RefDebouncedReturn, RefThrottledReturn, RemovableRef, ShallowOrDeepRef, ShallowUnwrapRef, SharedComposableReturn, SingletonPromiseReturn, Stoppable, SyncRefOptions, SyncRefsOptions, ThrottleFilterOptions, TimerHandle, ToRefsOptions, ToggleFn, UntilArrayInstance, UntilBaseInstance, UntilToMatchOptions, UntilValueInstance, UseArrayDifferenceOptions, UseArrayDifferenceReturn, UseArrayEveryReturn, UseArrayFilterReturn, UseArrayFindIndexReturn, UseArrayFindLastReturn, UseArrayFindReturn, UseArrayIncludesComparatorFn, UseArrayIncludesOptions, UseArrayIncludesReturn, UseArrayJoinReturn, UseArrayMapReturn, UseArrayReducer, UseArraySomeReturn, UseArrayUniqueReturn, UseCounterOptions, UseCounterReturn, UseDateFormatOptions, UseDateFormatReturn, UseDebounceFnReturn, UseIntervalControls, UseIntervalFnOptions, UseIntervalFnReturn, UseIntervalOptions, UseIntervalReturn, UseLastChangedOptions, UseLastChangedReturn, UseTimeoutFnOptions, UseTimeoutFnReturn, UseTimeoutOptions, UseTimoutReturn, UseToNumberOptions, UseToggleOptions, UseToggleReturn, WatchArrayCallback, WatchAtMostOptions, WatchAtMostReturn, WatchDebouncedOptions, WatchIgnorableReturn, WatchPausableOptions, WatchPausableReturn, WatchThrottledOptions, WatchTriggerableCallback, WatchTriggerableReturn, WatchWithFilterOptions, WheneverOptions, WritableComputedRefWithControl, assert, refAutoReset as autoResetRef, refAutoReset, bypassFilter, camelize, clamp, computedEager, computedEager as eagerComputed, computedWithControl, computedWithControl as controlledComputed, containsProp, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, reactify, createRef, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, refDebounced, refDebounced as useDebounce, watchDebounced as debouncedWatch, watchDebounced, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, watchIgnorable, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, watchPausable, promiseTimeout, provideLocal, pxValue, rand, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refDefault, refThrottled, refThrottled as throttledRef, refThrottled as useThrottle, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, watchThrottled as throttledWatch, watchThrottled, timestamp, toArray, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, useDebounceFn, useInterval, useIntervalFn, useLastChanged, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDeep, watchImmediate, watchOnce, watchTriggerable, watchWithFilter, whenever };
+export { AnyFn, ArgumentsType, Arrayable, Awaitable, Awaited, ComputedEagerOptions, ComputedEagerReturn, ComputedRefWithControl, ComputedWithControlRef, ComputedWithControlRefExtra, ConfigurableEventFilter, ConfigurableFlush, ConfigurableFlushSync, ControlledRefOptions, CreateGlobalStateReturn, CreateInjectionStateOptions, CreateRefReturn, DateLike, DebounceFilterOptions, DeepMaybeRef, ElementOf, EventFilter, EventHook, EventHookOff, EventHookOn, EventHookReturn, EventHookTrigger, ExtendRefOptions, ExtendRefReturn, Fn$1 as Fn, FunctionArgs, FunctionWrapperOptions, IfAny, IgnoredPrevAsyncUpdates, IgnoredUpdater, InstanceProxy, IsAny, IsDefinedReturn, ManualResetRefReturn, MapOldSources, MapSources, MultiWatchSources, Mutable, Pausable, PausableFilterOptions, Promisify, PromisifyFn, ProvideLocalReturn, Reactified, ReactifyNested, ReactifyObjectOptions, ReactifyObjectReturn, ReactifyOptions, ReactifyReturn, ReactiveComputedReturn, ReactiveOmitPredicate, ReactiveOmitReturn, ReactivePickPredicate, ReactivePickReturn, ReadonlyRefOrGetter, RefAutoResetReturn, RefDebouncedReturn, RefThrottledReturn, RemovableRef, ShallowOrDeepRef, ShallowUnwrapRef, SharedComposableReturn, SingletonPromiseReturn, Stoppable, SyncRefOptions, SyncRefsOptions, ThrottleFilterOptions, TimerHandle, ToRefsOptions, ToggleFn, UntilArrayInstance, UntilBaseInstance, UntilToMatchOptions, UntilValueInstance, UseArrayDifferenceOptions, UseArrayDifferenceReturn, UseArrayEveryReturn, UseArrayFilterReturn, UseArrayFindIndexReturn, UseArrayFindLastReturn, UseArrayFindReturn, UseArrayIncludesComparatorFn, UseArrayIncludesOptions, UseArrayIncludesReturn, UseArrayJoinReturn, UseArrayMapReturn, UseArrayReducer, UseArraySomeReturn, UseArrayUniqueReturn, UseCounterOptions, UseCounterReturn, UseDateFormatOptions, UseDateFormatReturn, UseDebounceFnReturn, UseIntervalControls, UseIntervalFnOptions, UseIntervalFnReturn, UseIntervalOptions, UseIntervalReturn, UseLastChangedOptions, UseLastChangedReturn, UseTimeoutFnOptions, UseTimeoutFnReturn, UseTimeoutOptions, UseTimoutReturn, UseToNumberOptions, UseToggleOptions, UseToggleReturn, WatchArrayCallback, WatchAtMostOptions, WatchAtMostReturn, WatchDebouncedOptions, WatchIgnorableReturn, WatchOptionFlush, WatchPausableOptions, WatchPausableReturn, WatchThrottledOptions, WatchTriggerableCallback, WatchTriggerableReturn, WatchWithFilterOptions, WheneverOptions, WritableComputedRefWithControl, assert, autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, createReactiveFn, createRef, createSharedComposable, createSingletonPromise, debounceFilter, debouncedRef, debouncedWatch, eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, pausableWatch, promiseTimeout, provideLocal, pxValue, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refManualReset, refThrottled, refWithControl, set, syncRef, syncRefs, throttleFilter, throttledRef, throttledWatch, timestamp, toArray, toReactive, toRef, toRefs, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };