@vueuse/shared 14.2.1 → 14.4.0

package/dist/index.d.ts

@@ -1,6 +1,4 @@
-import * as vue0 from "vue";
-import { ComponentInternalInstance, ComputedGetter, ComputedRef, InjectionKey, MaybeRef, MaybeRefOrGetter, MultiWatchSources, MultiWatchSources as MultiWatchSources$1, 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, FunctionDirective, InjectionKey, MaybeRef, MaybeRefOrGetter, MultiWatchSources, MultiWatchSources as MultiWatchSources$1, ObjectDirective, 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>>;
@@ -36,6 +34,17 @@ declare function computedWithControl<T>(source: WatchSource | MultiWatchSources$
 /** @deprecated use `computedWithControl` instead */
 declare const controlledComputed: typeof computedWithControl;
 //#endregion
+//#region createDisposableDirective/index.d.ts
+type originDirective<H, V, A> = FunctionDirective<H, V, string, A> | ObjectDirective<H, V, string, A>;
+/**
+ * Utility for authoring disposable directives. Reactive effects created within `mounted` directive hook will be tracked and automatically disposed when directive is unmounted.
+ *
+ * @see https://vueuse.org/createDisposableDirective
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function createDisposableDirective<H extends HTMLElement, V, A = any>(origin?: originDirective<H, V, A>): originDirective<H, V, A>;
+//#endregion
 //#region utils/types.d.ts
 /**
  * Void function
@@ -62,7 +71,7 @@ type ReadonlyRefOrGetter<T> = ComputedRef<T> | (() => T);
  * UnwrapRef<DeepMaybeRef<T>> === T
  * ```
  */
-type DeepMaybeRef<T> = T extends Ref<infer V> ? MaybeRef<V> : T extends Array<any> | object ? { [K in keyof T]: DeepMaybeRef<T[K]> } : MaybeRef<T>;
+type DeepMaybeRef<T> = T extends Ref<infer V> ? MaybeRef<V> : T extends Array<any> | object ? { [K in keyof T]: DeepMaybeRef<T[K]>; } : MaybeRef<T>;
 type Arrayable<T> = T[] | T;
 /**
  * Infers the element type of an array
@@ -125,9 +134,9 @@ interface ConfigurableFlushSync {
    */
   flush?: WatchOptionFlush;
 }
-type MapSources<T> = { [K in keyof T]: T[K] extends WatchSource<infer V> ? V : never };
-type MapOldSources<T, Immediate> = { [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : never };
-type Mutable<T> = { -readonly [P in keyof T]: T[P] };
+type MapSources<T> = { [K in keyof T]: T[K] extends WatchSource<infer V> ? V : never; };
+type MapOldSources<T, Immediate> = { [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : never; };
+type Mutable<T> = { -readonly [P in keyof T]: T[P]; };
 type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
 /**
  * will return `true` if `T` is `any`, or `false` otherwise
@@ -170,6 +179,12 @@ interface FunctionWrapperOptions<Args extends any[] = any[], This = any> {
   thisArg: This;
 }
 type EventFilter<Args extends any[] = any[], This = any, Invoke extends AnyFn = AnyFn> = (invoke: Invoke, options: FunctionWrapperOptions<Args, This>) => ReturnType<Invoke> | Promisify<ReturnType<Invoke>>;
+interface CancelableEventFilter<Args extends any[] = any[], This = any, Invoke extends AnyFn = AnyFn> {
+  (invoke: Invoke, options: FunctionWrapperOptions<Args, This>): ReturnType<Invoke> | Promisify<ReturnType<Invoke>>;
+  cancel: () => void;
+  flush: () => void;
+  readonly isPending: Readonly<Ref<boolean>>;
+}
 interface ConfigurableEventFilter {
   /**
    * Filter for if events should to be received.
@@ -191,15 +206,21 @@ interface DebounceFilterOptions {
    */
   rejectOnCancel?: boolean;
 }
+type CancelablePromisifyFn<T extends AnyFn> = PromisifyFn<T> & {
+  cancel: () => void;
+  flush: () => void;
+  readonly isPending: Readonly<Ref<boolean>>;
+};
 /**
  * @internal
  */
-declare function createFilterWrapper<T extends AnyFn>(filter: EventFilter, fn: T): (this: any, ...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+declare function createFilterWrapper<T extends AnyFn>(filter: CancelableEventFilter, fn: T): CancelablePromisifyFn<T>;
+declare function createFilterWrapper<T extends AnyFn>(filter: EventFilter, fn: T): PromisifyFn<T>;
 declare const bypassFilter: EventFilter;
 /**
  * Create an EventFilter that debounce the events
  */
-declare function debounceFilter(ms: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): EventFilter<any[], any, AnyFn>;
+declare function debounceFilter(ms: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): CancelableEventFilter;
 interface ThrottleFilterOptions {
   /**
    * The maximum time allowed to be delayed before it's invoked.
@@ -304,7 +325,7 @@ declare const timestamp: () => number;
 declare const clamp: (n: number, min: number, max: number) => number;
 declare const noop: () => void;
 declare const rand: (min: number, max: number) => number;
-declare const hasOwn: <T extends object, K$1 extends keyof T>(val: T, key: K$1) => key is K$1;
+declare const hasOwn: <T extends object, K extends keyof T>(val: T, key: K) => key is K;
 declare const isIOS: boolean;
 //#endregion
 //#region utils/port.d.ts
@@ -315,7 +336,7 @@ declare const camelize: (str: string) => string;
 declare function getLifeCycleTarget(target?: ComponentInternalInstance | null): ComponentInternalInstance | null;
 //#endregion
 //#region createGlobalState/index.d.ts
-type CreateGlobalStateReturn<Fn$1 extends AnyFn = AnyFn> = Fn$1;
+type CreateGlobalStateReturn<Fn extends AnyFn = AnyFn> = Fn;
 /**
  * Keep states in the global scope to be reusable across Vue instances.
  *
@@ -324,23 +345,23 @@ type CreateGlobalStateReturn<Fn$1 extends AnyFn = AnyFn> = Fn$1;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function createGlobalState<Fn$1 extends AnyFn>(stateFactory: Fn$1): CreateGlobalStateReturn<Fn$1>;
+declare function createGlobalState<Fn extends AnyFn>(stateFactory: Fn): CreateGlobalStateReturn<Fn>;
 //#endregion
 //#region createInjectionState/index.d.ts
-type CreateInjectionStateReturn<Arguments extends Array<any>, Return> = Readonly<[
+type CreateInjectionStateReturn<Arguments extends Array<any>, ProvideReturn, InjectReturn> = 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,
+useProvidingState: (...args: Arguments) => ProvideReturn,
 /**
  * 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]>;
+useInjectedState: () => InjectReturn]>;
 interface CreateInjectionStateOptions<Return> {
   /**
    * Custom injectionKey for InjectionState
@@ -358,7 +379,10 @@ interface CreateInjectionStateOptions<Return> {
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function createInjectionState<Arguments extends Array<any>, Return>(composable: (...args: Arguments) => Return, options?: CreateInjectionStateOptions<Return>): CreateInjectionStateReturn<Arguments, Return>;
+declare function createInjectionState<Arguments extends Array<any>, Return>(composable: (...args: Arguments) => Return, options: {
+  defaultValue: Return;
+} & CreateInjectionStateOptions<Return>): CreateInjectionStateReturn<Arguments, Return, Return>;
+declare function createInjectionState<Arguments extends Array<any>, Return>(composable: (...args: Arguments) => Return, options?: CreateInjectionStateOptions<Return>): CreateInjectionStateReturn<Arguments, Return, Return | undefined>;
 //#endregion
 //#region createRef/index.d.ts
 type CreateRefReturn<T = any, D extends boolean = false> = ShallowOrDeepRef<T, D>;
@@ -389,7 +413,7 @@ type SharedComposableReturn<T extends AnyFn = AnyFn> = T;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function createSharedComposable<Fn$1 extends AnyFn>(composable: Fn$1): SharedComposableReturn<Fn$1>;
+declare function createSharedComposable<Fn extends AnyFn>(composable: Fn): SharedComposableReturn<Fn>;
 //#endregion
 //#region extendRef/index.d.ts
 type ExtendRefReturn<T = any> = Ref<T>;
@@ -410,18 +434,18 @@ interface ExtendRefOptions<Unwrap extends boolean = boolean> {
 /**
  * Overload 1: Unwrap set to false
  */
-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;
+declare function extendRef<R extends Ref<any>, Extend extends object, Options extends ExtendRefOptions<false>>(ref: R, extend: Extend, options?: Options): ShallowUnwrapRef$1<Extend> & R;
 /**
  * Overload 2: Unwrap unset or set to true
  */
-declare function extendRef<R$1 extends Ref<any>, Extend extends object, Options extends ExtendRefOptions>(ref: R$1, extend: Extend, options?: Options): Extend & R$1;
+declare function extendRef<R extends Ref<any>, Extend extends object, Options extends ExtendRefOptions>(ref: R, extend: Extend, options?: Options): Extend & R;
 //#endregion
 //#region get/index.d.ts
 /**
  * Shorthand for accessing `ref.value`
  */
 declare function get<T>(ref: MaybeRef<T>): T;
-declare function get<T, K$1 extends keyof T>(ref: MaybeRef<T>, key: K$1): T[K$1];
+declare function get<T, K extends keyof T>(ref: MaybeRef<T>, key: K): T[K];
 //#endregion
 //#region injectLocal/index.d.ts
 /**
@@ -444,7 +468,7 @@ declare function isDefined<T>(v: Ref<T>): v is Ref<Exclude<T, null | undefined>>
 declare function isDefined<T>(v: T): v is Exclude<T, null | undefined>;
 //#endregion
 //#region makeDestructurable/index.d.ts
-declare function makeDestructurable<T extends Record<string, unknown>, A$1 extends readonly any[]>(obj: T, arr: A$1): T & A$1;
+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;
@@ -460,11 +484,11 @@ type ProvideLocalReturn = void;
  * const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
  * ```
  */
-declare function provideLocal<T, K$1 = LocalProvidedKey<T>>(key: K$1, value: K$1 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<A[K]> : MaybeRef<A[K]> }) => ComputedRef<R> : never;
-type ReactifyReturn<T extends AnyFn = AnyFn, K$1 extends boolean = true> = Reactified<T, K$1>;
+type Reactified<T, Computed extends boolean> = T extends ((...args: infer A) => infer R) ? (...args: { [K in keyof A]: Computed extends true ? MaybeRefOrGetter<A[K]> : MaybeRef<A[K]>; }) => ComputedRef<R> : never;
+type ReactifyReturn<T extends AnyFn = AnyFn, K extends boolean = true> = Reactified<T, K>;
 interface ReactifyOptions<T extends boolean> {
   /**
    * Accept passing a function as a reactive getter
@@ -483,13 +507,13 @@ interface ReactifyOptions<T extends boolean> {
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function reactify<T extends AnyFn, K$1 extends boolean = true>(fn: T, options?: ReactifyOptions<K$1>): ReactifyReturn<T, K$1>;
+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$1 extends boolean = true> = { [K in Keys]: T[K] extends AnyFn ? Reactified<T[K], S$1> : T[K] };
-type ReactifyObjectReturn<T, Keys extends keyof T, S$1 extends boolean = true> = ReactifyNested<T, Keys, S$1>;
+type ReactifyNested<T, Keys extends keyof T = keyof T, S extends boolean = true> = { [K in Keys]: T[K] extends AnyFn ? Reactified<T[K], S> : T[K]; };
+type ReactifyObjectReturn<T, Keys extends keyof T, S extends boolean = true> = ReactifyNested<T, Keys, S>;
 interface ReactifyObjectOptions<T extends boolean> extends ReactifyOptions<T> {
   /**
    * Includes names from Object.getOwnPropertyNames
@@ -504,7 +528,7 @@ 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$1 extends boolean = true>(obj: T, options?: ReactifyObjectOptions<S$1>): ReactifyObjectReturn<T, keyof T, S$1>;
+declare function reactifyObject<T extends object, S extends boolean = true>(obj: T, options?: ReactifyObjectOptions<S>): ReactifyObjectReturn<T, keyof T, S>;
 //#endregion
 //#region reactiveComputed/index.d.ts
 type ReactiveComputedReturn<T extends object> = UnwrapNestedRefs<T>;
@@ -514,15 +538,15 @@ type ReactiveComputedReturn<T extends object> = UnwrapNestedRefs<T>;
 declare function reactiveComputed<T extends object>(fn: ComputedGetter<T>): ReactiveComputedReturn<T>;
 //#endregion
 //#region reactiveOmit/index.d.ts
-type ReactiveOmitReturn<T extends object, K$1 extends keyof T | undefined = undefined> = [K$1] extends [undefined] ? Partial<T> : Omit<T, Extract<K$1, keyof T>>;
+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$1 extends keyof T>(obj: T, ...keys: (K$1 | K$1[])[]): ReactiveOmitReturn<T, K$1>;
+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>;
 //#endregion
 //#region reactivePick/index.d.ts
-type ReactivePickReturn<T extends object, K$1 extends keyof T> = { [S in K$1]: UnwrapRef<T[S]> };
+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$1 extends keyof T>(obj: T, ...keys: (K$1 | K$1[])[]): ReactivePickReturn<T, K$1>;
+declare function reactivePick<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): ReactivePickReturn<T, K>;
 declare function reactivePick<T extends object>(obj: T, predicate: ReactivePickPredicate<T>): ReactivePickReturn<T, keyof T>;
 //#endregion
 //#region refAutoReset/index.d.ts
@@ -614,63 +638,63 @@ interface ControlledRefOptions<T> {
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function refWithControl<T>(initial: T, options?: ControlledRefOptions<T>): vue0.ShallowUnwrapRef<{
+declare function refWithControl<T>(initial: T, options?: ControlledRefOptions<T>): {
   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>;
+} & import("vue").Ref<T, T>;
 /** @deprecated use `refWithControl` instead */
 declare const controlledRef: typeof refWithControl;
 //#endregion
 //#region set/index.d.ts
 declare function set<T>(ref: Ref<T>, value: T): void;
-declare function set<O extends object, K$1 extends keyof O>(target: O, key: K$1, value: O[K$1]): void;
+declare function set<O extends object, K extends keyof O>(target: O, key: K, value: O[K]): void;
 //#endregion
 //#region syncRef/index.d.ts
 type Direction = 'ltr' | 'rtl' | 'both';
-type SpecificFieldPartial<T, K$1 extends keyof T> = Partial<Pick<T, K$1>> & Omit<T, K$1>;
+type SpecificFieldPartial<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
 /**
  * A = B
  */
-type Equal<A$1, B> = [A$1] extends [B] ? ([B] extends [A$1] ? true : false) : false;
+type Equal<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
 /**
  * A ∩ B ≠ ∅
  */
-type IntersectButNotEqual<A$1, B> = Equal<A$1, B> extends true ? false : A$1 & B extends never ? false : true;
+type IntersectButNotEqual<A, B> = Equal<A, B> extends true ? false : A & B extends never ? false : true;
 /**
  * A ⊆ B
  */
-type IncludeButNotEqual<A$1, B> = Equal<A$1, B> extends true ? false : A$1 extends B ? true : false;
+type IncludeButNotEqual<A, B> = Equal<A, B> extends true ? false : A extends B ? true : false;
 /**
  * A ∩ B = ∅
  */
-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 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 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>;
+type StrictIncludeMap<IncludeType extends 'LR' | 'RL', D extends Exclude<Direction, 'both'>, L, R> = (Equal<[IncludeType, D], ['LR', 'ltr']> & Equal<[IncludeType, D], ['RL', 'rtl']>) extends true ? {
+  transform?: SpecificFieldPartial<Pick<Transform<L, R>, D>, D>;
 } : {
-  transform: Pick<Transform<L, R$1>, D>;
+  transform: Pick<Transform<L, R>, D>;
 };
-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>;
+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>;
 } : D extends Exclude<Direction, 'both'> ? {
-  transform: Pick<Transform<L, R$1>, D>;
+  transform: Pick<Transform<L, R>, D>;
 } : never;
-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 NotIntersectType<D extends Direction, L, R> = IntersectButNotEqualType<D, L, R>;
+interface Transform<L, R> {
+  ltr: (left: L) => R;
+  rtl: (right: R) => L;
 }
-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 & {
+type TransformType<D extends Direction, L, R> = Equal<L, R> extends true ? EqualType<D, L, R> : IncludeButNotEqual<L, R> extends true ? StrictIncludeType<'LR', D, L, R> : IncludeButNotEqual<R, L> extends true ? StrictIncludeType<'RL', D, L, R> : IntersectButNotEqual<L, R> extends true ? IntersectButNotEqualType<D, L, R> : NotIntersect<L, R> extends true ? NotIntersectType<D, L, R> : never;
+type SyncRefOptions<L, R, D extends Direction> = ConfigurableFlushSync & {
   /**
    * Watch deeply
    *
@@ -689,7 +713,7 @@ type SyncRefOptions<L, R$1, D extends Direction> = ConfigurableFlushSync & {
    * @default 'both'
    */
   direction?: D;
-} & TransformType<D, L, R$1>;
+} & TransformType<D, L, R>;
 /**
  * Two-way refs synchronization.
  * From the set theory perspective to restrict the option's type
@@ -699,7 +723,7 @@ type SyncRefOptions<L, R$1, D extends Direction> = ConfigurableFlushSync & {
  * 3. L ⊆ R
  * 4. L ∩ R = ∅
  */
-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;
+declare function syncRef<L, R, D extends Direction = 'both'>(left: Ref<L>, right: Ref<R>, ...[options]: Equal<L, R> extends true ? [options?: SyncRefOptions<L, R, D>] : [options: SyncRefOptions<L, R, D>]): () => void;
 //#endregion
 //#region syncRefs/index.d.ts
 interface SyncRefsOptions extends ConfigurableFlushSync {
@@ -722,7 +746,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>(source: WatchSource<T>, targets: Ref<T> | Ref<T>[], options?: SyncRefsOptions): import("vue").WatchHandle;
 //#endregion
 //#region toReactive/index.d.ts
 /**
@@ -741,8 +765,8 @@ 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$1 extends keyof T>(object: T, key: K$1): ToRef<T[K$1]>;
-declare function toRef<T extends object, K$1 extends keyof T>(object: T, key: K$1, defaultValue: T[K$1]): ToRef<Exclude<T[K$1], undefined>>;
+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>>;
 //#endregion
 //#region toRefs/index.d.ts
 interface ToRefsOptions {
@@ -831,14 +855,14 @@ interface UntilToMatchOptions extends ConfigurableFlushSync {
   deep?: WatchOptions['deep'];
 }
 interface UntilBaseInstance<T, Not extends boolean = false> {
-  toMatch: (<U$1 extends T = T>(condition: (v: T) => v is U$1, options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, U$1>> : Promise<U$1>) & ((condition: (v: T) => boolean, options?: UntilToMatchOptions) => Promise<T>);
+  toMatch: (<U extends T = T>(condition: (v: T) => v is U, options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, U>> : Promise<U>) & ((condition: (v: T) => boolean, options?: UntilToMatchOptions) => Promise<T>);
   changed: (options?: UntilToMatchOptions) => Promise<T>;
   changedTimes: (n?: number, options?: UntilToMatchOptions) => Promise<T>;
 }
 type Falsy = false | void | null | undefined | 0 | 0n | '';
 interface UntilValueInstance<T, Not extends boolean = false> extends UntilBaseInstance<T, Not> {
   readonly not: UntilValueInstance<T, Not extends true ? false : true>;
-  toBe: <P$1 = T>(value: MaybeRefOrGetter<P$1>, options?: UntilToMatchOptions) => Not extends true ? Promise<T> : Promise<P$1>;
+  toBe: <P = T>(value: MaybeRefOrGetter<P>, options?: UntilToMatchOptions) => Not extends true ? Promise<T> : Promise<P>;
   toBeTruthy: (options?: UntilToMatchOptions) => Not extends true ? Promise<T & Falsy> : Promise<Exclude<T, Falsy>>;
   toBeNull: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, null>> : Promise<null>;
   toBeUndefined: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, undefined>> : Promise<undefined>;
@@ -906,7 +930,7 @@ type UseArrayFilterReturn<T = any> = ComputedRef<T[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayFilter<T, S$1 extends T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => element is S$1): UseArrayFilterReturn<S$1>;
+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
@@ -955,10 +979,10 @@ type UseArrayFindLastReturn<T = any> = ComputedRef<T | undefined>;
 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$1> = ((element: T, value: V$1, index: number, array: MaybeRefOrGetter<T>[]) => boolean);
-interface UseArrayIncludesOptions<T, V$1> {
+type UseArrayIncludesComparatorFn<T, V> = ((element: T, value: V, index: number, array: MaybeRefOrGetter<T>[]) => boolean);
+interface UseArrayIncludesOptions<T, V> {
   fromIndex?: number;
-  comparator?: UseArrayIncludesComparatorFn<T, V$1> | keyof T;
+  comparator?: UseArrayIncludesComparatorFn<T, V> | keyof T;
 }
 type UseArrayIncludesReturn = ComputedRef<boolean>;
 /**
@@ -970,9 +994,9 @@ type UseArrayIncludesReturn = ComputedRef<boolean>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayIncludes<T, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V$1>, comparator?: UseArrayIncludesComparatorFn<T, V$1>): UseArrayIncludesReturn;
-declare function useArrayIncludes<T, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V$1>, comparator?: keyof T): UseArrayIncludesReturn;
-declare function useArrayIncludes<T, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V$1>, options?: UseArrayIncludesOptions<T, V$1>): 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>;
@@ -1002,10 +1026,10 @@ type UseArrayMapReturn<T = any> = ComputedRef<T[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayMap<T, U$1 = T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => U$1): UseArrayMapReturn<U$1>;
+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$1> = (previousValue: PV, currentValue: CV, currentIndex: number) => R$1;
+type UseArrayReducer<PV, CV, R> = (previousValue: PV, currentValue: CV, currentIndex: number) => R;
 type UseArrayReduceReturn<T = any> = ComputedRef<T>;
 /**
  * Reactive `Array.reduce`
@@ -1031,7 +1055,7 @@ declare function useArrayReduce<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function useArrayReduce<T, U$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<U$1, T, U$1>, initialValue: MaybeRefOrGetter<U$1>): UseArrayReduceReturn<U$1>;
+declare function useArrayReduce<T, U>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<U, T, U>, initialValue: MaybeRefOrGetter<U>): UseArrayReduceReturn<U>;
 //#endregion
 //#region useArraySome/index.d.ts
 type UseArraySomeReturn = ComputedRef<boolean>;
@@ -1106,7 +1130,7 @@ interface UseCounterReturn {
  * @param options
  */
 declare function useCounter(initialValue?: MaybeRef<number>, options?: UseCounterOptions): {
-  count: Readonly<Ref<number, number> | vue0.ShallowRef<number, number> | vue0.WritableComputedRef<number, number>>;
+  count: Readonly<Ref<number, number> | import("vue").ShallowRef<number, number> | import("vue").WritableComputedRef<number, number>>;
   inc: (delta?: number) => number;
   dec: (delta?: number) => number;
   get: () => number;
@@ -1145,7 +1169,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 extends FunctionArgs> = CancelablePromisifyFn<T>;
 /**
  * Debounce execution of a function.
  *
@@ -1154,9 +1178,7 @@ type UseDebounceFnReturn<T extends FunctionArgs> = PromisifyFn<T>;
  * @param  ms          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
  * @param  options     Options
  *
- * @return A new, debounce, function.
- *
- * @__NO_SIDE_EFFECTS__
+ * @return A new, debounced, function with isPending, cancel, and flush properties.
  */
 declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): UseDebounceFnReturn<T>;
 //#endregion
@@ -1354,26 +1376,26 @@ 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$1> {
+interface UseToggleOptions<Truthy, Falsy> {
   truthyValue?: MaybeRefOrGetter<Truthy>;
-  falsyValue?: MaybeRefOrGetter<Falsy$1>;
+  falsyValue?: MaybeRefOrGetter<Falsy>;
 }
-declare function useToggle<Truthy, Falsy$1, T = Truthy | Falsy$1>(initialValue: Ref<T>, options?: UseToggleOptions<Truthy, Falsy$1>): (value?: T) => T;
-declare function useToggle<Truthy = true, Falsy$1 = false, T = Truthy | Falsy$1>(initialValue?: T, options?: UseToggleOptions<Truthy, Falsy$1>): [ShallowRef<T>, (value?: T) => T];
+declare function useToggle<Truthy, Falsy, T = Truthy | Falsy>(initialValue: Ref<T>, options?: UseToggleOptions<Truthy, Falsy>): (value?: T) => T;
+declare function useToggle<Truthy = true, Falsy = false, T = Truthy | Falsy>(initialValue?: T, options?: UseToggleOptions<Truthy, Falsy>): [ShallowRef<T>, (value?: T) => T];
 //#endregion
 //#region watchArray/index.d.ts
-declare type WatchArrayCallback<V$1 = any, OV = any> = (value: V$1, oldValue: OV, added: V$1, removed: OV, onCleanup: (cleanupFn: () => void) => void) => any;
+declare type WatchArrayCallback<V = any, OV = any> = (value: V, oldValue: OV, added: V, removed: OV, onCleanup: (cleanupFn: () => void) => void) => any;
 /**
  * Watch for an array with additions and removals.
  *
  * @see https://vueuse.org/watchArray
  */
-declare function watchArray<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T[]> | T[], cb: WatchArrayCallback<T[], Immediate extends true ? T[] | undefined : T[]>, options?: WatchOptions<Immediate>): vue0.WatchHandle;
+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>): import("vue").WatchHandle;
 //#endregion
 //#region watchWithFilter/index.d.ts
 interface WatchWithFilterOptions<Immediate> extends WatchOptions<Immediate>, ConfigurableEventFilter {}
-declare function watchWithFilter<T extends Readonly<MultiWatchSources$1>, 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 Readonly<MultiWatchSources$1>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, 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
@@ -1386,22 +1408,23 @@ interface WatchAtMostReturn {
   resume: () => void;
   count: ShallowRef<number>;
 }
-declare function watchAtMost<T extends Readonly<MultiWatchSources$1>, 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 extends Readonly<MultiWatchSources$1>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options: WatchAtMostOptions<Immediate>): WatchAtMostReturn;
+declare function watchAtMost<T extends object, Immediate extends Readonly<boolean> = false>(sources: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, 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<MultiWatchSources$1>, 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 Readonly<MultiWatchSources$1>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, 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<MultiWatchSources$1>, 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 Readonly<MultiWatchSources$1>, Immediate extends Readonly<boolean> = false>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, 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
@@ -1412,20 +1435,20 @@ interface WatchIgnorableReturn {
   ignorePrevAsyncUpdates: IgnoredPrevAsyncUpdates;
   stop: WatchStopHandle;
 }
-declare function watchIgnorable<T extends Readonly<MultiWatchSources$1>, 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 Readonly<MultiWatchSources$1>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, 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<MultiWatchSources$1>>(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 Readonly<MultiWatchSources$1>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, 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<MultiWatchSources$1>>(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 Readonly<MultiWatchSources$1>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, 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
@@ -1434,10 +1457,10 @@ interface WatchPausableReturn extends Pausable {
 }
 type WatchPausableOptions<Immediate> = WatchWithFilterOptions<Immediate> & PausableFilterOptions;
 /** @deprecated Use Vue's built-in `watch` instead. This function will be removed in future version. */
-declare function watchPausable<T extends Readonly<MultiWatchSources$1>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
-/** @deprecated Use Vue's built-in `watch` instead. This function will be removed in future version. */
 declare function watchPausable<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
 /** @deprecated Use Vue's built-in `watch` instead. This function will be removed in future version. */
+declare function watchPausable<T extends Readonly<MultiWatchSources$1>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
+/** @deprecated Use Vue's built-in `watch` instead. This function will be removed in future version. */
 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 Vue's built-in `watch` instead. This function will be removed in future version. */
 declare const pausableWatch: typeof watchPausable;
@@ -1448,8 +1471,8 @@ interface WatchThrottledOptions<Immediate> extends WatchOptions<Immediate> {
   trailing?: boolean;
   leading?: boolean;
 }
-declare function watchThrottled<T extends Readonly<MultiWatchSources$1>, 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 Readonly<MultiWatchSources$1>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, 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;
@@ -1460,13 +1483,14 @@ interface WatchTriggerableReturn<FnReturnT = void> extends WatchIgnorableReturn
   trigger: () => FnReturnT;
 }
 type OnCleanup = (cleanupFn: () => void) => void;
-type WatchTriggerableCallback<V$1 = any, OV = any, R$1 = void> = (value: V$1, oldValue: OV, onCleanup: OnCleanup) => R$1;
-declare function watchTriggerable<T extends Readonly<MultiWatchSources$1>, FnReturnT>(sources: [...T], cb: WatchTriggerableCallback<MapSources<T>, MapOldSources<T, true>, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
+type WatchTriggerableCallback<V = any, OV = any, R = void> = (value: V, oldValue: OV, onCleanup: OnCleanup) => R;
 declare function watchTriggerable<T, FnReturnT>(source: WatchSource<T>, cb: WatchTriggerableCallback<T, T | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
+declare function watchTriggerable<T extends Readonly<MultiWatchSources$1>, FnReturnT>(sources: [...T], cb: WatchTriggerableCallback<MapSources<T>, MapOldSources<T, true>, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
 declare function watchTriggerable<T extends object, FnReturnT>(source: T, cb: WatchTriggerableCallback<T, T | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
 //#endregion
 //#region whenever/index.d.ts
-interface WheneverOptions extends WatchOptions {
+type Truthy<T> = T extends false | null | undefined ? never : T;
+interface WheneverOptions<Immediate = boolean> extends WatchOptions<Immediate> {
   /**
    * Only trigger once when the condition is met
    *
@@ -1481,6 +1505,7 @@ 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>(source: WatchSource<T>, cb: WatchCallback<Truthy<T>, T | undefined>, options?: WheneverOptions<true>): WatchHandle;
+declare function whenever<T>(source: WatchSource<T>, cb: WatchCallback<Truthy<T>, T>, options?: WheneverOptions<false>): WatchHandle;
 //#endregion
-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, type 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, UseArrayReduceReturn, UseArrayReducer, UseArraySomeReturn, UseArrayUniqueReturn, UseCounterOptions, UseCounterReturn, UseDateFormatOptions, UseDateFormatReturn, UseDebounceFnReturn, UseIntervalControls, UseIntervalFnOptions, UseIntervalFnReturn, UseIntervalOptions, UseIntervalReturn, UseLastChangedOptions, UseLastChangedReturn, UseTimeoutFnOptions, UseTimeoutFnReturn, UseTimeoutOptions, UseTimeoutReturn, 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, CancelableEventFilter, CancelablePromisifyFn, 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, type 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, UseArrayReduceReturn, UseArrayReducer, UseArraySomeReturn, UseArrayUniqueReturn, UseCounterOptions, UseCounterReturn, UseDateFormatOptions, UseDateFormatReturn, UseDebounceFnReturn, UseIntervalControls, UseIntervalFnOptions, UseIntervalFnReturn, UseIntervalOptions, UseIntervalReturn, UseLastChangedOptions, UseLastChangedReturn, UseTimeoutFnOptions, UseTimeoutFnReturn, UseTimeoutOptions, UseTimeoutReturn, 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, createDisposableDirective, 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 };