@reactive-vscode/vueuse 1.0.0-beta.2 → 1.0.1

package/dist/index.d.ts

@@ -33,9 +33,9 @@ export declare interface AfterFetchContext<T = any> {
  */
 export declare type AnyFn = (...args: any[]) => any;
 
-export declare type ArgumentsType<T$1> = T$1 extends ((...args: infer U) => any) ? U : never;
+export declare type ArgumentsType<T> = T extends ((...args: infer U) => any) ? U : never;
 
-export declare type Arrayable<T$1> = T$1[] | T$1;
+export declare type Arrayable<T> = T[] | T;
 
 export declare const assert: (condition: boolean, ...infos: any[]) => void;
 
@@ -49,7 +49,7 @@ export declare const asyncComputed: typeof computedAsync;
  */
 export declare type AsyncComputedOnCancel = (cancelCallback: Fn) => void;
 
-export declare interface AsyncComputedOptions<Lazy = boolean> {
+export declare interface AsyncComputedOptions<Lazy = boolean> extends ConfigurableFlushSync {
     /**
      * Should value be evaluated lazily
      *
@@ -66,15 +66,6 @@ export declare interface AsyncComputedOptions<Lazy = boolean> {
      * @default true
      */
     shallow?: boolean;
-    /**
-     * The flush option allows for greater control over the timing of a history point, default to `pre`
-     *
-     * Possible values: `pre`, `post`, `sync`
-     *
-     * It works in the same way as the flush option in watch and watch effect in vue reactivity
-     * @default 'sync'
-     */
-    flush?: WatchOptionFlush;
     /**
      * Callback when error is caught.
      */
@@ -84,14 +75,14 @@ export declare interface AsyncComputedOptions<Lazy = boolean> {
 /** @deprecated use `refAutoReset` instead */
 export declare const autoResetRef: typeof refAutoReset;
 
-export declare type Awaitable<T$1> = Promise<T$1> | T$1;
+export declare type Awaitable<T> = Promise<T> | T;
 
 /**
  * Compatible with versions below TypeScript 4.5 Awaited
  */
-declare type Awaited_2<T$1> = T$1 extends null | undefined ? T$1 : T$1 extends object & {
+declare type Awaited_2<T> = T extends null | undefined ? T : T extends object & {
     then: (onfulfilled: infer F, ...args: infer _) => any;
-} ? F extends ((value: infer V, ...args: infer _) => any) ? Awaited_2<V> : never : T$1;
+} ? F extends ((value: infer V, ...args: infer _) => any) ? Awaited_2<V> : never : T;
 export { Awaited_2 as Awaited }
 
 export declare interface BeforeFetchContext {
@@ -126,7 +117,7 @@ declare interface BrowserLocationState {
 
 export declare const bypassFilter: EventFilter;
 
-declare type Callback<T$1> = IsAny<T$1> extends true ? (...param: any) => void : ([T$1] extends [void] ? (...param: unknown[]) => void : [T$1] extends [any[]] ? (...param: T$1) => void : (...param: [T$1, ...unknown[]]) => void);
+declare type Callback<T> = IsAny<T> extends true ? (...param: any) => void : ([T] extends [void] ? (...param: unknown[]) => void : [T] extends [any[]] ? (...param: T) => void : (...param: [T, ...unknown[]]) => void);
 
 export declare const camelize: (str: string) => string;
 
@@ -167,11 +158,11 @@ export declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncCom
  * @param options WatchOptionsBase
  * @returns readonly shallowRef
  */
-export declare function computedEager<T$1>(fn: () => T$1, options?: ComputedEagerOptions): ComputedEagerReturn<T$1>;
+export declare function computedEager<T>(fn: () => T, options?: ComputedEagerOptions): ComputedEagerReturn<T>;
 
 export declare type ComputedEagerOptions = WatchOptionsBase;
 
-export declare type ComputedEagerReturn<T$1 = any> = Readonly<ShallowRef<T$1>>;
+export declare type ComputedEagerReturn<T = any> = Readonly<ShallowRef<T>>;
 
 declare type ComputedInjectGetter<T, K$1> = (source: T | undefined, oldValue?: K$1) => K$1;
 
@@ -179,13 +170,13 @@ declare type ComputedInjectGetterWithDefault<T, K$1> = (source: T, oldValue?: K$
 
 declare type ComputedInjectSetter<T> = (v: T) => void;
 
-export declare interface ComputedRefWithControl<T$1> extends ComputedRef<T$1>, ComputedWithControlRefExtra {}
+export declare interface ComputedRefWithControl<T> extends ComputedRef<T>, ComputedWithControlRefExtra {}
 
-export declare function computedWithControl<T$1>(source: WatchSource | MultiWatchSources, fn: ComputedGetter<T$1>, options?: WatchOptions): ComputedRefWithControl<T$1>;
+export declare function computedWithControl<T>(source: WatchSource | MultiWatchSources, fn: ComputedGetter<T>, options?: WatchOptions): ComputedRefWithControl<T>;
 
-export declare function computedWithControl<T$1>(source: WatchSource | MultiWatchSources, fn: WritableComputedOptions<T$1>, options?: WatchOptions): WritableComputedRefWithControl<T$1>;
+export declare function computedWithControl<T>(source: WatchSource | MultiWatchSources, fn: WritableComputedOptions<T>, options?: WatchOptions): WritableComputedRefWithControl<T>;
 
-export declare type ComputedWithControlRef<T$1 = any> = ComputedRefWithControl<T$1> | WritableComputedRefWithControl<T$1>;
+export declare type ComputedWithControlRef<T = any> = ComputedRefWithControl<T> | WritableComputedRefWithControl<T>;
 
 export declare interface ComputedWithControlRefExtra {
     /**
@@ -231,8 +222,11 @@ export declare interface ConfigurableFlushSync {
     flush?: WatchOptionFlush;
 }
 
-declare interface ConfigurableNavigator {
-    navigator?: Navigator;
+declare interface ConfigurableScheduler {
+    /**
+     * Custom scheduler to use for interval execution.
+     */
+    scheduler?: (cb: Fn) => Pausable;
 }
 
 declare interface ConfigurableWindow {
@@ -247,19 +241,19 @@ export declare const controlledComputed: typeof computedWithControl;
 /** @deprecated use `refWithControl` instead */
 export declare const controlledRef: typeof refWithControl;
 
-export declare interface ControlledRefOptions<T$1> {
+export declare interface ControlledRefOptions<T> {
     /**
      * Callback function before the ref changing.
      *
      * Returning `false` to dismiss the change.
      */
-    onBeforeChange?: (value: T$1, oldValue: T$1) => void | boolean;
+    onBeforeChange?: (value: T, oldValue: T) => void | boolean;
     /**
      * Callback function after the ref changed
      *
      * This happens synchronously, with less overhead compare to `watch`
      */
-    onChanged?: (value: T$1, oldValue: T$1) => void;
+    onChanged?: (value: T, oldValue: T) => void;
 }
 
 /**
@@ -269,7 +263,7 @@ export declare interface ControlledRefOptions<T$1> {
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function createEventHook<T$1 = any>(): EventHookReturn<T$1>;
+export declare function createEventHook<T = any>(): EventHookReturn<T>;
 
 export declare function createFetch(config?: CreateFetchOptions): typeof useFetch;
 
@@ -325,9 +319,9 @@ export declare const createReactiveFn: typeof reactify;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function createRef<T$1 = any, D extends boolean = false>(value: T$1, deep?: D): CreateRefReturn<T$1, D>;
+export declare function createRef<T = any, D extends boolean = false>(value: T, deep?: D): CreateRefReturn<T, D>;
 
-export declare type CreateRefReturn<T$1 = any, D extends boolean = false> = ShallowOrDeepRef<T$1, D>;
+export declare type CreateRefReturn<T = any, D extends boolean = false> = ShallowOrDeepRef<T, D>;
 
 /**
  * Make a composable function usable with multiple Vue instances.
@@ -350,7 +344,7 @@ export declare function createSharedComposable<Fn$1 extends AnyFn>(composable: F
  * await promise() // and be resolved together
  * ```
  */
-export declare function createSingletonPromise<T$1>(fn: () => Promise<T$1>): SingletonPromiseReturn<T$1>;
+export declare function createSingletonPromise<T>(fn: () => Promise<T>): SingletonPromiseReturn<T>;
 
 /**
  * Make a plain function accepting ref and raw values as arguments.
@@ -396,7 +390,7 @@ export declare interface DebounceFilterOptions {
  * UnwrapRef<DeepMaybeRef<T>> === T
  * ```
  */
-export declare type DeepMaybeRef<T$1> = T$1 extends Ref<infer V> ? MaybeRef<V> : T$1 extends Array<any> | object ? { [K in keyof T$1]: DeepMaybeRef<T$1[K]> } : MaybeRef<T$1>;
+export declare type DeepMaybeRef<T> = T extends Ref<infer V> ? MaybeRef<V> : T extends Array<any> | object ? { [K in keyof T]: DeepMaybeRef<T[K]> } : MaybeRef<T>;
 
 declare type Direction = 'ltr' | 'rtl' | 'both';
 
@@ -406,7 +400,7 @@ export declare const eagerComputed: typeof computedEager;
 /**
  * Infers the element type of an array
  */
-export declare type ElementOf<T$1> = T$1 extends (infer E)[] ? E : never;
+export declare type ElementOf<T> = T extends (infer E)[] ? E : never;
 
 /**
  * A = B
@@ -427,22 +421,22 @@ export declare type EventBusListener<T = unknown, P$1 = any> = (event: T, payloa
 
 export declare type EventFilter<Args extends any[] = any[], This = any, Invoke extends AnyFn = AnyFn> = (invoke: Invoke, options: FunctionWrapperOptions<Args, This>) => ReturnType<Invoke> | Promisify<ReturnType<Invoke>>;
 
-export declare interface EventHook<T$1 = any> {
-    on: EventHookOn<T$1>;
-    off: EventHookOff<T$1>;
-    trigger: EventHookTrigger<T$1>;
+export declare interface EventHook<T = any> {
+    on: EventHookOn<T>;
+    off: EventHookOff<T>;
+    trigger: EventHookTrigger<T>;
     clear: () => void;
 }
 
-export declare type EventHookOff<T$1 = any> = (fn: Callback<T$1>) => void;
+export declare type EventHookOff<T = any> = (fn: Callback<T>) => void;
 
-export declare type EventHookOn<T$1 = any> = (fn: Callback<T$1>) => {
+export declare type EventHookOn<T = any> = (fn: Callback<T>) => {
     off: () => void;
 };
 
-export declare type EventHookReturn<T$1> = EventHook<T$1>;
+export declare type EventHookReturn<T> = EventHook<T>;
 
-export declare type EventHookTrigger<T$1 = any> = (...param: Parameters<Callback<T$1>>) => Promise<unknown[]>;
+export declare type EventHookTrigger<T = any> = (...param: Parameters<Callback<T>>) => Promise<unknown[]>;
 
 /**
  * Overload 1: Unwrap set to false
@@ -469,7 +463,7 @@ export declare interface ExtendRefOptions<Unwrap extends boolean = boolean> {
     unwrap?: Unwrap;
 }
 
-export declare type ExtendRefReturn<T$1 = any> = Ref<T$1>;
+export declare type ExtendRefReturn<T = any> = Ref<T>;
 
 declare type Falsy = false | void | null | undefined | 0 | 0n | '';
 
@@ -530,17 +524,17 @@ export declare interface GeneralEventListener<E = Event> {
 /**
  * Shorthand for accessing `ref.value`
  */
-export declare function get<T$1>(ref: MaybeRef<T$1>): T$1;
+export declare function get<T>(ref: MaybeRef<T>): T;
 
-export declare function get<T$1, K$1 extends keyof T$1>(ref: MaybeRef<T$1>, key: K$1): T$1[K$1];
+export declare function get<T, K$1 extends keyof T>(ref: MaybeRef<T>, key: K$1): T[K$1];
 
-export declare const hasOwn: <T extends object, K extends keyof T>(val: T, key: K) => key is K;
+export declare const hasOwn: <T extends object, K$1 extends keyof T>(val: T, key: K$1) => key is K$1;
 
 export declare const hyphenate: (str: string) => string;
 
-export declare function identity<T$1>(arg: T$1): T$1;
+export declare function identity<T>(arg: T): T;
 
-export declare type IfAny<T$1, Y, N> = 0 extends (1 & T$1) ? Y : N;
+export declare type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
 
 /** @deprecated use `watchIgnorable` instead */
 export declare const ignorableWatch: typeof watchIgnorable;
@@ -579,26 +573,26 @@ declare type IntersectButNotEqualType<D extends Direction, L, R$1> = D extends '
     transform: Pick<Transform<L, R$1>, D>;
 } : never;
 
-export declare function invoke<T$1>(fn: () => T$1): T$1;
+export declare function invoke<T>(fn: () => T): T;
 
 /**
  * will return `true` if `T` is `any`, or `false` otherwise
  */
-export declare type IsAny<T$1> = IfAny<T$1, true, false>;
+export declare type IsAny<T> = IfAny<T, true, false>;
 
 export declare const isDef: <T = any>(val?: T) => val is T;
 
-export declare function isDefined<T$1>(v: ComputedRef<T$1>): v is ComputedRef<Exclude<T$1, null | undefined>>;
+export declare function isDefined<T>(v: ComputedRef<T>): v is ComputedRef<Exclude<T, null | undefined>>;
 
-export declare function isDefined<T$1>(v: Ref<T$1>): v is Ref<Exclude<T$1, null | undefined>>;
+export declare function isDefined<T>(v: Ref<T>): v is Ref<Exclude<T, null | undefined>>;
 
-export declare function isDefined<T$1>(v: T$1): v is Exclude<T$1, null | undefined>;
+export declare function isDefined<T>(v: T): v is Exclude<T, null | undefined>;
 
 export declare type IsDefinedReturn = boolean;
 
 export declare const isObject: (val: any) => val is object;
 
-export declare function makeDestructurable<T$1 extends Record<string, unknown>, A$1 extends readonly any[]>(obj: T$1, arr: A$1): T$1 & A$1;
+export declare function makeDestructurable<T extends Record<string, unknown>, A$1 extends readonly any[]>(obj: T, arr: A$1): T & A$1;
 
 /**
  * Define the shape of a ref that supports manual reset functionality.
@@ -606,19 +600,19 @@ export declare function makeDestructurable<T$1 extends Record<string, unknown>,
  * This interface extends the standard `Ref` type from Vue and adds a `reset` method.
  * The `reset` method allows the ref to be manually reset to its default value.
  */
-export declare interface ManualResetRefReturn<T$1> extends Ref<T$1> {
+export declare interface ManualResetRefReturn<T> extends Ref<T> {
     reset: Fn;
 }
 
-export declare type MapOldSources<T$1, Immediate> = { [K in keyof T$1]: T$1[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : never };
+export declare type MapOldSources<T, Immediate> = { [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : never };
 
 declare type MapQueueTask<T extends any[]> = { [K in keyof T]: UseAsyncQueueTask<T[K]> };
 
-export declare type MapSources<T$1> = { [K in keyof T$1]: T$1[K] extends WatchSource<infer V> ? V : never };
+export declare type MapSources<T> = { [K in keyof T]: T[K] extends WatchSource<infer V> ? V : never };
 
 export { MultiWatchSources }
 
-export declare type Mutable<T$1> = { -readonly [P in keyof T$1]: T$1[P] };
+export declare type Mutable<T> = { -readonly [P in keyof T]: T[P] };
 
 export declare const noop: () => void;
 
@@ -635,17 +629,17 @@ export declare const notNullish: <T = any>(val?: T | null | undefined) => val is
 
 export declare const now: () => number;
 
-export declare function objectEntries<T$1 extends object>(obj: T$1): Array<[keyof T$1, T$1[keyof T$1]]>;
+export declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
 
 /**
  * Create a new subset object by omit giving keys
  */
-export declare function objectOmit<O extends object, T$1 extends keyof O>(obj: O, keys: T$1[], omitUndefined?: boolean): Omit<O, T$1>;
+export declare function objectOmit<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined?: boolean): Omit<O, T>;
 
 /**
  * Create a new subset object by giving keys
  */
-export declare function objectPick<O extends object, T$1 extends keyof O>(obj: O, keys: T$1[], omitUndefined?: boolean): Pick<O, T$1>;
+export declare function objectPick<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined?: boolean): Pick<O, T>;
 
 declare type OnCleanup = (cleanupFn: () => void) => void;
 
@@ -691,16 +685,16 @@ export declare interface PausableFilterOptions {
     initialState?: 'active' | 'paused';
 }
 
-/** @deprecated use `watchPausable` instead */
+/** @deprecated Use Vue's built-in `watch` instead. This function will be removed in future version. */
 export declare const pausableWatch: typeof watchPausable;
 
 declare type PostMessage = typeof Worker.prototype['postMessage'];
 
 export declare function promiseTimeout(ms: number, throwOnTimeout?: boolean, reason?: string): Promise<void>;
 
-export declare type Promisify<T$1> = Promise<Awaited_2<T$1>>;
+export declare type Promisify<T> = Promise<Awaited_2<T>>;
 
-export declare type PromisifyFn<T$1 extends AnyFn> = (...args: ArgumentsType<T$1>) => Promisify<ReturnType<T$1>>;
+export declare type PromisifyFn<T extends AnyFn> = (...args: ArgumentsType<T>) => Promisify<ReturnType<T>>;
 
 /**
  * Get a px value for SSR use, do not rely on this method outside of SSR as REM unit is assumed at 16px, which might not be the case on the client
@@ -709,7 +703,7 @@ export declare function pxValue(px: string): number;
 
 export declare const rand: (min: number, max: number) => number;
 
-export declare type Reactified<T$1, Computed extends boolean> = T$1 extends ((...args: infer A) => infer R) ? (...args: { [K in keyof A]: Computed extends true ? MaybeRefOrGetter<A[K]> : MaybeRef<A[K]> }) => ComputedRef<R> : never;
+export declare type Reactified<T, Computed extends boolean> = T extends ((...args: infer A) => infer R) ? (...args: { [K in keyof A]: Computed extends true ? MaybeRefOrGetter<A[K]> : MaybeRef<A[K]> }) => ComputedRef<R> : never;
 
 /**
  * Converts plain function into a reactive function.
@@ -721,20 +715,20 @@ export declare type Reactified<T$1, Computed extends boolean> = T$1 extends ((..
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function reactify<T$1 extends AnyFn, K$1 extends boolean = true>(fn: T$1, options?: ReactifyOptions<K$1>): ReactifyReturn<T$1, K$1>;
+export declare function reactify<T extends AnyFn, K$1 extends boolean = true>(fn: T, options?: ReactifyOptions<K$1>): ReactifyReturn<T, K$1>;
 
-export declare type ReactifyNested<T$1, Keys extends keyof T$1 = keyof T$1, S$1 extends boolean = true> = { [K in Keys]: T$1[K] extends AnyFn ? Reactified<T$1[K], S$1> : T$1[K] };
+export declare 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] };
 
 /**
  * Apply `reactify` to an object
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function reactifyObject<T$1 extends object, Keys extends keyof T$1>(obj: T$1, keys?: (keyof T$1)[]): ReactifyObjectReturn<T$1, Keys, true>;
+export declare function reactifyObject<T extends object, Keys extends keyof T>(obj: T, keys?: (keyof T)[]): ReactifyObjectReturn<T, Keys, true>;
 
-export declare function reactifyObject<T$1 extends object, S$1 extends boolean = true>(obj: T$1, options?: ReactifyObjectOptions<S$1>): ReactifyObjectReturn<T$1, keyof T$1, S$1>;
+export declare function reactifyObject<T extends object, S$1 extends boolean = true>(obj: T, options?: ReactifyObjectOptions<S$1>): ReactifyObjectReturn<T, keyof T, S$1>;
 
-export declare interface ReactifyObjectOptions<T$1 extends boolean> extends ReactifyOptions<T$1> {
+export declare interface ReactifyObjectOptions<T extends boolean> extends ReactifyOptions<T> {
     /**
      * Includes names from Object.getOwnPropertyNames
      *
@@ -743,46 +737,46 @@ export declare interface ReactifyObjectOptions<T$1 extends boolean> extends Reac
     includeOwnProperties?: boolean;
 }
 
-export declare type ReactifyObjectReturn<T$1, Keys extends keyof T$1, S$1 extends boolean = true> = ReactifyNested<T$1, Keys, S$1>;
+export declare type ReactifyObjectReturn<T, Keys extends keyof T, S$1 extends boolean = true> = ReactifyNested<T, Keys, S$1>;
 
-export declare interface ReactifyOptions<T$1 extends boolean> {
+export declare interface ReactifyOptions<T extends boolean> {
     /**
      * Accept passing a function as a reactive getter
      *
      * @default true
      */
-    computedGetter?: T$1;
+    computedGetter?: T;
 }
 
-export declare type ReactifyReturn<T$1 extends AnyFn = AnyFn, K$1 extends boolean = true> = Reactified<T$1, K$1>;
+export declare type ReactifyReturn<T extends AnyFn = AnyFn, K$1 extends boolean = true> = Reactified<T, K$1>;
 
 /**
  * Computed reactive object.
  */
-export declare function reactiveComputed<T$1 extends object>(fn: ComputedGetter<T$1>): ReactiveComputedReturn<T$1>;
+export declare function reactiveComputed<T extends object>(fn: ComputedGetter<T>): ReactiveComputedReturn<T>;
 
-export declare type ReactiveComputedReturn<T$1 extends object> = UnwrapNestedRefs<T$1>;
+export declare type ReactiveComputedReturn<T extends object> = UnwrapNestedRefs<T>;
 
-export declare function reactiveOmit<T$1 extends object, K$1 extends keyof T$1>(obj: T$1, ...keys: (K$1 | K$1[])[]): ReactiveOmitReturn<T$1, K$1>;
+export declare function reactiveOmit<T extends object, K$1 extends keyof T>(obj: T, ...keys: (K$1 | K$1[])[]): ReactiveOmitReturn<T, K$1>;
 
-export declare function reactiveOmit<T$1 extends object>(obj: T$1, predicate: ReactiveOmitPredicate<T$1>): ReactiveOmitReturn<T$1>;
+export declare function reactiveOmit<T extends object>(obj: T, predicate: ReactiveOmitPredicate<T>): ReactiveOmitReturn<T>;
 
-export declare type ReactiveOmitPredicate<T$1> = (value: T$1[keyof T$1], key: keyof T$1) => boolean;
+export declare type ReactiveOmitPredicate<T> = (value: T[keyof T], key: keyof T) => boolean;
 
-export declare type ReactiveOmitReturn<T$1 extends object, K$1 extends keyof T$1 | undefined = undefined> = [K$1] extends [undefined] ? Partial<T$1> : Omit<T$1, Extract<K$1, keyof T$1>>;
+export declare 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>>;
 
-export declare function reactivePick<T$1 extends object, K$1 extends keyof T$1>(obj: T$1, ...keys: (K$1 | K$1[])[]): ReactivePickReturn<T$1, K$1>;
+export declare function reactivePick<T extends object, K$1 extends keyof T>(obj: T, ...keys: (K$1 | K$1[])[]): ReactivePickReturn<T, K$1>;
 
-export declare function reactivePick<T$1 extends object>(obj: T$1, predicate: ReactivePickPredicate<T$1>): ReactivePickReturn<T$1, keyof T$1>;
+export declare function reactivePick<T extends object>(obj: T, predicate: ReactivePickPredicate<T>): ReactivePickReturn<T, keyof T>;
 
-export declare type ReactivePickPredicate<T$1> = (value: T$1[keyof T$1], key: keyof T$1) => boolean;
+export declare type ReactivePickPredicate<T> = (value: T[keyof T], key: keyof T) => boolean;
 
-export declare type ReactivePickReturn<T$1 extends object, K$1 extends keyof T$1> = { [S in K$1]: UnwrapRef<T$1[S]> };
+export declare type ReactivePickReturn<T extends object, K$1 extends keyof T> = { [S in K$1]: UnwrapRef<T[S]> };
 
 /**
  * Maybe it's a computed ref, or a readonly value, or a getter function
  */
-export declare type ReadonlyRefOrGetter<T$1> = ComputedRef<T$1> | (() => T$1);
+export declare type ReadonlyRefOrGetter<T> = ComputedRef<T> | (() => T);
 
 /**
  * Create a ref which will be reset to the default value after some time.
@@ -791,25 +785,25 @@ export declare type ReadonlyRefOrGetter<T$1> = ComputedRef<T$1> | (() => T$1);
  * @param defaultValue The value which will be set.
  * @param afterMs      A zero-or-greater delay in milliseconds.
  */
-export declare function refAutoReset<T$1>(defaultValue: MaybeRefOrGetter<T$1>, afterMs?: MaybeRefOrGetter<number>): RefAutoResetReturn<T$1>;
+export declare function refAutoReset<T>(defaultValue: MaybeRefOrGetter<T>, afterMs?: MaybeRefOrGetter<number>): RefAutoResetReturn<T>;
 
-export declare type RefAutoResetReturn<T$1 = any> = Ref<T$1>;
+export declare type RefAutoResetReturn<T = any> = Ref<T>;
 
 /**
  * Debounce updates of a ref.
  *
  * @return A new debounced ref.
  */
-export declare function refDebounced<T$1>(value: Ref<T$1>, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): RefDebouncedReturn<T$1>;
+export declare function refDebounced<T>(value: Ref<T>, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): RefDebouncedReturn<T>;
 
-export declare type RefDebouncedReturn<T$1 = any> = Readonly<Ref<T$1>>;
+export declare type RefDebouncedReturn<T = any> = Readonly<Ref<T>>;
 
 /**
  * Apply default value to a ref.
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function refDefault<T$1>(source: Ref<T$1 | undefined | null>, defaultValue: T$1): Ref<T$1>;
+export declare function refDefault<T>(source: Ref<T | undefined | null>, defaultValue: T): Ref<T>;
 
 /**
  * Create a ref with manual reset functionality.
@@ -817,7 +811,7 @@ export declare function refDefault<T$1>(source: Ref<T$1 | undefined | null>, def
  * @see https://vueuse.org/refManualReset
  * @param defaultValue The value which will be set.
  */
-export declare function refManualReset<T$1>(defaultValue: MaybeRefOrGetter<T$1>): ManualResetRefReturn<T$1>;
+export declare function refManualReset<T>(defaultValue: MaybeRefOrGetter<T>): ManualResetRefReturn<T>;
 
 /**
  * Throttle execution of a function. Especially useful for rate limiting
@@ -828,28 +822,28 @@ export declare function refManualReset<T$1>(defaultValue: MaybeRefOrGetter<T$1>)
  * @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
  */
-export declare function refThrottled<T$1 = any>(value: Ref<T$1>, delay?: number, trailing?: boolean, leading?: boolean): RefThrottledReturn<T$1>;
+export declare function refThrottled<T = any>(value: Ref<T>, delay?: number, trailing?: boolean, leading?: boolean): RefThrottledReturn<T>;
 
-export declare type RefThrottledReturn<T$1 = any> = Ref<T$1>;
+export declare type RefThrottledReturn<T = any> = Ref<T>;
 
 /**
  * Fine-grained controls over ref and its reactivity.
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function refWithControl<T$1>(initial: T$1, options?: ControlledRefOptions<T$1>): vue0.ShallowUnwrapRef<{
-    get: (tracking?: boolean) => T$1;
-    set: (value: T$1, triggering?: boolean) => void;
-    untrackedGet: () => T$1;
-    silentSet: (v: T$1) => void;
-    peek: () => T$1;
-    lay: (v: T$1) => void;
-}> & vue0.Ref<T$1, T$1>;
+export 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>;
 
 /**
  * A ref that allow to set null or undefined
  */
-export declare type RemovableRef<T$1> = Ref<T$1, T$1 | null | undefined>;
+export declare type RemovableRef<T> = Ref<T, T | null | undefined>;
 
 export declare interface Serializer<T> {
     read: (raw: string) => T;
@@ -861,18 +855,18 @@ export declare interface SerializerAsync<T> {
     write: (value: T) => Awaitable<string>;
 }
 
-export declare function set<T$1>(ref: Ref<T$1>, value: T$1): void;
+export declare function set<T>(ref: Ref<T>, value: T): void;
 
 export declare function set<O extends object, K$1 extends keyof O>(target: O, key: K$1, value: O[K$1]): void;
 
-export declare type ShallowOrDeepRef<T$1 = any, D extends boolean = false> = D extends true ? Ref<T$1> : ShallowRef<T$1>;
+export declare type ShallowOrDeepRef<T = any, D extends boolean = false> = D extends true ? Ref<T> : ShallowRef<T>;
 
-export declare type ShallowUnwrapRef<T$1> = T$1 extends Ref<infer P> ? P : T$1;
+export declare type ShallowUnwrapRef<T> = T extends Ref<infer P> ? P : T;
 
-export declare type SharedComposableReturn<T$1 extends AnyFn = AnyFn> = T$1;
+export declare type SharedComposableReturn<T extends AnyFn = AnyFn> = T;
 
-export declare interface SingletonPromiseReturn<T$1> {
-    (): Promise<T$1>;
+export declare interface SingletonPromiseReturn<T> {
+    (): Promise<T>;
     /**
      * Reset current staled promise.
      * await it to have proper shutdown.
@@ -880,7 +874,7 @@ export declare interface SingletonPromiseReturn<T$1> {
     reset: () => Promise<void>;
 }
 
-declare type SpecificFieldPartial<T$1, K$1 extends keyof T$1> = Partial<Pick<T$1, K$1>> & Omit<T$1, K$1>;
+declare type SpecificFieldPartial<T, K$1 extends keyof T> = Partial<Pick<T, K$1>> & Omit<T, K$1>;
 
 export declare interface Stoppable<StartFnArgs extends any[] = any[]> {
     /**
@@ -907,6 +901,10 @@ declare type StrictIncludeType<IncludeType extends 'LR' | 'RL', D extends Direct
     transform: SpecificFieldPartial<Transform<L, R$1>, IncludeType extends 'LR' ? 'ltr' : 'rtl'>;
 } : D extends Exclude<Direction, 'both'> ? StrictIncludeMap<IncludeType, D, L, R$1> : never;
 
+declare interface Supportable {
+    isSupported: ComputedRef<boolean>;
+}
+
 /**
  * Two-way refs synchronization.
  * From the set theory perspective to restrict the option's type
@@ -945,7 +943,7 @@ export declare type SyncRefOptions<L, R$1, D extends Direction> = ConfigurableFl
  * @param source source ref
  * @param targets
  */
-export declare function syncRefs<T$1>(source: WatchSource<T$1>, targets: Ref<T$1> | Ref<T$1>[], options?: SyncRefsOptions): vue0.WatchHandle;
+export declare function syncRefs<T>(source: WatchSource<T>, targets: Ref<T> | Ref<T>[], options?: SyncRefsOptions): vue0.WatchHandle;
 
 export declare interface SyncRefsOptions extends ConfigurableFlushSync {
     /**
@@ -1001,9 +999,9 @@ export declare type TimerHandle = ReturnType<typeof setTimeout> | undefined;
 
 export declare const timestamp: () => number;
 
-export declare function toArray<T$1>(value: T$1 | readonly T$1[]): readonly T$1[];
+export declare function toArray<T>(value: T | readonly T[]): readonly T[];
 
-export declare function toArray<T$1>(value: T$1 | T$1[]): T$1[];
+export declare function toArray<T>(value: T | T[]): T[];
 
 export declare interface ToDataURLOptions extends UseBase64Options {
     /**
@@ -1024,22 +1022,22 @@ export declare type ToggleFn = (value?: boolean) => void;
  * @see https://vueuse.org/toReactive
  * @param objectRef A ref of object
  */
-export declare function toReactive<T$1 extends object>(objectRef: MaybeRef<T$1>): UnwrapNestedRefs<T$1>;
+export declare function toReactive<T extends object>(objectRef: MaybeRef<T>): UnwrapNestedRefs<T>;
 
 /**
  * Normalize value/ref/getter to `ref` or `computed`.
  */
-export declare function toRef<T$1>(r: () => T$1): Readonly<Ref<T$1>>;
+export declare function toRef<T>(r: () => T): Readonly<Ref<T>>;
 
-export declare function toRef<T$1>(r: ComputedRef<T$1>): ComputedRef<T$1>;
+export declare function toRef<T>(r: ComputedRef<T>): ComputedRef<T>;
 
-export declare function toRef<T$1>(r: MaybeRefOrGetter<T$1>): Ref<T$1>;
+export declare function toRef<T>(r: MaybeRefOrGetter<T>): Ref<T>;
 
-export declare function toRef<T$1>(r: T$1): Ref<T$1>;
+export declare function toRef<T>(r: T): Ref<T>;
 
-export declare function toRef<T$1 extends object, K$1 extends keyof T$1>(object: T$1, key: K$1): ToRef<T$1[K$1]>;
+export declare function toRef<T extends object, K$1 extends keyof T>(object: T, key: K$1): ToRef<T[K$1]>;
 
-export declare function toRef<T$1 extends object, K$1 extends keyof T$1>(object: T$1, key: K$1, defaultValue: T$1[K$1]): ToRef<Exclude<T$1[K$1], undefined>>;
+export 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>>;
 
 /**
  * Extended `toRefs` that also accepts refs of an object.
@@ -1048,7 +1046,7 @@ export declare function toRef<T$1 extends object, K$1 extends keyof T$1>(object:
  * @param objectRef A ref or normal object or array.
  * @param options Options
  */
-export declare function toRefs<T$1 extends object>(objectRef: MaybeRef<T$1>, options?: ToRefsOptions): ToRefs<T$1>;
+export declare function toRefs<T extends object>(objectRef: MaybeRef<T>, options?: ToRefsOptions): ToRefs<T>;
 
 export declare interface ToRefsOptions {
     /**
@@ -1081,22 +1079,22 @@ export declare type UnrefFn<T> = T extends ((...args: infer A) => infer R) ? (..
  * alert('Counter is now larger than 7!')
  * ```
  */
-export declare function until<T$1 extends unknown[]>(r: WatchSource<T$1> | MaybeRefOrGetter<T$1>): UntilArrayInstance<T$1>;
+export declare function until<T extends unknown[]>(r: WatchSource<T> | MaybeRefOrGetter<T>): UntilArrayInstance<T>;
 
-export declare function until<T$1>(r: WatchSource<T$1> | MaybeRefOrGetter<T$1>): UntilValueInstance<T$1>;
+export declare function until<T>(r: WatchSource<T> | MaybeRefOrGetter<T>): UntilValueInstance<T>;
 
-export declare interface UntilArrayInstance<T$1> extends UntilBaseInstance<T$1> {
-    readonly not: UntilArrayInstance<T$1>;
-    toContains: (value: MaybeRefOrGetter<ElementOf<ShallowUnwrapRef<T$1>>>, options?: UntilToMatchOptions) => Promise<T$1>;
+export declare interface UntilArrayInstance<T> extends UntilBaseInstance<T> {
+    readonly not: UntilArrayInstance<T>;
+    toContains: (value: MaybeRefOrGetter<ElementOf<ShallowUnwrapRef<T>>>, options?: UntilToMatchOptions) => Promise<T>;
 }
 
-export declare interface UntilBaseInstance<T$1, Not extends boolean = false> {
-    toMatch: (<U extends T$1 = T$1>(condition: (v: T$1) => v is U, options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T$1, U>> : Promise<U>) & ((condition: (v: T$1) => boolean, options?: UntilToMatchOptions) => Promise<T$1>);
-    changed: (options?: UntilToMatchOptions) => Promise<T$1>;
-    changedTimes: (n?: number, options?: UntilToMatchOptions) => Promise<T$1>;
+export declare interface 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>);
+    changed: (options?: UntilToMatchOptions) => Promise<T>;
+    changedTimes: (n?: number, options?: UntilToMatchOptions) => Promise<T>;
 }
 
-export declare interface UntilToMatchOptions {
+export declare interface UntilToMatchOptions extends ConfigurableFlushSync {
     /**
      * Milliseconds timeout for promise to resolve/reject if the when condition does not meet.
      * 0 for never timed out
@@ -1110,12 +1108,6 @@ export declare interface UntilToMatchOptions {
      * @default false
      */
     throwOnTimeout?: boolean;
-    /**
-     * `flush` option for internal watch
-     *
-     * @default 'sync'
-     */
-    flush?: WatchOptionFlush;
     /**
      * `deep` option for internal watch
      *
@@ -1124,20 +1116,20 @@ export declare interface UntilToMatchOptions {
     deep?: WatchOptions['deep'];
 }
 
-export declare interface UntilValueInstance<T$1, Not extends boolean = false> extends UntilBaseInstance<T$1, Not> {
-    readonly not: UntilValueInstance<T$1, Not extends true ? false : true>;
-    toBe: <P = T$1>(value: MaybeRefOrGetter<P>, options?: UntilToMatchOptions) => Not extends true ? Promise<T$1> : Promise<P>;
-    toBeTruthy: (options?: UntilToMatchOptions) => Not extends true ? Promise<T$1 & Falsy> : Promise<Exclude<T$1, Falsy>>;
-    toBeNull: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T$1, null>> : Promise<null>;
-    toBeUndefined: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T$1, undefined>> : Promise<undefined>;
-    toBeNaN: (options?: UntilToMatchOptions) => Promise<T$1>;
+export declare 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>;
+    toBeTruthy: (options?: UntilToMatchOptions) => Not extends true ? Promise<T & Falsy> : Promise<Exclude<T, Falsy>>;
+    toBeNull: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, null>> : Promise<null>;
+    toBeUndefined: (options?: UntilToMatchOptions) => Not extends true ? Promise<Exclude<T, undefined>> : Promise<undefined>;
+    toBeNaN: (options?: UntilToMatchOptions) => Promise<T>;
 }
 
 export declare type UrlParams = Record<string, string[] | string>;
 
-export declare function useArrayDifference<T$1>(list: MaybeRefOrGetter<T$1[]>, values: MaybeRefOrGetter<T$1[]>, key?: keyof T$1, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T$1>;
+export declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, key?: keyof T, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
 
-export declare function useArrayDifference<T$1>(list: MaybeRefOrGetter<T$1[]>, values: MaybeRefOrGetter<T$1[]>, compareFn?: (value: T$1, othVal: T$1) => boolean, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T$1>;
+export declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, compareFn?: (value: T, othVal: T) => boolean, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
 
 export declare interface UseArrayDifferenceOptions {
     /**
@@ -1149,7 +1141,7 @@ export declare interface UseArrayDifferenceOptions {
     symmetric?: boolean;
 }
 
-export declare type UseArrayDifferenceReturn<T$1 = any> = ComputedRef<T$1[]>;
+export declare type UseArrayDifferenceReturn<T = any> = ComputedRef<T[]>;
 
 /**
  * Reactive `Array.every`
@@ -1162,7 +1154,7 @@ export declare type UseArrayDifferenceReturn<T$1 = any> = ComputedRef<T$1[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayEvery<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => unknown): UseArrayEveryReturn;
+export declare function useArrayEvery<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayEveryReturn;
 
 export declare type UseArrayEveryReturn = ComputedRef<boolean>;
 
@@ -1177,11 +1169,11 @@ export declare type UseArrayEveryReturn = ComputedRef<boolean>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayFilter<T$1, S$1 extends T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: T$1[]) => element is S$1): UseArrayFilterReturn<S$1>;
+export declare function useArrayFilter<T, S$1 extends T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => element is S$1): UseArrayFilterReturn<S$1>;
 
-export declare function useArrayFilter<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: T$1[]) => unknown): UseArrayFilterReturn<T$1>;
+export declare function useArrayFilter<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => unknown): UseArrayFilterReturn<T>;
 
-export declare type UseArrayFilterReturn<T$1 = any> = ComputedRef<T$1[]>;
+export declare type UseArrayFilterReturn<T = any> = ComputedRef<T[]>;
 
 /**
  * Reactive `Array.find`
@@ -1194,7 +1186,7 @@ export declare type UseArrayFilterReturn<T$1 = any> = ComputedRef<T$1[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayFind<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => boolean): UseArrayFindReturn<T$1>;
+export declare function useArrayFind<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindReturn<T>;
 
 /**
  * Reactive `Array.findIndex`
@@ -1207,7 +1199,7 @@ export declare function useArrayFind<T$1>(list: MaybeRefOrGetter<MaybeRefOrGette
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayFindIndex<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => unknown): UseArrayFindIndexReturn;
+export declare function useArrayFindIndex<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayFindIndexReturn;
 
 export declare type UseArrayFindIndexReturn = ComputedRef<number>;
 
@@ -1222,11 +1214,11 @@ export declare type UseArrayFindIndexReturn = ComputedRef<number>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayFindLast<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => boolean): UseArrayFindLastReturn<T$1>;
+export declare function useArrayFindLast<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindLastReturn<T>;
 
-export declare type UseArrayFindLastReturn<T$1 = any> = ComputedRef<T$1 | undefined>;
+export declare type UseArrayFindLastReturn<T = any> = ComputedRef<T | undefined>;
 
-export declare type UseArrayFindReturn<T$1 = any> = ComputedRef<T$1 | undefined>;
+export declare type UseArrayFindReturn<T = any> = ComputedRef<T | undefined>;
 
 /**
  * Reactive `Array.includes`
@@ -1237,17 +1229,17 @@ export declare type UseArrayFindReturn<T$1 = any> = ComputedRef<T$1 | undefined>
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayIncludes<T$1, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, value: MaybeRefOrGetter<V$1>, comparator?: UseArrayIncludesComparatorFn<T$1, V$1>): UseArrayIncludesReturn;
+export declare function useArrayIncludes<T, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V$1>, comparator?: UseArrayIncludesComparatorFn<T, V$1>): UseArrayIncludesReturn;
 
-export declare function useArrayIncludes<T$1, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, value: MaybeRefOrGetter<V$1>, comparator?: keyof T$1): UseArrayIncludesReturn;
+export declare function useArrayIncludes<T, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V$1>, comparator?: keyof T): UseArrayIncludesReturn;
 
-export declare function useArrayIncludes<T$1, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, value: MaybeRefOrGetter<V$1>, options?: UseArrayIncludesOptions<T$1, V$1>): UseArrayIncludesReturn;
+export declare function useArrayIncludes<T, V$1 = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V$1>, options?: UseArrayIncludesOptions<T, V$1>): UseArrayIncludesReturn;
 
-export declare type UseArrayIncludesComparatorFn<T$1, V$1> = ((element: T$1, value: V$1, index: number, array: MaybeRefOrGetter<T$1>[]) => boolean);
+export declare type UseArrayIncludesComparatorFn<T, V$1> = ((element: T, value: V$1, index: number, array: MaybeRefOrGetter<T>[]) => boolean);
 
-export declare interface UseArrayIncludesOptions<T$1, V$1> {
+export declare interface UseArrayIncludesOptions<T, V$1> {
     fromIndex?: number;
-    comparator?: UseArrayIncludesComparatorFn<T$1, V$1> | keyof T$1;
+    comparator?: UseArrayIncludesComparatorFn<T, V$1> | keyof T;
 }
 
 export declare type UseArrayIncludesReturn = ComputedRef<boolean>;
@@ -1278,9 +1270,9 @@ export declare type UseArrayJoinReturn = ComputedRef<string>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayMap<T$1, U$1 = T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: T$1[]) => U$1): UseArrayMapReturn<U$1>;
+export declare function useArrayMap<T, U$1 = T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => U$1): UseArrayMapReturn<U$1>;
 
-export declare type UseArrayMapReturn<T$1 = any> = ComputedRef<T$1[]>;
+export declare type UseArrayMapReturn<T = any> = ComputedRef<T[]>;
 
 /**
  * Reactive `Array.reduce`
@@ -1293,7 +1285,7 @@ export declare type UseArrayMapReturn<T$1 = any> = ComputedRef<T$1[]>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayReduce<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, reducer: UseArrayReducer<T$1, T$1, T$1>): UseArrayReduceReturn<T$1>;
+export declare function useArrayReduce<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<T, T, T>): UseArrayReduceReturn<T>;
 
 /**
  * Reactive `Array.reduce`
@@ -1307,11 +1299,11 @@ export declare function useArrayReduce<T$1>(list: MaybeRefOrGetter<MaybeRefOrGet
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayReduce<T$1, U$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, reducer: UseArrayReducer<U$1, T$1, U$1>, initialValue: MaybeRefOrGetter<U$1>): UseArrayReduceReturn<U$1>;
+export declare function useArrayReduce<T, U$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<U$1, T, U$1>, initialValue: MaybeRefOrGetter<U$1>): UseArrayReduceReturn<U$1>;
 
 export declare type UseArrayReducer<PV, CV, R$1> = (previousValue: PV, currentValue: CV, currentIndex: number) => R$1;
 
-export declare type UseArrayReduceReturn<T$1 = any> = ComputedRef<T$1>;
+export declare type UseArrayReduceReturn<T = any> = ComputedRef<T>;
 
 /**
  * Reactive `Array.some`
@@ -1324,7 +1316,7 @@ export declare type UseArrayReduceReturn<T$1 = any> = ComputedRef<T$1>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArraySome<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, fn: (element: T$1, index: number, array: MaybeRefOrGetter<T$1>[]) => unknown): UseArraySomeReturn;
+export declare function useArraySome<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArraySomeReturn;
 
 export declare type UseArraySomeReturn = ComputedRef<boolean>;
 
@@ -1337,9 +1329,9 @@ export declare type UseArraySomeReturn = ComputedRef<boolean>;
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayUnique<T$1>(list: MaybeRefOrGetter<MaybeRefOrGetter<T$1>[]>, compareFn?: (a: T$1, b: T$1, array: T$1[]) => boolean): UseArrayUniqueReturn<T$1>;
+export declare function useArrayUnique<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, compareFn?: (a: T, b: T, array: T[]) => boolean): UseArrayUniqueReturn<T>;
 
-export declare type UseArrayUniqueReturn<T$1 = any> = ComputedRef<T$1[]>;
+export declare type UseArrayUniqueReturn<T = any> = ComputedRef<T[]>;
 
 /**
  * Asynchronous queue task controller.
@@ -1453,8 +1445,8 @@ export declare interface UseAsyncStateReturnBase<Data, Params extends any[], Sha
     isReady: Ref<boolean>;
     isLoading: Ref<boolean>;
     error: Ref<unknown>;
-    execute: (delay?: number, ...args: Params) => Promise<Data>;
-    executeImmediate: (...args: Params) => Promise<Data>;
+    execute: (delay?: number, ...args: Params) => Promise<Data | undefined>;
+    executeImmediate: (...args: Params) => Promise<Data | undefined>;
 }
 
 export declare function useBase64(target: MaybeRefOrGetter<string | undefined>, options?: UseBase64Options): UseBase64Return;
@@ -1511,8 +1503,7 @@ export declare interface UseBroadcastChannelOptions extends ConfigurableWindow {
     name: string;
 }
 
-export declare interface UseBroadcastChannelReturn<D, P$1> {
-    isSupported: ComputedRef<boolean>;
+export declare interface UseBroadcastChannelReturn<D, P$1> extends Supportable {
     channel: Ref<BroadcastChannel | undefined>;
     data: Ref<D>;
     post: (data: P$1) => void;
@@ -1521,42 +1512,7 @@ export declare interface UseBroadcastChannelReturn<D, P$1> {
     isClosed: ShallowRef<boolean>;
 }
 
-/**
- * Reactive browser location.
- *
- * @see https://vueuse.org/useBrowserLocation
- *
- * @__NO_SIDE_EFFECTS__
- */
-declare function useBrowserLocation(options?: ConfigurableWindow): Ref<{
-    readonly trigger: string;
-    readonly state?: any;
-    readonly length?: number | undefined;
-    readonly origin?: string | undefined;
-    hash?: string | undefined;
-    host?: string | undefined;
-    hostname?: string | undefined;
-    href?: string | undefined;
-    pathname?: string | undefined;
-    port?: string | undefined;
-    protocol?: string | undefined;
-    search?: string | undefined;
-}, BrowserLocationState | {
-    readonly trigger: string;
-    readonly state?: any;
-    readonly length?: number | undefined;
-    readonly origin?: string | undefined;
-    hash?: string | undefined;
-    host?: string | undefined;
-    hostname?: string | undefined;
-    href?: string | undefined;
-    pathname?: string | undefined;
-    port?: string | undefined;
-    protocol?: string | undefined;
-    search?: string | undefined;
-}>;
-
-export declare type UseBrowserLocationReturn = ReturnType<typeof useBrowserLocation>;
+export declare type UseBrowserLocationReturn = Ref<BrowserLocationState>;
 
 export declare function useCached<T, D extends boolean = true>(refValue: Ref<T>, comparator?: (a: T, b: T) => boolean, options?: UseCachedOptions<D>): UseCachedReturn<T, D>;
 
@@ -1738,9 +1694,9 @@ export declare function useDebouncedRefHistory<Raw, Serialized = Raw>(source: Re
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useDebounceFn<T$1 extends FunctionArgs>(fn: T$1, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): UseDebounceFnReturn<T$1>;
+export declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): UseDebounceFnReturn<T>;
 
-export declare type UseDebounceFnReturn<T$1 extends FunctionArgs> = PromisifyFn<T$1>;
+export declare type UseDebounceFnReturn<T extends FunctionArgs> = PromisifyFn<T>;
 
 export declare function useEventBus<T = unknown, P$1 = any>(key: EventBusIdentifier<T>): UseEventBusReturn<T, P$1>;
 
@@ -2116,7 +2072,7 @@ export declare function useNow(options: UseNowOptions<true>): {
     now: Ref<Date>;
 } & Pausable;
 
-export declare interface UseNowOptions<Controls extends boolean> {
+export declare interface UseNowOptions<Controls extends boolean> extends ConfigurableScheduler {
     /**
      * Expose more controls
      *
@@ -2126,18 +2082,22 @@ export declare interface UseNowOptions<Controls extends boolean> {
     /**
      * Start the clock immediately
      *
+     * @deprecated Please use `scheduler` option instead
      * @default true
      */
     immediate?: boolean;
     /**
      * Update interval in milliseconds, or use requestAnimationFrame
      *
+     * @deprecated Please use `scheduler` option instead
      * @default requestAnimationFrame
      */
     interval?: 'requestAnimationFrame' | number;
 }
 
-export declare type UseNowReturn = ReturnType<typeof useNow>;
+export declare type UseNowReturn<Controls extends boolean> = Controls extends true ? ({
+    now: Ref<Date>;
+} & Pausable) : Ref<Date>;
 
 /**
  * Reactive URL representing an object.
@@ -2210,7 +2170,7 @@ export declare function usePrevious<T>(value: MaybeRefOrGetter<T>, initialValue:
  */
 export declare function useRefHistory<Raw, Serialized = Raw>(source: Ref<Raw>, options?: UseRefHistoryOptions<Raw, Serialized>): UseRefHistoryReturn<Raw, Serialized>;
 
-export declare interface UseRefHistoryOptions<Raw, Serialized = Raw> extends ConfigurableEventFilter {
+export declare interface UseRefHistoryOptions<Raw, Serialized = Raw> extends ConfigurableEventFilter, ConfigurableFlush {
     /**
      * Watch for deep changes, default to false
      *
@@ -2219,15 +2179,6 @@ export declare interface UseRefHistoryOptions<Raw, Serialized = Raw> extends Con
      * @default false
      */
     deep?: boolean;
-    /**
-     * The flush option allows for greater control over the timing of a history point, default to 'pre'
-     *
-     * Possible values: 'pre', 'post', 'sync'
-     * It works in the same way as the flush option in watch and watch effect in vue reactivity
-     *
-     * @default 'pre'
-     */
-    flush?: WatchOptionFlush;
     /**
      * Maximum number of history to be kept. Default to unlimited.
      */
@@ -2288,20 +2239,6 @@ export declare interface UseRefHistoryReturn<Raw, Serialized> extends UseManualR
     dispose: () => void;
 }
 
-/**
- * Reactive Web Share API.
- *
- * @see https://vueuse.org/useShare
- * @param shareOptions
- * @param options
- *
- * @__NO_SIDE_EFFECTS__
- */
-declare function useShare(shareOptions?: MaybeRefOrGetter<UseShareOptions>, options?: ConfigurableNavigator): {
-    isSupported: vue0.ComputedRef<boolean>;
-    share: (overrideOptions?: MaybeRefOrGetter<UseShareOptions>) => Promise<void>;
-};
-
 export declare interface UseShareOptions {
     title?: string;
     files?: File[];
@@ -2309,7 +2246,9 @@ export declare interface UseShareOptions {
     url?: string;
 }
 
-export declare type UseShareReturn = ReturnType<typeof useShare>;
+export declare interface UseShareReturn extends Supportable {
+    share: (overrideOptions?: MaybeRefOrGetter<UseShareOptions>) => Promise<void>;
+}
 
 /**
  * reactive sort array
@@ -2387,12 +2326,6 @@ export declare interface UseStepperReturn<StepName, Steps, Step> {
     isAfter: (step: StepName) => boolean;
 }
 
-declare function useTextareaAutosize(options?: UseTextareaAutosizeOptions): {
-    textarea: vue0.Ref<HTMLTextAreaElement | null | undefined, HTMLTextAreaElement | null | undefined>;
-    input: vue0.Ref<string, string>;
-    triggerResize: () => void;
-};
-
 export declare interface UseTextareaAutosizeOptions extends ConfigurableWindow {
     /** Textarea element to autosize. */
     element?: MaybeRef<HTMLTextAreaElement | undefined | null>;
@@ -2408,7 +2341,11 @@ export declare interface UseTextareaAutosizeOptions extends ConfigurableWindow {
     styleProp?: 'height' | 'minHeight';
 }
 
-export declare type UseTextareaAutosizeReturn = ReturnType<typeof useTextareaAutosize>;
+export declare interface UseTextareaAutosizeReturn {
+    textarea: Ref<HTMLTextAreaElement | undefined | null>;
+    input: Ref<string>;
+    triggerResize: () => void;
+}
 
 /** @deprecated use `refThrottled` instead */
 export declare const useThrottle: typeof refThrottled;
@@ -2448,7 +2385,7 @@ export declare type UseThrottledRefHistoryReturn<Raw, Serialized = Raw> = UseRef
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function useThrottleFn<T$1 extends FunctionArgs>(fn: T$1, ms?: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): PromisifyFn<T$1>;
+export declare function useThrottleFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): PromisifyFn<T>;
 
 /**
  * Reactive time ago formatter.
@@ -2472,7 +2409,7 @@ export declare interface UseTimeAgoMessagesBuiltIn {
     invalid: string;
 }
 
-export declare interface UseTimeAgoOptions<Controls extends boolean, UnitNames extends string = UseTimeAgoUnitNamesDefault> extends FormatTimeAgoOptions<UnitNames> {
+export declare interface UseTimeAgoOptions<Controls extends boolean, UnitNames extends string = UseTimeAgoUnitNamesDefault> extends FormatTimeAgoOptions<UnitNames>, ConfigurableScheduler {
     /**
      * Expose more controls
      *
@@ -2482,6 +2419,7 @@ export declare interface UseTimeAgoOptions<Controls extends boolean, UnitNames e
     /**
      * Intervals to update, set 0 to disable auto update
      *
+     * @deprecated Please use `scheduler` option instead
      * @default 30_000
      */
     updateInterval?: number;
@@ -2569,7 +2507,7 @@ export declare function useTimestamp(options: UseTimestampOptions<true>): {
     timestamp: ShallowRef<number>;
 } & Pausable;
 
-export declare interface UseTimestampOptions<Controls extends boolean> {
+export declare interface UseTimestampOptions<Controls extends boolean> extends ConfigurableScheduler {
     /**
      * Expose more controls
      *
@@ -2585,12 +2523,14 @@ export declare interface UseTimestampOptions<Controls extends boolean> {
     /**
      * Update the timestamp immediately
      *
+     * @deprecated Please use `scheduler` option instead
      * @default true
      */
     immediate?: boolean;
     /**
      * Update interval, or use requestAnimationFrame
      *
+     * @deprecated Please use `scheduler` option instead
      * @default requestAnimationFrame
      */
     interval?: 'requestAnimationFrame' | number;
@@ -2600,16 +2540,18 @@ export declare interface UseTimestampOptions<Controls extends boolean> {
     callback?: (timestamp: number) => void;
 }
 
-export declare type UseTimestampReturn = ReturnType<typeof useTimestamp>;
+export declare type UseTimestampReturn<Controls extends boolean> = Controls extends true ? ({
+    timestamp: ShallowRef<number>;
+} & Pausable) : ShallowRef<number>;
 
 /**
  * @deprecated use UseTimeoutReturn instead
  */
 export declare type UseTimoutReturn = UseTimeoutReturn;
 
-export declare function useToggle<Truthy, Falsy$1, T$1 = Truthy | Falsy$1>(initialValue: Ref<T$1>, options?: UseToggleOptions<Truthy, Falsy$1>): (value?: T$1) => T$1;
+export declare function useToggle<Truthy, Falsy$1, T = Truthy | Falsy$1>(initialValue: Ref<T>, options?: UseToggleOptions<Truthy, Falsy$1>): (value?: T) => T;
 
-export declare function useToggle<Truthy = true, Falsy$1 = false, T$1 = Truthy | Falsy$1>(initialValue?: T$1, options?: UseToggleOptions<Truthy, Falsy$1>): [ShallowRef<T$1>, (value?: T$1) => T$1];
+export declare function useToggle<Truthy = true, Falsy$1 = false, T = Truthy | Falsy$1>(initialValue?: T, options?: UseToggleOptions<Truthy, Falsy$1>): [ShallowRef<T>, (value?: T) => T];
 
 export declare interface UseToggleOptions<Truthy, Falsy$1> {
     truthyValue?: MaybeRefOrGetter<Truthy>;
@@ -2718,7 +2660,7 @@ export declare interface UseWebSocketOptions {
      *
      * @default false
      */
-    heartbeat?: boolean | {
+    heartbeat?: boolean | ConfigurableScheduler & {
         /**
          * Message for the heartbeat
          *
@@ -2732,6 +2674,7 @@ export declare interface UseWebSocketOptions {
         /**
          * Interval, in milliseconds
          *
+         * @deprecated Please use `scheduler` option instead
          * @default 1000
          */
         interval?: number;
@@ -2835,13 +2778,13 @@ export declare interface UseWebSocketReturn<T> {
  * @param fn
  * @param options
  */
-export declare function useWebWorkerFn<T extends (...fnArgs: any[]) => any>(fn: T, options?: UseWebWorkerOptions): {
+export declare function useWebWorkerFn<T extends (...fnArgs: any[]) => any>(fn: T, options?: UseWebWorkerOptions): UseWebWorkerFnReturn<T>;
+
+export declare interface UseWebWorkerFnReturn<T extends (...fnArgs: any[]) => any> {
     workerFn: (...fnArgs: Parameters<T>) => Promise<ReturnType<T>>;
-    workerStatus: vue0.ShallowRef<WebWorkerStatus, WebWorkerStatus>;
+    workerStatus: ShallowRef<WebWorkerStatus>;
     workerTerminate: (status?: WebWorkerStatus) => void;
-};
-
-export declare type UseWebWorkerFnReturn = ReturnType<typeof useWebWorkerFn>;
+}
 
 export declare interface UseWebWorkerOptions extends ConfigurableWindow {
     /**
@@ -2872,13 +2815,13 @@ export declare interface UseWebWorkerReturn<Data = any> {
  *
  * @see https://vueuse.org/watchArray
  */
-export declare function watchArray<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1[]> | T$1[], cb: WatchArrayCallback<T$1[], Immediate extends true ? T$1[] | undefined : T$1[]>, options?: WatchOptions<Immediate>): vue0.WatchHandle;
+export declare 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;
 
 export declare type WatchArrayCallback<V$1 = any, OV = any> = (value: V$1, oldValue: OV, added: V$1, removed: OV, onCleanup: (cleanupFn: () => void) => void) => any;
 
-export declare function watchAtMost<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options: WatchAtMostOptions<Immediate>): WatchAtMostReturn;
+export declare function watchAtMost<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options: WatchAtMostOptions<Immediate>): WatchAtMostReturn;
 
-export declare function watchAtMost<T$1, Immediate extends Readonly<boolean> = false>(sources: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options: WatchAtMostOptions<Immediate>): WatchAtMostReturn;
+export declare function watchAtMost<T, Immediate extends Readonly<boolean> = false>(sources: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options: WatchAtMostOptions<Immediate>): WatchAtMostReturn;
 
 export declare interface WatchAtMostOptions<Immediate> extends WatchWithFilterOptions<Immediate> {
     count: MaybeRefOrGetter<number>;
@@ -2891,27 +2834,27 @@ export declare interface WatchAtMostReturn {
     count: ShallowRef<number>;
 }
 
-export declare function watchDebounced<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: WatchDebouncedOptions<Immediate>): WatchHandle;
+export declare function watchDebounced<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchDebouncedOptions<Immediate>): WatchHandle;
 
-export declare function watchDebounced<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchDebouncedOptions<Immediate>): WatchHandle;
+export 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;
 
-export declare function watchDebounced<T$1 extends object, Immediate extends Readonly<boolean> = false>(source: T$1, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchDebouncedOptions<Immediate>): WatchHandle;
+export declare 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;
 
 export declare interface WatchDebouncedOptions<Immediate> extends WatchOptions<Immediate>, DebounceFilterOptions {
     debounce?: MaybeRefOrGetter<number>;
 }
 
-export declare function watchDeep<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(source: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchHandle;
+export declare function watchDeep<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchHandle;
 
-export declare function watchDeep<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchHandle;
+export declare function watchDeep<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchHandle;
 
-export declare function watchDeep<T$1 extends object, Immediate extends Readonly<boolean> = false>(source: T$1, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchHandle;
+export declare function watchDeep<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchHandle;
 
-export declare function watchIgnorable<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
+export declare function watchIgnorable<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
 
-export declare function watchIgnorable<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
+export declare function watchIgnorable<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
 
-export declare function watchIgnorable<T$1 extends object, Immediate extends Readonly<boolean> = false>(source: T$1, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
+export declare function watchIgnorable<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
 
 export declare interface WatchIgnorableReturn {
     ignoreUpdates: IgnoredUpdater;
@@ -2919,28 +2862,28 @@ export declare interface WatchIgnorableReturn {
     stop: WatchStopHandle;
 }
 
-export declare function watchImmediate<T$1 extends Readonly<MultiWatchSources>>(source: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, true>>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
+export declare function watchImmediate<T extends Readonly<MultiWatchSources>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
 
-export declare function watchImmediate<T$1>(source: WatchSource<T$1>, cb: WatchCallback<T$1, T$1 | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
+export declare function watchImmediate<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
 
-export declare function watchImmediate<T$1 extends object>(source: T$1, cb: WatchCallback<T$1, T$1 | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
+export declare function watchImmediate<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
 
-export declare function watchOnce<T$1 extends Readonly<MultiWatchSources>>(source: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, true>>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
+export declare function watchOnce<T extends Readonly<MultiWatchSources>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
 
-export declare function watchOnce<T$1>(source: WatchSource<T$1>, cb: WatchCallback<T$1, T$1 | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
+export declare function watchOnce<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
 
-export declare function watchOnce<T$1 extends object>(source: T$1, cb: WatchCallback<T$1, T$1 | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
+export declare function watchOnce<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchHandle;
 
 export declare type WatchOptionFlush = WatchOptions['flush'];
 
-/**
- * @deprecated This function will be removed in future version.
- */
-export declare function watchPausable<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
+/** @deprecated Use Vue's built-in `watch` instead. This function will be removed in future version. */
+export declare function watchPausable<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
 
-export declare function watchPausable<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
+/** @deprecated Use Vue's built-in `watch` instead. This function will be removed in future version. */
+export 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;
 
-export declare function watchPausable<T$1 extends object, Immediate extends Readonly<boolean> = false>(source: T$1, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
+/** @deprecated Use Vue's built-in `watch` instead. This function will be removed in future version. */
+export declare function watchPausable<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;
 
 export declare type WatchPausableOptions<Immediate> = WatchWithFilterOptions<Immediate> & PausableFilterOptions;
 
@@ -2948,11 +2891,11 @@ export declare interface WatchPausableReturn extends Pausable {
     stop: WatchStopHandle;
 }
 
-export declare function watchThrottled<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: WatchThrottledOptions<Immediate>): WatchHandle;
+export declare function watchThrottled<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchThrottledOptions<Immediate>): WatchHandle;
 
-export declare function watchThrottled<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchThrottledOptions<Immediate>): WatchHandle;
+export 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;
 
-export declare function watchThrottled<T$1 extends object, Immediate extends Readonly<boolean> = false>(source: T$1, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchThrottledOptions<Immediate>): WatchHandle;
+export declare 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;
 
 export declare interface WatchThrottledOptions<Immediate> extends WatchOptions<Immediate> {
     throttle?: MaybeRefOrGetter<number>;
@@ -2960,11 +2903,11 @@ export declare interface WatchThrottledOptions<Immediate> extends WatchOptions<I
     leading?: boolean;
 }
 
-export declare function watchTriggerable<T$1 extends Readonly<MultiWatchSources>, FnReturnT>(sources: [...T$1], cb: WatchTriggerableCallback<MapSources<T$1>, MapOldSources<T$1, true>, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
+export declare function watchTriggerable<T extends Readonly<MultiWatchSources>, FnReturnT>(sources: [...T], cb: WatchTriggerableCallback<MapSources<T>, MapOldSources<T, true>, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
 
-export declare function watchTriggerable<T$1, FnReturnT>(source: WatchSource<T$1>, cb: WatchTriggerableCallback<T$1, T$1 | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
+export declare function watchTriggerable<T, FnReturnT>(source: WatchSource<T>, cb: WatchTriggerableCallback<T, T | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
 
-export declare function watchTriggerable<T$1 extends object, FnReturnT>(source: T$1, cb: WatchTriggerableCallback<T$1, T$1 | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
+export declare function watchTriggerable<T extends object, FnReturnT>(source: T, cb: WatchTriggerableCallback<T, T | undefined, FnReturnT>, options?: WatchWithFilterOptions<boolean>): WatchTriggerableReturn<FnReturnT>;
 
 export declare type WatchTriggerableCallback<V$1 = any, OV = any, R$1 = void> = (value: V$1, oldValue: OV, onCleanup: OnCleanup) => R$1;
 
@@ -2973,11 +2916,11 @@ export declare interface WatchTriggerableReturn<FnReturnT = void> extends WatchI
     trigger: () => FnReturnT;
 }
 
-export declare function watchWithFilter<T$1 extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T$1], cb: WatchCallback<MapSources<T$1>, MapOldSources<T$1, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchHandle;
+export declare function watchWithFilter<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchHandle;
 
-export declare function watchWithFilter<T$1, Immediate extends Readonly<boolean> = false>(source: WatchSource<T$1>, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchWithFilterOptions<Immediate>): WatchHandle;
+export declare function watchWithFilter<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchHandle;
 
-export declare function watchWithFilter<T$1 extends object, Immediate extends Readonly<boolean> = false>(source: T$1, cb: WatchCallback<T$1, Immediate extends true ? T$1 | undefined : T$1>, options?: WatchWithFilterOptions<Immediate>): WatchHandle;
+export declare function watchWithFilter<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchHandle;
 
 export declare interface WatchWithFilterOptions<Immediate> extends WatchOptions<Immediate>, ConfigurableEventFilter {}
 
@@ -2992,7 +2935,7 @@ export declare type WebWorkerStatus = 'PENDING' | 'SUCCESS' | 'RUNNING' | 'ERROR
  *
  * @see https://vueuse.org/whenever
  */
-export declare function whenever<T$1>(source: WatchSource<T$1 | false | null | undefined>, cb: WatchCallback<T$1>, options?: WheneverOptions): vue0.WatchHandle;
+export declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WheneverOptions): vue0.WatchHandle;
 
 export declare interface WheneverOptions extends WatchOptions {
     /**
@@ -3017,6 +2960,6 @@ export declare interface WritableComputedInjectOptionsWithDefault<T, K$1> {
     set: ComputedInjectSetter<K$1>;
 }
 
-export declare interface WritableComputedRefWithControl<T$1> extends WritableComputedRef<T$1>, ComputedWithControlRefExtra {}
+export declare interface WritableComputedRefWithControl<T> extends WritableComputedRef<T>, ComputedWithControlRefExtra {}
 
 export { }