@vueuse/shared 8.9.4 → 9.0.0-beta.2

package/index.d.ts

@@ -1,6 +1,6 @@
 import * as vue_demi from 'vue-demi';
 import { WatchOptionsBase, Ref, ComputedRef, WritableComputedRef, WatchSource, ComputedGetter, WritableComputedOptions, ShallowUnwrapRef as ShallowUnwrapRef$1, WatchOptions, UnwrapRef, ToRefs, WatchCallback, WatchStopHandle } from 'vue-demi';
-import { MaybeRef as MaybeRef$1 } from '@vueuse/shared';
+import { MaybeComputedRef as MaybeComputedRef$1 } from '@vueuse/shared';
 
 declare function computedEager<T>(fn: () => T, options?: WatchOptionsBase): Readonly<Ref<T>>;
 
@@ -125,13 +125,13 @@ declare type RemoveableRef<T> = RemovableRef<T>;
  */
 declare type MaybeRef<T> = T | Ref<T>;
 /**
- * Maybe it's a ref, or a getter function
+ * Maybe it's a ref, or a plain value, or a getter function
  *
  * ```ts
- * type MaybeRef<T> = T | Ref<T>
+ * type MaybeComputedRef<T> = T | Ref<T> | (() => T)
  * ```
  */
-declare type MaybeComputedRef<T> = T extends Function ? never : (() => T) | MaybeRef<T>;
+declare type MaybeComputedRef<T> = T extends () => void ? never : (() => T) | MaybeRef<T>;
 /**
  * Make all the nested attributes of an object or array to MaybeRef<T>
  *
@@ -150,6 +150,7 @@ declare type DeepMaybeRef<T> = T extends Ref<infer V> ? MaybeRef<V> : T extends
 declare type ElementOf<T> = T extends (infer E)[] ? E : never;
 declare type ShallowUnwrapRef<T> = T extends Ref<infer P> ? P : T;
 declare type Awaitable<T> = Promise<T> | T;
+declare type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
 interface Pausable {
     /**
      * A ref indicate whether a pusable instance is active
@@ -226,7 +227,7 @@ interface DebounceFilterOptions {
      * The maximum time allowed to be delayed before it's invoked.
      * In milliseconds.
      */
-    maxWait?: number;
+    maxWait?: MaybeComputedRef<number>;
 }
 /**
  * @internal
@@ -239,7 +240,7 @@ declare const bypassFilter: EventFilter;
  * @param ms
  * @param [maxWait=null]
  */
-declare function debounceFilter(ms: MaybeRef<number>, options?: DebounceFilterOptions): EventFilter<any[], any>;
+declare function debounceFilter(ms: MaybeComputedRef<number>, options?: DebounceFilterOptions): EventFilter<any[], any>;
 /**
  * Create an EventFilter that throttle the events
  *
@@ -247,7 +248,7 @@ declare function debounceFilter(ms: MaybeRef<number>, options?: DebounceFilterOp
  * @param [trailing=true]
  * @param [leading=true]
  */
-declare function throttleFilter(ms: MaybeRef<number>, trailing?: boolean, leading?: boolean): EventFilter<any[], any>;
+declare function throttleFilter(ms: MaybeComputedRef<number>, trailing?: boolean, leading?: boolean): EventFilter<any[], any>;
 /**
  * EventFilter that gives extra controls to pause and resume the filter
  *
@@ -316,32 +317,19 @@ 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>;
 
-/**
- * `AND` conditions for refs.
- *
- * @see https://vueuse.org/logicAnd
- */
-declare function logicAnd(...args: MaybeRef<any>[]): ComputedRef<boolean>;
-
-/**
- * `NOT` conditions for refs.
- *
- * @see https://vueuse.org/logicNot
- */
-declare function logicNot(v: MaybeRef<any>): ComputedRef<boolean>;
-
-/**
- * `OR` conditions for refs.
- *
- * @see https://vueuse.org/logicOr
- */
-declare function logicOr(...args: MaybeRef<any>[]): ComputedRef<boolean>;
-
 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]>;
+declare type Reactified<T, Computed extends boolean> = T extends (...args: infer A) => infer R ? (...args: {
+    [K in keyof A]: Computed extends true ? MaybeComputedRef<A[K]> : MaybeRef<A[K]>;
 }) => ComputedRef<R> : never;
+interface ReactifyOptions<T extends boolean> {
+    /**
+     * Accept passing a function as a reactive getter
+     *
+     * @default true
+     */
+    computedGetter?: T;
+}
 /**
  * Converts plain function into a reactive function.
  * The converted function accepts refs as it's arguments
@@ -349,12 +337,12 @@ declare type Reactify<T> = T extends (...args: infer A) => infer R ? (...args: {
  *
  * @param fn - Source function
  */
-declare function reactify<T extends Function>(fn: T): Reactify<T>;
+declare function reactify<T extends Function, K extends boolean = true>(fn: T, options?: ReactifyOptions<K>): Reactified<T, K>;
 
-declare type ReactifyNested<T, Keys extends keyof T = keyof T> = {
-    [K in Keys]: T[K] extends (...args: any[]) => any ? Reactify<T[K]> : T[K];
+declare type ReactifyNested<T, Keys extends keyof T = keyof T, S extends boolean = true> = {
+    [K in Keys]: T[K] extends (...args: any[]) => any ? Reactified<T[K], S> : T[K];
 };
-interface ReactifyObjectOptions {
+interface ReactifyObjectOptions<T extends boolean> extends ReactifyOptions<T> {
     /**
      * Includes names from Object.getOwnPropertyNames
      *
@@ -365,8 +353,8 @@ interface ReactifyObjectOptions {
 /**
  * Apply `reactify` to an object
  */
-declare function reactifyObject<T extends object, Keys extends keyof T>(obj: T, keys?: (keyof T)[]): ReactifyNested<T, Keys>;
-declare function reactifyObject<T extends object>(obj: T, options?: ReactifyObjectOptions): ReactifyNested<T>;
+declare function reactifyObject<T extends object, Keys extends keyof T>(obj: T, keys?: (keyof T)[]): ReactifyNested<T, Keys, true>;
+declare function reactifyObject<T extends object, S extends boolean = true>(obj: T, options?: ReactifyObjectOptions<S>): ReactifyNested<T, keyof T, S>;
 
 /**
  * Computed reactive object.
@@ -376,14 +364,14 @@ declare function reactiveComputed<T extends {}>(fn: () => T): T;
 /**
  * Reactively omit fields from a reactive object
  *
- * @see https://vueuse.js.org/reactiveOmit
+ * @see https://vueuse.org/reactiveOmit
  */
 declare function reactiveOmit<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): Omit<T, K>;
 
 /**
  * Reactively pick fields from a reactive object
  *
- * @see https://vueuse.js.org/reactivePick
+ * @see https://vueuse.org/reactivePick
  */
 declare function reactivePick<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): {
     [S in K]: UnwrapRef<T[S]>;
@@ -396,7 +384,7 @@ declare function reactivePick<T extends object, K extends keyof T>(obj: T, ...ke
  * @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>;
+declare function refAutoReset<T>(defaultValue: T, afterMs?: MaybeComputedRef$1<number>): Ref<T>;
 
 /**
  * Debounce updates of a ref.
@@ -462,6 +450,7 @@ declare const controlledRef: typeof refWithControl;
  */
 declare function resolveRef<T>(r: MaybeComputedRef<T>): ComputedRef<T>;
 declare function resolveRef<T>(r: MaybeRef<T>): Ref<T>;
+declare function resolveRef<T>(r: T): Ref<T>;
 
 /**
  * Normalize value/ref/getter to `ref` or `computed`.
@@ -471,7 +460,7 @@ declare function resolveUnref<T>(r: MaybeComputedRef<T>): T;
 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;
 
-interface SyncRefOptions extends ConfigurableFlushSync {
+interface SyncRefOptions<L, R = L> extends ConfigurableFlushSync {
     /**
      * Watch deeply
      *
@@ -485,11 +474,18 @@ interface SyncRefOptions extends ConfigurableFlushSync {
      */
     immediate?: boolean;
     /**
-     * Direction of syncing
+     * Direction of syncing. Value will be redefined if you define syncConvertors
      *
      * @default 'both'
      */
     direction?: 'ltr' | 'rtl' | 'both';
+    /**
+     * Custom transform function
+     */
+    transform?: {
+        ltr?: (left: L) => R;
+        rtl?: (right: R) => L;
+    };
 }
 /**
  * Two-way refs synchronization.
@@ -497,7 +493,7 @@ interface SyncRefOptions extends ConfigurableFlushSync {
  * @param left
  * @param right
  */
-declare function syncRef<R extends Ref<any>>(left: R, right: R, options?: SyncRefOptions): () => void;
+declare function syncRef<L, R = L>(left: Ref<L>, right: Ref<R>, options?: SyncRefOptions<L, R>): () => void;
 
 interface SyncRefsOptions extends ConfigurableFlushSync {
     /**
@@ -610,7 +606,7 @@ interface UntilBaseInstance<T, Not extends boolean = false> {
 declare type Falsy = false | void | null | undefined | 0 | 0n | '';
 interface UntilValueInstance<T, Not extends boolean = false> extends UntilBaseInstance<T, Not> {
     readonly not: UntilValueInstance<T, Not extends true ? false : true>;
-    toBe<P = T>(value: MaybeRef<P>, options?: UntilToMatchOptions): Not extends true ? Promise<T> : Promise<P>;
+    toBe<P = T>(value: MaybeComputedRef<P>, options?: UntilToMatchOptions): Not extends true ? Promise<T> : Promise<P>;
     toBeTruthy(options?: UntilToMatchOptions): Not extends true ? Promise<T & Falsy> : Promise<Exclude<T, Falsy>>;
     toBeNull(options?: UntilToMatchOptions): Not extends true ? Promise<Exclude<T, null>> : Promise<null>;
     toBeUndefined(options?: UntilToMatchOptions): Not extends true ? Promise<Exclude<T, undefined>> : Promise<undefined>;
@@ -618,7 +614,7 @@ interface UntilValueInstance<T, Not extends boolean = false> extends UntilBaseIn
 }
 interface UntilArrayInstance<T> extends UntilBaseInstance<T> {
     readonly not: UntilArrayInstance<T>;
-    toContains(value: MaybeRef<ElementOf<ShallowUnwrapRef<T>>>, options?: UntilToMatchOptions): Promise<T>;
+    toContains(value: MaybeComputedRef<ElementOf<ShallowUnwrapRef<T>>>, options?: UntilToMatchOptions): Promise<T>;
 }
 /**
  * Promised one-time watch for changes
@@ -633,8 +629,26 @@ interface UntilArrayInstance<T> extends UntilBaseInstance<T> {
  * alert('Counter is now larger than 7!')
  * ```
  */
-declare function until<T extends unknown[]>(r: WatchSource<T> | MaybeRef<T>): UntilArrayInstance<T>;
-declare function until<T>(r: WatchSource<T> | MaybeRef<T>): UntilValueInstance<T>;
+declare function until<T extends unknown[]>(r: WatchSource<T> | MaybeComputedRef<T>): UntilArrayInstance<T>;
+declare function until<T>(r: WatchSource<T> | MaybeComputedRef<T>): UntilValueInstance<T>;
+
+declare function useArrayEvery<T>(list: MaybeComputedRef$1<MaybeComputedRef$1<T>[]>, fn: (element: T, index: number, array: MaybeComputedRef$1<T>[]) => unknown): ComputedRef<boolean>;
+
+declare function useArrayFilter<T>(list: MaybeComputedRef$1<MaybeComputedRef$1<T>[]>, fn: (element: T, index: number, array: T[]) => boolean): ComputedRef<T[]>;
+
+declare function useArrayFind<T>(list: MaybeComputedRef$1<MaybeComputedRef$1<T>[]>, fn: (element: T, index: number, array: MaybeComputedRef$1<T>[]) => boolean): ComputedRef<T | undefined>;
+
+declare function useArrayFindIndex<T>(list: MaybeComputedRef$1<MaybeComputedRef$1<T>[]>, fn: (element: T, index: number, array: MaybeComputedRef$1<T>[]) => unknown): ComputedRef<number>;
+
+declare function useArrayJoin(list: MaybeComputedRef$1<MaybeComputedRef$1<any>[]>, separator?: MaybeComputedRef$1<string>): ComputedRef<string>;
+
+declare function useArrayMap<T>(list: MaybeComputedRef$1<MaybeComputedRef$1<T>[]>, fn: (element: T, index: number, array: T[]) => T): ComputedRef<T[]>;
+
+declare type UseArrayReducer<PV, CV, R> = (previousValue: PV, currentValue: CV, currentIndex: number) => R;
+declare function useArrayReduce<T>(list: MaybeComputedRef$1<MaybeComputedRef$1<T>[]>, reducer: UseArrayReducer<T, T, T>): ComputedRef<T>;
+declare function useArrayReduce<T, U>(list: MaybeComputedRef$1<MaybeComputedRef$1<T>[]>, reducer: UseArrayReducer<U, T, U>, initialValue: MaybeComputedRef$1<U>): ComputedRef<U>;
+
+declare function useArraySome<T>(list: MaybeComputedRef$1<MaybeComputedRef$1<T>[]>, fn: (element: T, index: number, array: MaybeComputedRef$1<T>[]) => unknown): ComputedRef<boolean>;
 
 interface UseCounterOptions {
     min?: number;
@@ -666,21 +680,22 @@ declare const normalizeDate: (date: DateLike) => Date;
  * @param date
  * @param formatStr
  */
-declare function useDateFormat(date: MaybeRef$1<DateLike>, formatStr?: MaybeRef$1<string>): vue_demi.ComputedRef<string>;
+declare function useDateFormat(date: MaybeComputedRef$1<DateLike>, formatStr?: MaybeComputedRef$1<string>): vue_demi.ComputedRef<string>;
 declare type UseDateFormatReturn = ReturnType<typeof useDateFormat>;
 
 /**
  * Debounce execution of a function.
  *
+ * @see https://vueuse.org/useDebounceFn
  * @param  fn          A function to be executed after delay milliseconds debounced.
  * @param  ms          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
  * @param  opts        options
  *
  * @return A new, debounce, function.
  */
-declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: MaybeRef<number>, options?: DebounceFilterOptions): T;
+declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: MaybeComputedRef$1<number>, options?: DebounceFilterOptions): T;
 
-interface IntervalOptions<Controls extends boolean> {
+interface UseIntervalOptions<Controls extends boolean> {
     /**
      * Expose more controls
      *
@@ -694,12 +709,17 @@ interface IntervalOptions<Controls extends boolean> {
      */
     immediate?: boolean;
 }
-declare function useInterval(interval?: MaybeRef<number>, options?: IntervalOptions<false>): Ref<number>;
-declare function useInterval(interval: MaybeRef<number>, options: IntervalOptions<true>): {
+/**
+ * Reactive counter increases on every interval
+ *
+ * @see https://vueuse.org/useInterval
+ */
+declare function useInterval(interval?: MaybeComputedRef<number>, options?: UseIntervalOptions<false>): Ref<number>;
+declare function useInterval(interval: MaybeComputedRef<number>, options: UseIntervalOptions<true>): {
     counter: Ref<number>;
 } & Pausable;
 
-interface IntervalFnOptions {
+interface UseIntervalFnOptions {
     /**
      * Start the timer immediately
      *
@@ -720,7 +740,7 @@ interface IntervalFnOptions {
  * @param interval
  * @param options
  */
-declare function useIntervalFn(cb: Fn, interval?: MaybeRef<number>, options?: IntervalFnOptions): Pausable;
+declare function useIntervalFn(cb: Fn, interval?: MaybeComputedRef<number>, options?: UseIntervalFnOptions): Pausable;
 
 interface UseLastChangedOptions<Immediate extends boolean, InitialValue extends number | null | undefined = undefined> extends WatchOptions<Immediate> {
     initialValue?: InitialValue;
@@ -742,15 +762,15 @@ declare function useLastChanged(source: WatchSource, options: UseLastChangedOpti
  *                                    to `callback` when the throttled-function is executed.
  * @param   ms             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, call fn again after the time is up
+ * @param [trailing=false] if true, call fn again after the time is up
  *
  * @param [leading=true] if true, call fn on the leading edge of the ms timeout
  *
  * @return  A new, throttled, function.
  */
-declare function useThrottleFn<T extends FunctionArgs>(fn: T, ms?: MaybeRef<number>, trailing?: boolean, leading?: boolean): T;
+declare function useThrottleFn<T extends FunctionArgs>(fn: T, ms?: MaybeComputedRef<number>, trailing?: boolean, leading?: boolean): T;
 
-interface TimeoutFnOptions {
+interface UseTimeoutFnOptions {
     /**
      * Start the timer immediate after calling this function
      *
@@ -765,9 +785,9 @@ interface TimeoutFnOptions {
  * @param interval
  * @param immediate
  */
-declare function useTimeoutFn(cb: (...args: unknown[]) => any, interval: MaybeRef<number>, options?: TimeoutFnOptions): Stoppable;
+declare function useTimeoutFn(cb: (...args: unknown[]) => any, interval: MaybeComputedRef$1<number>, options?: UseTimeoutFnOptions): Stoppable;
 
-interface TimeoutOptions<Controls extends boolean> extends TimeoutFnOptions {
+interface UseTimeoutOptions<Controls extends boolean> extends UseTimeoutFnOptions {
     /**
      * Expose more controls
      *
@@ -782,14 +802,14 @@ interface TimeoutOptions<Controls extends boolean> extends TimeoutFnOptions {
  * @param interval
  * @param immediate
  */
-declare function useTimeout(interval?: number, options?: TimeoutOptions<false>): ComputedRef<boolean>;
-declare function useTimeout(interval: number, options: TimeoutOptions<true>): {
+declare function useTimeout(interval?: number, options?: UseTimeoutOptions<false>): ComputedRef<boolean>;
+declare function useTimeout(interval: number, options: UseTimeoutOptions<true>): {
     ready: ComputedRef<boolean>;
 } & Stoppable;
 
 interface UseToggleOptions<Truthy, Falsy> {
-    truthyValue?: MaybeRef<Truthy>;
-    falsyValue?: MaybeRef<Falsy>;
+    truthyValue?: MaybeComputedRef<Truthy>;
+    falsyValue?: MaybeComputedRef<Falsy>;
 }
 declare function useToggle<Truthy, Falsy, T = Truthy | Falsy>(initialValue: Ref<T>, options?: UseToggleOptions<Truthy, Falsy>): (value?: T) => T;
 declare function useToggle<Truthy = true, Falsy = false, T = Truthy | Falsy>(initialValue?: T, options?: UseToggleOptions<Truthy, Falsy>): [Ref<T>, (value?: T) => T];
@@ -809,7 +829,7 @@ declare function watchWithFilter<T, Immediate extends Readonly<boolean> = false>
 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>;
+    count: MaybeComputedRef<number>;
 }
 interface WatchAtMostReturn {
     stop: WatchStopHandle;
@@ -819,7 +839,7 @@ declare function watchAtMost<T extends Readonly<WatchSource<unknown>[]>, Immedia
 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>, DebounceFilterOptions {
-    debounce?: MaybeRef<number>;
+    debounce?: MaybeComputedRef<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;
@@ -846,7 +866,7 @@ declare function watchPausable<T, Immediate extends Readonly<boolean> = false>(s
 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>;
+    throttle?: MaybeComputedRef<number>;
     trailing?: boolean;
     leading?: boolean;
 }
@@ -867,8 +887,8 @@ declare function watchTriggerable<T extends object, FnReturnT>(source: T, cb: Wa
 /**
  * Shorthand for watching value to be truthy
  *
- * @see https://vueuse.js.org/whenever
+ * @see https://vueuse.org/whenever
  */
 declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WatchOptions): vue_demi.WatchStopHandle;
 
-export { Awaitable, ComputedRefWithControl, ComputedWithControlRefExtra, ConfigurableEventFilter, ConfigurableFlush, ConfigurableFlushSync, ControlledRefOptions, CreateGlobalStateReturn, DateLike, DebounceFilterOptions, DeepMaybeRef, ElementOf, EventFilter, EventHook, EventHookOff, EventHookOn, EventHookTrigger, ExtendRefOptions, Fn, FunctionArgs, FunctionWrapperOptions, IgnoredUpdater, IntervalFnOptions, IntervalOptions, MapOldSources, MapSources, MaybeComputedRef, MaybeRef, Pausable, Reactify, ReactifyNested, ReactifyObjectOptions, RemovableRef, RemoveableRef, ShallowUnwrapRef, SingletonPromiseReturn, Stopable, Stoppable, SyncRefOptions, SyncRefsOptions, TimeoutFnOptions, TimeoutOptions, UntilArrayInstance, UntilBaseInstance, UntilToMatchOptions, UntilValueInstance, UseCounterOptions, UseDateFormatReturn, UseLastChangedOptions, UseToggleOptions, WatchArrayCallback, WatchAtMostOptions, WatchAtMostReturn, WatchDebouncedOptions, WatchIgnorableReturn, WatchPausableReturn, WatchThrottledOptions, WatchTriggerableCallback, WatchTriggerableReturn, WatchWithFilterOptions, WritableComputedRefWithControl, __onlyVue3, logicAnd as and, assert, refAutoReset as autoResetRef, bypassFilter, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, directiveHooks, computedEager as eagerComputed, extendRef, formatDate, get, identity, watchIgnorable as ignorableWatch, increaseWithUnit, invoke, isBoolean, isClient, isDef, isDefined, isFunction, isIOS, 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, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toReactive, toRefs, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToggle, watchArray, watchAtMost, watchDebounced, watchIgnorable, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };
+export { ArgumentsType, Awaitable, ComputedRefWithControl, ComputedWithControlRefExtra, ConfigurableEventFilter, ConfigurableFlush, ConfigurableFlushSync, ControlledRefOptions, CreateGlobalStateReturn, DateLike, DebounceFilterOptions, DeepMaybeRef, ElementOf, EventFilter, EventHook, EventHookOff, EventHookOn, EventHookTrigger, ExtendRefOptions, Fn, FunctionArgs, FunctionWrapperOptions, IgnoredUpdater, MapOldSources, MapSources, MaybeComputedRef, MaybeRef, Pausable, Reactified, ReactifyNested, ReactifyObjectOptions, ReactifyOptions, RemovableRef, RemoveableRef, ShallowUnwrapRef, SingletonPromiseReturn, Stopable, Stoppable, SyncRefOptions, SyncRefsOptions, UntilArrayInstance, UntilBaseInstance, UntilToMatchOptions, UntilValueInstance, UseArrayReducer, UseCounterOptions, UseDateFormatReturn, UseIntervalFnOptions, UseIntervalOptions, UseLastChangedOptions, UseTimeoutFnOptions, UseTimeoutOptions, UseToggleOptions, WatchArrayCallback, WatchAtMostOptions, WatchAtMostReturn, WatchDebouncedOptions, WatchIgnorableReturn, WatchPausableReturn, WatchThrottledOptions, WatchTriggerableCallback, WatchTriggerableReturn, WatchWithFilterOptions, WritableComputedRefWithControl, __onlyVue3, assert, refAutoReset as autoResetRef, bypassFilter, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, directiveHooks, computedEager as eagerComputed, extendRef, formatDate, get, identity, watchIgnorable as ignorableWatch, increaseWithUnit, invoke, isBoolean, isClient, isDef, isDefined, isFunction, isIOS, isNumber, isObject, isString, isWindow, makeDestructurable, noop, normalizeDate, now, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toReactive, toRefs, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToggle, watchArray, watchAtMost, watchDebounced, watchIgnorable, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };