@vueuse/shared 7.7.1 → 8.0.0

package/index.d.ts

@@ -1,5 +1,76 @@
 import * as vue_demi from 'vue-demi';
-import { Ref, WatchOptions, WatchSource, ComputedRef, WatchCallback, WatchStopHandle, WatchOptionsBase, ShallowUnwrapRef as ShallowUnwrapRef$1, UnwrapRef, ToRefs } from 'vue-demi';
+import { WatchOptionsBase, Ref, WatchSource, ComputedRef, ShallowUnwrapRef as ShallowUnwrapRef$1, WatchOptions, UnwrapRef, ToRefs, WatchCallback, WatchStopHandle } from 'vue-demi';
+import { MaybeRef as MaybeRef$1 } from '@vueuse/shared';
+
+declare function computedEager<T>(fn: () => T, options?: WatchOptionsBase): Readonly<Ref<T>>;
+
+/**
+ * Explicitly define the deps of computed.
+ *
+ * @param source
+ * @param fn
+ */
+declare function computedWithControl<T, S>(source: WatchSource<S>, fn: () => T): ComputedRef<T>;
+
+/**
+ * The source code for this function was inspired by vue-apollo's `useEventHook` util
+ * https://github.com/vuejs/vue-apollo/blob/v4/packages/vue-apollo-composable/src/util/useEventHook.ts
+ */
+declare type EventHookOn<T = any> = (fn: (param: T) => void) => {
+    off: () => void;
+};
+declare type EventHookOff<T = any> = (fn: (param: T) => void) => void;
+declare type EventHookTrigger<T = any> = (param: T) => void;
+interface EventHook<T = any> {
+    on: EventHookOn<T>;
+    off: EventHookOff<T>;
+    trigger: EventHookTrigger<T>;
+}
+/**
+ * Utility for creating event hooks
+ *
+ * @see https://vueuse.org/createEventHook
+ */
+declare function createEventHook<T = any>(): EventHook<T>;
+
+declare type CreateGlobalStateReturn<T> = () => T;
+/**
+ * Keep states in the global scope to be reusable across Vue instances.
+ *
+ * @see https://vueuse.org/createGlobalState
+ * @param stateFactory A factory function to create the state
+ */
+declare function createGlobalState<T>(stateFactory: () => T): CreateGlobalStateReturn<T>;
+
+/**
+ * Make a composable function usable with multiple Vue instances.
+ *
+ * @see https://vueuse.org/createSharedComposable
+ */
+declare function createSharedComposable<Fn extends ((...args: any[]) => any)>(composable: Fn): Fn;
+
+interface ExtendRefOptions<Unwrap extends boolean = boolean> {
+    /**
+     * Is the extends properties enumerable
+     *
+     * @default false
+     */
+    enumerable?: boolean;
+    /**
+     * Unwrap for Ref properties
+     *
+     * @default true
+     */
+    unwrap?: Unwrap;
+}
+/**
+ * Overlad 1: Unwrap set to false
+ */
+declare function extendRef<R extends Ref<any>, Extend extends object, Options extends ExtendRefOptions<false>>(ref: R, extend: Extend, options?: Options): ShallowUnwrapRef$1<Extend> & R;
+/**
+ * Overlad 2: Unwrap unset or set to true
+ */
+declare function extendRef<R extends Ref<any>, Extend extends object, Options extends ExtendRefOptions>(ref: R, extend: Extend, options?: Options): Extend & R;
 
 declare const isClient: boolean;
 declare const isDef: <T = any>(val?: T | undefined) => val is T;
@@ -207,86 +278,37 @@ declare function increaseWithUnit(target: string | number, delta: number): strin
 declare function objectPick<O, T extends keyof O>(obj: O, keys: T[], omitUndefined?: boolean): Pick<O, T>;
 
 /**
- * `AND` conditions for refs.
- *
- * @see https://vueuse.org/and
+ * Shorthand for accessing `ref.value`
  */
-declare function and(...args: MaybeRef<any>[]): ComputedRef<boolean>;
+declare function get<T>(ref: MaybeRef<T>): T;
+declare function get<T, K extends keyof T>(ref: MaybeRef<T>, key: K): T[K];
 
-/**
- * Two-way refs synchronization.
- *
- * @param a
- * @param b
- */
-declare function biSyncRef<R extends Ref<any>>(a: R, b: R): () => void;
+declare function isDefined<T>(v: Ref<T>): v is Ref<Exclude<T, null | undefined>>;
+declare function isDefined<T>(v: ComputedRef<T>): v is ComputedRef<Exclude<T, null | undefined>>;
+declare function isDefined<T>(v: T): v is Exclude<T, null | undefined>;
 
 /**
- * Explicitly define the deps of computed.
+ * `AND` conditions for refs.
  *
- * @param source
- * @param fn
+ * @see https://vueuse.org/logicAnd
  */
-declare function controlledComputed<T, S>(source: WatchSource<S>, fn: () => T): ComputedRef<T>;
+declare function logicAnd(...args: MaybeRef<any>[]): ComputedRef<boolean>;
 
-interface ControlledRefOptions<T> {
-    /**
-     * Callback function before the ref changing.
-     *
-     * Returning `false` to dismiss the change.
-     */
-    onBeforeChange?: (value: T, oldValue: T) => void | boolean;
-    /**
-     * Callback function after the ref changed
-     *
-     * This happends synchronously, with less overhead compare to `watch`
-     */
-    onChanged?: (value: T, oldValue: T) => void;
-}
 /**
- * Explicitly define the deps of computed.
+ * `NOT` conditions for refs.
  *
- * @param source
- * @param fn
+ * @see https://vueuse.org/logicNot
  */
-declare function controlledRef<T>(initial: T, options?: ControlledRefOptions<T>): vue_demi.ShallowUnwrapRef<{
-    get: (tracking?: boolean) => T;
-    set: (value: T, triggering?: boolean) => void;
-    untrackedGet: () => T;
-    silentSet: (v: T) => void;
-    peek: () => T;
-    lay: (v: T) => void;
-}> & vue_demi.Ref<T>;
+declare function logicNot(v: MaybeRef<any>): ComputedRef<boolean>;
 
 /**
- * The source code for this function was inspired by vue-apollo's `useEventHook` util
- * https://github.com/vuejs/vue-apollo/blob/v4/packages/vue-apollo-composable/src/util/useEventHook.ts
- */
-declare type EventHookOn<T = any> = (fn: (param: T) => void) => {
-    off: () => void;
-};
-declare type EventHookOff<T = any> = (fn: (param: T) => void) => void;
-declare type EventHookTrigger<T = any> = (param: T) => void;
-interface EventHook<T = any> {
-    on: EventHookOn<T>;
-    off: EventHookOff<T>;
-    trigger: EventHookTrigger<T>;
-}
-/**
- * Utility for creating event hooks
+ * `OR` conditions for refs.
  *
- * @see https://vueuse.org/createEventHook
+ * @see https://vueuse.org/logicOr
  */
-declare function createEventHook<T = any>(): EventHook<T>;
+declare function logicOr(...args: MaybeRef<any>[]): ComputedRef<boolean>;
 
-declare type CreateGlobalStateReturn<T> = () => T;
-/**
- * Keep states in the global scope to be reusable across Vue instances.
- *
- * @see https://vueuse.org/createGlobalState
- * @param stateFactory A factory function to create the state
- */
-declare function createGlobalState<T>(stateFactory: () => T): CreateGlobalStateReturn<T>;
+declare function makeDestructurable<T extends Record<string, unknown>, A extends readonly any[]>(obj: T, arr: A): T & A;
 
 declare type Reactify<T> = T extends (...args: infer A) => infer R ? (...args: {
     [K in keyof A]: MaybeRef<A[K]>;
@@ -300,101 +322,6 @@ declare type Reactify<T> = T extends (...args: infer A) => infer R ? (...args: {
  */
 declare function reactify<T extends Function>(fn: T): Reactify<T>;
 
-/**
- * Make a composable function usable with multiple Vue instances.
- *
- * @see https://vueuse.org/createSharedComposable
- */
-declare function createSharedComposable<Fn extends ((...args: any[]) => any)>(composable: Fn): Fn;
-
-/**
- * Debounce updates of a ref.
- *
- * @return A new debounced ref.
- */
-declare function useDebounce<T>(value: Ref<T>, ms?: number, options?: DebounceFilterOptions): Readonly<Ref<T>>;
-
-interface DebouncedWatchOptions<Immediate> extends WatchOptions<Immediate> {
-    debounce?: MaybeRef<number>;
-}
-declare function debouncedWatch<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: DebouncedWatchOptions<Immediate>): WatchStopHandle;
-declare function debouncedWatch<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: DebouncedWatchOptions<Immediate>): WatchStopHandle;
-declare function debouncedWatch<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: DebouncedWatchOptions<Immediate>): WatchStopHandle;
-
-declare function eagerComputed<T>(fn: () => T, options?: WatchOptionsBase): Readonly<Ref<T>>;
-
-interface ExtendRefOptions<Unwrap extends boolean = boolean> {
-    /**
-     * Is the extends properties enumerable
-     *
-     * @default false
-     */
-    enumerable?: boolean;
-    /**
-     * Unwrap for Ref properties
-     *
-     * @default true
-     */
-    unwrap?: Unwrap;
-}
-/**
- * Overlad 1: Unwrap set to false
- */
-declare function extendRef<R extends Ref<any>, Extend extends object, Options extends ExtendRefOptions<false>>(ref: R, extend: Extend, options?: Options): ShallowUnwrapRef$1<Extend> & R;
-/**
- * Overlad 2: Unwrap unset or set to true
- */
-declare function extendRef<R extends Ref<any>, Extend extends object, Options extends ExtendRefOptions>(ref: R, extend: Extend, options?: Options): Extend & R;
-
-/**
- * Shorthand for accessing `ref.value`
- */
-declare function get<T>(ref: MaybeRef<T>): T;
-declare function get<T, K extends keyof T>(ref: MaybeRef<T>, key: K): T[K];
-
-interface WatchWithFilterOptions<Immediate> extends WatchOptions<Immediate>, ConfigurableEventFilter {
-}
-declare function watchWithFilter<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchStopHandle;
-declare function watchWithFilter<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchStopHandle;
-declare function watchWithFilter<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchStopHandle;
-
-declare type IgnoredUpdater = (updater: () => void) => void;
-interface IgnorableWatchReturn {
-    ignoreUpdates: IgnoredUpdater;
-    ignorePrevAsyncUpdates: () => void;
-    stop: WatchStopHandle;
-}
-declare function ignorableWatch<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchWithFilterOptions<Immediate>): IgnorableWatchReturn;
-declare function ignorableWatch<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): IgnorableWatchReturn;
-declare function ignorableWatch<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): IgnorableWatchReturn;
-
-declare function isDefined<T>(v: Ref<T>): v is Ref<Exclude<T, null | undefined>>;
-declare function isDefined<T>(v: ComputedRef<T>): v is ComputedRef<Exclude<T, null | undefined>>;
-declare function isDefined<T>(v: T): v is Exclude<T, null | undefined>;
-
-declare function makeDestructurable<T extends Record<string, unknown>, A extends readonly any[]>(obj: T, arr: A): T & A;
-
-/**
- * `NOT` conditions for refs.
- *
- * @see https://vueuse.org/not
- */
-declare function not(v: MaybeRef<any>): ComputedRef<boolean>;
-
-/**
- * `OR` conditions for refs.
- *
- * @see https://vueuse.org/or
- */
-declare function or(...args: MaybeRef<any>[]): ComputedRef<boolean>;
-
-interface PausableWatchReturn extends Pausable {
-    stop: WatchStopHandle;
-}
-declare function pausableWatch<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchWithFilterOptions<Immediate>): PausableWatchReturn;
-declare function pausableWatch<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): PausableWatchReturn;
-declare function pausableWatch<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): PausableWatchReturn;
-
 declare type ReactifyNested<T, Keys extends keyof T = keyof T> = {
     [K in Keys]: T[K] extends (...args: any[]) => any ? Reactify<T[K]> : T[K];
 };
@@ -433,6 +360,22 @@ declare function reactivePick<T extends object, K extends keyof T>(obj: T, ...ke
     [S in K]: UnwrapRef<T[S]>;
 };
 
+/**
+ * Create a ref which will be reset to the default value after some time.
+ *
+ * @see https://vueuse.org/refAutoReset
+ * @param defaultValue The value which will be set.
+ * @param afterMs      A zero-or-greater delay in milliseconds.
+ */
+declare function refAutoReset<T>(defaultValue: T, afterMs?: MaybeRef$1<number>): Ref<T>;
+
+/**
+ * Debounce updates of a ref.
+ *
+ * @return A new debounced ref.
+ */
+declare function refDebounced<T>(value: Ref<T>, ms?: number, options?: DebounceFilterOptions): Readonly<Ref<T>>;
+
 /**
  * Apply default value to a ref.
  *
@@ -441,6 +384,50 @@ declare function reactivePick<T extends object, K extends keyof T>(obj: T, ...ke
  */
 declare function refDefault<T>(source: Ref<T | undefined | null>, defaultValue: T): Ref<T>;
 
+/**
+ * Throttle execution of a function. Especially useful for rate limiting
+ * execution of handlers on events like resize and scroll.
+ *
+ * @param value Ref value to be watched with throttle effect
+ * @param  delay  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+ * @param [trailing=true] if true, update the value again after the delay time is up
+ * @param [leading=true] if true, update the value on the leading edge of the ms timeout
+ */
+declare function refThrottled<T>(value: Ref<T>, delay?: number, trailing?: boolean, leading?: boolean): Ref<T>;
+
+interface ControlledRefOptions<T> {
+    /**
+     * Callback function before the ref changing.
+     *
+     * Returning `false` to dismiss the change.
+     */
+    onBeforeChange?: (value: T, oldValue: T) => void | boolean;
+    /**
+     * Callback function after the ref changed
+     *
+     * This happends synchronously, with less overhead compare to `watch`
+     */
+    onChanged?: (value: T, oldValue: T) => void;
+}
+/**
+ * Explicitly define the deps of computed.
+ *
+ * @param source
+ * @param fn
+ */
+declare function refWithControl<T>(initial: T, options?: ControlledRefOptions<T>): vue_demi.ShallowUnwrapRef<{
+    get: (tracking?: boolean) => T;
+    set: (value: T, triggering?: boolean) => void;
+    untrackedGet: () => T;
+    silentSet: (v: T) => void;
+    peek: () => T;
+    lay: (v: T) => void;
+}> & vue_demi.Ref<T>;
+/**
+ * Alias for `refWithControl`
+ */
+declare const controlledRef: typeof refWithControl;
+
 declare function set<T>(ref: Ref<T>, value: T): void;
 declare function set<O extends object, K extends keyof O>(target: O, key: K, value: O[K]): void;
 
@@ -457,34 +444,42 @@ interface SyncRefOptions extends ConfigurableFlushSync {
      * @default true
      */
     immediate?: boolean;
+    /**
+     * Direction of syncing
+     *
+     * @default 'both'
+     */
+    direction?: 'ltr' | 'rtl' | 'both';
 }
 /**
- * Keep target ref(s) in sync with the source ref
+ * Two-way refs synchronization.
  *
- * @param source source ref
- * @param targets
+ * @param left
+ * @param right
  */
-declare function syncRef<T>(source: WatchSource<T>, targets: Ref<T> | Ref<T>[], { flush, deep, immediate, }?: SyncRefOptions): vue_demi.WatchStopHandle;
+declare function syncRef<R extends Ref<any>>(left: R, right: R, options?: SyncRefOptions): () => void;
 
+interface SyncRefsOptions extends ConfigurableFlushSync {
+    /**
+     * Watch deeply
+     *
+     * @default false
+     */
+    deep?: boolean;
+    /**
+     * Sync values immediately
+     *
+     * @default true
+     */
+    immediate?: boolean;
+}
 /**
- * Throttle execution of a function. Especially useful for rate limiting
- * execution of handlers on events like resize and scroll.
+ * Keep target ref(s) in sync with the source ref
  *
- * @param value Ref value to be watched with throttle effect
- * @param  delay  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
- * @param [trailing=true] if true, update the value again after the delay time is up
- * @param [leading=true] if true, update the value on the leading edge of the ms timeout
+ * @param source source ref
+ * @param targets
  */
-declare function useThrottle<T>(value: Ref<T>, delay?: number, trailing?: boolean, leading?: boolean): Ref<T>;
-
-interface ThrottledWatchOptions<Immediate> extends WatchOptions<Immediate> {
-    throttle?: MaybeRef<number>;
-    trailing?: boolean;
-    leading?: boolean;
-}
-declare function throttledWatch<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: ThrottledWatchOptions<Immediate>): WatchStopHandle;
-declare function throttledWatch<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: ThrottledWatchOptions<Immediate>): WatchStopHandle;
-declare function throttledWatch<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: ThrottledWatchOptions<Immediate>): WatchStopHandle;
+declare function syncRefs<T>(source: WatchSource<T>, targets: Ref<T> | Ref<T>[], options?: SyncRefsOptions): vue_demi.WatchStopHandle;
 
 /**
  * Converts ref to reactive.
@@ -611,6 +606,19 @@ declare function useCounter(initialValue?: number, options?: UseCounterOptions):
     reset: (val?: number) => number;
 };
 
+declare type DateLike = Date | number | string | undefined;
+declare const formatDate: (date: Date, formatStr: string) => string;
+declare const normalizeDate: (date: DateLike) => Date;
+/**
+ * Get the formatted date according to the string of tokens passed in.
+ *
+ * @see https://vueuse.org/useDateFormat
+ * @param date
+ * @param formatStr
+ */
+declare function useDateFormat(date: MaybeRef$1<DateLike>, formatStr?: MaybeRef$1<string>): vue_demi.ComputedRef<string>;
+declare type UseDateFormatReturn = ReturnType<typeof useDateFormat>;
+
 /**
  * Debounce execution of a function.
  *
@@ -738,6 +746,12 @@ declare function useTimeout(interval: number, options: TimeoutOptions<true>): {
 declare function useToggle(value: Ref<boolean>): (value?: boolean) => boolean;
 declare function useToggle(initialValue?: boolean): [Ref<boolean>, (value?: boolean) => boolean];
 
+interface WatchWithFilterOptions<Immediate> extends WatchOptions<Immediate>, ConfigurableEventFilter {
+}
+declare function watchWithFilter<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchStopHandle;
+declare function watchWithFilter<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchStopHandle;
+declare function watchWithFilter<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchStopHandle;
+
 interface WatchAtMostOptions<Immediate> extends WatchWithFilterOptions<Immediate> {
     count: MaybeRef<number>;
 }
@@ -749,10 +763,43 @@ declare function watchAtMost<T extends Readonly<WatchSource<unknown>[]>, Immedia
 declare function watchAtMost<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(source: 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;
 
+interface WatchDebouncedOptions<Immediate> extends WatchOptions<Immediate> {
+    debounce?: MaybeRef<number>;
+}
+declare function watchDebounced<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchDebouncedOptions<Immediate>): WatchStopHandle;
+declare function watchDebounced<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchDebouncedOptions<Immediate>): WatchStopHandle;
+declare function watchDebounced<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchDebouncedOptions<Immediate>): WatchStopHandle;
+
+declare type IgnoredUpdater = (updater: () => void) => void;
+interface WatchIgnorableReturn {
+    ignoreUpdates: IgnoredUpdater;
+    ignorePrevAsyncUpdates: () => void;
+    stop: WatchStopHandle;
+}
+declare function watchIgnorable<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
+declare function watchIgnorable<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
+declare function watchIgnorable<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchIgnorableReturn;
+
 declare function watchOnce<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchOptions<Immediate>): void;
 declare function watchOnce<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchOptions<Immediate>): void;
 declare function watchOnce<T, Immediate extends Readonly<boolean> = false>(sources: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchOptions<Immediate>): void;
 
+interface WatchPausableReturn extends Pausable {
+    stop: WatchStopHandle;
+}
+declare function watchPausable<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchWithFilterOptions<Immediate>): WatchPausableReturn;
+declare function watchPausable<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchPausableReturn;
+declare function watchPausable<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchWithFilterOptions<Immediate>): WatchPausableReturn;
+
+interface WatchThrottledOptions<Immediate> extends WatchOptions<Immediate> {
+    throttle?: MaybeRef<number>;
+    trailing?: boolean;
+    leading?: boolean;
+}
+declare function watchThrottled<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchThrottledOptions<Immediate>): WatchStopHandle;
+declare function watchThrottled<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchThrottledOptions<Immediate>): WatchStopHandle;
+declare function watchThrottled<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchThrottledOptions<Immediate>): WatchStopHandle;
+
 /**
  * Shorthand for watching value to be truthy
  *
@@ -760,4 +807,4 @@ declare function watchOnce<T, Immediate extends Readonly<boolean> = false>(sourc
  */
 declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WatchOptions): vue_demi.WatchStopHandle;
 
-export { Awaitable, ConfigurableEventFilter, ConfigurableFlush, ConfigurableFlushSync, ControlledRefOptions, CreateGlobalStateReturn, DebounceFilterOptions, DebouncedWatchOptions, DeepMaybeRef, ElementOf, EventFilter, EventHook, EventHookOff, EventHookOn, EventHookTrigger, ExtendRefOptions, Fn, FunctionArgs, FunctionWrapperOptions, IgnorableWatchReturn, IgnoredUpdater, IntervalFnOptions, IntervalOptions, MapOldSources, MapSources, MaybeRef, Pausable, PausableWatchReturn, Reactify, ReactifyNested, ReactifyObjectOptions, RemovableRef, RemoveableRef, ShallowUnwrapRef, SingletonPromiseReturn, Stopable, Stoppable, SyncRefOptions, ThrottledWatchOptions, TimeoutFnOptions, TimeoutOptions, UntilArrayInstance, UntilBaseInstance, UntilToMatchOptions, UntilValueInstance, UseCounterOptions, UseLastChangedOptions, WatchAtMostOptions, WatchAtMostReturn, WatchWithFilterOptions, and, assert, biSyncRef, bypassFilter, clamp, containsProp, controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, useDebounce as debouncedRef, debouncedWatch, eagerComputed, extendRef, get, identity, ignorableWatch, increaseWithUnit, invoke, isBoolean, isClient, isDef, isDefined, isFunction, isNumber, isObject, isString, isWindow, makeDestructurable, noop, not, now, objectPick, or, pausableFilter, pausableWatch, promiseTimeout, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refDefault, set, syncRef, throttleFilter, useThrottle as throttledRef, throttledWatch, timestamp, toReactive, toRefs, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useCounter, useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToggle, watchAtMost, watchOnce, watchWithFilter, whenever };
+export { Awaitable, ConfigurableEventFilter, ConfigurableFlush, ConfigurableFlushSync, ControlledRefOptions, CreateGlobalStateReturn, DateLike, DebounceFilterOptions, DeepMaybeRef, ElementOf, EventFilter, EventHook, EventHookOff, EventHookOn, EventHookTrigger, ExtendRefOptions, Fn, FunctionArgs, FunctionWrapperOptions, IgnoredUpdater, IntervalFnOptions, IntervalOptions, MapOldSources, MapSources, MaybeRef, Pausable, Reactify, ReactifyNested, ReactifyObjectOptions, RemovableRef, RemoveableRef, ShallowUnwrapRef, SingletonPromiseReturn, Stopable, Stoppable, SyncRefOptions, SyncRefsOptions, TimeoutFnOptions, TimeoutOptions, UntilArrayInstance, UntilBaseInstance, UntilToMatchOptions, UntilValueInstance, UseCounterOptions, UseDateFormatReturn, UseLastChangedOptions, WatchAtMostOptions, WatchAtMostReturn, WatchDebouncedOptions, WatchIgnorableReturn, WatchPausableReturn, WatchThrottledOptions, WatchWithFilterOptions, logicAnd as and, assert, refAutoReset as autoResetRef, bypassFilter, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, computedEager as eagerComputed, extendRef, formatDate, get, identity, watchIgnorable as ignorableWatch, increaseWithUnit, invoke, isBoolean, isClient, isDef, isDefined, isFunction, isNumber, isObject, isString, isWindow, logicAnd, logicNot, logicOr, makeDestructurable, noop, normalizeDate, logicNot as not, now, objectPick, logicOr as or, pausableFilter, watchPausable as pausableWatch, promiseTimeout, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toReactive, toRefs, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToggle, watchAtMost, watchDebounced, watchIgnorable, watchOnce, watchPausable, watchThrottled, watchWithFilter, whenever };