@vueuse/integrations 10.2.1 → 10.3.0

package/useAsyncValidator.d.mts

@@ -0,0 +1,48 @@
+import { MaybeRefOrGetter } from '@vueuse/shared';
+import { ValidateError, ValidateOption, Rules } from 'async-validator';
+import { Ref } from 'vue-demi';
+
+type AsyncValidatorError = Error & {
+    errors: ValidateError[];
+    fields: Record<string, ValidateError[]>;
+};
+interface UseAsyncValidatorExecuteReturn {
+    pass: boolean;
+    errors: AsyncValidatorError['errors'] | undefined;
+    errorInfo: AsyncValidatorError | null;
+    errorFields: AsyncValidatorError['fields'] | undefined;
+}
+interface UseAsyncValidatorReturn {
+    pass: Ref<boolean>;
+    isFinished: Ref<boolean>;
+    errors: Ref<AsyncValidatorError['errors'] | undefined>;
+    errorInfo: Ref<AsyncValidatorError | null>;
+    errorFields: Ref<AsyncValidatorError['fields'] | undefined>;
+    execute: () => Promise<UseAsyncValidatorExecuteReturn>;
+}
+interface UseAsyncValidatorOptions {
+    /**
+     * @see https://github.com/yiminghe/async-validator#options
+     */
+    validateOption?: ValidateOption;
+    /**
+     * The validation will be triggered right away for the first time.
+     * Only works when `manual` is not set to true.
+     *
+     * @default true
+     */
+    immediate?: boolean;
+    /**
+     * If set to true, the validation will not be triggered automatically.
+     */
+    manual?: boolean;
+}
+/**
+ * Wrapper for async-validator.
+ *
+ * @see https://vueuse.org/useAsyncValidator
+ * @see https://github.com/yiminghe/async-validator
+ */
+declare function useAsyncValidator(value: MaybeRefOrGetter<Record<string, any>>, rules: MaybeRefOrGetter<Rules>, options?: UseAsyncValidatorOptions): UseAsyncValidatorReturn & PromiseLike<UseAsyncValidatorReturn>;
+
+export { AsyncValidatorError, UseAsyncValidatorExecuteReturn, UseAsyncValidatorOptions, UseAsyncValidatorReturn, useAsyncValidator };

package/useAxios.d.cts

@@ -0,0 +1,94 @@
+import { ShallowRef, Ref } from 'vue-demi';
+import { AxiosResponse, AxiosRequestConfig, AxiosInstance } from 'axios';
+
+interface UseAxiosReturn<T, R = AxiosResponse<T>, _D = any> {
+    /**
+     * Axios Response
+     */
+    response: ShallowRef<R | undefined>;
+    /**
+     * Axios response data
+     */
+    data: Ref<T | undefined>;
+    /**
+     * Indicates if the request has finished
+     */
+    isFinished: Ref<boolean>;
+    /**
+     * Indicates if the request is currently loading
+     */
+    isLoading: Ref<boolean>;
+    /**
+     * Indicates if the request was canceled
+     */
+    isAborted: Ref<boolean>;
+    /**
+     * Any errors that may have occurred
+     */
+    error: ShallowRef<unknown | undefined>;
+    /**
+     * Aborts the current request
+     */
+    abort: (message?: string | undefined) => void;
+    /**
+     * Alias to `abort`
+     */
+    cancel: (message?: string | undefined) => void;
+    /**
+     * Alias to `isAborted`
+     */
+    isCanceled: Ref<boolean>;
+}
+interface StrictUseAxiosReturn<T, R, D> extends UseAxiosReturn<T, R, D> {
+    /**
+     * Manually call the axios request
+     */
+    execute: (url?: string | AxiosRequestConfig<D>, config?: AxiosRequestConfig<D>) => Promise<StrictUseAxiosReturn<T, R, D>>;
+}
+interface EasyUseAxiosReturn<T, R, D> extends UseAxiosReturn<T, R, D> {
+    /**
+     * Manually call the axios request
+     */
+    execute: (url: string, config?: AxiosRequestConfig<D>) => Promise<EasyUseAxiosReturn<T, R, D>>;
+}
+interface UseAxiosOptions<T = any> {
+    /**
+     * Will automatically run axios request when `useAxios` is used
+     *
+     */
+    immediate?: boolean;
+    /**
+     * Use shallowRef.
+     *
+     * @default true
+     */
+    shallow?: boolean;
+    /**
+     * Callback when error is caught.
+     */
+    onError?: (e: unknown) => void;
+    /**
+     * Callback when success is caught.
+     */
+    onSuccess?: (data: T) => void;
+    /**
+     * Initial data to use
+     */
+    initialData?: T;
+    /**
+     * Sets the state to initialState before executing the promise.
+     */
+    resetOnExecute?: boolean;
+    /**
+     * Callback when request is finished.
+     */
+    onFinish?: () => void;
+}
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>, options?: UseAxiosOptions): StrictUseAxiosReturn<T, R, D> & Promise<StrictUseAxiosReturn<T, R, D>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(url: string, instance?: AxiosInstance, options?: UseAxiosOptions): StrictUseAxiosReturn<T, R, D> & Promise<StrictUseAxiosReturn<T, R, D>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(url: string, config: AxiosRequestConfig<D>, instance: AxiosInstance, options?: UseAxiosOptions): StrictUseAxiosReturn<T, R, D> & Promise<StrictUseAxiosReturn<T, R, D>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(config?: AxiosRequestConfig<D>): EasyUseAxiosReturn<T, R, D> & Promise<EasyUseAxiosReturn<T, R, D>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(instance?: AxiosInstance): EasyUseAxiosReturn<T, R, D> & Promise<EasyUseAxiosReturn<T, R, D>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(config?: AxiosRequestConfig<D>, instance?: AxiosInstance): EasyUseAxiosReturn<T, R, D> & Promise<EasyUseAxiosReturn<T, R, D>>;
+
+export { EasyUseAxiosReturn, StrictUseAxiosReturn, UseAxiosOptions, UseAxiosReturn, useAxios };

package/useAxios.d.mts

@@ -0,0 +1,94 @@
+import { ShallowRef, Ref } from 'vue-demi';
+import { AxiosResponse, AxiosRequestConfig, AxiosInstance } from 'axios';
+
+interface UseAxiosReturn<T, R = AxiosResponse<T>, _D = any> {
+    /**
+     * Axios Response
+     */
+    response: ShallowRef<R | undefined>;
+    /**
+     * Axios response data
+     */
+    data: Ref<T | undefined>;
+    /**
+     * Indicates if the request has finished
+     */
+    isFinished: Ref<boolean>;
+    /**
+     * Indicates if the request is currently loading
+     */
+    isLoading: Ref<boolean>;
+    /**
+     * Indicates if the request was canceled
+     */
+    isAborted: Ref<boolean>;
+    /**
+     * Any errors that may have occurred
+     */
+    error: ShallowRef<unknown | undefined>;
+    /**
+     * Aborts the current request
+     */
+    abort: (message?: string | undefined) => void;
+    /**
+     * Alias to `abort`
+     */
+    cancel: (message?: string | undefined) => void;
+    /**
+     * Alias to `isAborted`
+     */
+    isCanceled: Ref<boolean>;
+}
+interface StrictUseAxiosReturn<T, R, D> extends UseAxiosReturn<T, R, D> {
+    /**
+     * Manually call the axios request
+     */
+    execute: (url?: string | AxiosRequestConfig<D>, config?: AxiosRequestConfig<D>) => Promise<StrictUseAxiosReturn<T, R, D>>;
+}
+interface EasyUseAxiosReturn<T, R, D> extends UseAxiosReturn<T, R, D> {
+    /**
+     * Manually call the axios request
+     */
+    execute: (url: string, config?: AxiosRequestConfig<D>) => Promise<EasyUseAxiosReturn<T, R, D>>;
+}
+interface UseAxiosOptions<T = any> {
+    /**
+     * Will automatically run axios request when `useAxios` is used
+     *
+     */
+    immediate?: boolean;
+    /**
+     * Use shallowRef.
+     *
+     * @default true
+     */
+    shallow?: boolean;
+    /**
+     * Callback when error is caught.
+     */
+    onError?: (e: unknown) => void;
+    /**
+     * Callback when success is caught.
+     */
+    onSuccess?: (data: T) => void;
+    /**
+     * Initial data to use
+     */
+    initialData?: T;
+    /**
+     * Sets the state to initialState before executing the promise.
+     */
+    resetOnExecute?: boolean;
+    /**
+     * Callback when request is finished.
+     */
+    onFinish?: () => void;
+}
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>, options?: UseAxiosOptions): StrictUseAxiosReturn<T, R, D> & Promise<StrictUseAxiosReturn<T, R, D>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(url: string, instance?: AxiosInstance, options?: UseAxiosOptions): StrictUseAxiosReturn<T, R, D> & Promise<StrictUseAxiosReturn<T, R, D>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(url: string, config: AxiosRequestConfig<D>, instance: AxiosInstance, options?: UseAxiosOptions): StrictUseAxiosReturn<T, R, D> & Promise<StrictUseAxiosReturn<T, R, D>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(config?: AxiosRequestConfig<D>): EasyUseAxiosReturn<T, R, D> & Promise<EasyUseAxiosReturn<T, R, D>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(instance?: AxiosInstance): EasyUseAxiosReturn<T, R, D> & Promise<EasyUseAxiosReturn<T, R, D>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(config?: AxiosRequestConfig<D>, instance?: AxiosInstance): EasyUseAxiosReturn<T, R, D> & Promise<EasyUseAxiosReturn<T, R, D>>;
+
+export { EasyUseAxiosReturn, StrictUseAxiosReturn, UseAxiosOptions, UseAxiosReturn, useAxios };

package/useChangeCase.d.cts

@@ -0,0 +1,36 @@
+import { camelCase, capitalCase, constantCase, dotCase, headerCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase, Options } from 'change-case';
+import { MaybeRef, MaybeRefOrGetter } from '@vueuse/shared';
+import { WritableComputedRef, ComputedRef } from 'vue-demi';
+
+declare const changeCase_camelCase: typeof camelCase;
+declare const changeCase_capitalCase: typeof capitalCase;
+declare const changeCase_constantCase: typeof constantCase;
+declare const changeCase_dotCase: typeof dotCase;
+declare const changeCase_headerCase: typeof headerCase;
+declare const changeCase_noCase: typeof noCase;
+declare const changeCase_paramCase: typeof paramCase;
+declare const changeCase_pascalCase: typeof pascalCase;
+declare const changeCase_pathCase: typeof pathCase;
+declare const changeCase_sentenceCase: typeof sentenceCase;
+declare const changeCase_snakeCase: typeof snakeCase;
+declare namespace changeCase {
+  export {
+    changeCase_camelCase as camelCase,
+    changeCase_capitalCase as capitalCase,
+    changeCase_constantCase as constantCase,
+    changeCase_dotCase as dotCase,
+    changeCase_headerCase as headerCase,
+    changeCase_noCase as noCase,
+    changeCase_paramCase as paramCase,
+    changeCase_pascalCase as pascalCase,
+    changeCase_pathCase as pathCase,
+    changeCase_sentenceCase as sentenceCase,
+    changeCase_snakeCase as snakeCase,
+  };
+}
+
+type ChangeCaseType = keyof typeof changeCase;
+declare function useChangeCase(input: MaybeRef<string>, type: ChangeCaseType, options?: Options | undefined): WritableComputedRef<string>;
+declare function useChangeCase(input: MaybeRefOrGetter<string>, type: ChangeCaseType, options?: Options | undefined): ComputedRef<string>;
+
+export { ChangeCaseType, useChangeCase };

package/useChangeCase.d.mts

@@ -0,0 +1,36 @@
+import { camelCase, capitalCase, constantCase, dotCase, headerCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase, Options } from 'change-case';
+import { MaybeRef, MaybeRefOrGetter } from '@vueuse/shared';
+import { WritableComputedRef, ComputedRef } from 'vue-demi';
+
+declare const changeCase_camelCase: typeof camelCase;
+declare const changeCase_capitalCase: typeof capitalCase;
+declare const changeCase_constantCase: typeof constantCase;
+declare const changeCase_dotCase: typeof dotCase;
+declare const changeCase_headerCase: typeof headerCase;
+declare const changeCase_noCase: typeof noCase;
+declare const changeCase_paramCase: typeof paramCase;
+declare const changeCase_pascalCase: typeof pascalCase;
+declare const changeCase_pathCase: typeof pathCase;
+declare const changeCase_sentenceCase: typeof sentenceCase;
+declare const changeCase_snakeCase: typeof snakeCase;
+declare namespace changeCase {
+  export {
+    changeCase_camelCase as camelCase,
+    changeCase_capitalCase as capitalCase,
+    changeCase_constantCase as constantCase,
+    changeCase_dotCase as dotCase,
+    changeCase_headerCase as headerCase,
+    changeCase_noCase as noCase,
+    changeCase_paramCase as paramCase,
+    changeCase_pascalCase as pascalCase,
+    changeCase_pathCase as pathCase,
+    changeCase_sentenceCase as sentenceCase,
+    changeCase_snakeCase as snakeCase,
+  };
+}
+
+type ChangeCaseType = keyof typeof changeCase;
+declare function useChangeCase(input: MaybeRef<string>, type: ChangeCaseType, options?: Options | undefined): WritableComputedRef<string>;
+declare function useChangeCase(input: MaybeRefOrGetter<string>, type: ChangeCaseType, options?: Options | undefined): ComputedRef<string>;
+
+export { ChangeCaseType, useChangeCase };

package/useCookies.d.cts

@@ -0,0 +1,54 @@
+import * as universal_cookie from 'universal-cookie';
+import universal_cookie__default from 'universal-cookie';
+import { IncomingMessage } from 'node:http';
+
+/**
+ * Creates a new {@link useCookies} function
+ * @param {Object} req - incoming http request (for SSR)
+ * @see https://github.com/reactivestack/cookies/tree/master/packages/universal-cookie universal-cookie
+ * @description Creates universal-cookie instance using request (default is window.document.cookie) and returns {@link useCookies} function with provided universal-cookie instance
+ */
+declare function createCookies(req?: IncomingMessage): (dependencies?: string[] | null, { doNotParse, autoUpdateDependencies }?: {
+    doNotParse?: boolean | undefined;
+    autoUpdateDependencies?: boolean | undefined;
+}) => {
+    /**
+     * Reactive get cookie by name. If **autoUpdateDependencies = true** then it will update watching dependencies
+     */
+    get: <T = any>(name: string, options?: universal_cookie.CookieGetOptions | undefined) => T;
+    /**
+     * Reactive get all cookies
+     */
+    getAll: <T_1 = any>(options?: universal_cookie.CookieGetOptions | undefined) => T_1;
+    set: (name: string, value: any, options?: universal_cookie.CookieSetOptions | undefined) => void;
+    remove: (name: string, options?: universal_cookie.CookieSetOptions | undefined) => void;
+    addChangeListener: (callback: universal_cookie.CookieChangeListener) => void;
+    removeChangeListener: (callback: universal_cookie.CookieChangeListener) => void;
+};
+/**
+ * Reactive methods to work with cookies (use {@link createCookies} method instead if you are using SSR)
+ * @param {string[]|null|undefined} dependencies - array of watching cookie's names. Pass empty array if don't want to watch cookies changes.
+ * @param {Object} options
+ * @param {boolean} options.doNotParse - don't try parse value as JSON
+ * @param {boolean} options.autoUpdateDependencies - automatically update watching dependencies
+ * @param {Object} cookies - universal-cookie instance
+ */
+declare function useCookies(dependencies?: string[] | null, { doNotParse, autoUpdateDependencies }?: {
+    doNotParse?: boolean | undefined;
+    autoUpdateDependencies?: boolean | undefined;
+}, cookies?: universal_cookie__default): {
+    /**
+     * Reactive get cookie by name. If **autoUpdateDependencies = true** then it will update watching dependencies
+     */
+    get: <T = any>(name: string, options?: universal_cookie.CookieGetOptions | undefined) => T;
+    /**
+     * Reactive get all cookies
+     */
+    getAll: <T_1 = any>(options?: universal_cookie.CookieGetOptions | undefined) => T_1;
+    set: (name: string, value: any, options?: universal_cookie.CookieSetOptions | undefined) => void;
+    remove: (name: string, options?: universal_cookie.CookieSetOptions | undefined) => void;
+    addChangeListener: (callback: universal_cookie.CookieChangeListener) => void;
+    removeChangeListener: (callback: universal_cookie.CookieChangeListener) => void;
+};
+
+export { createCookies, useCookies };

package/useCookies.d.mts

@@ -0,0 +1,54 @@
+import * as universal_cookie from 'universal-cookie';
+import universal_cookie__default from 'universal-cookie';
+import { IncomingMessage } from 'node:http';
+
+/**
+ * Creates a new {@link useCookies} function
+ * @param {Object} req - incoming http request (for SSR)
+ * @see https://github.com/reactivestack/cookies/tree/master/packages/universal-cookie universal-cookie
+ * @description Creates universal-cookie instance using request (default is window.document.cookie) and returns {@link useCookies} function with provided universal-cookie instance
+ */
+declare function createCookies(req?: IncomingMessage): (dependencies?: string[] | null, { doNotParse, autoUpdateDependencies }?: {
+    doNotParse?: boolean | undefined;
+    autoUpdateDependencies?: boolean | undefined;
+}) => {
+    /**
+     * Reactive get cookie by name. If **autoUpdateDependencies = true** then it will update watching dependencies
+     */
+    get: <T = any>(name: string, options?: universal_cookie.CookieGetOptions | undefined) => T;
+    /**
+     * Reactive get all cookies
+     */
+    getAll: <T_1 = any>(options?: universal_cookie.CookieGetOptions | undefined) => T_1;
+    set: (name: string, value: any, options?: universal_cookie.CookieSetOptions | undefined) => void;
+    remove: (name: string, options?: universal_cookie.CookieSetOptions | undefined) => void;
+    addChangeListener: (callback: universal_cookie.CookieChangeListener) => void;
+    removeChangeListener: (callback: universal_cookie.CookieChangeListener) => void;
+};
+/**
+ * Reactive methods to work with cookies (use {@link createCookies} method instead if you are using SSR)
+ * @param {string[]|null|undefined} dependencies - array of watching cookie's names. Pass empty array if don't want to watch cookies changes.
+ * @param {Object} options
+ * @param {boolean} options.doNotParse - don't try parse value as JSON
+ * @param {boolean} options.autoUpdateDependencies - automatically update watching dependencies
+ * @param {Object} cookies - universal-cookie instance
+ */
+declare function useCookies(dependencies?: string[] | null, { doNotParse, autoUpdateDependencies }?: {
+    doNotParse?: boolean | undefined;
+    autoUpdateDependencies?: boolean | undefined;
+}, cookies?: universal_cookie__default): {
+    /**
+     * Reactive get cookie by name. If **autoUpdateDependencies = true** then it will update watching dependencies
+     */
+    get: <T = any>(name: string, options?: universal_cookie.CookieGetOptions | undefined) => T;
+    /**
+     * Reactive get all cookies
+     */
+    getAll: <T_1 = any>(options?: universal_cookie.CookieGetOptions | undefined) => T_1;
+    set: (name: string, value: any, options?: universal_cookie.CookieSetOptions | undefined) => void;
+    remove: (name: string, options?: universal_cookie.CookieSetOptions | undefined) => void;
+    addChangeListener: (callback: universal_cookie.CookieChangeListener) => void;
+    removeChangeListener: (callback: universal_cookie.CookieChangeListener) => void;
+};
+
+export { createCookies, useCookies };

package/useDrauu.d.cts

@@ -0,0 +1,32 @@
+import { Ref } from 'vue-demi';
+import { Options, Drauu, Brush } from 'drauu';
+import { EventHookOn, MaybeComputedElementRef } from '@vueuse/core';
+
+type UseDrauuOptions = Omit<Options, 'el'>;
+interface UseDrauuReturn {
+    drauuInstance: Ref<Drauu | undefined>;
+    load: (svg: string) => void;
+    dump: () => string | undefined;
+    clear: () => void;
+    cancel: () => void;
+    undo: () => boolean | undefined;
+    redo: () => boolean | undefined;
+    canUndo: Ref<boolean>;
+    canRedo: Ref<boolean>;
+    brush: Ref<Brush>;
+    onChanged: EventHookOn;
+    onCommitted: EventHookOn;
+    onStart: EventHookOn;
+    onEnd: EventHookOn;
+    onCanceled: EventHookOn;
+}
+/**
+ * Reactive drauu
+ *
+ * @see https://vueuse.org/useDrauu
+ * @param target The target svg element
+ * @param options Drauu Options
+ */
+declare function useDrauu(target: MaybeComputedElementRef, options?: UseDrauuOptions): UseDrauuReturn;
+
+export { UseDrauuOptions, UseDrauuReturn, useDrauu };

package/useDrauu.d.mts

@@ -0,0 +1,32 @@
+import { Ref } from 'vue-demi';
+import { Options, Drauu, Brush } from 'drauu';
+import { EventHookOn, MaybeComputedElementRef } from '@vueuse/core';
+
+type UseDrauuOptions = Omit<Options, 'el'>;
+interface UseDrauuReturn {
+    drauuInstance: Ref<Drauu | undefined>;
+    load: (svg: string) => void;
+    dump: () => string | undefined;
+    clear: () => void;
+    cancel: () => void;
+    undo: () => boolean | undefined;
+    redo: () => boolean | undefined;
+    canUndo: Ref<boolean>;
+    canRedo: Ref<boolean>;
+    brush: Ref<Brush>;
+    onChanged: EventHookOn;
+    onCommitted: EventHookOn;
+    onStart: EventHookOn;
+    onEnd: EventHookOn;
+    onCanceled: EventHookOn;
+}
+/**
+ * Reactive drauu
+ *
+ * @see https://vueuse.org/useDrauu
+ * @param target The target svg element
+ * @param options Drauu Options
+ */
+declare function useDrauu(target: MaybeComputedElementRef, options?: UseDrauuOptions): UseDrauuReturn;
+
+export { UseDrauuOptions, UseDrauuReturn, useDrauu };

package/useFocusTrap/component.d.cts

@@ -0,0 +1,17 @@
+import * as vue_demi from 'vue-demi';
+import { RenderableComponent } from '@vueuse/core';
+import { Options } from 'focus-trap';
+
+interface UseFocusTrapOptions extends Options {
+    /**
+     * Immediately activate the trap
+     */
+    immediate?: boolean;
+}
+
+interface ComponentUseFocusTrapOptions extends RenderableComponent {
+    options?: UseFocusTrapOptions;
+}
+declare const UseFocusTrap: vue_demi.DefineComponent<ComponentUseFocusTrapOptions, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.VNodeProps & vue_demi.AllowedComponentProps & vue_demi.ComponentCustomProps, Readonly<ComponentUseFocusTrapOptions>, {}, {}>;
+
+export { ComponentUseFocusTrapOptions, UseFocusTrap };

package/useFocusTrap/component.d.mts

@@ -0,0 +1,17 @@
+import * as vue_demi from 'vue-demi';
+import { RenderableComponent } from '@vueuse/core';
+import { Options } from 'focus-trap';
+
+interface UseFocusTrapOptions extends Options {
+    /**
+     * Immediately activate the trap
+     */
+    immediate?: boolean;
+}
+
+interface ComponentUseFocusTrapOptions extends RenderableComponent {
+    options?: UseFocusTrapOptions;
+}
+declare const UseFocusTrap: vue_demi.DefineComponent<ComponentUseFocusTrapOptions, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.VNodeProps & vue_demi.AllowedComponentProps & vue_demi.ComponentCustomProps, Readonly<ComponentUseFocusTrapOptions>, {}, {}>;
+
+export { ComponentUseFocusTrapOptions, UseFocusTrap };

package/useFocusTrap.d.cts

@@ -0,0 +1,57 @@
+import { Fn, MaybeElementRef } from '@vueuse/core';
+import { Ref } from 'vue-demi';
+import { Options, ActivateOptions, DeactivateOptions } from 'focus-trap';
+
+interface UseFocusTrapOptions extends Options {
+    /**
+     * Immediately activate the trap
+     */
+    immediate?: boolean;
+}
+interface UseFocusTrapReturn {
+    /**
+     * Indicates if the focus trap is currently active
+     */
+    hasFocus: Ref<boolean>;
+    /**
+     * Indicates if the focus trap is currently paused
+     */
+    isPaused: Ref<boolean>;
+    /**
+     * Activate the focus trap
+     *
+     * @see https://github.com/focus-trap/focus-trap#trapactivateactivateoptions
+     * @param opts Activate focus trap options
+     */
+    activate: (opts?: ActivateOptions) => void;
+    /**
+     * Deactivate the focus trap
+     *
+     * @see https://github.com/focus-trap/focus-trap#trapdeactivatedeactivateoptions
+     * @param opts Deactivate focus trap options
+     */
+    deactivate: (opts?: DeactivateOptions) => void;
+    /**
+     * Pause the focus trap
+     *
+     * @see https://github.com/focus-trap/focus-trap#trappause
+     */
+    pause: Fn;
+    /**
+     * Unpauses the focus trap
+     *
+     * @see https://github.com/focus-trap/focus-trap#trapunpause
+     */
+    unpause: Fn;
+}
+/**
+ * Reactive focus-trap
+ *
+ * @see https://vueuse.org/useFocusTrap
+ * @param target The target element to trap focus within
+ * @param options Focus trap options
+ * @param autoFocus Focus trap automatically when mounted
+ */
+declare function useFocusTrap(target: MaybeElementRef, options?: UseFocusTrapOptions): UseFocusTrapReturn;
+
+export { UseFocusTrapOptions, UseFocusTrapReturn, useFocusTrap };

package/useFocusTrap.d.mts

@@ -0,0 +1,57 @@
+import { Fn, MaybeElementRef } from '@vueuse/core';
+import { Ref } from 'vue-demi';
+import { Options, ActivateOptions, DeactivateOptions } from 'focus-trap';
+
+interface UseFocusTrapOptions extends Options {
+    /**
+     * Immediately activate the trap
+     */
+    immediate?: boolean;
+}
+interface UseFocusTrapReturn {
+    /**
+     * Indicates if the focus trap is currently active
+     */
+    hasFocus: Ref<boolean>;
+    /**
+     * Indicates if the focus trap is currently paused
+     */
+    isPaused: Ref<boolean>;
+    /**
+     * Activate the focus trap
+     *
+     * @see https://github.com/focus-trap/focus-trap#trapactivateactivateoptions
+     * @param opts Activate focus trap options
+     */
+    activate: (opts?: ActivateOptions) => void;
+    /**
+     * Deactivate the focus trap
+     *
+     * @see https://github.com/focus-trap/focus-trap#trapdeactivatedeactivateoptions
+     * @param opts Deactivate focus trap options
+     */
+    deactivate: (opts?: DeactivateOptions) => void;
+    /**
+     * Pause the focus trap
+     *
+     * @see https://github.com/focus-trap/focus-trap#trappause
+     */
+    pause: Fn;
+    /**
+     * Unpauses the focus trap
+     *
+     * @see https://github.com/focus-trap/focus-trap#trapunpause
+     */
+    unpause: Fn;
+}
+/**
+ * Reactive focus-trap
+ *
+ * @see https://vueuse.org/useFocusTrap
+ * @param target The target element to trap focus within
+ * @param options Focus trap options
+ * @param autoFocus Focus trap automatically when mounted
+ */
+declare function useFocusTrap(target: MaybeElementRef, options?: UseFocusTrapOptions): UseFocusTrapReturn;
+
+export { UseFocusTrapOptions, UseFocusTrapReturn, useFocusTrap };

package/useFuse.d.cts

@@ -0,0 +1,25 @@
+import * as vue_demi from 'vue-demi';
+import { ComputedRef } from 'vue-demi';
+import Fuse from 'fuse.js';
+import { MaybeRefOrGetter } from '@vueuse/shared';
+
+type FuseOptions<T> = Fuse.IFuseOptions<T>;
+interface UseFuseOptions<T> {
+    fuseOptions?: FuseOptions<T>;
+    resultLimit?: number;
+    matchAllWhenSearchEmpty?: boolean;
+}
+declare function useFuse<DataItem>(search: MaybeRefOrGetter<string>, data: MaybeRefOrGetter<DataItem[]>, options?: MaybeRefOrGetter<UseFuseOptions<DataItem>>): {
+    fuse: vue_demi.Ref<{
+        search: <R = DataItem>(pattern: string | Fuse.Expression, options?: Fuse.FuseSearchOptions | undefined) => Fuse.FuseResult<R>[];
+        setCollection: (docs: readonly DataItem[], index?: Fuse.FuseIndex<DataItem> | undefined) => void;
+        add: (doc: DataItem) => void;
+        remove: (predicate: (doc: DataItem, idx: number) => boolean) => DataItem[];
+        removeAt: (idx: number) => void;
+        getIndex: () => Fuse.FuseIndex<DataItem>;
+    }>;
+    results: ComputedRef<Fuse.FuseResult<DataItem>[]>;
+};
+type UseFuseReturn = ReturnType<typeof useFuse>;
+
+export { FuseOptions, UseFuseOptions, UseFuseReturn, useFuse };