@reactive-vscode/vueuse 0.3.0 → 0.3.2

package/dist/index.d.ts

@@ -43,13 +43,13 @@ export declare const assert: (condition: boolean, ...infos: any[]) => void;
  */
 export declare type AsyncComputedOnCancel = (cancelCallback: Fn) => void;
 
-export declare interface AsyncComputedOptions {
+export declare interface AsyncComputedOptions<Lazy = boolean> {
     /**
      * Should value be evaluated lazily
      *
      * @default false
      */
-    lazy?: boolean;
+    lazy?: Lazy;
     /**
      * Ref passed to receive the updated of async evaluation
      */
@@ -60,6 +60,15 @@ export declare interface AsyncComputedOptions {
      * @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 'pre'
+     */
+    flush?: 'pre' | 'post' | 'sync';
     /**
      * Callback when error is caught.
      */
@@ -135,24 +144,28 @@ declare type Combination = 'overwrite' | 'chain';
  * @param initialState           The initial state, used until the first evaluation finishes
  * @param optionsOrRef           Additional options or a ref passed to receive the updates of the async evaluation
  */
+declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: T, optionsOrRef: AsyncComputedOptions<true>): ComputedRef<T>;
+
+declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: undefined, optionsOrRef: AsyncComputedOptions<true>): ComputedRef<T | undefined>;
+
 declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: T, optionsOrRef?: Ref<boolean> | AsyncComputedOptions): Ref<T>;
 
 declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState?: undefined, optionsOrRef?: Ref<boolean> | AsyncComputedOptions): Ref<T | undefined>;
 export { computedAsync as asyncComputed }
 export { computedAsync }
 
-declare type ComputedInjectGetter<T, K> = (source: T | undefined, ctx?: any) => K;
+declare type ComputedInjectGetter<T, K> = (source: T | undefined, oldValue?: K) => K;
 
-declare type ComputedInjectGetterWithDefault<T, K> = (source: T, ctx?: any) => K;
+declare type ComputedInjectGetterWithDefault<T, K> = (source: T, oldValue?: K) => K;
 
 declare type ComputedInjectSetter<T> = (v: T) => void;
 
 export declare interface ComputedRefWithControl<T> extends ComputedRef<T>, ComputedWithControlRefExtra {
 }
 
-declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: ComputedGetter<T>): ComputedRefWithControl<T>;
+declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: ComputedGetter<T>, options?: WatchOptions): ComputedRefWithControl<T>;
 
-declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: WritableComputedOptions<T>): WritableComputedRefWithControl<T>;
+declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: WritableComputedOptions<T>, options?: WatchOptions): WritableComputedRefWithControl<T>;
 export { computedWithControl }
 export { computedWithControl as controlledComputed }
 
@@ -234,8 +247,10 @@ export declare interface ControlledRefOptions<T> {
  * Utility for creating event hooks
  *
  * @see https://vueuse.org/createEventHook
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function createEventHook<T = any>(): EventHook<T>;
+export declare function createEventHook<T = any>(): EventHookReturn<T>;
 
 export declare function createFetch(config?: CreateFetchOptions): typeof useFetch;
 
@@ -266,15 +281,21 @@ export declare interface CreateFetchOptions {
  *
  * @see https://vueuse.org/createGlobalState
  * @param stateFactory A factory function to create the state
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function createGlobalState<Fn extends AnyFn>(stateFactory: Fn): Fn;
+export declare function createGlobalState<Fn extends AnyFn>(stateFactory: Fn): CreateGlobalStateReturn<Fn>;
+
+declare type CreateGlobalStateReturn<Fn extends AnyFn = AnyFn> = Fn;
 
 /**
  * Make a composable function usable with multiple Vue instances.
  *
  * @see https://vueuse.org/createSharedComposable
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function createSharedComposable<Fn extends AnyFn>(composable: Fn): Fn;
+export declare function createSharedComposable<Fn extends AnyFn>(composable: Fn): SharedComposableReturn<Fn>;
 
 /**
  * Create singleton promise function
@@ -293,6 +314,8 @@ export declare function createSingletonPromise<T>(fn: () => Promise<T>): Singlet
 /**
  * Make a plain function accepting ref and raw values as arguments.
  * Returns the same value the unconverted function returns, with proper typing.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function createUnrefFn<T extends Function>(fn: T): UnrefFn<T>;
 
@@ -370,6 +393,8 @@ export declare type EventHookOn<T = any> = (fn: Callback<T>) => {
     off: () => void;
 };
 
+declare type EventHookReturn<T> = EventHook<T>;
+
 export declare type EventHookTrigger<T = any> = (...param: Parameters<Callback<T>>) => Promise<unknown[]>;
 
 /**
@@ -470,6 +495,8 @@ export declare function identity<T>(arg: T): T;
 
 export declare type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
 
+declare type IgnoredPrevAsyncUpdates = () => void;
+
 export declare type IgnoredUpdater = (updater: () => void) => void;
 
 /**
@@ -578,7 +605,7 @@ export declare interface Pausable {
     /**
      * A ref indicate whether a pausable instance is active
      */
-    isActive: Readonly<ShallowRef<boolean>>;
+    readonly isActive: Readonly<ShallowRef<boolean>>;
     /**
      * Temporary pause the effect from executing
      */
@@ -628,8 +655,11 @@ export declare type Reactified<T, Computed extends boolean> = T extends (...args
  * and returns a ComputedRef, with proper typing.
  *
  * @param fn - Source function
+ * @param options - Options
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-declare function reactify<T extends Function, K extends boolean = true>(fn: T, options?: ReactifyOptions<K>): Reactified<T, K>;
+declare function reactify<T extends AnyFn, K extends boolean = true>(fn: T, options?: ReactifyOptions<K>): ReactifyReturn<T, K>;
 export { reactify as createReactiveFn }
 export { reactify }
 
@@ -639,10 +669,12 @@ export declare type ReactifyNested<T, Keys extends keyof T = keyof T, S extends
 
 /**
  * Apply `reactify` to an object
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function reactifyObject<T extends object, Keys extends keyof T>(obj: T, keys?: (keyof T)[]): ReactifyNested<T, 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 extends object, S extends boolean = true>(obj: T, options?: ReactifyObjectOptions<S>): ReactifyNested<T, keyof T, S>;
+export declare function reactifyObject<T extends object, S extends boolean = true>(obj: T, options?: ReactifyObjectOptions<S>): ReactifyObjectReturn<T, keyof T, S>;
 
 export declare interface ReactifyObjectOptions<T extends boolean> extends ReactifyOptions<T> {
     /**
@@ -653,6 +685,8 @@ export declare interface ReactifyObjectOptions<T extends boolean> extends Reacti
     includeOwnProperties?: boolean;
 }
 
+declare type ReactifyObjectReturn<T, Keys extends keyof T, S extends boolean = true> = ReactifyNested<T, Keys, S>;
+
 export declare interface ReactifyOptions<T extends boolean> {
     /**
      * Accept passing a function as a reactive getter
@@ -662,27 +696,33 @@ export declare interface ReactifyOptions<T extends boolean> {
     computedGetter?: T;
 }
 
+declare type ReactifyReturn<T extends AnyFn = AnyFn, K extends boolean = true> = Reactified<T, K>;
+
 /**
  * Computed reactive object.
  */
-export declare function reactiveComputed<T extends object>(fn: ComputedGetter<T>): UnwrapNestedRefs<T>;
+export declare function reactiveComputed<T extends object>(fn: ComputedGetter<T>): ReactiveComputedReturn<T>;
 
-export declare function reactiveOmit<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): Omit<T, K>;
+declare type ReactiveComputedReturn<T extends object> = UnwrapNestedRefs<T>;
 
-export declare function reactiveOmit<T extends object>(obj: T, predicate: ReactiveOmitPredicate<T>): Partial<T>;
+export declare function reactiveOmit<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): ReactiveOmitReturn<T, K>;
+
+export declare function reactiveOmit<T extends object>(obj: T, predicate: ReactiveOmitPredicate<T>): ReactiveOmitReturn<T>;
 
 export declare type ReactiveOmitPredicate<T> = (value: T[keyof T], key: keyof T) => boolean;
 
-export declare function reactivePick<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): {
-    [S in K]: UnwrapRef<T[S]>;
-};
+declare type ReactiveOmitReturn<T extends object, K extends keyof T | undefined = undefined> = [K] extends [undefined] ? Partial<T> : Omit<T, Extract<K, keyof T>>;
 
-export declare function reactivePick<T extends object>(obj: T, predicate: ReactivePickPredicate<T>): {
-    [S in keyof T]?: UnwrapRef<T[S]>;
-};
+export declare function reactivePick<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): ReactivePickReturn<T, K>;
+
+export declare function reactivePick<T extends object>(obj: T, predicate: ReactivePickPredicate<T>): ReactivePickReturn<T, keyof T>;
 
 export declare type ReactivePickPredicate<T> = (value: T[keyof T], key: keyof T) => boolean;
 
+declare type ReactivePickReturn<T extends object, K extends keyof T> = {
+    [S in K]: UnwrapRef<T[S]>;
+};
+
 /**
  * Maybe it's a computed ref, or a readonly value, or a getter function
  */
@@ -695,22 +735,28 @@ export declare type ReadonlyRefOrGetter<T> = ComputedRef<T> | (() => T);
  * @param defaultValue The value which will be set.
  * @param afterMs      A zero-or-greater delay in milliseconds.
  */
-declare function refAutoReset<T>(defaultValue: MaybeRefOrGetter<T>, afterMs?: MaybeRefOrGetter<number>): Ref<T>;
+declare function refAutoReset<T>(defaultValue: MaybeRefOrGetter<T>, afterMs?: MaybeRefOrGetter<number>): RefAutoResetReturn<T>;
 export { refAutoReset as autoResetRef }
 export { refAutoReset }
 
+declare type RefAutoResetReturn<T = any> = Ref<T>;
+
 /**
  * Debounce updates of a ref.
  *
  * @return A new debounced ref.
  */
-declare function refDebounced<T>(value: Ref<T>, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): Readonly<Ref<T>>;
+declare function refDebounced<T>(value: Ref<T>, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): RefDebouncedReturn<T>;
 export { refDebounced as debouncedRef }
 export { refDebounced }
 export { refDebounced as useDebounce }
 
+declare type RefDebouncedReturn<T = any> = Readonly<Ref<T>>;
+
 /**
  * Apply default value to a ref.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function refDefault<T>(source: Ref<T | undefined | null>, defaultValue: T): Ref<T>;
 
@@ -720,16 +766,20 @@ export declare function refDefault<T>(source: Ref<T | undefined | null>, default
  *
  * @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] 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
+ * @param trailing if true, update the value again after the delay time is up
+ * @param leading if true, update the value on the leading edge of the ms timeout
  */
-declare function refThrottled<T>(value: Ref<T>, delay?: number, trailing?: boolean, leading?: boolean): Ref<T, T>;
+declare function refThrottled<T = any>(value: Ref<T>, delay?: number, trailing?: boolean, leading?: boolean): RefThrottledReturn<T>;
 export { refThrottled }
 export { refThrottled as throttledRef }
 export { refThrottled as useThrottle }
 
+declare type RefThrottledReturn<T = any> = Ref<T>;
+
 /**
  * Fine-grained controls over ref and its reactivity.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function refWithControl<T>(initial: T, options?: ControlledRefOptions<T>): vue.ShallowUnwrapRef<{
     get: (tracking?: boolean) => T;
@@ -776,6 +826,8 @@ declare type ShallowOrDeepRef<T = any, D extends boolean = false> = D extends tr
 
 export declare type ShallowUnwrapRef<T> = T extends Ref<infer P> ? P : T;
 
+declare type SharedComposableReturn<T extends AnyFn = AnyFn> = T;
+
 export declare interface SingletonPromiseReturn<T> {
     (): Promise<T>;
     /**
@@ -791,7 +843,7 @@ export declare interface Stoppable<StartFnArgs extends any[] = any[]> {
     /**
      * A ref indicate whether a stoppable instance is executing
      */
-    isPending: Readonly<Ref<boolean>>;
+    readonly isPending: Readonly<Ref<boolean>>;
     /**
      * Stop the effect from executing
      */
@@ -869,11 +921,6 @@ export declare interface SyncRefsOptions extends ConfigurableFlushSync {
 
 /**
  * Create an EventFilter that throttle the events
- *
- * @param ms
- * @param [trailing]
- * @param [leading]
- * @param [rejectOnCancel]
  */
 export declare function throttleFilter(ms: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): EventFilter;
 
@@ -937,6 +984,7 @@ export declare function toRef<T extends object, K extends keyof T>(object: T, ke
  *
  * @see https://vueuse.org/toRefs
  * @param objectRef A ref or normal object or array.
+ * @param options Options
  */
 export declare function toRefs<T extends object>(objectRef: MaybeRef<T>, options?: ToRefsOptions): ToRefs<T>;
 
@@ -1041,9 +1089,9 @@ export declare interface UntilValueInstance<T, Not extends boolean = false> exte
 
 export declare type UrlParams = Record<string, string[] | string>;
 
-export declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, key?: keyof T, options?: UseArrayDifferenceOptions): ComputedRef<T[]>;
+export declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, key?: keyof T, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
 
-export declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, compareFn?: (value: T, othVal: T) => boolean, options?: UseArrayDifferenceOptions): ComputedRef<T[]>;
+export declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, compareFn?: (value: T, othVal: T) => boolean, options?: UseArrayDifferenceOptions): UseArrayDifferenceReturn<T>;
 
 declare interface UseArrayDifferenceOptions {
     /**
@@ -1055,6 +1103,8 @@ declare interface UseArrayDifferenceOptions {
     symmetric?: boolean;
 }
 
+declare type UseArrayDifferenceReturn<T = any> = ComputedRef<T[]>;
+
 /**
  * Reactive `Array.every`
  *
@@ -1063,8 +1113,12 @@ declare interface UseArrayDifferenceOptions {
  * @param fn - a function to test each element.
  *
  * @returns **true** if the `fn` function returns a **truthy** value for every element from the array. Otherwise, **false**.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayEvery<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): ComputedRef<boolean>;
+export declare function useArrayEvery<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayEveryReturn;
+
+declare type UseArrayEveryReturn = ComputedRef<boolean>;
 
 /**
  * Reactive `Array.filter`
@@ -1074,10 +1128,14 @@ export declare function useArrayEvery<T>(list: MaybeRefOrGetter<MaybeRefOrGetter
  * @param fn - a function that is called for every element of the given `list`. Each time `fn` executes, the returned value is added to the new array.
  *
  * @returns a shallow copy of a portion of the given array, filtered down to just the elements from the given array that pass the test implemented by the provided function. If no elements pass the test, an empty array will be returned.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayFilter<T, S extends T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => element is S): ComputedRef<S[]>;
+export declare function useArrayFilter<T, S extends T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => element is S): UseArrayFilterReturn<S>;
+
+export declare function useArrayFilter<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => unknown): UseArrayFilterReturn<T>;
 
-export declare function useArrayFilter<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => unknown): ComputedRef<T[]>;
+declare type UseArrayFilterReturn<T = any> = ComputedRef<T[]>;
 
 /**
  * Reactive `Array.find`
@@ -1087,8 +1145,10 @@ export declare function useArrayFilter<T>(list: MaybeRefOrGetter<MaybeRefOrGette
  * @param fn - a function to test each element.
  *
  * @returns the first element in the array that satisfies the provided testing function. Otherwise, undefined is returned.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayFind<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): ComputedRef<T | undefined>;
+export declare function useArrayFind<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindReturn<T>;
 
 /**
  * Reactive `Array.findIndex`
@@ -1098,8 +1158,12 @@ export declare function useArrayFind<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<
  * @param fn - a function to test each element.
  *
  * @returns the index of the first element in the array that passes the test. Otherwise, "-1".
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayFindIndex<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): ComputedRef<number>;
+export declare function useArrayFindIndex<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayFindIndexReturn;
+
+declare type UseArrayFindIndexReturn = ComputedRef<number>;
 
 /**
  * Reactive `Array.findLast`
@@ -1109,8 +1173,14 @@ export declare function useArrayFindIndex<T>(list: MaybeRefOrGetter<MaybeRefOrGe
  * @param fn - a function to test each element.
  *
  * @returns the last element in the array that satisfies the provided testing function. Otherwise, undefined is returned.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayFindLast<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): ComputedRef<T | undefined>;
+export declare function useArrayFindLast<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindLastReturn<T>;
+
+declare type UseArrayFindLastReturn<T = any> = ComputedRef<T | undefined>;
+
+declare type UseArrayFindReturn<T = any> = ComputedRef<T | undefined>;
 
 /**
  * Reactive `Array.includes`
@@ -1118,12 +1188,14 @@ export declare function useArrayFindLast<T>(list: MaybeRefOrGetter<MaybeRefOrGet
  * @see https://vueuse.org/useArrayIncludes
  *
  * @returns true if the `value` is found in the array. Otherwise, false.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: UseArrayIncludesComparatorFn<T, V>): ComputedRef<boolean>;
+export declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: UseArrayIncludesComparatorFn<T, V>): UseArrayIncludesReturn;
 
-export declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: keyof T): ComputedRef<boolean>;
+export declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: keyof T): UseArrayIncludesReturn;
 
-export declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, options?: UseArrayIncludesOptions<T, V>): ComputedRef<boolean>;
+export declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, options?: UseArrayIncludesOptions<T, V>): UseArrayIncludesReturn;
 
 export declare type UseArrayIncludesComparatorFn<T, V> = ((element: T, value: V, index: number, array: MaybeRefOrGetter<T>[]) => boolean);
 
@@ -1132,6 +1204,8 @@ export declare interface UseArrayIncludesOptions<T, V> {
     comparator?: UseArrayIncludesComparatorFn<T, V> | keyof T;
 }
 
+declare type UseArrayIncludesReturn = ComputedRef<boolean>;
+
 /**
  * Reactive `Array.join`
  *
@@ -1140,8 +1214,12 @@ export declare interface UseArrayIncludesOptions<T, V> {
  * @param separator - a string to separate each pair of adjacent elements of the array. If omitted, the array elements are separated with a comma (",").
  *
  * @returns a string with all array elements joined. If arr.length is 0, the empty string is returned.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayJoin(list: MaybeRefOrGetter<MaybeRefOrGetter<any>[]>, separator?: MaybeRefOrGetter<string>): ComputedRef<string>;
+export declare function useArrayJoin(list: MaybeRefOrGetter<MaybeRefOrGetter<any>[]>, separator?: MaybeRefOrGetter<string>): UseArrayJoinReturn;
+
+declare type UseArrayJoinReturn = ComputedRef<string>;
 
 /**
  * Reactive `Array.map`
@@ -1151,8 +1229,12 @@ export declare function useArrayJoin(list: MaybeRefOrGetter<MaybeRefOrGetter<any
  * @param fn - a function that is called for every element of the given `list`. Each time `fn` executes, the returned value is added to the new array.
  *
  * @returns a new array with each element being the result of the callback function.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayMap<T, U = T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => U): ComputedRef<U[]>;
+export declare function useArrayMap<T, U = T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => U): UseArrayMapReturn<U>;
+
+declare type UseArrayMapReturn<T = any> = ComputedRef<T[]>;
 
 /**
  * Reactive `Array.reduce`
@@ -1162,6 +1244,8 @@ export declare function useArrayMap<T, U = T>(list: MaybeRefOrGetter<MaybeRefOrG
  * @param reducer - a "reducer" function.
  *
  * @returns the value that results from running the "reducer" callback function to completion over the entire array.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function useArrayReduce<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<T, T, T>): ComputedRef<T>;
 
@@ -1174,6 +1258,8 @@ export declare function useArrayReduce<T>(list: MaybeRefOrGetter<MaybeRefOrGette
  * @param initialValue - a value to be initialized the first time when the callback is called.
  *
  * @returns the value that results from running the "reducer" callback function to completion over the entire array.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function useArrayReduce<T, U>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<U, T, U>, initialValue: MaybeRefOrGetter<U>): ComputedRef<U>;
 
@@ -1187,8 +1273,12 @@ export declare type UseArrayReducer<PV, CV, R> = (previousValue: PV, currentValu
  * @param fn - a function to test each element.
  *
  * @returns **true** if the `fn` function returns a **truthy** value for any element from the array. Otherwise, **false**.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function useArraySome<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): ComputedRef<boolean>;
+export declare function useArraySome<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArraySomeReturn;
+
+declare type UseArraySomeReturn = ComputedRef<boolean>;
 
 /**
  * reactive unique array
@@ -1196,8 +1286,12 @@ export declare function useArraySome<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<
  * @param list - the array was called upon.
  * @param compareFn
  * @returns A computed ref that returns a unique array of items.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function useArrayUnique<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, compareFn?: (a: T, b: T, array: T[]) => boolean): ComputedRef<T[]>;
+export declare function useArrayUnique<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, compareFn?: (a: T, b: T, array: T[]) => boolean): UseArrayUniqueReturn<T>;
+
+declare type UseArrayUniqueReturn<T = any> = ComputedRef<T[]>;
 
 /**
  * Asynchronous queue task controller.
@@ -1254,11 +1348,11 @@ export declare type UseAsyncQueueTask<T> = (...args: any[]) => T | Promise<T>;
  * @param initialState    The initial state, used until the first evaluation finishes
  * @param options
  */
-export declare function useAsyncState<Data, Params extends any[] = any[], Shallow extends boolean = true>(promise: Promise<Data> | ((...args: Params) => Promise<Data>), initialState: Data, options?: UseAsyncStateOptions<Shallow, Data>): UseAsyncStateReturn<Data, Params, Shallow>;
+export declare function useAsyncState<Data, Params extends any[] = any[], Shallow extends boolean = true>(promise: Promise<Data> | ((...args: Params) => Promise<Data>), initialState: MaybeRef<Data>, options?: UseAsyncStateOptions<Shallow, Data>): UseAsyncStateReturn<Data, Params, Shallow>;
 
 export declare interface UseAsyncStateOptions<Shallow extends boolean, D = any> {
     /**
-     * Delay for executing the promise. In milliseconds.
+     * Delay for the first execution of the promise when "immediate" is true. In milliseconds.
      *
      * @default 0
      */
@@ -1314,6 +1408,7 @@ export declare interface UseAsyncStateReturnBase<Data, Params extends any[], Sha
     isLoading: Ref<boolean>;
     error: Ref<unknown>;
     execute: (delay?: number, ...args: Params) => Promise<Data>;
+    executeImmediate: (...args: Params) => Promise<Data>;
 }
 
 export declare function useBase64(target: MaybeRefOrGetter<string | undefined>, options?: UseBase64Options): UseBase64Return;
@@ -1384,6 +1479,8 @@ export declare interface UseBroadcastChannelReturn<D, P> {
  * Reactive browser location.
  *
  * @see https://vueuse.org/useBrowserLocation
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useBrowserLocation(options?: ConfigurableWindow): Ref<{
     readonly trigger: string;
@@ -1462,7 +1559,7 @@ export declare interface UseClonedReturn<T> {
  * @param options
  */
 export declare function useCounter(initialValue?: MaybeRef<number>, options?: UseCounterOptions): {
-    count: vue.Ref<number, number> | vue.ShallowRef<number, number> | vue.WritableComputedRef<number, number>;
+    count: Readonly<Ref<number, number> | vue.ShallowRef<number, number> | vue.WritableComputedRef<number, number>>;
     inc: (delta?: number) => number;
     dec: (delta?: number) => number;
     get: () => number;
@@ -1516,8 +1613,10 @@ export declare interface UseCycleListReturn<T> {
  * @param date - The date to format, can either be a `Date` object, a timestamp, or a string
  * @param formatStr - The combination of tokens to format the date
  * @param options - UseDateFormatOptions
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function useDateFormat(date: MaybeRefOrGetter<DateLike>, formatStr?: MaybeRefOrGetter<string>, options?: UseDateFormatOptions): vue.ComputedRef<string>;
+export declare function useDateFormat(date: MaybeRefOrGetter<DateLike>, formatStr?: MaybeRefOrGetter<string>, options?: UseDateFormatOptions): UseDateFormatReturn;
 
 export declare interface UseDateFormatOptions {
     /**
@@ -1533,7 +1632,7 @@ export declare interface UseDateFormatOptions {
     customMeridiem?: (hours: number, minutes: number, isLowercase?: boolean, hasPeriod?: boolean) => string;
 }
 
-export declare type UseDateFormatReturn = ReturnType<typeof useDateFormat>;
+export declare type UseDateFormatReturn = ComputedRef<string>;
 
 /**
  * Shorthand for [useRefHistory](https://vueuse.org/useRefHistory) with debounce filter.
@@ -1555,8 +1654,12 @@ export declare function useDebouncedRefHistory<Raw, Serialized = Raw>(source: Re
  * @param  options     Options
  *
  * @return A new, debounce, function.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): PromisifyFn<T>;
+export declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): UseDebounceFnReturn<T>;
+
+declare type UseDebounceFnReturn<T extends FunctionArgs> = PromisifyFn<T>;
 
 export declare function useEventBus<T = unknown, P = any>(key: EventBusIdentifier<T>): UseEventBusReturn<T, P>;
 
@@ -1685,7 +1788,7 @@ export declare interface UseFetchReturn<T> {
     /**
      * Abort the fetch request
      */
-    abort: Fn;
+    abort: (reason?: any) => void;
     /**
      * Manually call the fetch
      * (default not throwing error)
@@ -1760,9 +1863,9 @@ declare interface UseIdleReturn {
  * @param interval
  * @param options
  */
-export declare function useInterval(interval?: MaybeRefOrGetter<number>, options?: UseIntervalOptions<false>): ShallowRef<number>;
+export declare function useInterval(interval?: MaybeRefOrGetter<number>, options?: UseIntervalOptions<false>): Readonly<ShallowRef<number>>;
 
-export declare function useInterval(interval: MaybeRefOrGetter<number>, options: UseIntervalOptions<true>): UseIntervalControls & Pausable;
+export declare function useInterval(interval: MaybeRefOrGetter<number>, options: UseIntervalOptions<true>): Readonly<UseIntervalControls & Pausable>;
 
 export declare interface UseIntervalControls {
     counter: ShallowRef<number>;
@@ -1772,11 +1875,12 @@ export declare interface UseIntervalControls {
 /**
  * Wrapper for `setInterval` with controls
  *
+ * @see https://vueuse.org/useIntervalFn
  * @param cb
  * @param interval
  * @param options
  */
-export declare function useIntervalFn(cb: Fn, interval?: MaybeRefOrGetter<number>, options?: UseIntervalFnOptions): Pausable;
+export declare function useIntervalFn(cb: Fn, interval?: MaybeRefOrGetter<number>, options?: UseIntervalFnOptions): UseIntervalFnReturn;
 
 export declare interface UseIntervalFnOptions {
     /**
@@ -1793,6 +1897,8 @@ export declare interface UseIntervalFnOptions {
     immediateCallback?: boolean;
 }
 
+declare type UseIntervalFnReturn = Pausable;
+
 export declare interface UseIntervalOptions<Controls extends boolean> {
     /**
      * Expose more controls
@@ -1817,9 +1923,9 @@ export declare interface UseIntervalOptions<Controls extends boolean> {
  *
  * @see https://vueuse.org/useLastChanged
  */
-export declare function useLastChanged(source: WatchSource, options?: UseLastChangedOptions<false>): ShallowRef<number | null>;
+export declare function useLastChanged(source: WatchSource, options?: UseLastChangedOptions<false>): Readonly<ShallowRef<number | null>>;
 
-export declare function useLastChanged(source: WatchSource, options: UseLastChangedOptions<true> | UseLastChangedOptions<boolean, number>): ShallowRef<number>;
+export declare function useLastChanged(source: WatchSource, options: UseLastChangedOptions<true> | UseLastChangedOptions<boolean, number>): Readonly<ShallowRef<number>>;
 
 export declare interface UseLastChangedOptions<Immediate extends boolean, InitialValue extends number | null | undefined = undefined> extends WatchOptions<Immediate> {
     initialValue?: InitialValue;
@@ -1916,6 +2022,8 @@ export declare interface UseManualRefHistoryReturn<Raw, Serialized> {
  *
  * @see https://vueuse.org/useNow
  * @param options
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function useNow(options?: UseNowOptions<false>): Ref<Date>;
 
@@ -1930,6 +2038,12 @@ export declare interface UseNowOptions<Controls extends boolean> {
      * @default false
      */
     controls?: Controls;
+    /**
+     * Start the clock immediately
+     *
+     * @default true
+     */
+    immediate?: boolean;
     /**
      * Update interval in milliseconds, or use requestAnimationFrame
      *
@@ -2048,6 +2162,13 @@ export declare interface UseRefHistoryOptions<Raw, Serialized = Raw> extends Con
      * Deserialize data from the history
      */
     parse?: (v: Serialized) => Raw;
+    /**
+     * Function to determine if the commit should proceed
+     * @param oldValue Previous value
+     * @param newValue New value
+     * @returns boolean indicating if commit should proceed
+     */
+    shouldCommit?: (oldValue: Raw | undefined, newValue: Raw) => boolean;
 }
 
 export declare interface UseRefHistoryRecord<T> {
@@ -2088,6 +2209,8 @@ export declare interface UseRefHistoryReturn<Raw, Serialized> extends UseManualR
  * @see https://vueuse.org/useShare
  * @param shareOptions
  * @param options
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useShare(shareOptions?: MaybeRefOrGetter<UseShareOptions>, options?: ConfigurableNavigator): {
     isSupported: vue.ComputedRef<boolean>;
@@ -2180,14 +2303,14 @@ export declare interface UseStepperReturn<StepName, Steps, Step> {
 }
 
 declare function useTextareaAutosize(options?: UseTextareaAutosizeOptions): {
-    textarea: vue.Ref<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
+    textarea: vue.Ref<HTMLTextAreaElement | null | undefined, HTMLTextAreaElement | null | undefined>;
     input: vue.Ref<string, string>;
     triggerResize: () => void;
 };
 
 export declare interface UseTextareaAutosizeOptions extends ConfigurableWindow {
     /** Textarea element to autosize. */
-    element?: MaybeRef<HTMLTextAreaElement | undefined>;
+    element?: MaybeRef<HTMLTextAreaElement | undefined | null>;
     /** Textarea content. */
     input?: MaybeRef<string>;
     /** Watch sources that should trigger a textarea resize. */
@@ -2234,6 +2357,8 @@ export declare type UseThrottledRefHistoryReturn<Raw, Serialized = Raw> = UseRef
  * @param [rejectOnCancel] if true, reject the last call if it's been cancel (default value: false)
  *
  * @return  A new, throttled, function.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function useThrottleFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): PromisifyFn<T>;
 
@@ -2241,6 +2366,8 @@ export declare function useThrottleFn<T extends FunctionArgs>(fn: T, ms?: MaybeR
  * Reactive time ago formatter.
  *
  * @see https://vueuse.org/useTimeAgo
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function useTimeAgo<UnitNames extends string = UseTimeAgoUnitNamesDefault>(time: MaybeRefOrGetter<Date | number | string>, options?: UseTimeAgoOptions<false, UnitNames>): UseTimeAgoReturn<false>;
 
@@ -2304,7 +2431,7 @@ export declare function useTimeout(interval: MaybeRefOrGetter<number>, options:
  * @param interval
  * @param options
  */
-export declare function useTimeoutFn<CallbackFn extends AnyFn>(cb: CallbackFn, interval: MaybeRefOrGetter<number>, options?: UseTimeoutFnOptions): Stoppable<Parameters<CallbackFn> | []>;
+export declare function useTimeoutFn<CallbackFn extends AnyFn>(cb: CallbackFn, interval: MaybeRefOrGetter<number>, options?: UseTimeoutFnOptions): UseTimeoutFnReturn<CallbackFn>;
 
 export declare interface UseTimeoutFnOptions {
     /**
@@ -2321,6 +2448,8 @@ export declare interface UseTimeoutFnOptions {
     immediateCallback?: boolean;
 }
 
+declare type UseTimeoutFnReturn<CallbackFn extends AnyFn> = Stoppable<Parameters<CallbackFn> | []>;
+
 export declare interface UseTimeoutOptions<Controls extends boolean> extends UseTimeoutFnOptions {
     /**
      * Expose more controls
@@ -2392,6 +2521,8 @@ export declare interface UseToggleOptions<Truthy, Falsy> {
 
 /**
  * Reactively convert a string ref to number.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function useToNumber(value: MaybeRefOrGetter<number | string>, options?: UseToNumberOptions): ComputedRef<number>;
 
@@ -2421,6 +2552,8 @@ export declare interface UseToNumberOptions {
  * Reactively convert a ref to string.
  *
  * @see https://vueuse.org/useToString
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function useToString(value: MaybeRefOrGetter<unknown>): ComputedRef<string>;
 
@@ -2459,6 +2592,13 @@ export declare interface UseUrlSearchParamsOptions<T> extends ConfigurableWindow
      * @default 'replace'
      */
     writeMode?: 'replace' | 'push';
+    /**
+     * Custom function to serialize URL parameters
+     * When provided, this function will be used instead of the default URLSearchParams.toString()
+     * @param params The URLSearchParams object to serialize
+     * @returns The serialized query string (should not include the leading '?' or '#')
+     */
+    stringify?: (params: URLSearchParams) => string;
 }
 
 /**
@@ -2676,7 +2816,7 @@ export { watchIgnorable }
 
 export declare interface WatchIgnorableReturn {
     ignoreUpdates: IgnoredUpdater;
-    ignorePrevAsyncUpdates: () => void;
+    ignorePrevAsyncUpdates: IgnoredPrevAsyncUpdates;
     stop: WatchStopHandle;
 }
 
@@ -2686,9 +2826,11 @@ export declare function watchImmediate<T>(source: WatchSource<T>, cb: WatchCallb
 
 export declare function watchImmediate<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
 
-export 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>): WatchStopHandle;
+export declare function watchOnce<T extends Readonly<WatchSource<unknown>[]>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'once'>): WatchStopHandle;
+
+export declare function watchOnce<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchStopHandle;
 
-export declare function watchOnce<T, Immediate extends Readonly<boolean> = false>(sources: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchOptions<Immediate>): WatchStopHandle;
+export declare function watchOnce<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'once'>): WatchStopHandle;
 
 declare function watchPausable<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchPausableOptions<Immediate>): WatchPausableReturn;