@vueuse/shared 14.0.0-beta.1 → 14.0.0

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import * as vue0 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";
+import { ComponentInternalInstance, 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>>;
+type ComputedEagerReturn<T$1 = any> = Readonly<ShallowRef<T$1>>;
 /**
  *
  * @deprecated This function will be removed in future version.
@@ -17,7 +17,7 @@ type ComputedEagerReturn<T = any> = Readonly<ShallowRef<T>>;
  * @param options WatchOptionsBase
  * @returns readonly shallowRef
  */
-declare function computedEager<T>(fn: () => T, options?: ComputedEagerOptions): ComputedEagerReturn<T>;
+declare function computedEager<T$1>(fn: () => T$1, options?: ComputedEagerOptions): ComputedEagerReturn<T$1>;
 /** @deprecated use `computedEager` instead */
 declare const eagerComputed: typeof computedEager;
 //#endregion
@@ -28,11 +28,11 @@ interface ComputedWithControlRefExtra {
    */
   trigger: () => void;
 }
-interface ComputedRefWithControl<T> extends ComputedRef<T>, ComputedWithControlRefExtra {}
-interface WritableComputedRefWithControl<T> extends WritableComputedRef<T>, ComputedWithControlRefExtra {}
-type ComputedWithControlRef<T = any> = ComputedRefWithControl<T> | WritableComputedRefWithControl<T>;
-declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: ComputedGetter<T>, options?: WatchOptions): ComputedRefWithControl<T>;
-declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: WritableComputedOptions<T>, options?: WatchOptions): WritableComputedRefWithControl<T>;
+interface ComputedRefWithControl<T$1> extends ComputedRef<T$1>, ComputedWithControlRefExtra {}
+interface WritableComputedRefWithControl<T$1> extends WritableComputedRef<T$1>, ComputedWithControlRefExtra {}
+type ComputedWithControlRef<T$1 = any> = ComputedRefWithControl<T$1> | WritableComputedRefWithControl<T$1>;
+declare function computedWithControl<T$1, S$1>(source: WatchSource<S$1> | WatchSource<S$1>[], fn: ComputedGetter<T$1>, options?: WatchOptions): ComputedRefWithControl<T$1>;
+declare function computedWithControl<T$1, S$1>(source: WatchSource<S$1> | WatchSource<S$1>[], fn: WritableComputedOptions<T$1>, options?: WatchOptions): WritableComputedRefWithControl<T$1>;
 /** @deprecated use `computedWithControl` instead */
 declare const controlledComputed: typeof computedWithControl;
 //#endregion
@@ -40,7 +40,7 @@ declare const controlledComputed: typeof computedWithControl;
 /**
  * Void function
  */
-type Fn$1 = () => void;
+type Fn = () => void;
 /**
  * Any function
  */
@@ -48,14 +48,14 @@ type AnyFn = (...args: any[]) => any;
 /**
  * A ref that allow to set null or undefined
  */
-type RemovableRef<T> = Omit<Ref<T>, 'value'> & {
-  get value(): T;
-  set value(value: T | null | undefined);
+type RemovableRef<T$1> = Omit<Ref<T$1>, 'value'> & {
+  get value(): T$1;
+  set value(value: T$1 | null | undefined);
 };
 /**
  * Maybe it's a computed ref, or a readonly value, or a getter function
  */
-type ReadonlyRefOrGetter<T> = ComputedRef<T> | (() => T);
+type ReadonlyRefOrGetter<T$1> = ComputedRef<T$1> | (() => T$1);
 /**
  * Make all the nested attributes of an object or array to MaybeRef<T>
  *
@@ -65,23 +65,23 @@ type ReadonlyRefOrGetter<T> = ComputedRef<T> | (() => T);
  * UnwrapRef<DeepMaybeRef<T>> === T
  * ```
  */
-type DeepMaybeRef<T> = T extends Ref<infer V> ? MaybeRef<V> : T extends Array<any> | object ? { [K in keyof T]: DeepMaybeRef<T[K]> } : MaybeRef<T>;
-type Arrayable<T> = T[] | T;
+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>;
+type Arrayable<T$1> = T$1[] | T$1;
 /**
  * Infers the element type of an array
  */
-type ElementOf<T> = T extends (infer E)[] ? E : never;
-type ShallowUnwrapRef<T> = T extends Ref<infer P> ? P : T;
-type Awaitable<T> = Promise<T> | T;
-type ArgumentsType<T> = T extends ((...args: infer U) => any) ? U : never;
+type ElementOf<T$1> = T$1 extends (infer E)[] ? E : never;
+type ShallowUnwrapRef<T$1> = T$1 extends Ref<infer P> ? P : T$1;
+type Awaitable<T$1> = Promise<T$1> | T$1;
+type ArgumentsType<T$1> = T$1 extends ((...args: infer U) => any) ? U : never;
 /**
  * Compatible with versions below TypeScript 4.5 Awaited
  */
-type Awaited<T> = T extends null | undefined ? T : T extends object & {
+type Awaited<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<V> : never : T;
-type Promisify<T> = Promise<Awaited<T>>;
-type PromisifyFn<T extends AnyFn> = (...args: ArgumentsType<T>) => Promisify<ReturnType<T>>;
+} ? F extends ((value: infer V, ...args: infer _) => any) ? Awaited<V> : never : T$1;
+type Promisify<T$1> = Promise<Awaited<T$1>>;
+type PromisifyFn<T$1 extends AnyFn> = (...args: ArgumentsType<T$1>) => Promisify<ReturnType<T$1>>;
 interface Pausable {
   /**
    * A ref indicate whether a pausable instance is active
@@ -90,11 +90,11 @@ interface Pausable {
   /**
    * Temporary pause the effect from executing
    */
-  pause: Fn$1;
+  pause: Fn;
   /**
    * Resume the effects
    */
-  resume: Fn$1;
+  resume: Fn;
 }
 interface Stoppable<StartFnArgs extends any[] = any[]> {
   /**
@@ -104,7 +104,7 @@ interface Stoppable<StartFnArgs extends any[] = any[]> {
   /**
    * Stop the effect from executing
    */
-  stop: Fn$1;
+  stop: Fn;
   /**
    * Start the effects
    */
@@ -129,14 +129,14 @@ interface ConfigurableFlushSync {
   flush?: WatchOptionFlush;
 }
 type MultiWatchSources = (WatchSource<unknown> | object)[];
-type MapSources<T> = { [K in keyof T]: T[K] extends WatchSource<infer V> ? V : never };
-type MapOldSources<T, Immediate> = { [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : never };
-type Mutable<T> = { -readonly [P in keyof T]: T[P] };
-type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
+type MapSources<T$1> = { [K in keyof T$1]: T$1[K] extends WatchSource<infer V> ? V : never };
+type MapOldSources<T$1, Immediate> = { [K in keyof T$1]: T$1[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : never };
+type Mutable<T$1> = { -readonly [P in keyof T$1]: T$1[P] };
+type IfAny<T$1, Y, N> = 0 extends (1 & T$1) ? Y : N;
 /**
  * will return `true` if `T` is `any`, or `false` otherwise
  */
-type IsAny<T> = IfAny<T, true, false>;
+type IsAny<T$1> = IfAny<T$1, true, false>;
 /**
  * Universal timer handle that works in both browser and Node.js environments
  */
@@ -144,19 +144,19 @@ 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);
-type EventHookOn<T = any> = (fn: Callback<T>) => {
+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);
+type EventHookOn<T$1 = any> = (fn: Callback<T$1>) => {
   off: () => void;
 };
-type EventHookOff<T = any> = (fn: Callback<T>) => void;
-type EventHookTrigger<T = any> = (...param: Parameters<Callback<T>>) => Promise<unknown[]>;
-interface EventHook<T = any> {
-  on: EventHookOn<T>;
-  off: EventHookOff<T>;
-  trigger: EventHookTrigger<T>;
+type EventHookOff<T$1 = any> = (fn: Callback<T$1>) => void;
+type EventHookTrigger<T$1 = any> = (...param: Parameters<Callback<T$1>>) => Promise<unknown[]>;
+interface EventHook<T$1 = any> {
+  on: EventHookOn<T$1>;
+  off: EventHookOff<T$1>;
+  trigger: EventHookTrigger<T$1>;
   clear: () => void;
 }
-type EventHookReturn<T> = EventHook<T>;
+type EventHookReturn<T$1> = EventHook<T$1>;
 /**
  * Utility for creating event hooks
  *
@@ -164,7 +164,7 @@ type EventHookReturn<T> = EventHook<T>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function createEventHook<T = any>(): EventHookReturn<T>;
+declare function createEventHook<T$1 = any>(): EventHookReturn<T$1>;
 //#endregion
 //#region utils/filters.d.ts
 type FunctionArgs<Args extends any[] = any[], Return = void> = (...args: Args) => Return;
@@ -198,7 +198,7 @@ interface DebounceFilterOptions {
 /**
  * @internal
  */
-declare function createFilterWrapper<T extends AnyFn>(filter: EventFilter, fn: T): (this: any, ...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+declare function createFilterWrapper<T$1 extends AnyFn>(filter: EventFilter, fn: T$1): (this: any, ...args: ArgumentsType<T$1>) => Promise<Awaited<ReturnType<T$1>>>;
 declare const bypassFilter: EventFilter;
 /**
  * Create an EventFilter that debounce the events
@@ -247,9 +247,9 @@ declare function pausableFilter(extendFilter?: EventFilter, options?: PausableFi
 //#endregion
 //#region utils/general.d.ts
 declare function promiseTimeout(ms: number, throwOnTimeout?: boolean, reason?: string): Promise<void>;
-declare function identity<T>(arg: T): T;
-interface SingletonPromiseReturn<T> {
-  (): Promise<T>;
+declare function identity<T$1>(arg: T$1): T$1;
+interface SingletonPromiseReturn<T$1> {
+  (): Promise<T$1>;
   /**
    * Reset current staled promise.
    * await it to have proper shutdown.
@@ -268,8 +268,8 @@ interface SingletonPromiseReturn<T> {
  * await promise() // and be resolved together
  * ```
  */
-declare function createSingletonPromise<T>(fn: () => Promise<T>): SingletonPromiseReturn<T>;
-declare function invoke<T>(fn: () => T): T;
+declare function createSingletonPromise<T$1>(fn: () => Promise<T$1>): SingletonPromiseReturn<T$1>;
+declare function invoke<T$1>(fn: () => T$1): T$1;
 declare function containsProp(obj: object, ...props: string[]): boolean;
 /**
  * Increase string a value with unit
@@ -287,14 +287,14 @@ declare function pxValue(px: string): number;
 /**
  * Create a new subset object by giving keys
  */
-declare function objectPick<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined?: boolean): Pick<O, T>;
+declare function objectPick<O extends object, T$1 extends keyof O>(obj: O, keys: T$1[], omitUndefined?: boolean): Pick<O, T$1>;
 /**
  * Create a new subset object by omit giving keys
  */
-declare function objectOmit<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined?: boolean): Omit<O, T>;
-declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
-declare function toArray<T>(value: T | readonly T[]): readonly T[];
-declare function toArray<T>(value: T | T[]): T[];
+declare function objectOmit<O extends object, T$1 extends keyof O>(obj: O, keys: T$1[], omitUndefined?: boolean): Omit<O, T$1>;
+declare function objectEntries<T$1 extends object>(obj: T$1): Array<[keyof T$1, T$1[keyof T$1]]>;
+declare function toArray<T$1>(value: T$1 | readonly T$1[]): readonly T$1[];
+declare function toArray<T$1>(value: T$1 | T$1[]): T$1[];
 //#endregion
 //#region utils/is.d.ts
 declare const isClient: boolean;
@@ -316,10 +316,10 @@ declare const hyphenate: (str: string) => string;
 declare const camelize: (str: string) => string;
 //#endregion
 //#region utils/vue.d.ts
-declare function getLifeCycleTarget(target?: any): any;
+declare function getLifeCycleTarget(target?: ComponentInternalInstance | null): ComponentInternalInstance | null;
 //#endregion
 //#region createGlobalState/index.d.ts
-type CreateGlobalStateReturn<Fn extends AnyFn = AnyFn> = Fn;
+type CreateGlobalStateReturn<Fn$1 extends AnyFn = AnyFn> = Fn$1;
 /**
  * Keep states in the global scope to be reusable across Vue instances.
  *
@@ -328,9 +328,23 @@ type CreateGlobalStateReturn<Fn extends AnyFn = AnyFn> = Fn;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function createGlobalState<Fn extends AnyFn>(stateFactory: Fn): CreateGlobalStateReturn<Fn>;
+declare function createGlobalState<Fn$1 extends AnyFn>(stateFactory: Fn$1): CreateGlobalStateReturn<Fn$1>;
 //#endregion
 //#region createInjectionState/index.d.ts
+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]>;
 interface CreateInjectionStateOptions<Return> {
   /**
    * Custom injectionKey for InjectionState
@@ -348,11 +362,11 @@ interface CreateInjectionStateOptions<Return> {
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function createInjectionState<Arguments extends Array<any>, Return>(composable: (...args: Arguments) => Return, options?: CreateInjectionStateOptions<Return>): readonly [useProvidingState: (...args: Arguments) => Return, useInjectedState: () => Return | undefined];
+declare function createInjectionState<Arguments extends Array<any>, Return>(composable: (...args: Arguments) => Return, options?: CreateInjectionStateOptions<Return>): CreateInjectionStateReturn<Arguments, Return>;
 //#endregion
 //#region createRef/index.d.ts
-type CreateRefReturn<T = any, D extends boolean = false> = ShallowOrDeepRef<T, D>;
-type ShallowOrDeepRef<T = any, D extends boolean = false> = D extends true ? Ref<T> : ShallowRef<T>;
+type CreateRefReturn<T$1 = any, D extends boolean = false> = ShallowOrDeepRef<T$1, D>;
+type ShallowOrDeepRef<T$1 = any, D extends boolean = false> = D extends true ? Ref<T$1> : ShallowRef<T$1>;
 /**
  * Returns a `deepRef` or `shallowRef` depending on the `deep` param.
  *
@@ -368,10 +382,10 @@ type ShallowOrDeepRef<T = any, D extends boolean = false> = D extends true ? Ref
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function createRef<T = any, D extends boolean = false>(value: T, deep?: D): CreateRefReturn<T, D>;
+declare function createRef<T$1 = any, D extends boolean = false>(value: T$1, deep?: D): CreateRefReturn<T$1, D>;
 //#endregion
 //#region createSharedComposable/index.d.ts
-type SharedComposableReturn<T extends AnyFn = AnyFn> = T;
+type SharedComposableReturn<T$1 extends AnyFn = AnyFn> = T$1;
 /**
  * Make a composable function usable with multiple Vue instances.
  *
@@ -379,10 +393,10 @@ type SharedComposableReturn<T extends AnyFn = AnyFn> = T;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function createSharedComposable<Fn extends AnyFn>(composable: Fn): SharedComposableReturn<Fn>;
+declare function createSharedComposable<Fn$1 extends AnyFn>(composable: Fn$1): SharedComposableReturn<Fn$1>;
 //#endregion
 //#region extendRef/index.d.ts
-type ExtendRefReturn<T = any> = Ref<T>;
+type ExtendRefReturn<T$1 = any> = Ref<T$1>;
 interface ExtendRefOptions<Unwrap extends boolean = boolean> {
   /**
    * Is the extends properties enumerable
@@ -400,18 +414,18 @@ interface ExtendRefOptions<Unwrap extends boolean = boolean> {
 /**
  * Overload 1: Unwrap set to false
  */
-declare function extendRef<R extends Ref<any>, Extend extends object, Options extends ExtendRefOptions<false>>(ref: R, extend: Extend, options?: Options): ShallowUnwrapRef$1<Extend> & R;
+declare function extendRef<R$1 extends Ref<any>, Extend extends object, Options extends ExtendRefOptions<false>>(ref: R$1, extend: Extend, options?: Options): ShallowUnwrapRef$1<Extend> & R$1;
 /**
  * Overload 2: Unwrap unset or set to true
  */
-declare function extendRef<R extends Ref<any>, Extend extends object, Options extends ExtendRefOptions>(ref: R, extend: Extend, options?: Options): Extend & R;
+declare function extendRef<R$1 extends Ref<any>, Extend extends object, Options extends ExtendRefOptions>(ref: R$1, extend: Extend, options?: Options): Extend & R$1;
 //#endregion
 //#region get/index.d.ts
 /**
  * Shorthand for accessing `ref.value`
  */
-declare function get<T>(ref: MaybeRef<T>): T;
-declare function get<T, K extends keyof T>(ref: MaybeRef<T>, key: K): T[K];
+declare function get<T$1>(ref: MaybeRef<T$1>): T$1;
+declare function get<T$1, K$1 extends keyof T$1>(ref: MaybeRef<T$1>, key: K$1): T$1[K$1];
 //#endregion
 //#region injectLocal/index.d.ts
 /**
@@ -429,15 +443,15 @@ declare const injectLocal: typeof inject;
 //#endregion
 //#region isDefined/index.d.ts
 type IsDefinedReturn = boolean;
-declare function isDefined<T>(v: ComputedRef<T>): v is ComputedRef<Exclude<T, null | undefined>>;
-declare function isDefined<T>(v: Ref<T>): v is Ref<Exclude<T, null | undefined>>;
-declare function isDefined<T>(v: T): v is Exclude<T, null | undefined>;
+declare function isDefined<T$1>(v: ComputedRef<T$1>): v is ComputedRef<Exclude<T$1, null | undefined>>;
+declare function isDefined<T$1>(v: Ref<T$1>): v is Ref<Exclude<T$1, null | undefined>>;
+declare function isDefined<T$1>(v: T$1): v is Exclude<T$1, null | undefined>;
 //#endregion
 //#region makeDestructurable/index.d.ts
-declare function makeDestructurable<T extends Record<string, unknown>, A extends readonly any[]>(obj: T, arr: A): T & A;
+declare function makeDestructurable<T$1 extends Record<string, unknown>, A$1 extends readonly any[]>(obj: T$1, arr: A$1): T$1 & A$1;
 //#endregion
 //#region provideLocal/map.d.ts
-type LocalProvidedKey<T> = InjectionKey<T> | string | number;
+type LocalProvidedKey<T$1> = InjectionKey<T$1> | string | number;
 //#endregion
 //#region provideLocal/index.d.ts
 type ProvideLocalReturn = void;
@@ -450,18 +464,18 @@ type ProvideLocalReturn = void;
  * const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
  * ```
  */
-declare function provideLocal<T, K = LocalProvidedKey<T>>(key: K, value: K extends InjectionKey<infer V> ? V : T): ProvideLocalReturn;
+declare function provideLocal<T$1, K$1 = LocalProvidedKey<T$1>>(key: K$1, value: K$1 extends InjectionKey<infer V> ? V : T$1): ProvideLocalReturn;
 //#endregion
 //#region reactify/index.d.ts
-type Reactified<T, Computed extends boolean> = T extends ((...args: infer A) => infer R) ? (...args: { [K in keyof A]: Computed extends true ? MaybeRefOrGetter<A[K]> : MaybeRef<A[K]> }) => ComputedRef<R> : never;
-type ReactifyReturn<T extends AnyFn = AnyFn, K extends boolean = true> = Reactified<T, K>;
-interface ReactifyOptions<T extends boolean> {
+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;
+type ReactifyReturn<T$1 extends AnyFn = AnyFn, K$1 extends boolean = true> = Reactified<T$1, K$1>;
+interface ReactifyOptions<T$1 extends boolean> {
   /**
    * Accept passing a function as a reactive getter
    *
    * @default true
    */
-  computedGetter?: T;
+  computedGetter?: T$1;
 }
 /**
  * Converts plain function into a reactive function.
@@ -473,14 +487,14 @@ 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>;
+declare function reactify<T$1 extends AnyFn, K$1 extends boolean = true>(fn: T$1, options?: ReactifyOptions<K$1>): ReactifyReturn<T$1, K$1>;
 /** @deprecated use `reactify` instead */
 declare const createReactiveFn: typeof reactify;
 //#endregion
 //#region reactifyObject/index.d.ts
-type ReactifyNested<T, Keys extends keyof T = keyof T, S extends boolean = true> = { [K in Keys]: T[K] extends AnyFn ? Reactified<T[K], S> : T[K] };
-type ReactifyObjectReturn<T, Keys extends keyof T, S extends boolean = true> = ReactifyNested<T, Keys, S>;
-interface ReactifyObjectOptions<T extends boolean> extends ReactifyOptions<T> {
+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] };
+type ReactifyObjectReturn<T$1, Keys extends keyof T$1, S$1 extends boolean = true> = ReactifyNested<T$1, Keys, S$1>;
+interface ReactifyObjectOptions<T$1 extends boolean> extends ReactifyOptions<T$1> {
   /**
    * Includes names from Object.getOwnPropertyNames
    *
@@ -493,30 +507,30 @@ interface ReactifyObjectOptions<T extends boolean> extends ReactifyOptions<T> {
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function reactifyObject<T extends object, Keys extends keyof T>(obj: T, keys?: (keyof T)[]): ReactifyObjectReturn<T, Keys, true>;
-declare function reactifyObject<T extends object, S extends boolean = true>(obj: T, options?: ReactifyObjectOptions<S>): ReactifyObjectReturn<T, keyof T, S>;
+declare function reactifyObject<T$1 extends object, Keys extends keyof T$1>(obj: T$1, keys?: (keyof T$1)[]): ReactifyObjectReturn<T$1, Keys, true>;
+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>;
 //#endregion
 //#region reactiveComputed/index.d.ts
-type ReactiveComputedReturn<T extends object> = UnwrapNestedRefs<T>;
+type ReactiveComputedReturn<T$1 extends object> = UnwrapNestedRefs<T$1>;
 /**
  * Computed reactive object.
  */
-declare function reactiveComputed<T extends object>(fn: ComputedGetter<T>): ReactiveComputedReturn<T>;
+declare function reactiveComputed<T$1 extends object>(fn: ComputedGetter<T$1>): ReactiveComputedReturn<T$1>;
 //#endregion
 //#region reactiveOmit/index.d.ts
-type ReactiveOmitReturn<T extends object, K extends keyof T | undefined = undefined> = [K] extends [undefined] ? Partial<T> : Omit<T, Extract<K, keyof T>>;
-type ReactiveOmitPredicate<T> = (value: T[keyof T], key: keyof T) => boolean;
-declare function reactiveOmit<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): ReactiveOmitReturn<T, K>;
-declare function reactiveOmit<T extends object>(obj: T, predicate: ReactiveOmitPredicate<T>): ReactiveOmitReturn<T>;
+type 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>>;
+type ReactiveOmitPredicate<T$1> = (value: T$1[keyof T$1], key: keyof T$1) => boolean;
+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>;
+declare function reactiveOmit<T$1 extends object>(obj: T$1, predicate: ReactiveOmitPredicate<T$1>): ReactiveOmitReturn<T$1>;
 //#endregion
 //#region reactivePick/index.d.ts
-type ReactivePickReturn<T extends object, K extends keyof T> = { [S in K]: UnwrapRef<T[S]> };
-type ReactivePickPredicate<T> = (value: T[keyof T], key: keyof T) => boolean;
-declare function reactivePick<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): ReactivePickReturn<T, K>;
-declare function reactivePick<T extends object>(obj: T, predicate: ReactivePickPredicate<T>): ReactivePickReturn<T, keyof T>;
+type ReactivePickReturn<T$1 extends object, K$1 extends keyof T$1> = { [S in K$1]: UnwrapRef<T$1[S]> };
+type ReactivePickPredicate<T$1> = (value: T$1[keyof T$1], key: keyof T$1) => boolean;
+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>;
+declare function reactivePick<T$1 extends object>(obj: T$1, predicate: ReactivePickPredicate<T$1>): ReactivePickReturn<T$1, keyof T$1>;
 //#endregion
 //#region refAutoReset/index.d.ts
-type RefAutoResetReturn<T = any> = Ref<T>;
+type RefAutoResetReturn<T$1 = any> = Ref<T$1>;
 /**
  * Create a ref which will be reset to the default value after some time.
  *
@@ -524,18 +538,18 @@ 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<T>, afterMs?: MaybeRefOrGetter<number>): RefAutoResetReturn<T>;
+declare function refAutoReset<T$1>(defaultValue: MaybeRefOrGetter<T$1>, afterMs?: MaybeRefOrGetter<number>): RefAutoResetReturn<T$1>;
 /** @deprecated use `refAutoReset` instead */
 declare const autoResetRef: typeof refAutoReset;
 //#endregion
 //#region refDebounced/index.d.ts
-type RefDebouncedReturn<T = any> = Readonly<Ref<T>>;
+type RefDebouncedReturn<T$1 = any> = Readonly<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>;
+declare function refDebounced<T$1>(value: Ref<T$1>, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): RefDebouncedReturn<T$1>;
 /** @deprecated use `refDebounced` instead */
 declare const debouncedRef: typeof refDebounced;
 /** @deprecated use `refDebounced` instead */
@@ -547,7 +561,7 @@ declare const useDebounce: typeof refDebounced;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function refDefault<T>(source: Ref<T | undefined | null>, defaultValue: T): Ref<T>;
+declare function refDefault<T$1>(source: Ref<T$1 | undefined | null>, defaultValue: T$1): Ref<T$1>;
 //#endregion
 //#region refManualReset/index.d.ts
 /**
@@ -556,8 +570,8 @@ declare function refDefault<T>(source: Ref<T | undefined | null>, defaultValue:
  * 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;
+interface ManualResetRefReturn<T$1> extends Ref<T$1> {
+  reset: Fn;
 }
 /**
  * Create a ref with manual reset functionality.
@@ -565,10 +579,10 @@ interface ManualResetRefReturn<T> extends Ref<T> {
  * @see https://vueuse.org/refManualReset
  * @param defaultValue The value which will be set.
  */
-declare function refManualReset<T>(defaultValue: MaybeRefOrGetter<T>): ManualResetRefReturn<T>;
+declare function refManualReset<T$1>(defaultValue: MaybeRefOrGetter<T$1>): ManualResetRefReturn<T$1>;
 //#endregion
 //#region refThrottled/index.d.ts
-type RefThrottledReturn<T = any> = Ref<T>;
+type RefThrottledReturn<T$1 = any> = Ref<T$1>;
 /**
  * Throttle execution of a function. Especially useful for rate limiting
  * execution of handlers on events like resize and scroll.
@@ -578,89 +592,89 @@ type RefThrottledReturn<T = any> = Ref<T>;
  * @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>;
+declare function refThrottled<T$1 = any>(value: Ref<T$1>, delay?: number, trailing?: boolean, leading?: boolean): RefThrottledReturn<T$1>;
 /** @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> {
+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;
 }
 /**
  * Fine-grained controls over ref and its reactivity.
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function refWithControl<T>(initial: T, options?: ControlledRefOptions<T>): vue0.ShallowUnwrapRef<{
-  get: (tracking?: boolean) => T;
-  set: (value: T, triggering?: boolean) => void;
-  untrackedGet: () => T;
-  silentSet: (v: T) => void;
-  peek: () => T;
-  lay: (v: T) => void;
-}> & vue0.Ref<T, T>;
+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>;
 /** @deprecated use `refWithControl` instead */
 declare const controlledRef: typeof refWithControl;
 //#endregion
 //#region set/index.d.ts
-declare function set<T>(ref: Ref<T>, value: T): void;
-declare function set<O extends object, K extends keyof O>(target: O, key: K, value: O[K]): void;
+declare function set<T$1>(ref: Ref<T$1>, value: T$1): void;
+declare function set<O extends object, K$1 extends keyof O>(target: O, key: K$1, value: O[K$1]): void;
 //#endregion
 //#region syncRef/index.d.ts
 type Direction = 'ltr' | 'rtl' | 'both';
-type SpecificFieldPartial<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
+type SpecificFieldPartial<T$1, K$1 extends keyof T$1> = Partial<Pick<T$1, K$1>> & Omit<T$1, K$1>;
 /**
  * A = B
  */
-type Equal<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+type Equal<A$1, B> = [A$1] extends [B] ? ([B] extends [A$1] ? true : false) : false;
 /**
  * A ∩ B ≠ ∅
  */
-type IntersectButNotEqual<A, B> = Equal<A, B> extends true ? false : A & B extends never ? false : true;
+type IntersectButNotEqual<A$1, B> = Equal<A$1, B> extends true ? false : A$1 & B extends never ? false : true;
 /**
  * A ⊆ B
  */
-type IncludeButNotEqual<A, B> = Equal<A, B> extends true ? false : A extends B ? true : false;
+type IncludeButNotEqual<A$1, B> = Equal<A$1, B> extends true ? false : A$1 extends B ? true : false;
 /**
  * A ∩ B = ∅
  */
-type NotIntersect<A, B> = Equal<A, B> extends true ? false : A & B extends never ? true : false;
-interface EqualType<D extends Direction, L, R, O extends keyof Transform<L, R> = (D extends 'both' ? 'ltr' | 'rtl' : D)> {
-  transform?: SpecificFieldPartial<Pick<Transform<L, R>, O>, O>;
+type NotIntersect<A$1, B> = Equal<A$1, B> extends true ? false : A$1 & B extends never ? true : false;
+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>;
 }
-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>;
+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>;
 };
-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;
-type IntersectButNotEqualType<D extends Direction, L, R> = D extends 'both' ? {
-  transform: Transform<L, R>;
+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;
+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;
-type NotIntersectType<D extends Direction, L, R> = IntersectButNotEqualType<D, L, R>;
-interface Transform<L, R> {
-  ltr: (left: L) => R;
-  rtl: (right: R) => L;
+type NotIntersectType<D extends Direction, L, R$1> = IntersectButNotEqualType<D, L, R$1>;
+interface Transform<L, R$1> {
+  ltr: (left: L) => R$1;
+  rtl: (right: R$1) => L;
 }
-type TransformType<D extends Direction, L, R> = Equal<L, R> extends true ? EqualType<D, L, R> : IncludeButNotEqual<L, R> extends true ? StrictIncludeType<'LR', D, L, R> : IncludeButNotEqual<R, L> extends true ? StrictIncludeType<'RL', D, L, R> : IntersectButNotEqual<L, R> extends true ? IntersectButNotEqualType<D, L, R> : NotIntersect<L, R> extends true ? NotIntersectType<D, L, R> : never;
-type SyncRefOptions<L, R, D extends Direction> = ConfigurableFlushSync & {
+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;
+type SyncRefOptions<L, R$1, D extends Direction> = ConfigurableFlushSync & {
   /**
    * Watch deeply
    *
@@ -679,7 +693,7 @@ type SyncRefOptions<L, R, D extends Direction> = ConfigurableFlushSync & {
    * @default 'both'
    */
   direction?: D;
-} & TransformType<D, L, R>;
+} & TransformType<D, L, R$1>;
 /**
  * Two-way refs synchronization.
  * From the set theory perspective to restrict the option's type
@@ -689,7 +703,7 @@ type SyncRefOptions<L, R, D extends Direction> = ConfigurableFlushSync & {
  * 3. L ⊆ R
  * 4. L ∩ R = ∅
  */
-declare function syncRef<L, R, D extends Direction = 'both'>(left: Ref<L>, right: Ref<R>, ...[options]: Equal<L, R> extends true ? [options?: SyncRefOptions<L, R, D>] : [options: SyncRefOptions<L, R, D>]): () => void;
+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;
 //#endregion
 //#region syncRefs/index.d.ts
 interface SyncRefsOptions extends ConfigurableFlushSync {
@@ -712,7 +726,7 @@ interface SyncRefsOptions extends ConfigurableFlushSync {
  * @param source source ref
  * @param targets
  */
-declare function syncRefs<T>(source: WatchSource<T>, targets: Ref<T> | Ref<T>[], options?: SyncRefsOptions): vue0.WatchHandle;
+declare function syncRefs<T$1>(source: WatchSource<T$1>, targets: Ref<T$1> | Ref<T$1>[], options?: SyncRefsOptions): vue0.WatchHandle;
 //#endregion
 //#region toReactive/index.d.ts
 /**
@@ -721,18 +735,18 @@ 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<T>): UnwrapNestedRefs<T>;
+declare function toReactive<T$1 extends object>(objectRef: MaybeRef<T$1>): UnwrapNestedRefs<T$1>;
 //#endregion
 //#region toRef/index.d.ts
 /**
  * Normalize value/ref/getter to `ref` or `computed`.
  */
-declare function toRef<T>(r: () => T): Readonly<Ref<T>>;
-declare function toRef<T>(r: ComputedRef<T>): ComputedRef<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>>;
+declare function toRef<T$1>(r: () => T$1): Readonly<Ref<T$1>>;
+declare function toRef<T$1>(r: ComputedRef<T$1>): ComputedRef<T$1>;
+declare function toRef<T$1>(r: MaybeRefOrGetter<T$1>): Ref<T$1>;
+declare function toRef<T$1>(r: T$1): Ref<T$1>;
+declare function toRef<T$1 extends object, K$1 extends keyof T$1>(object: T$1, key: K$1): ToRef<T$1[K$1]>;
+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>>;
 //#endregion
 //#region toRefs/index.d.ts
 interface ToRefsOptions {
@@ -750,7 +764,7 @@ interface ToRefsOptions {
  * @param objectRef A ref or normal object or array.
  * @param options Options
  */
-declare function toRefs<T extends object>(objectRef: MaybeRef<T>, options?: ToRefsOptions): ToRefs<T>;
+declare function toRefs<T$1 extends object>(objectRef: MaybeRef<T$1>, options?: ToRefsOptions): ToRefs<T$1>;
 //#endregion
 //#region tryOnBeforeMount/index.d.ts
 /**
@@ -760,7 +774,7 @@ declare function toRefs<T extends object>(objectRef: MaybeRef<T>, options?: ToRe
  * @param sync if set to false, it will run in the nextTick() of Vue
  * @param target
  */
-declare function tryOnBeforeMount(fn: Fn$1, sync?: boolean, target?: any): void;
+declare function tryOnBeforeMount(fn: Fn, sync?: boolean, target?: ComponentInternalInstance | null): void;
 //#endregion
 //#region tryOnBeforeUnmount/index.d.ts
 /**
@@ -769,7 +783,7 @@ declare function tryOnBeforeMount(fn: Fn$1, sync?: boolean, target?: any): void;
  * @param fn
  * @param target
  */
-declare function tryOnBeforeUnmount(fn: Fn$1, target?: any): void;
+declare function tryOnBeforeUnmount(fn: Fn, target?: ComponentInternalInstance | null): void;
 //#endregion
 //#region tryOnMounted/index.d.ts
 /**
@@ -779,7 +793,7 @@ declare function tryOnBeforeUnmount(fn: Fn$1, target?: any): void;
  * @param sync if set to false, it will run in the nextTick() of Vue
  * @param target
  */
-declare function tryOnMounted(fn: Fn$1, sync?: boolean, target?: any): void;
+declare function tryOnMounted(fn: Fn, sync?: boolean, target?: ComponentInternalInstance | null): void;
 //#endregion
 //#region tryOnScopeDispose/index.d.ts
 /**
@@ -787,7 +801,7 @@ declare function tryOnMounted(fn: Fn$1, sync?: boolean, target?: any): void;
  *
  * @param fn
  */
-declare function tryOnScopeDispose(fn: Fn$1): boolean;
+declare function tryOnScopeDispose(fn: Fn, failSilently?: boolean): boolean;
 //#endregion
 //#region tryOnUnmounted/index.d.ts
 /**
@@ -796,7 +810,7 @@ declare function tryOnScopeDispose(fn: Fn$1): boolean;
  * @param fn
  * @param target
  */
-declare function tryOnUnmounted(fn: Fn$1, target?: any): void;
+declare function tryOnUnmounted(fn: Fn, target?: ComponentInternalInstance | null): void;
 //#endregion
 //#region until/index.d.ts
 interface UntilToMatchOptions {
@@ -826,23 +840,23 @@ interface UntilToMatchOptions {
    */
   deep?: WatchOptions['deep'];
 }
-interface UntilBaseInstance<T, Not extends boolean = false> {
-  toMatch: (<U extends T = T>(condition: (v: T) => v is U, options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, U>> : Promise<U>) & ((condition: (v: T) => boolean, options?: UntilToMatchOptions) => Promise<T>);
-  changed: (options?: UntilToMatchOptions) => Promise<T>;
-  changedTimes: (n?: number, options?: UntilToMatchOptions) => Promise<T>;
+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>;
 }
-type Falsy$1 = false | void | null | undefined | 0 | 0n | '';
-interface UntilValueInstance<T, Not extends boolean = false> extends UntilBaseInstance<T, Not> {
-  readonly not: UntilValueInstance<T, Not extends true ? false : true>;
-  toBe: <P = T>(value: MaybeRefOrGetter<P>, options?: UntilToMatchOptions) => Not extends true ? Promise<T> : Promise<P>;
-  toBeTruthy: (options?: UntilToMatchOptions) => Not extends true ? Promise<T & Falsy$1> : Promise<Exclude<T, Falsy$1>>;
-  toBeNull: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, null>> : Promise<null>;
-  toBeUndefined: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, undefined>> : Promise<undefined>;
-  toBeNaN: (options?: UntilToMatchOptions) => Promise<T>;
+type Falsy = false | void | null | undefined | 0 | 0n | '';
+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>;
 }
-interface UntilArrayInstance<T> extends UntilBaseInstance<T> {
-  readonly not: UntilArrayInstance<T>;
-  toContains: (value: MaybeRefOrGetter<ElementOf<ShallowUnwrapRef<T>>>, options?: UntilToMatchOptions) => Promise<T>;
+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>;
 }
 /**
  * Promised one-time watch for changes
@@ -857,8 +871,8 @@ interface UntilArrayInstance<T> extends UntilBaseInstance<T> {
  * alert('Counter is now larger than 7!')
  * ```
  */
-declare function until<T extends unknown[]>(r: WatchSource<T> | MaybeRefOrGetter<T>): UntilArrayInstance<T>;
-declare function until<T>(r: WatchSource<T> | MaybeRefOrGetter<T>): UntilValueInstance<T>;
+declare function until<T$1 extends unknown[]>(r: WatchSource<T$1> | MaybeRefOrGetter<T$1>): UntilArrayInstance<T$1>;
+declare function until<T$1>(r: WatchSource<T$1> | MaybeRefOrGetter<T$1>): UntilValueInstance<T$1>;
 //#endregion
 //#region useArrayDifference/index.d.ts
 interface UseArrayDifferenceOptions {
@@ -870,9 +884,9 @@ interface UseArrayDifferenceOptions {
    */
   symmetric?: boolean;
 }
-type UseArrayDifferenceReturn<T = any> = ComputedRef<T[]>;
-declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, key?: keyof T, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
-declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, compareFn?: (value: T, othVal: T) => boolean, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
+type UseArrayDifferenceReturn<T$1 = any> = ComputedRef<T$1[]>;
+declare function useArrayDifference<T$1>(list: MaybeRefOrGetter<T$1[]>, values: MaybeRefOrGetter<T$1[]>, key?: keyof T$1, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T$1>;
+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>;
 //#endregion
 //#region useArrayEvery/index.d.ts
 type UseArrayEveryReturn = ComputedRef<boolean>;
@@ -887,10 +901,10 @@ type UseArrayEveryReturn = ComputedRef<boolean>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayEvery<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayEveryReturn;
+declare function useArrayEvery<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => unknown): UseArrayEveryReturn;
 //#endregion
 //#region useArrayFilter/index.d.ts
-type UseArrayFilterReturn<T = any> = ComputedRef<T[]>;
+type UseArrayFilterReturn<T$1 = any> = ComputedRef<T$1[]>;
 /**
  * Reactive `Array.filter`
  *
@@ -902,11 +916,11 @@ type UseArrayFilterReturn<T = any> = ComputedRef<T[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-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>;
+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>;
+declare function useArrayFilter<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: T$1[]) => unknown): UseArrayFilterReturn<T$1>;
 //#endregion
 //#region useArrayFind/index.d.ts
-type UseArrayFindReturn<T = any> = ComputedRef<T | undefined>;
+type UseArrayFindReturn<T$1 = any> = ComputedRef<T$1 | undefined>;
 /**
  * Reactive `Array.find`
  *
@@ -918,7 +932,7 @@ type UseArrayFindReturn<T = any> = ComputedRef<T | undefined>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayFind<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindReturn<T>;
+declare function useArrayFind<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => boolean): UseArrayFindReturn<T$1>;
 //#endregion
 //#region useArrayFindIndex/index.d.ts
 type UseArrayFindIndexReturn = ComputedRef<number>;
@@ -933,10 +947,10 @@ type UseArrayFindIndexReturn = ComputedRef<number>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayFindIndex<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayFindIndexReturn;
+declare function useArrayFindIndex<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => unknown): UseArrayFindIndexReturn;
 //#endregion
 //#region useArrayFindLast/index.d.ts
-type UseArrayFindLastReturn<T = any> = ComputedRef<T | undefined>;
+type UseArrayFindLastReturn<T$1 = any> = ComputedRef<T$1 | undefined>;
 /**
  * Reactive `Array.findLast`
  *
@@ -948,13 +962,13 @@ type UseArrayFindLastReturn<T = any> = ComputedRef<T | undefined>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayFindLast<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindLastReturn<T>;
+declare function useArrayFindLast<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => boolean): UseArrayFindLastReturn<T$1>;
 //#endregion
 //#region useArrayIncludes/index.d.ts
-type UseArrayIncludesComparatorFn<T, V> = ((element: T, value: V, index: number, array: MaybeRefOrGetter<T>[]) => boolean);
-interface UseArrayIncludesOptions<T, V> {
+type UseArrayIncludesComparatorFn<T$1, V$1> = ((element: T$1, value: V$1, index: number, array: MaybeRefOrGetter<T$1>[]) => boolean);
+interface UseArrayIncludesOptions<T$1, V$1> {
   fromIndex?: number;
-  comparator?: UseArrayIncludesComparatorFn<T, V> | keyof T;
+  comparator?: UseArrayIncludesComparatorFn<T$1, V$1> | keyof T$1;
 }
 type UseArrayIncludesReturn = ComputedRef<boolean>;
 /**
@@ -966,9 +980,9 @@ type UseArrayIncludesReturn = ComputedRef<boolean>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-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;
+declare function useArrayIncludes<T$1, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, value: MaybeRefOrGetter<V$1>, comparator?: UseArrayIncludesComparatorFn<T$1, V$1>): UseArrayIncludesReturn;
+declare function useArrayIncludes<T$1, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, value: MaybeRefOrGetter<V$1>, comparator?: keyof T$1): UseArrayIncludesReturn;
+declare function useArrayIncludes<T$1, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, value: MaybeRefOrGetter<V$1>, options?: UseArrayIncludesOptions<T$1, V$1>): UseArrayIncludesReturn;
 //#endregion
 //#region useArrayJoin/index.d.ts
 type UseArrayJoinReturn = ComputedRef<string>;
@@ -986,7 +1000,7 @@ type UseArrayJoinReturn = ComputedRef<string>;
 declare function useArrayJoin(list: MaybeRefOrGetter<MaybeRefOrGetter<any>[]>, separator?: MaybeRefOrGetter<string>): UseArrayJoinReturn;
 //#endregion
 //#region useArrayMap/index.d.ts
-type UseArrayMapReturn<T = any> = ComputedRef<T[]>;
+type UseArrayMapReturn<T$1 = any> = ComputedRef<T$1[]>;
 /**
  * Reactive `Array.map`
  *
@@ -998,10 +1012,10 @@ type UseArrayMapReturn<T = any> = ComputedRef<T[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayMap<T, U = T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => U): UseArrayMapReturn<U>;
+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>;
 //#endregion
 //#region useArrayReduce/index.d.ts
-type UseArrayReducer<PV, CV, R> = (previousValue: PV, currentValue: CV, currentIndex: number) => R;
+type UseArrayReducer<PV, CV, R$1> = (previousValue: PV, currentValue: CV, currentIndex: number) => R$1;
 /**
  * Reactive `Array.reduce`
  *
@@ -1013,7 +1027,7 @@ type UseArrayReducer<PV, CV, R> = (previousValue: PV, currentValue: CV, currentI
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayReduce<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<T, T, T>): ComputedRef<T>;
+declare function useArrayReduce<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, reducer: UseArrayReducer<T$1, T$1, T$1>): ComputedRef<T$1>;
 /**
  * Reactive `Array.reduce`
  *
@@ -1026,7 +1040,7 @@ declare function useArrayReduce<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayReduce<T, U>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<U, T, U>, initialValue: MaybeRefOrGetter<U>): ComputedRef<U>;
+declare function useArrayReduce<T$1, U$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, reducer: UseArrayReducer<U$1, T$1, U$1>, initialValue: MaybeRefOrGetter<U$1>): ComputedRef<U$1>;
 //#endregion
 //#region useArraySome/index.d.ts
 type UseArraySomeReturn = ComputedRef<boolean>;
@@ -1041,10 +1055,10 @@ type UseArraySomeReturn = ComputedRef<boolean>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArraySome<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArraySomeReturn;
+declare function useArraySome<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => unknown): UseArraySomeReturn;
 //#endregion
 //#region useArrayUnique/index.d.ts
-type UseArrayUniqueReturn<T = any> = ComputedRef<T[]>;
+type UseArrayUniqueReturn<T$1 = any> = ComputedRef<T$1[]>;
 /**
  * reactive unique array
  * @see https://vueuse.org/useArrayUnique
@@ -1054,7 +1068,7 @@ type UseArrayUniqueReturn<T = any> = ComputedRef<T[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayUnique<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, compareFn?: (a: T, b: T, array: T[]) => boolean): UseArrayUniqueReturn<T>;
+declare function useArrayUnique<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, compareFn?: (a: T$1, b: T$1, array: T$1[]) => boolean): UseArrayUniqueReturn<T$1>;
 //#endregion
 //#region useCounter/index.d.ts
 interface UseCounterOptions {
@@ -1140,7 +1154,7 @@ type UseDateFormatReturn = ComputedRef<string>;
 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>;
+type UseDebounceFnReturn<T$1 extends FunctionArgs> = PromisifyFn<T$1>;
 /**
  * Debounce execution of a function.
  *
@@ -1153,7 +1167,7 @@ type UseDebounceFnReturn<T extends FunctionArgs> = PromisifyFn<T>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): UseDebounceFnReturn<T>;
+declare function useDebounceFn<T$1 extends FunctionArgs>(fn: T$1, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): UseDebounceFnReturn<T$1>;
 //#endregion
 //#region useInterval/index.d.ts
 interface UseIntervalOptions<Controls extends boolean> {
@@ -1213,7 +1227,7 @@ type UseIntervalFnReturn = Pausable;
  * @param interval
  * @param options
  */
-declare function useIntervalFn(cb: Fn$1, interval?: MaybeRefOrGetter<number>, options?: UseIntervalFnOptions): UseIntervalFnReturn;
+declare function useIntervalFn(cb: Fn, 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> {
@@ -1248,7 +1262,7 @@ declare function useLastChanged(source: WatchSource, options: UseLastChangedOpti
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useThrottleFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): PromisifyFn<T>;
+declare function useThrottleFn<T$1 extends FunctionArgs>(fn: T$1, ms?: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): PromisifyFn<T$1>;
 //#endregion
 //#region useTimeoutFn/index.d.ts
 interface UseTimeoutFnOptions {
@@ -1286,7 +1300,7 @@ interface UseTimeoutOptions<Controls extends boolean> extends UseTimeoutFnOption
   /**
    * Callback on timeout
    */
-  callback?: Fn$1;
+  callback?: Fn;
 }
 type UseTimoutReturn = ComputedRef<boolean> | {
   readonly ready: ComputedRef<boolean>;
@@ -1345,27 +1359,27 @@ declare function useToString(value: MaybeRefOrGetter<unknown>): ComputedRef<stri
 //#region useToggle/index.d.ts
 type ToggleFn = (value?: boolean) => void;
 type UseToggleReturn = [ShallowRef<boolean>, ToggleFn] | ToggleFn;
-interface UseToggleOptions<Truthy, Falsy> {
+interface UseToggleOptions<Truthy, Falsy$1> {
   truthyValue?: MaybeRefOrGetter<Truthy>;
-  falsyValue?: MaybeRefOrGetter<Falsy>;
+  falsyValue?: MaybeRefOrGetter<Falsy$1>;
 }
-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];
+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;
+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];
 //#endregion
 //#region watchArray/index.d.ts
-declare type WatchArrayCallback<V = any, OV = any> = (value: V, oldValue: OV, added: V, removed: OV, onCleanup: (cleanupFn: () => void) => void) => any;
+declare type WatchArrayCallback<V$1 = any, OV = any> = (value: V$1, oldValue: OV, added: V$1, removed: OV, onCleanup: (cleanupFn: () => void) => void) => any;
 /**
  * Watch for an array with additions and removals.
  *
  * @see https://vueuse.org/watchArray
  */
-declare function watchArray<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T[]> | T[], cb: WatchArrayCallback<T[], Immediate extends true ? T[] | undefined : T[]>, options?: WatchOptions<Immediate>): vue0.WatchHandle;
+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;
 //#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>): 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;
+declare function watchWithFilter<T$1 extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchHandle;
+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;
+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;
 //#endregion
 //#region watchAtMost/index.d.ts
 interface WatchAtMostOptions<Immediate> extends WatchWithFilterOptions<Immediate> {
@@ -1377,23 +1391,23 @@ interface WatchAtMostReturn {
   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;
-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;
+declare function watchAtMost<T$1 extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options: WatchAtMostOptions<Immediate>): WatchAtMostReturn;
+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;
 //#endregion
 //#region watchDebounced/index.d.ts
 interface WatchDebouncedOptions<Immediate> extends WatchOptions<Immediate>, DebounceFilterOptions {
   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>): 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;
+declare function watchDebounced<T$1 extends Readonly<WatchSource<unknown>[]>, 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$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$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;
 /** @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'>): 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;
+declare function watchDeep<T$1 extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(source: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchHandle;
+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;
+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;
 //#endregion
 //#region watchIgnorable/index.d.ts
 type IgnoredUpdater = (updater: () => void) => void;
@@ -1403,21 +1417,21 @@ interface WatchIgnorableReturn {
   ignorePrevAsyncUpdates: IgnoredPrevAsyncUpdates;
   stop: WatchStopHandle;
 }
-declare function watchIgnorable<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
-declare function watchIgnorable<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
-declare function watchIgnorable<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
+declare function watchIgnorable<T$1 extends Readonly<WatchSource<unknown>[]>, 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$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$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;
 /** @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'>): 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;
+declare function watchImmediate<T$1 extends Readonly<WatchSource<unknown>[]>>(source: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, true>>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
+declare function watchImmediate<T$1>(source: WatchSource<T$1>, cb: WatchCallback<T$1, T$1 | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
+declare function watchImmediate<T$1 extends object>(source: T$1, cb: WatchCallback<T$1, T$1 | 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'>): 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;
+declare function watchOnce<T$1 extends Readonly<WatchSource<unknown>[]>>(source: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, true>>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
+declare function watchOnce<T$1>(source: WatchSource<T$1>, cb: WatchCallback<T$1, T$1 | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
+declare function watchOnce<T$1 extends object>(source: T$1, cb: WatchCallback<T$1, T$1 | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
 //#endregion
 //#region watchPausable/index.d.ts
 interface WatchPausableReturn extends Pausable {
@@ -1427,9 +1441,9 @@ type WatchPausableOptions<Immediate> = WatchWithFilterOptions<Immediate> & Pausa
 /**
  * @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;
+declare function watchPausable<T$1 extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
+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$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;
 /** @deprecated use `watchPausable` instead */
 declare const pausableWatch: typeof watchPausable;
 //#endregion
@@ -1439,9 +1453,9 @@ interface WatchThrottledOptions<Immediate> extends WatchOptions<Immediate> {
   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>): 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;
+declare function watchThrottled<T$1 extends Readonly<WatchSource<unknown>[]>, 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$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$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;
 /** @deprecated use `watchThrottled` instead */
 declare const throttledWatch: typeof watchThrottled;
 //#endregion
@@ -1451,10 +1465,10 @@ interface WatchTriggerableReturn<FnReturnT = void> extends WatchIgnorableReturn
   trigger: () => FnReturnT;
 }
 type OnCleanup = (cleanupFn: () => void) => void;
-type WatchTriggerableCallback<V = any, OV = any, R = void> = (value: V, oldValue: OV, onCleanup: OnCleanup) => R;
-declare function watchTriggerable<T extends Readonly<WatchSource<unknown>[]>, FnReturnT>(sources: [...T], cb: WatchTriggerableCallback<MapSources<T>, MapOldSources<T, true>, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
-declare function watchTriggerable<T, FnReturnT>(source: WatchSource<T>, cb: WatchTriggerableCallback<T, T | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
-declare function watchTriggerable<T extends object, FnReturnT>(source: T, cb: WatchTriggerableCallback<T, T | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
+type WatchTriggerableCallback<V$1 = any, OV = any, R$1 = void> = (value: V$1, oldValue: OV, onCleanup: OnCleanup) => R$1;
+declare function watchTriggerable<T$1 extends Readonly<WatchSource<unknown>[]>, FnReturnT>(sources: [...T$1], cb: WatchTriggerableCallback<MapSources<T$1>, MapOldSources<T$1, true>, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
+declare function watchTriggerable<T$1, FnReturnT>(source: WatchSource<T$1>, cb: WatchTriggerableCallback<T$1, T$1 | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
+declare function watchTriggerable<T$1 extends object, FnReturnT>(source: T$1, cb: WatchTriggerableCallback<T$1, T$1 | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
 //#endregion
 //#region whenever/index.d.ts
 interface WheneverOptions extends WatchOptions {
@@ -1472,6 +1486,6 @@ interface WheneverOptions extends WatchOptions {
  *
  * @see https://vueuse.org/whenever
  */
-declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WheneverOptions): vue0.WatchHandle;
+declare function whenever<T$1>(source: WatchSource<T$1 | false | null | undefined>, cb: WatchCallback<T$1>, options?: WheneverOptions): vue0.WatchHandle;
 //#endregion
-export { AnyFn, ArgumentsType, Arrayable, Awaitable, Awaited, ComputedEagerOptions, ComputedEagerReturn, ComputedRefWithControl, ComputedWithControlRef, ComputedWithControlRefExtra, ConfigurableEventFilter, ConfigurableFlush, ConfigurableFlushSync, ControlledRefOptions, CreateGlobalStateReturn, CreateInjectionStateOptions, CreateRefReturn, DateLike, DebounceFilterOptions, DeepMaybeRef, ElementOf, EventFilter, EventHook, EventHookOff, EventHookOn, EventHookReturn, EventHookTrigger, ExtendRefOptions, ExtendRefReturn, Fn$1 as Fn, FunctionArgs, FunctionWrapperOptions, IfAny, IgnoredPrevAsyncUpdates, IgnoredUpdater, InstanceProxy, IsAny, IsDefinedReturn, ManualResetRefReturn, MapOldSources, MapSources, MultiWatchSources, Mutable, Pausable, PausableFilterOptions, Promisify, PromisifyFn, ProvideLocalReturn, Reactified, ReactifyNested, ReactifyObjectOptions, ReactifyObjectReturn, ReactifyOptions, ReactifyReturn, ReactiveComputedReturn, ReactiveOmitPredicate, ReactiveOmitReturn, ReactivePickPredicate, ReactivePickReturn, ReadonlyRefOrGetter, RefAutoResetReturn, RefDebouncedReturn, RefThrottledReturn, RemovableRef, ShallowOrDeepRef, ShallowUnwrapRef, SharedComposableReturn, SingletonPromiseReturn, Stoppable, SyncRefOptions, SyncRefsOptions, ThrottleFilterOptions, TimerHandle, ToRefsOptions, ToggleFn, UntilArrayInstance, UntilBaseInstance, UntilToMatchOptions, UntilValueInstance, UseArrayDifferenceOptions, UseArrayDifferenceReturn, UseArrayEveryReturn, UseArrayFilterReturn, UseArrayFindIndexReturn, UseArrayFindLastReturn, UseArrayFindReturn, UseArrayIncludesComparatorFn, UseArrayIncludesOptions, UseArrayIncludesReturn, UseArrayJoinReturn, UseArrayMapReturn, UseArrayReducer, UseArraySomeReturn, UseArrayUniqueReturn, UseCounterOptions, UseCounterReturn, UseDateFormatOptions, UseDateFormatReturn, UseDebounceFnReturn, UseIntervalControls, UseIntervalFnOptions, UseIntervalFnReturn, UseIntervalOptions, UseIntervalReturn, UseLastChangedOptions, UseLastChangedReturn, UseTimeoutFnOptions, UseTimeoutFnReturn, UseTimeoutOptions, UseTimoutReturn, UseToNumberOptions, UseToggleOptions, UseToggleReturn, WatchArrayCallback, WatchAtMostOptions, WatchAtMostReturn, WatchDebouncedOptions, WatchIgnorableReturn, 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 };
+export { AnyFn, ArgumentsType, Arrayable, Awaitable, Awaited, ComputedEagerOptions, ComputedEagerReturn, ComputedRefWithControl, ComputedWithControlRef, ComputedWithControlRefExtra, ConfigurableEventFilter, ConfigurableFlush, ConfigurableFlushSync, ControlledRefOptions, CreateGlobalStateReturn, CreateInjectionStateOptions, CreateInjectionStateReturn, CreateRefReturn, DateLike, DebounceFilterOptions, DeepMaybeRef, ElementOf, EventFilter, EventHook, EventHookOff, EventHookOn, EventHookReturn, EventHookTrigger, ExtendRefOptions, ExtendRefReturn, 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 };