@sidekick-coder/zenith-kit 0.3.1 → 0.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/dist/client/index.d.mts +17 -2
  2. package/dist/client/index.mjs +2 -2
  3. package/dist/components/index.es.js +78 -71
  4. package/dist/server/index.d.mts +43 -6
  5. package/dist/server/index.mjs +4 -4
  6. package/dist/shared/index.d.mts +1 -1
  7. package/package.json +1 -1
  8. package/tsdown.config.ts +7 -1
package/dist/client/index.d.mts CHANGED
@@ -9,7 +9,10 @@ import { ComputedRef, DefineComponent, MaybeRef, MaybeRefOrGetter, Ref, getCurre
9
9
  import { toTypedSchema as toTypedSchema$1 } from "@vee-validate/valibot";
10
10
  import * as VeeValidate from "vee-validate";
11
11
  import { FormContext, FormOptions, GenericObject } from "vee-validate";
12
+ import * as UnheadVue from "@unhead/vue";
12
13
  import { useRouteQuery as useRouteQuery$1 } from "@vueuse/router";
14
+ import { ClassValue } from "clsx";
15
+ import { ClassNameValue } from "tailwind-merge";
13
16
 
14
17
  //#region src/shared/utils/compose.d.ts
15
18
  type Constructor$1<T = {}> = new (...args: any[]) => T;
@@ -869,6 +872,13 @@ declare const useForm: typeof useValibotForm;
869
872
  declare const toTypedSchema: typeof toTypedSchema$1;
870
873
  declare function useValibotForm<T extends ValibotObjectSchema = ValibotObjectSchema>(schema: T, options?: ValibotFormOptions<T>): FormContext<ValidatorResult<T>>;
871
874
  //#endregion
875
+ //#region src/client/facades/unheadVue.d.ts
876
+ declare const UNHEAD_VUE_CONTAINER_KEY = "unhead-vue";
877
+ declare const unheadVue: typeof UnheadVue;
878
+ //#endregion
879
+ //#region src/client/composables/useHead.d.ts
880
+ declare const useHead: typeof unheadVue.useHead;
881
+ //#endregion
872
882
  //#region src/client/composables/useLayoutOptions.d.ts
873
883
  declare function useLayoutOptions(): _$vue.Ref<any, any>;
874
884
  //#endregion
@@ -1139,6 +1149,11 @@ declare const $toast: ((message: string | (() => string | _$vue.Component) | _$v
1139
1149
  getToasts: () => (_$vue_sonner0.ToastT<_$vue.Component> | _$vue_sonner0.ToastToDismiss)[];
1140
1150
  };
1141
1151
  //#endregion
1152
+ //#region src/client/utils/twMerge.d.ts
1153
+ declare function twMerge(...inputs: ClassNameValue[]): string;
1154
+ declare function clsx(...inputs: ClassValue[]): string;
1155
+ declare function cn(...inputs: ClassValue[]): string;
1156
+ //#endregion
1142
1157
  //#region src/client/guards/authGuard.d.ts
1143
1158
  interface AuthGuardOptions {
1144
1159
  redirect: string | ((to: RouteLocationNormalized) => string);
@@ -1157,5 +1172,5 @@ declare const guestGuard: () => string | undefined;
1157
1172
  //#region src/client/guards/setupGuard.d.ts
1158
1173
  declare const setupGuard: NavigationGuard;
1159
1174
  //#endregion
1160
- export { $fetch, $file, $toast, AuthGuardOptions, AuthService, AutoOptions, DASHBOARD_ROW_HEIGHT, Dashboard, DashboardGridUnit, DashboardOptions, DashboardWidget, DashboardWidgetAction, DashboardWidgetData, DashboardWidgetDefinition, DashboardWidgetDefinitionChart, DashboardWidgetRegistry, DataTableColumn, DefineFormField, FetchBrowserService, FetchNodeService, FetchOptions, FetchService, GuestGuardOptions, HSL, LayoutService, LifecycleService, ListFilter, MenuBase, MenuGroup, MenuItem, MenuItem$1 as MenuItemEntity, MenuService, MenuSingle, MenuWithChildren, Module as ModuleEntity, OKLCH, PluginEntity, RGB, RGBA, Router, ToastService, UseFetchPaginationOptions, UseMenu, UseStateOptions, VEE_VALIDATE_CONTAINER_KEY, VUE_CONTAINER_KEY, VUE_ROUTER_CONTAINER_KEY, ValibotFormOptions, ValibotFormResultObject, acl, auth, authGuard, auto, autoRoutes, config, _default as container, createAuthGuard, createGuestGuard, createId, createRouter, dashboardRegistry, defineColumns, defineFormFields, emmitter, extracRGB, extractOKLCH, extractRGBA, fetcher, guestGuard, hexToRGB, hslToRgb, layout, lifecycle, logger, menu, oklchToRgb, parseTo, provideDashboard, provideDashboardWidget, rgbToHex, rgbToHsl, rgbToOklch, rgbaToString, route, router, setupGuard, toTypedSchema, toast, useBreakpoints, useColor, useColorType, useDashboard, useDashboardWidget, useFetchPagination, useForm, useHSL, useHex, useLayoutOptions, useLoading, useMenu, useRGB, useRGBA, useRouteQuery, useState, useValibotForm, veeValidate, vue, vueRouter };
1161
- //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/shared/utils/compose.d.ts","../../src/shared/entities/PermissionEntity.d.ts","../../src/shared/entities/RoleEntity.d.ts","../../src/shared/entities/UserEntity.d.ts","../../src/client/services/AuthService.d.ts","../../src/client/services/FetchService.d.ts","../../src/client/services/FetchBrowserService.d.ts","../../src/client/services/FetchNodeService.d.ts","../../src/client/services/LayoutService.d.ts","../../src/shared/services/LoggerService.d.ts","../../src/shared/entities/LifecycleHook.d.ts","../../src/shared/services/LifecycleService.d.ts","../../src/client/services/LifecycleService.d.ts","../../src/client/entities/MenuItemEntity.d.ts","../../src/client/services/MenuService.d.ts","../../src/client/services/RouterService.d.ts","../../src/client/services/ToastService.d.ts","../../node_modules/@vueuse/core/dist/index.d.ts","../../src/client/composables/useBreakpoint.d.ts","../../src/client/composables/useColor.d.ts","../../src/shared/services/EmmitterService.d.ts","../../src/client/entities/DashboardWidgetData.d.ts","../../src/client/entities/DashboardWidgetDefinition.d.ts","../../src/client/entities/DashboardWidget.d.ts","../../src/shared/validators/urlValidator.d.ts","../../src/shared/validators/keyValueValidator.d.ts","../../src/shared/validators/paginationValidator.d.ts","../../src/shared/validators/index.d.ts","../../src/shared/services/ValidatorService.d.ts","../../src/shared/schemas/dashboardSchema.d.ts","../../src/client/entities/Dashboard.d.ts","../../src/client/composables/useDashboard.d.ts","../../src/client/composables/useDashboardWidget.d.ts","../../src/client/composables/useFetchPagination.d.ts","../../src/shared/services/ConfigService.d.ts","../../src/shared/services/ContainerService.d.ts","../../src/shared/utils/createId.d.ts","../../src/shared/entities/AclEntity.d.ts","../../src/shared/entities/ModuleManifestEntity.d.ts","../../src/shared/entities/ModuleEntity.d.ts","../../src/shared/entities/PluginEntity.d.ts","../../src/client/composables/useForm.d.ts","../../src/client/composables/useLayoutOptions.d.ts","../../src/client/composables/useLoading.d.ts","../../src/client/composables/useMenu.d.ts","../../src/client/composables/useRouteQuery.d.ts","../../src/client/composables/useState.d.ts","../../src/client/facades/acl.d.ts","../../src/client/facades/auth.d.ts","../../src/client/facades/config.d.ts","../../src/client/facades/container.d.ts","../../src/client/registry/DashboardWidgetRegistry.d.ts","../../src/client/facades/dashboardRegistry.d.ts","../../src/client/facades/emmitter.d.ts","../../src/client/facades/fetcher.d.ts","../../src/client/facades/layout.d.ts","../../src/client/facades/lifecycle.d.ts","../../src/client/facades/logger.d.ts","../../src/client/facades/menu.d.ts","../../src/client/facades/route.d.ts","../../src/client/facades/router.d.ts","../../src/client/facades/toast.d.ts","../../src/client/facades/veeValidate.d.ts","../../src/client/facades/vue.d.ts","../../src/client/facades/vueRouter.d.ts","../../src/client/entities/DashboardWidgetDefinitionChart.d.ts","../../src/client/entities/ModuleEntity.d.ts","../../src/client/entities/PluginEntity.d.ts","../../src/client/utils/autoPages.d.ts","../../src/client/utils/defineColumns.d.ts","../../src/client/utils/defineFormFields.d.ts","../../src/client/utils/fetcher.d.ts","../../src/client/utils/file.d.ts","../../src/client/utils/parseTo.d.ts","../../src/client/utils/toast.d.ts","../../src/client/guards/authGuard.d.ts","../../src/client/guards/guestGuard.d.ts","../../src/client/guards/setupGuard.d.ts"],"sourcesContent":["import type { UnionToIntersection } from './typing.ts';\nexport type AnyClass = new (...args: any[]) => any;\nexport type Constructor<T = {}> = new (...args: any[]) => T;\nexport type Mixin<T> = (base: Constructor) => Constructor<T>;\n/**\n * Composes multiple mixins into a single class that can be extended.\n * Allows for multiple inheritance-like behavior by applying mixins sequentially.\n *\n * @param mixins - Array of mixin functions to compose\n * @returns A class constructor that includes all mixin functionality\n *\n * @example\n * ```typescript\n * class User extends compose(Timestamp, SoftDelete) {\n *   constructor(public name: string) {\n *     super()\n *   }\n * }\n * ```\n */\nexport declare function compose<M extends Array<(base: Constructor<any>) => Constructor<any>>>(...mixins: M): UnionToIntersection<ReturnType<M[number]>>;\n/**\n * Alternative compose function that starts with a base class\n *\n * @param baseClass - The base class to start with\n * @param mixins - Array of mixin functions to apply\n * @returns A class constructor that extends the base class with all mixin functionality\n *\n * @example\n * ```typescript\n * class User extends composeWith(BaseEntity, Timestamp, SoftDelete) {\n *   constructor(public name: string) {\n *     super()\n *   }\n * }\n * ```\n */\nexport declare function composeWith<TBase extends Constructor, M extends Array<(base: Constructor) => Constructor<any>>>(baseClass: TBase, ...mixins: M): TBase & UnionToIntersection<ReturnType<M[number]>>;\nexport declare function mixin<TBase extends Constructor>(Source: TBase): <TTarget extends Constructor>(Target: TTarget) => TTarget & TBase;\n","declare const PermissionEntity_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor;\nexport default class PermissionEntity extends PermissionEntity_base {\n    id: number;\n    name: string;\n    description: string | null;\n    origin: string;\n    subject: string;\n    action: string;\n    conditions: string | null | Record<string, any>;\n    get editable(): boolean;\n    get parsedConditions(): any;\n}\nexport {};\n","declare const Role_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor & {\n    new (...args: any[]): {\n        created_at: Date | string;\n        updated_at: Date | string;\n    };\n} & {\n    new (...args: any[]): {\n        deleted_at: Date | string | null;\n    };\n};\nexport default class Role extends Role_base {\n    id: number;\n    name: string;\n    description?: string;\n}\nexport {};\n","import type Permission from './PermissionEntity.ts';\nimport type Role from './RoleEntity.ts';\ndeclare const UserEntity_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor & {\n    new (...args: any[]): {\n        created_at: Date | string;\n        updated_at: Date | string;\n    };\n} & {\n    new (...args: any[]): {\n        deleted_at: Date | string | null;\n    };\n};\nexport default class UserEntity extends UserEntity_base {\n    id: number;\n    email: string;\n    name: string;\n    username: string;\n    password?: string;\n    verified_at?: Date | string | null;\n    permissions?: Permission[];\n    roles?: Role[];\n    get initials(): string;\n}\nexport {};\n","import User from '#shared/entities/UserEntity.ts';\ninterface LogoutOptions {\n    redirect?: string;\n}\nexport default class AuthService {\n    static __container_entry_key: string;\n    user: User | null;\n    constructor(data?: Partial<AuthService>);\n    logout(options?: LogoutOptions): Promise<void>;\n}\nexport {};\n","export interface FetchOptions extends RequestInit {\n    query?: Record<string, any>;\n    data?: Record<string, any>;\n}\nexport default class FetchService {\n    static __container_entry_key: string;\n    protected handleError(response: Response): Promise<any>;\n    protected buildUrl(url: string, query?: Record<string, any>): string;\n    protected buildRequestInit(options: FetchOptions): RequestInit;\n    protected parseResponse<T>(response: Response): Promise<T>;\n    fetch<T>(_url: string, _options?: FetchOptions): Promise<T>;\n    try<T = any>(url: string, options?: FetchOptions): Promise<[Error, null] | [null, Awaited<T>]>;\n    get<T = any>(url: string, options?: FetchOptions): Promise<T>;\n    post<T = any>(url: string, options?: FetchOptions): Promise<T>;\n    put<T = any>(url: string, options?: FetchOptions): Promise<T>;\n    delete<T = any>(url: string, options?: FetchOptions): Promise<T>;\n}\n","import type { FetchOptions } from './FetchService.ts';\nimport FetchService from './FetchService.ts';\nexport default class FetchBrowserService extends FetchService {\n    fetch<T>(url: string, options?: FetchOptions): Promise<T>;\n}\n","import type { FetchOptions } from './FetchService.ts';\nimport FetchService from './FetchService.ts';\nexport default class FetchNodeService extends FetchService {\n    fetch<T>(url: string, options?: FetchOptions): Promise<T>;\n    protected fetchExternal<T>(url: string, options?: FetchOptions): Promise<T>;\n    protected fetchInternal<T>(url: string, options?: FetchOptions): Promise<T>;\n}\n","import type { DefineComponent } from \"vue\";\nexport default class LayoutService {\n    static __container_entry_key: string;\n    components: Map<string, DefineComponent>;\n    options: Record<string, any>;\n    currendId: string | null;\n    setCurrent(id: string): void;\n    add(name: string, component: DefineComponent, options?: any): void;\n    has(name: string): boolean;\n    get(name: string): DefineComponent;\n    getOptions(): Record<string, any>;\n    getCurrent(): DefineComponent | null;\n    setOptions(options?: any): void;\n}\n","export default class LoggerService {\n    static __container_entry_key: string;\n    info(message: string, meta?: any): void;\n    debug(message: string, meta?: any): void;\n    warn(message: string, meta?: any): void;\n    error(message: string | Error, meta?: any): void;\n    child(options: any): LoggerService;\n}\n","export default class LifecycleHook {\n    hook_id: string;\n    hook_aliases?: string[];\n    order?: number;\n    subhooks?: LifecycleHook[];\n    register(): Promise<void>;\n    load(): Promise<void>;\n    boot(): Promise<void>;\n    shutdown(): Promise<void>;\n    /** @deprecated Use register */\n    onRegister(): Promise<void>;\n    /** @deprecated Use load */\n    onLoad(): Promise<void>;\n    /** @deprecated Use boot */\n    onBoot(): Promise<void>;\n    /** @deprecated Use shutdown */\n    onShutdown(): Promise<void>;\n}\n","import LoggerService from './LoggerService.ts';\nimport LifecycleHook from '#shared/entities/LifecycleHook.ts';\nimport type { Constructor } from '#shared/utils/compose.ts';\ntype LifecycleMethod = 'register' | 'load' | 'boot' | 'shutdown';\ninterface ListOptions {\n    include?: string | string[];\n    exclude?: string | string[];\n}\nexport interface LifecycleServiceOptions {\n    debug?: boolean;\n    hooks?: Map<string, LifecycleHook>;\n    logger?: LoggerService;\n    onError?: (error: Error, context: {\n        hookId: string;\n        method: LifecycleMethod;\n    }) => void;\n}\nexport default class LifecycleService {\n    static __container_entry_key: string;\n    hooks: Map<string, LifecycleHook>;\n    logger: LoggerService;\n    debug: boolean;\n    constructor(data?: LifecycleServiceOptions);\n    setOnError(handler: Required<LifecycleServiceOptions>['onError']): void;\n    onError(error: Error, context: {\n        hookId: string;\n        method: LifecycleMethod;\n    }): void;\n    mapAliases(args: string[]): string[];\n    list(options?: ListOptions): LifecycleHook[];\n    add(...payload: (LifecycleHook | Constructor<LifecycleHook>)[]): void;\n    emitMethod(method: LifecycleMethod, options?: ListOptions): Promise<void>;\n    emit(payload: LifecycleMethod | LifecycleMethod[], options?: ListOptions): Promise<void>;\n    on(method: LifecycleMethod, handler: () => Promise<void>): void;\n    register(options?: ListOptions): Promise<void>;\n    load(options?: ListOptions): Promise<void>;\n    boot(options?: ListOptions): Promise<void>;\n    shutdown(options?: ListOptions): Promise<void>;\n    clear(): void;\n}\nexport {};\n","import BaseLifecycleService from '#shared/services/LifecycleService.ts';\nexport default class LifecycleService extends BaseLifecycleService {\n    addImports(imports: Record<string, any>): void;\n}\n","declare const MenuItem_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor;\nexport default class MenuItem extends MenuItem_base {\n    id: string;\n    label: string;\n    layout: string;\n    to?: string;\n    target?: '_blank' | '_self' | '_parent' | '_top';\n    group?: string;\n    order?: number;\n    icon?: string;\n    parent?: string;\n}\nexport {};\n","import MenuItem from '#client/entities/MenuItemEntity.ts';\nexport interface ListFilter {\n    layout?: string;\n    group?: string;\n    parent?: string;\n    allowed?: boolean;\n}\nexport default class MenuService {\n    static __container_entry_key: string;\n    items: Map<string, MenuItem>;\n    add(...item: Omit<Partial<MenuItem>, 'merge' | 'from'>[]): void;\n    remove(id: MenuItem['id']): void;\n    list(filter?: ListFilter): MenuItem[];\n    clear(): void;\n}\n","import type { NavigationGuard, Router as VueRouter } from 'vue-router';\nimport type { RouteRecordRaw } from 'vue-router';\nimport type { DefineComponent } from 'vue';\nexport interface Router extends VueRouter {\n    auto: typeof auto;\n}\nexport interface AutoOptions {\n    guards?: NavigationGuard[] | ((record: RouteRecordRaw) => NavigationGuard[]);\n    strip?: (string | RegExp)[];\n    exclude?: (string | RegExp)[];\n    prefix?: string;\n    refine?: (records: RouteRecordRaw[]) => RouteRecordRaw[];\n}\nexport declare function auto(imports: Record<string, DefineComponent | (() => Promise<DefineComponent>)>, options?: AutoOptions): RouteRecordRaw[];\nexport declare function createRouter(): Router;\n","export default class ToastService {\n    static __container_entry_key: string;\n    success(message: string, options?: Record<string, any>): void;\n    error(message: string, options?: Record<string, any>): void;\n}\n","import * as _vueuse_shared0 from \"@vueuse/shared\";\nimport { Arrayable, Awaitable, ConfigurableEventFilter, ConfigurableFlush, ConfigurableFlushSync, EventHookOn, Fn, IsAny, Pausable, ReadonlyRefOrGetter, RemovableRef, ShallowOrDeepRef, Stoppable, UseTimeoutFnOptions } from \"@vueuse/shared\";\nimport * as vue0 from \"vue\";\nimport { App, Component, ComponentObjectPropsOptions, ComponentPublicInstance, ComputedRef, DefineComponent, InjectionKey, MaybeRef, MaybeRefOrGetter, MultiWatchSources, Ref, ShallowRef, Slot, StyleValue, ToRefs, TransitionGroupProps, UnwrapNestedRefs, UnwrapRef, WatchOptions, WatchOptionsBase, WatchSource, WatchStopHandle, WritableComputedRef } from \"vue\";\nexport * from \"@vueuse/shared\";\n\n//#region computedAsync/index.d.ts\n/**\n * Handle overlapping async evaluations.\n *\n * @param cancelCallback The provided callback is invoked when a re-evaluation of the computed value is triggered before the previous one finished\n */\ntype AsyncComputedOnCancel = (cancelCallback: Fn) => void;\ninterface AsyncComputedOptions<Lazy = boolean> extends ConfigurableFlushSync {\n  /**\n   * Should value be evaluated lazily\n   *\n   * @default false\n   */\n  lazy?: Lazy;\n  /**\n   * Ref passed to receive the updated of async evaluation\n   */\n  evaluating?: Ref<boolean>;\n  /**\n   * Use shallowRef\n   *\n   * @default true\n   */\n  shallow?: boolean;\n  /**\n   * Callback when error is caught.\n   */\n  onError?: (e: unknown) => void;\n}\n/**\n * Create an asynchronous computed dependency.\n *\n * @see https://vueuse.org/computedAsync\n * @param evaluationCallback     The promise-returning callback which generates the computed value\n * @param initialState           The initial state, used until the first evaluation finishes\n * @param optionsOrRef           Additional options or a ref passed to receive the updates of the async evaluation\n */\ndeclare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: T, optionsOrRef: AsyncComputedOptions<true>): ComputedRef<T>;\ndeclare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: undefined, optionsOrRef: AsyncComputedOptions<true>): ComputedRef<T | undefined>;\ndeclare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: T, optionsOrRef?: Ref<boolean> | AsyncComputedOptions): Ref<T>;\ndeclare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState?: undefined, optionsOrRef?: Ref<boolean> | AsyncComputedOptions): Ref<T | undefined>;\n/** @deprecated use `computedAsync` instead */\ndeclare const asyncComputed: typeof computedAsync;\n//#endregion\n//#region computedInject/index.d.ts\ntype ComputedInjectGetter<T, K$1> = (source: T | undefined, oldValue?: K$1) => K$1;\ntype ComputedInjectGetterWithDefault<T, K$1> = (source: T, oldValue?: K$1) => K$1;\ntype ComputedInjectSetter<T> = (v: T) => void;\ninterface WritableComputedInjectOptions<T, K$1> {\n  get: ComputedInjectGetter<T, K$1>;\n  set: ComputedInjectSetter<K$1>;\n}\ninterface WritableComputedInjectOptionsWithDefault<T, K$1> {\n  get: ComputedInjectGetterWithDefault<T, K$1>;\n  set: ComputedInjectSetter<K$1>;\n}\ndeclare function computedInject<T, K$1 = any>(key: InjectionKey<T> | string, getter: ComputedInjectGetter<T, K$1>): ComputedRef<K$1 | undefined>;\ndeclare function computedInject<T, K$1 = any>(key: InjectionKey<T> | string, options: WritableComputedInjectOptions<T, K$1>): ComputedRef<K$1 | undefined>;\ndeclare function computedInject<T, K$1 = any>(key: InjectionKey<T> | string, getter: ComputedInjectGetterWithDefault<T, K$1>, defaultSource: T, treatDefaultAsFactory?: false): ComputedRef<K$1>;\ndeclare function computedInject<T, K$1 = any>(key: InjectionKey<T> | string, options: WritableComputedInjectOptionsWithDefault<T, K$1>, defaultSource: T | (() => T), treatDefaultAsFactory: true): ComputedRef<K$1>;\n//#endregion\n//#region createReusableTemplate/index.d.ts\ntype ObjectLiteralWithPotentialObjectLiterals = Record<string, Record<string, any> | undefined>;\ntype GenerateSlotsFromSlotMap<T extends ObjectLiteralWithPotentialObjectLiterals> = { [K in keyof T]: Slot<T[K]> };\ntype DefineTemplateComponent<Bindings extends Record<string, any>, MapSlotNameToSlotProps extends ObjectLiteralWithPotentialObjectLiterals> = DefineComponent & {\n  new (): {\n    $slots: {\n      default: (_: Bindings & {\n        $slots: GenerateSlotsFromSlotMap<MapSlotNameToSlotProps>;\n      }) => any;\n    };\n  };\n};\ntype ReuseTemplateComponent<Bindings extends Record<string, any>, MapSlotNameToSlotProps extends ObjectLiteralWithPotentialObjectLiterals> = DefineComponent<Bindings> & {\n  new (): {\n    $slots: GenerateSlotsFromSlotMap<MapSlotNameToSlotProps>;\n  };\n};\ntype ReusableTemplatePair<Bindings extends Record<string, any>, MapSlotNameToSlotProps extends ObjectLiteralWithPotentialObjectLiterals> = [DefineTemplateComponent<Bindings, MapSlotNameToSlotProps>, ReuseTemplateComponent<Bindings, MapSlotNameToSlotProps>] & {\n  define: DefineTemplateComponent<Bindings, MapSlotNameToSlotProps>;\n  reuse: ReuseTemplateComponent<Bindings, MapSlotNameToSlotProps>;\n};\ninterface CreateReusableTemplateOptions<Props extends Record<string, any>> {\n  /**\n   * Inherit attrs from reuse component.\n   *\n   * @default true\n   */\n  inheritAttrs?: boolean;\n  /**\n   * Props definition for reuse component.\n   */\n  props?: ComponentObjectPropsOptions<Props>;\n}\n/**\n * This function creates `define` and `reuse` components in pair,\n * It also allow to pass a generic to bind with type.\n *\n * @see https://vueuse.org/createReusableTemplate\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function createReusableTemplate<Bindings extends Record<string, any>, MapSlotNameToSlotProps extends ObjectLiteralWithPotentialObjectLiterals = Record<'default', undefined>>(options?: CreateReusableTemplateOptions<Bindings>): ReusableTemplatePair<Bindings, MapSlotNameToSlotProps>;\n//#endregion\n//#region createTemplatePromise/index.d.ts\ninterface TemplatePromiseProps<Return, Args extends any[] = []> {\n  /**\n   * The promise instance.\n   */\n  promise: Promise<Return> | undefined;\n  /**\n   * Resolve the promise.\n   */\n  resolve: (v: Return | Promise<Return>) => void;\n  /**\n   * Reject the promise.\n   */\n  reject: (v: any) => void;\n  /**\n   * Arguments passed to TemplatePromise.start()\n   */\n  args: Args;\n  /**\n   * Indicates if the promise is resolving.\n   * When passing another promise to `resolve`, this will be set to `true` until the promise is resolved.\n   */\n  isResolving: boolean;\n  /**\n   * Options passed to createTemplatePromise()\n   */\n  options: TemplatePromiseOptions;\n  /**\n   * Unique key for list rendering.\n   */\n  key: number;\n}\ninterface TemplatePromiseOptions {\n  /**\n   * Determines if the promise can be called only once at a time.\n   *\n   * @default false\n   */\n  singleton?: boolean;\n  /**\n   * Transition props for the promise.\n   */\n  transition?: TransitionGroupProps;\n}\ntype TemplatePromise<Return, Args extends any[] = []> = DefineComponent<object> & {\n  new (): {\n    $slots: {\n      default: (_: TemplatePromiseProps<Return, Args>) => any;\n    };\n  };\n} & {\n  start: (...args: Args) => Promise<Return>;\n};\n/**\n * Creates a template promise component.\n *\n * @see https://vueuse.org/createTemplatePromise\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function createTemplatePromise<Return, Args extends any[] = []>(options?: TemplatePromiseOptions): TemplatePromise<Return, Args>;\n//#endregion\n//#region createUnrefFn/index.d.ts\ntype UnrefFn<T> = T extends ((...args: infer A) => infer R) ? (...args: { [K in keyof A]: MaybeRef<A[K]> }) => R : never;\n/**\n * Make a plain function accepting ref and raw values as arguments.\n * Returns the same value the unconverted function returns, with proper typing.\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function createUnrefFn<T extends Function>(fn: T): UnrefFn<T>;\n//#endregion\n//#region _configurable.d.ts\ninterface ConfigurableWindow {\n  window?: Window;\n}\ninterface ConfigurableDocument {\n  document?: Document;\n}\ninterface ConfigurableDocumentOrShadowRoot {\n  document?: DocumentOrShadowRoot;\n}\ninterface ConfigurableNavigator {\n  navigator?: Navigator;\n}\ninterface ConfigurableLocation {\n  location?: Location;\n}\ndeclare const defaultWindow: (Window & typeof globalThis) | undefined;\ndeclare const defaultDocument: Document | undefined;\ndeclare const defaultNavigator: Navigator | undefined;\ndeclare const defaultLocation: Location | undefined;\ninterface ConfigurableDeepRefs<D extends boolean> {\n  /**\n   * Return deep refs instead of shallow refs.\n   *\n   * @default true - will be changed to `false` by default in the next major\n   */\n  deepRefs?: D;\n}\ninterface ConfigurableScheduler {\n  /**\n   * Custom scheduler to use for interval execution.\n   */\n  scheduler?: (cb: Fn) => Pausable;\n}\n//#endregion\n//#region unrefElement/index.d.ts\ntype VueInstance = ComponentPublicInstance;\ntype MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>;\ntype MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeRefOrGetter<T>;\ntype MaybeElement = HTMLElement | SVGElement | VueInstance | undefined | null;\ntype UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends VueInstance ? Exclude<MaybeElement, VueInstance> : T | undefined;\n/**\n * Get the dom element of a ref of element or Vue component instance\n *\n * @param elRef\n */\ndeclare function unrefElement<T extends MaybeElement>(elRef: MaybeComputedElementRef<T>): UnRefElementReturn<T>;\n//#endregion\n//#region onClickOutside/index.d.ts\ninterface OnClickOutsideOptions<Controls extends boolean = false> extends ConfigurableWindow {\n  /**\n   * List of elements that should not trigger the event,\n   * provided as Refs or CSS Selectors.\n   */\n  ignore?: MaybeRefOrGetter<(MaybeElementRef | string)[]>;\n  /**\n   * Use capturing phase for internal event listener.\n   * @default true\n   */\n  capture?: boolean;\n  /**\n   * Run handler function if focus moves to an iframe.\n   * @default false\n   */\n  detectIframe?: boolean;\n  /**\n   * Use controls to cancel/trigger listener.\n   * @default false\n   */\n  controls?: Controls;\n}\ntype OnClickOutsideHandler<T extends OnClickOutsideOptions<boolean> = OnClickOutsideOptions> = (event: (T['detectIframe'] extends true ? FocusEvent : never) | (T['controls'] extends true ? Event : never) | PointerEvent) => void;\ntype OnClickOutsideReturn<Controls extends boolean = false> = Controls extends false ? Fn : {\n  stop: Fn;\n  cancel: Fn;\n  trigger: (event: Event) => void;\n};\n/**\n * Listen for clicks outside of an element.\n *\n * @see https://vueuse.org/onClickOutside\n * @param target\n * @param handler\n * @param options\n */\ndeclare function onClickOutside<T extends OnClickOutsideOptions>(target: MaybeComputedElementRef, handler: OnClickOutsideHandler<T>, options?: T): Fn;\ndeclare function onClickOutside<T extends OnClickOutsideOptions<true>>(target: MaybeComputedElementRef, handler: OnClickOutsideHandler<T>, options: T): {\n  stop: Fn;\n  cancel: Fn;\n  trigger: (event: Event) => void;\n};\n//#endregion\n//#region onElementRemoval/index.d.ts\ninterface OnElementRemovalOptions extends ConfigurableWindow, ConfigurableDocumentOrShadowRoot, WatchOptionsBase {}\n/**\n * Fires when the element or any element containing it is removed.\n *\n * @param target\n * @param callback\n * @param options\n */\ndeclare function onElementRemoval(target: MaybeElementRef, callback: (mutationRecords: MutationRecord[]) => void, options?: OnElementRemovalOptions): Fn;\n//#endregion\n//#region onKeyStroke/index.d.ts\ntype KeyPredicate = (event: KeyboardEvent) => boolean;\ntype KeyFilter = true | string | string[] | KeyPredicate;\ntype KeyStrokeEventName = 'keydown' | 'keypress' | 'keyup';\ninterface OnKeyStrokeOptions {\n  eventName?: KeyStrokeEventName;\n  target?: MaybeRefOrGetter<EventTarget | null | undefined>;\n  passive?: boolean;\n  /**\n   * Set to `true` to ignore repeated events when the key is being held down.\n   *\n   * @default false\n   */\n  dedupe?: MaybeRefOrGetter<boolean>;\n}\n/**\n * Listen for keyboard keystrokes.\n *\n * @see https://vueuse.org/onKeyStroke\n */\ndeclare function onKeyStroke(key: KeyFilter, handler: (event: KeyboardEvent) => void, options?: OnKeyStrokeOptions): () => void;\ndeclare function onKeyStroke(handler: (event: KeyboardEvent) => void, options?: OnKeyStrokeOptions): () => void;\n/**\n * Listen to the keydown event of the given key.\n *\n * @see https://vueuse.org/onKeyStroke\n * @param key\n * @param handler\n * @param options\n */\ndeclare function onKeyDown(key: KeyFilter, handler: (event: KeyboardEvent) => void, options?: Omit<OnKeyStrokeOptions, 'eventName'>): () => void;\n/**\n * Listen to the keypress event of the given key.\n *\n * @see https://vueuse.org/onKeyStroke\n * @param key\n * @param handler\n * @param options\n */\ndeclare function onKeyPressed(key: KeyFilter, handler: (event: KeyboardEvent) => void, options?: Omit<OnKeyStrokeOptions, 'eventName'>): () => void;\n/**\n * Listen to the keyup event of the given key.\n *\n * @see https://vueuse.org/onKeyStroke\n * @param key\n * @param handler\n * @param options\n */\ndeclare function onKeyUp(key: KeyFilter, handler: (event: KeyboardEvent) => void, options?: Omit<OnKeyStrokeOptions, 'eventName'>): () => void;\n//#endregion\n//#region onLongPress/index.d.ts\ninterface OnLongPressOptions {\n  /**\n   * Time in ms till `longpress` gets called\n   *\n   * @default 500\n   */\n  delay?: number | ((ev: PointerEvent) => number);\n  modifiers?: OnLongPressModifiers;\n  /**\n   * Allowance of moving distance in pixels,\n   * The action will get canceled When moving too far from the pointerdown position.\n   * @default 10\n   */\n  distanceThreshold?: number | false;\n  /**\n   * Function called when the ref element is released.\n   * @param duration how long the element was pressed in ms\n   * @param distance distance from the pointerdown position\n   * @param isLongPress whether the action was a long press or not\n   */\n  onMouseUp?: (duration: number, distance: number, isLongPress: boolean) => void;\n}\ninterface OnLongPressModifiers {\n  stop?: boolean;\n  once?: boolean;\n  prevent?: boolean;\n  capture?: boolean;\n  self?: boolean;\n}\ntype OnLongPressReturn = () => void;\n/** @deprecated use {@link OnLongPressReturn} instead */\ntype UseOnLongPressReturn = OnLongPressReturn;\ndeclare function onLongPress(target: MaybeElementRef, handler: (evt: PointerEvent) => void, options?: OnLongPressOptions): OnLongPressReturn;\n//#endregion\n//#region onStartTyping/index.d.ts\n/**\n * Fires when users start typing on non-editable elements.\n *\n * @see https://vueuse.org/onStartTyping\n * @param callback\n * @param options\n */\ndeclare function onStartTyping(callback: (event: KeyboardEvent) => void, options?: ConfigurableDocument): void;\n//#endregion\n//#region templateRef/index.d.ts\n/**\n * @deprecated Use Vue's built-in `useTemplateRef` instead.\n *\n * Shorthand for binding ref to template element.\n *\n * @see https://vueuse.org/templateRef\n * @param key\n * @param initialValue\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function templateRef<T extends HTMLElement | SVGElement | Component | null, Keys extends string = string>(key: Keys, initialValue?: T | null): Readonly<Ref<T>>;\n//#endregion\n//#region useActiveElement/index.d.ts\ninterface UseActiveElementOptions extends ConfigurableWindow, ConfigurableDocumentOrShadowRoot {\n  /**\n   * Search active element deeply inside shadow dom\n   *\n   * @default true\n   */\n  deep?: boolean;\n  /**\n   * Track active element when it's removed from the DOM\n   * Using a MutationObserver under the hood\n   * @default false\n   */\n  triggerOnRemoval?: boolean;\n}\ntype UseActiveElementReturn<T extends HTMLElement = HTMLElement> = ShallowRef<T | null | undefined>;\n/**\n * Reactive `document.activeElement`\n *\n * @see https://vueuse.org/useActiveElement\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useActiveElement<T extends HTMLElement>(options?: UseActiveElementOptions): UseActiveElementReturn<T>;\n//#endregion\n//#region types.d.ts\ninterface Position {\n  x: number;\n  y: number;\n}\ninterface RenderableComponent {\n  /**\n   * The element that the component should be rendered as\n   *\n   * @default 'div'\n   */\n  as?: object | string;\n}\ntype PointerType = 'mouse' | 'touch' | 'pen';\ninterface Supportable {\n  isSupported: ComputedRef<boolean>;\n}\n//#endregion\n//#region useAnimate/index.d.ts\ninterface UseAnimateOptions extends KeyframeAnimationOptions, ConfigurableWindow {\n  /**\n   * Will automatically run play when `useAnimate` is used\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Whether to commits the end styling state of an animation to the element being animated\n   * In general, you should use `fill` option with this.\n   *\n   * @default false\n   */\n  commitStyles?: boolean;\n  /**\n   * Whether to persists the animation\n   *\n   * @default false\n   */\n  persist?: boolean;\n  /**\n   * Executed after animation initialization\n   */\n  onReady?: (animate: Animation) => void;\n  /**\n   * Callback when error is caught.\n   */\n  onError?: (e: unknown) => void;\n}\ntype UseAnimateKeyframes = MaybeRef<Keyframe[] | PropertyIndexedKeyframes | null>;\ninterface UseAnimateReturn extends Supportable {\n  animate: ShallowRef<Animation | undefined>;\n  play: () => void;\n  pause: () => void;\n  reverse: () => void;\n  finish: () => void;\n  cancel: () => void;\n  pending: ComputedRef<boolean>;\n  playState: ComputedRef<AnimationPlayState>;\n  replaceState: ComputedRef<AnimationReplaceState>;\n  startTime: WritableComputedRef<CSSNumberish | number | null>;\n  currentTime: WritableComputedRef<CSSNumberish | null>;\n  timeline: WritableComputedRef<AnimationTimeline | null>;\n  playbackRate: WritableComputedRef<number>;\n}\n/**\n * Reactive Web Animations API\n *\n * @see https://vueuse.org/useAnimate\n * @param target\n * @param keyframes\n * @param options\n */\ndeclare function useAnimate(target: MaybeComputedElementRef, keyframes: UseAnimateKeyframes, options?: number | UseAnimateOptions): UseAnimateReturn;\n//#endregion\n//#region useAsyncQueue/index.d.ts\ntype UseAsyncQueueTask<T> = (...args: any[]) => T | Promise<T>;\ntype MapQueueTask<T extends any[]> = { [K in keyof T]: UseAsyncQueueTask<T[K]> };\ninterface UseAsyncQueueResult<T> {\n  state: 'aborted' | 'fulfilled' | 'pending' | 'rejected';\n  data: T | null;\n}\ninterface UseAsyncQueueReturn<T> {\n  activeIndex: ShallowRef<number>;\n  result: T;\n}\ninterface UseAsyncQueueOptions {\n  /**\n   * Interrupt tasks when current task fails.\n   *\n   * @default true\n   */\n  interrupt?: boolean;\n  /**\n   * Trigger it when the tasks fails.\n   *\n   */\n  onError?: () => void;\n  /**\n   * Trigger it when the tasks ends.\n   *\n   */\n  onFinished?: () => void;\n  /**\n   * A AbortSignal that can be used to abort the task.\n   */\n  signal?: AbortSignal;\n}\n/**\n * Asynchronous queue task controller.\n *\n * @see https://vueuse.org/useAsyncQueue\n * @param tasks\n * @param options\n */\ndeclare function useAsyncQueue<T extends any[], S = MapQueueTask<T>>(tasks: S & Array<UseAsyncQueueTask<any>>, options?: UseAsyncQueueOptions): UseAsyncQueueReturn<{ [P in keyof T]: UseAsyncQueueResult<T[P]> }>;\n//#endregion\n//#region useAsyncState/index.d.ts\ninterface UseAsyncStateReturnBase<Data, Params extends any[], Shallow extends boolean> {\n  state: Shallow extends true ? Ref<Data> : Ref<UnwrapRef<Data>>;\n  isReady: Ref<boolean>;\n  isLoading: Ref<boolean>;\n  error: Ref<unknown>;\n  execute: (delay?: number, ...args: Params) => Promise<Data | undefined>;\n  executeImmediate: (...args: Params) => Promise<Data | undefined>;\n}\ntype UseAsyncStateReturn<Data, Params extends any[], Shallow extends boolean> = UseAsyncStateReturnBase<Data, Params, Shallow> & PromiseLike<UseAsyncStateReturnBase<Data, Params, Shallow>>;\ninterface UseAsyncStateOptions<Shallow extends boolean, D = any> {\n  /**\n   * Delay for the first execution of the promise when \"immediate\" is true. In milliseconds.\n   *\n   * @default 0\n   */\n  delay?: number;\n  /**\n   * Execute the promise right after the function is invoked.\n   * Will apply the delay if any.\n   *\n   * When set to false, you will need to execute it manually.\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Callback when error is caught.\n   */\n  onError?: (e: unknown) => void;\n  /**\n   * Callback when success is caught.\n   * @param {D} data\n   */\n  onSuccess?: (data: D) => void;\n  /**\n   * Sets the state to initialState before executing the promise.\n   *\n   * This can be useful when calling the execute function more than once (for\n   * example, to refresh data). When set to false, the current state remains\n   * unchanged until the promise resolves.\n   *\n   * @default true\n   */\n  resetOnExecute?: boolean;\n  /**\n   * Use shallowRef.\n   *\n   * @default true\n   */\n  shallow?: Shallow;\n  /**\n   *\n   * An error is thrown when executing the execute function\n   *\n   * @default false\n   */\n  throwError?: boolean;\n}\n/**\n * Reactive async state. Will not block your setup function and will trigger changes once\n * the promise is ready.\n *\n * @see https://vueuse.org/useAsyncState\n * @param promise         The promise / async function to be resolved\n * @param initialState    The initial state, used until the first evaluation finishes\n * @param options\n */\ndeclare 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>;\n//#endregion\n//#region useBase64/index.d.ts\ninterface UseBase64Options {\n  /**\n   * Output as Data URL format\n   *\n   * @default true\n   */\n  dataUrl?: boolean;\n}\ninterface ToDataURLOptions extends UseBase64Options {\n  /**\n   * MIME type\n   */\n  type?: string | undefined;\n  /**\n   * Image quality of jpeg or webp\n   */\n  quality?: any;\n}\ninterface UseBase64ObjectOptions<T> extends UseBase64Options {\n  serializer?: (v: T) => string;\n}\ninterface UseBase64Return {\n  base64: ShallowRef<string>;\n  promise: ShallowRef<Promise<string>>;\n  execute: () => Promise<string>;\n}\ndeclare function useBase64(target: MaybeRefOrGetter<string | undefined>, options?: UseBase64Options): UseBase64Return;\ndeclare function useBase64(target: MaybeRefOrGetter<Blob | undefined>, options?: UseBase64Options): UseBase64Return;\ndeclare function useBase64(target: MaybeRefOrGetter<ArrayBuffer | undefined>, options?: UseBase64Options): UseBase64Return;\ndeclare function useBase64(target: MaybeRefOrGetter<HTMLCanvasElement | undefined>, options?: ToDataURLOptions): UseBase64Return;\ndeclare function useBase64(target: MaybeRefOrGetter<HTMLImageElement | undefined>, options?: ToDataURLOptions): UseBase64Return;\ndeclare function useBase64<T extends Record<string, unknown>>(target: MaybeRefOrGetter<T>, options?: UseBase64ObjectOptions<T>): UseBase64Return;\ndeclare function useBase64<T extends Map<string, unknown>>(target: MaybeRefOrGetter<T>, options?: UseBase64ObjectOptions<T>): UseBase64Return;\ndeclare function useBase64<T extends Set<unknown>>(target: MaybeRefOrGetter<T>, options?: UseBase64ObjectOptions<T>): UseBase64Return;\ndeclare function useBase64<T>(target: MaybeRefOrGetter<T[]>, options?: UseBase64ObjectOptions<T[]>): UseBase64Return;\n//#endregion\n//#region useBattery/index.d.ts\ninterface UseBatteryOptions extends ConfigurableNavigator {}\ninterface UseBatteryReturn extends Supportable {\n  charging: ShallowRef<boolean>;\n  chargingTime: ShallowRef<number>;\n  dischargingTime: ShallowRef<number>;\n  level: ShallowRef<number>;\n}\ninterface BatteryManager extends EventTarget {\n  charging: boolean;\n  chargingTime: number;\n  dischargingTime: number;\n  level: number;\n}\n/**\n * Reactive Battery Status API.\n *\n * @see https://vueuse.org/useBattery\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useBattery(options?: UseBatteryOptions): UseBatteryReturn;\n//#endregion\n//#region useBluetooth/index.d.ts\ninterface UseBluetoothRequestDeviceOptions {\n  /**\n   *\n   * An array of BluetoothScanFilters. This filter consists of an array\n   * of BluetoothServiceUUIDs, a name parameter, and a namePrefix parameter.\n   *\n   */\n  filters?: BluetoothLEScanFilter[] | undefined;\n  /**\n   *\n   * An array of BluetoothServiceUUIDs.\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/BluetoothRemoteGATTService/uuid\n   *\n   */\n  optionalServices?: BluetoothServiceUUID[] | undefined;\n}\ninterface UseBluetoothOptions extends UseBluetoothRequestDeviceOptions, ConfigurableNavigator {\n  /**\n   *\n   * A boolean value indicating that the requesting script can accept all Bluetooth\n   * devices. The default is false.\n   *\n   * !! This may result in a bunch of unrelated devices being shown\n   * in the chooser and energy being wasted as there are no filters.\n   *\n   *\n   * Use it with caution.\n   *\n   * @default false\n   *\n   */\n  acceptAllDevices?: boolean;\n}\ndeclare function useBluetooth(options?: UseBluetoothOptions): UseBluetoothReturn;\ninterface UseBluetoothReturn extends Supportable {\n  isConnected: Readonly<ShallowRef<boolean>>;\n  device: ShallowRef<BluetoothDevice | undefined>;\n  requestDevice: () => Promise<void>;\n  server: ShallowRef<BluetoothRemoteGATTServer | undefined>;\n  error: ShallowRef<unknown | null>;\n}\n//#endregion\n//#region useBreakpoints/breakpoints.d.ts\n/**\n * Breakpoints from Tailwind V2\n *\n * @see https://tailwindcss.com/docs/breakpoints\n */\ndeclare const breakpointsTailwind: {\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n  '2xl': number;\n};\n/**\n * Breakpoints from Bootstrap V5\n *\n * @see https://getbootstrap.com/docs/5.0/layout/breakpoints\n */\ndeclare const breakpointsBootstrapV5: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n  xxl: number;\n};\n/**\n * Breakpoints from Vuetify V2\n *\n * @see https://v2.vuetifyjs.com/en/features/breakpoints/\n */\ndeclare const breakpointsVuetifyV2: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n};\n/**\n * Breakpoints from Vuetify V3\n *\n * @see https://vuetifyjs.com/en/styles/float/#overview\n */\ndeclare const breakpointsVuetifyV3: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n  xxl: number;\n};\n/**\n * Alias to `breakpointsVuetifyV2`\n *\n * @deprecated explictly use `breakpointsVuetifyV2` or `breakpointsVuetifyV3` instead\n */\ndeclare const breakpointsVuetify: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n};\n/**\n * Breakpoints from Ant Design\n *\n * @see https://ant.design/components/layout/#breakpoint-width\n */\ndeclare const breakpointsAntDesign: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n  xxl: number;\n};\n/**\n * Breakpoints from Quasar V2\n *\n * @see https://quasar.dev/style/breakpoints\n */\ndeclare const breakpointsQuasar: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n};\n/**\n * Sematic Breakpoints\n */\ndeclare const breakpointsSematic: {\n  mobileS: number;\n  mobileM: number;\n  mobileL: number;\n  tablet: number;\n  laptop: number;\n  laptopL: number;\n  desktop4K: number;\n};\n/**\n * Breakpoints from Master CSS\n *\n * @see https://docs.master.co/css/breakpoints\n */\ndeclare const breakpointsMasterCss: {\n  '3xs': number;\n  '2xs': number;\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n  '2xl': number;\n  '3xl': number;\n  '4xl': number;\n};\n/**\n * Breakpoints from PrimeFlex\n *\n * @see https://primeflex.org/installation\n */\ndeclare const breakpointsPrimeFlex: {\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n};\n/**\n * Breakpoints from ElementUI/ElementPlus\n *\n * @see https://element.eleme.io/#/en-US/component/layout\n * @see https://element-plus.org/en-US/component/layout.html\n */\ndeclare const breakpointsElement: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n};\n//#endregion\n//#region useBreakpoints/index.d.ts\ntype Breakpoints<K$1 extends string = string> = Record<K$1, MaybeRefOrGetter<number | string>>;\ninterface UseBreakpointsOptions extends ConfigurableWindow {\n  /**\n   * The query strategy to use for the generated shortcut methods like `.lg`\n   *\n   * 'min-width' - .lg will be true when the viewport is greater than or equal to the lg breakpoint (mobile-first)\n   * 'max-width' - .lg will be true when the viewport is smaller than the xl breakpoint (desktop-first)\n   *\n   * @default \"min-width\"\n   */\n  strategy?: 'min-width' | 'max-width';\n  ssrWidth?: number;\n}\ntype UseBreakpointReturn<K$1 extends string = string> = Record<K$1, ComputedRef<boolean>> & {\n  greaterOrEqual: (k: MaybeRefOrGetter<K$1>) => ComputedRef<boolean>;\n  smallerOrEqual: (k: MaybeRefOrGetter<K$1>) => ComputedRef<boolean>;\n  greater: (k: MaybeRefOrGetter<K$1>) => ComputedRef<boolean>;\n  smaller: (k: MaybeRefOrGetter<K$1>) => ComputedRef<boolean>;\n  between: (a: MaybeRefOrGetter<K$1>, b: MaybeRefOrGetter<K$1>) => ComputedRef<boolean>;\n  isGreater: (k: MaybeRefOrGetter<K$1>) => boolean;\n  isGreaterOrEqual: (k: MaybeRefOrGetter<K$1>) => boolean;\n  isSmaller: (k: MaybeRefOrGetter<K$1>) => boolean;\n  isSmallerOrEqual: (k: MaybeRefOrGetter<K$1>) => boolean;\n  isInBetween: (a: MaybeRefOrGetter<K$1>, b: MaybeRefOrGetter<K$1>) => boolean;\n  current: () => ComputedRef<K$1[]>;\n  active: () => ComputedRef<K$1 | ''>;\n};\n/**\n * Reactively viewport breakpoints\n *\n * @see https://vueuse.org/useBreakpoints\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useBreakpoints<K$1 extends string>(breakpoints: Breakpoints<K$1>, options?: UseBreakpointsOptions): UseBreakpointReturn<K$1>;\n//#endregion\n//#region useBroadcastChannel/index.d.ts\ninterface UseBroadcastChannelOptions extends ConfigurableWindow {\n  /**\n   * The name of the channel.\n   */\n  name: string;\n}\n/**\n * Reactive BroadcastChannel\n *\n * @see https://vueuse.org/useBroadcastChannel\n * @see https://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel\n * @param options\n *\n */\ndeclare function useBroadcastChannel<D, P$1>(options: UseBroadcastChannelOptions): UseBroadcastChannelReturn<D, P$1>;\ninterface UseBroadcastChannelReturn<D, P$1> extends Supportable {\n  channel: Ref<BroadcastChannel | undefined>;\n  data: Ref<D>;\n  post: (data: P$1) => void;\n  close: () => void;\n  error: ShallowRef<Event | null>;\n  isClosed: ShallowRef<boolean>;\n}\n//#endregion\n//#region useBrowserLocation/index.d.ts\ninterface UseBrowserLocationOptions extends ConfigurableWindow {}\ninterface BrowserLocationState {\n  readonly trigger: string;\n  readonly state?: any;\n  readonly length?: number;\n  readonly origin?: string;\n  hash?: string;\n  host?: string;\n  hostname?: string;\n  href?: string;\n  pathname?: string;\n  port?: string;\n  protocol?: string;\n  search?: string;\n}\ntype UseBrowserLocationReturn = Ref<BrowserLocationState>;\n/**\n * Reactive browser location.\n *\n * @see https://vueuse.org/useBrowserLocation\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useBrowserLocation(options?: UseBrowserLocationOptions): UseBrowserLocationReturn;\n//#endregion\n//#region useCached/index.d.ts\ninterface UseCachedOptions<D extends boolean = true> extends ConfigurableDeepRefs<D>, WatchOptions {}\ndeclare function useCached<T, D extends boolean = true>(refValue: Ref<T>, comparator?: (a: T, b: T) => boolean, options?: UseCachedOptions<D>): UseCachedReturn<T, D>;\ntype UseCachedReturn<T = any, D extends boolean = true> = ShallowOrDeepRef<T, D>;\n//#endregion\n//#region useClipboard/index.d.ts\ninterface UseClipboardOptions<Source> extends ConfigurableNavigator {\n  /**\n   * Enabled reading for clipboard\n   *\n   * @default false\n   */\n  read?: boolean;\n  /**\n   * Copy source\n   */\n  source?: Source;\n  /**\n   * Milliseconds to reset state of `copied` ref\n   *\n   * @default 1500\n   */\n  copiedDuring?: number;\n  /**\n   * Whether fallback to document.execCommand('copy') if clipboard is undefined.\n   *\n   * @default false\n   */\n  legacy?: boolean;\n}\ninterface UseClipboardReturn<Optional> extends Supportable {\n  text: Readonly<ShallowRef<string>>;\n  copied: Readonly<ShallowRef<boolean>>;\n  copy: Optional extends true ? (text?: string) => Promise<void> : (text: string) => Promise<void>;\n}\n/**\n * Reactive Clipboard API.\n *\n * @see https://vueuse.org/useClipboard\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useClipboard(options?: UseClipboardOptions<undefined>): UseClipboardReturn<false>;\ndeclare function useClipboard(options: UseClipboardOptions<MaybeRefOrGetter<string>>): UseClipboardReturn<true>;\n//#endregion\n//#region useClipboardItems/index.d.ts\ninterface UseClipboardItemsOptions<Source> extends ConfigurableNavigator {\n  /**\n   * Enabled reading for clipboard\n   *\n   * @default false\n   */\n  read?: boolean;\n  /**\n   * Copy source\n   */\n  source?: Source;\n  /**\n   * Milliseconds to reset state of `copied` ref\n   *\n   * @default 1500\n   */\n  copiedDuring?: number;\n}\ninterface UseClipboardItemsReturn<Optional> extends Supportable {\n  content: Readonly<Ref<ClipboardItems>>;\n  copied: Readonly<ShallowRef<boolean>>;\n  copy: Optional extends true ? (content?: ClipboardItems) => Promise<void> : (text: ClipboardItems) => Promise<void>;\n  read: () => void;\n}\n/**\n * Reactive Clipboard API.\n *\n * @see https://vueuse.org/useClipboardItems\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useClipboardItems(options?: UseClipboardItemsOptions<undefined>): UseClipboardItemsReturn<false>;\ndeclare function useClipboardItems(options: UseClipboardItemsOptions<MaybeRefOrGetter<ClipboardItems>>): UseClipboardItemsReturn<true>;\n//#endregion\n//#region useCloned/index.d.ts\ninterface UseClonedOptions<T = any> extends WatchOptions {\n  /**\n   * Custom clone function.\n   *\n   * By default, it use `JSON.parse(JSON.stringify(value))` to clone.\n   */\n  clone?: (source: T) => T;\n  /**\n   * Manually sync the ref\n   *\n   * @default false\n   */\n  manual?: boolean;\n}\ninterface UseClonedReturn<T> {\n  /**\n   * Cloned ref\n   */\n  cloned: Ref<T>;\n  /**\n   * Ref indicates whether the cloned data is modified\n   */\n  isModified: Ref<boolean>;\n  /**\n   * Sync cloned data with source manually\n   */\n  sync: () => void;\n}\ntype CloneFn<F, T = F> = (x: F) => T;\ndeclare function cloneFnJSON<T>(source: T): T;\ndeclare function useCloned<T>(source: MaybeRefOrGetter<T>, options?: UseClonedOptions): UseClonedReturn<T>;\n//#endregion\n//#region ssr-handlers.d.ts\ninterface StorageLikeAsync {\n  getItem: (key: string) => Awaitable<string | null>;\n  setItem: (key: string, value: string) => Awaitable<void>;\n  removeItem: (key: string) => Awaitable<void>;\n}\ninterface StorageLike {\n  getItem: (key: string) => string | null;\n  setItem: (key: string, value: string) => void;\n  removeItem: (key: string) => void;\n}\n/**\n * @experimental The API is not finalized yet. It might not follow semver.\n */\ninterface SSRHandlersMap {\n  getDefaultStorage: () => StorageLike | undefined;\n  getDefaultStorageAsync: () => StorageLikeAsync | undefined;\n  updateHTMLAttrs: (selector: string | MaybeElementRef, attribute: string, value: string) => void;\n}\ndeclare function getSSRHandler<T extends keyof SSRHandlersMap>(key: T, fallback: SSRHandlersMap[T]): SSRHandlersMap[T];\ndeclare function getSSRHandler<T extends keyof SSRHandlersMap>(key: T, fallback: SSRHandlersMap[T] | undefined): SSRHandlersMap[T] | undefined;\ndeclare function setSSRHandler<T extends keyof SSRHandlersMap>(key: T, fn: SSRHandlersMap[T]): void;\n//#endregion\n//#region useStorage/index.d.ts\ninterface Serializer<T> {\n  read: (raw: string) => T;\n  write: (value: T) => string;\n}\ninterface SerializerAsync<T> {\n  read: (raw: string) => Awaitable<T>;\n  write: (value: T) => Awaitable<string>;\n}\ndeclare const StorageSerializers: Record<'boolean' | 'object' | 'number' | 'any' | 'string' | 'map' | 'set' | 'date', Serializer<any>>;\ndeclare const customStorageEventName = \"vueuse-storage\";\ninterface StorageEventLike {\n  storageArea: StorageLike | null;\n  key: StorageEvent['key'];\n  oldValue: StorageEvent['oldValue'];\n  newValue: StorageEvent['newValue'];\n}\ninterface UseStorageOptions<T> extends ConfigurableEventFilter, ConfigurableWindow, ConfigurableFlush {\n  /**\n   * Watch for deep changes\n   *\n   * @default true\n   */\n  deep?: boolean;\n  /**\n   * Listen to storage changes, useful for multiple tabs application\n   *\n   * @default true\n   */\n  listenToStorageChanges?: boolean;\n  /**\n   * Write the default value to the storage when it does not exist\n   *\n   * @default true\n   */\n  writeDefaults?: boolean;\n  /**\n   * Merge the default value with the value read from the storage.\n   *\n   * When setting it to true, it will perform a **shallow merge** for objects.\n   * You can pass a function to perform custom merge (e.g. deep merge), for example:\n   *\n   * @default false\n   */\n  mergeDefaults?: boolean | ((storageValue: T, defaults: T) => T);\n  /**\n   * Custom data serialization\n   */\n  serializer?: Serializer<T>;\n  /**\n   * On error callback\n   *\n   * Default log error to `console.error`\n   */\n  onError?: (error: unknown) => void;\n  /**\n   * Use shallow ref as reference\n   *\n   * @default false\n   */\n  shallow?: boolean;\n  /**\n   * Wait for the component to be mounted before reading the storage.\n   *\n   * @default false\n   */\n  initOnMounted?: boolean;\n}\ndeclare function useStorage(key: MaybeRefOrGetter<string>, defaults: MaybeRefOrGetter<string>, storage?: StorageLike, options?: UseStorageOptions<string>): RemovableRef<string>;\ndeclare function useStorage(key: MaybeRefOrGetter<string>, defaults: MaybeRefOrGetter<boolean>, storage?: StorageLike, options?: UseStorageOptions<boolean>): RemovableRef<boolean>;\ndeclare function useStorage(key: MaybeRefOrGetter<string>, defaults: MaybeRefOrGetter<number>, storage?: StorageLike, options?: UseStorageOptions<number>): RemovableRef<number>;\ndeclare function useStorage<T>(key: MaybeRefOrGetter<string>, defaults: MaybeRefOrGetter<T>, storage?: StorageLike, options?: UseStorageOptions<T>): RemovableRef<T>;\ndeclare function useStorage<T = unknown>(key: MaybeRefOrGetter<string>, defaults: MaybeRefOrGetter<null>, storage?: StorageLike, options?: UseStorageOptions<T>): RemovableRef<T>;\n//#endregion\n//#region useColorMode/index.d.ts\ntype BasicColorMode = 'light' | 'dark';\ntype BasicColorSchema = BasicColorMode | 'auto';\ninterface UseColorModeOptions<T extends string = BasicColorMode> extends UseStorageOptions<T | BasicColorMode> {\n  /**\n   * CSS Selector for the target element applying to\n   *\n   * @default 'html'\n   */\n  selector?: string | MaybeElementRef;\n  /**\n   * HTML attribute applying the target element\n   *\n   * @default 'class'\n   */\n  attribute?: string;\n  /**\n   * The initial color mode\n   *\n   * @default 'auto'\n   */\n  initialValue?: MaybeRefOrGetter<T | BasicColorSchema>;\n  /**\n   * Prefix when adding value to the attribute\n   */\n  modes?: Partial<Record<T | BasicColorSchema, string>>;\n  /**\n   * A custom handler for handle the updates.\n   * When specified, the default behavior will be overridden.\n   *\n   * @default undefined\n   */\n  onChanged?: (mode: T | BasicColorMode, defaultHandler: ((mode: T | BasicColorMode) => void)) => void;\n  /**\n   * Custom storage ref\n   *\n   * When provided, `useStorage` will be skipped\n   */\n  storageRef?: Ref<T | BasicColorSchema>;\n  /**\n   * Key to persist the data into localStorage/sessionStorage.\n   *\n   * Pass `null` to disable persistence\n   *\n   * @default 'vueuse-color-scheme'\n   */\n  storageKey?: string | null;\n  /**\n   * Storage object, can be localStorage or sessionStorage\n   *\n   * @default localStorage\n   */\n  storage?: StorageLike;\n  /**\n   * Emit `auto` mode from state\n   *\n   * When set to `true`, preferred mode won't be translated into `light` or `dark`.\n   * This is useful when the fact that `auto` mode was selected needs to be known.\n   *\n   * @default undefined\n   * @deprecated use `store.value` when `auto` mode needs to be known\n   * @see https://vueuse.org/core/useColorMode/#advanced-usage\n   */\n  emitAuto?: boolean;\n  /**\n   * Disable transition on switch\n   *\n   * @see https://paco.me/writing/disable-theme-transitions\n   * @default true\n   */\n  disableTransition?: boolean;\n}\ntype UseColorModeReturn<T extends string = BasicColorMode> = Ref<T | BasicColorSchema> & {\n  store: Ref<T | BasicColorSchema>;\n  system: ComputedRef<BasicColorMode>;\n  state: ComputedRef<T | BasicColorMode>;\n};\n/**\n * Reactive color mode with auto data persistence.\n *\n * @see https://vueuse.org/useColorMode\n * @param options\n */\ndeclare function useColorMode<T extends string = BasicColorMode>(options?: UseColorModeOptions<T>): UseColorModeReturn<T>;\n//#endregion\n//#region useConfirmDialog/index.d.ts\ntype UseConfirmDialogRevealResult<C, D> = {\n  data?: C;\n  isCanceled: false;\n} | {\n  data?: D;\n  isCanceled: true;\n};\ninterface UseConfirmDialogReturn<RevealData, ConfirmData, CancelData> {\n  /**\n   * Revealing state\n   */\n  isRevealed: ComputedRef<boolean>;\n  /**\n   * Opens the dialog.\n   * Create promise and return it. Triggers `onReveal` hook.\n   */\n  reveal: (data?: RevealData) => Promise<UseConfirmDialogRevealResult<ConfirmData, CancelData>>;\n  /**\n   * Confirms and closes the dialog. Triggers a callback inside `onConfirm` hook.\n   * Resolves promise from `reveal()` with `data` and `isCanceled` ref with `false` value.\n   * Can accept any data and to pass it to `onConfirm` hook.\n   */\n  confirm: (data?: ConfirmData) => void;\n  /**\n   * Cancels and closes the dialog. Triggers a callback inside `onCancel` hook.\n   * Resolves promise from `reveal()` with `data` and `isCanceled` ref with `true` value.\n   * Can accept any data and to pass it to `onCancel` hook.\n   */\n  cancel: (data?: CancelData) => void;\n  /**\n   * Event Hook to be triggered right before dialog creating.\n   */\n  onReveal: EventHookOn<RevealData>;\n  /**\n   * Event Hook to be called on `confirm()`.\n   * Gets data object from `confirm` function.\n   */\n  onConfirm: EventHookOn<ConfirmData>;\n  /**\n   * Event Hook to be called on `cancel()`.\n   * Gets data object from `cancel` function.\n   */\n  onCancel: EventHookOn<CancelData>;\n}\n/**\n * Hooks for creating confirm dialogs. Useful for modal windows, popups and logins.\n *\n * @see https://vueuse.org/useConfirmDialog/\n * @param revealed `boolean` `ref` that handles a modal window\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useConfirmDialog<RevealData = any, ConfirmData = any, CancelData = any>(revealed?: ShallowRef<boolean>): UseConfirmDialogReturn<RevealData, ConfirmData, CancelData>;\n//#endregion\n//#region useCountdown/index.d.ts\ninterface UseCountdownOptions extends ConfigurableScheduler {\n  /**\n   *  Interval for the countdown in milliseconds. Default is 1000ms.\n   *\n   * @deprecated Please use `scheduler` option instead\n   */\n  interval?: MaybeRefOrGetter<number>;\n  /**\n   * Callback function called when the countdown reaches 0.\n   */\n  onComplete?: () => void;\n  /**\n   * Callback function called on each tick of the countdown.\n   */\n  onTick?: () => void;\n  /**\n   * Start the countdown immediately\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default false\n   */\n  immediate?: boolean;\n}\ninterface UseCountdownReturn extends Pausable {\n  /**\n   * Current countdown value.\n   */\n  remaining: ShallowRef<number>;\n  /**\n   * Resets the countdown and repeatsLeft to their initial values.\n   */\n  reset: (countdown?: MaybeRefOrGetter<number>) => void;\n  /**\n   * Stops the countdown and resets its state.\n   */\n  stop: () => void;\n  /**\n   * Reset the countdown and start it again.\n   */\n  start: (countdown?: MaybeRefOrGetter<number>) => void;\n}\n/**\n * Reactive countdown timer in seconds.\n *\n * @param initialCountdown\n * @param options\n *\n * @see https://vueuse.org/useCountdown\n */\ndeclare function useCountdown(initialCountdown: MaybeRefOrGetter<number>, options?: UseCountdownOptions): UseCountdownReturn;\n//#endregion\n//#region useCssSupports/index.d.ts\ninterface UseCssSupportsOptions extends ConfigurableWindow {\n  ssrValue?: boolean;\n}\ninterface UseCssSupportsReturn extends Supportable {}\ndeclare function useCssSupports(property: MaybeRefOrGetter<string>, value: MaybeRefOrGetter<string>, options?: UseCssSupportsOptions): UseCssSupportsReturn;\ndeclare function useCssSupports(conditionText: MaybeRefOrGetter<string>, options?: UseCssSupportsOptions): UseCssSupportsReturn;\n//#endregion\n//#region useCssVar/index.d.ts\ninterface UseCssVarOptions extends ConfigurableWindow {\n  initialValue?: string;\n  /**\n   * Use MutationObserver to monitor variable changes\n   * @default false\n   */\n  observe?: boolean;\n}\n/**\n * Manipulate CSS variables.\n *\n * @see https://vueuse.org/useCssVar\n * @param prop\n * @param target\n * @param options\n */\ndeclare function useCssVar(prop: MaybeRefOrGetter<string | null | undefined>, target?: MaybeElementRef, options?: UseCssVarOptions): vue0.ShallowRef<string | undefined, string | undefined>;\n//#endregion\n//#region useCurrentElement/index.d.ts\ndeclare function useCurrentElement<T extends MaybeElement = MaybeElement, R$1 extends VueInstance = VueInstance, E extends MaybeElement = (MaybeElement extends T ? IsAny<R$1['$el']> extends false ? R$1['$el'] : T : T)>(rootComponent?: MaybeElementRef<R$1>): _vueuse_shared0.ComputedRefWithControl<E>;\n//#endregion\n//#region useCycleList/index.d.ts\ninterface UseCycleListOptions<T> {\n  /**\n   * The initial value of the state.\n   * A ref can be provided to reuse.\n   */\n  initialValue?: MaybeRef<T>;\n  /**\n   * The default index when\n   */\n  fallbackIndex?: number;\n  /**\n   * Custom function to get the index of the current value.\n   */\n  getIndexOf?: (value: T, list: T[]) => number;\n}\n/**\n * Cycle through a list of items\n *\n * @see https://vueuse.org/useCycleList\n */\ndeclare function useCycleList<T>(list: MaybeRefOrGetter<T[]>, options?: UseCycleListOptions<T>): UseCycleListReturn<T>;\ninterface UseCycleListReturn<T> {\n  state: ShallowRef<T>;\n  index: WritableComputedRef<number>;\n  next: (n?: number) => T;\n  prev: (n?: number) => T;\n  /**\n   * Go to a specific index\n   */\n  go: (i: number) => T;\n}\n//#endregion\n//#region useDark/index.d.ts\ninterface UseDarkOptions extends Omit<UseColorModeOptions<BasicColorSchema>, 'modes' | 'onChanged'> {\n  /**\n   * Value applying to the target element when isDark=true\n   *\n   * @default 'dark'\n   */\n  valueDark?: string;\n  /**\n   * Value applying to the target element when isDark=false\n   *\n   * @default ''\n   */\n  valueLight?: string;\n  /**\n   * A custom handler for handle the updates.\n   * When specified, the default behavior will be overridden.\n   *\n   * @default undefined\n   */\n  onChanged?: (isDark: boolean, defaultHandler: ((mode: BasicColorSchema) => void), mode: BasicColorSchema) => void;\n}\ntype UseDarkReturn = WritableComputedRef<boolean>;\n/**\n * Reactive dark mode with auto data persistence.\n *\n * @see https://vueuse.org/useDark\n * @param options\n */\ndeclare function useDark(options?: UseDarkOptions): UseDarkReturn;\n//#endregion\n//#region useManualRefHistory/index.d.ts\ninterface UseRefHistoryRecord<T> {\n  snapshot: T;\n  timestamp: number;\n}\ninterface UseManualRefHistoryOptions<Raw, Serialized = Raw> {\n  /**\n   * Maximum number of history to be kept. Default to unlimited.\n   */\n  capacity?: number;\n  /**\n   * Clone when taking a snapshot, shortcut for dump: JSON.parse(JSON.stringify(value)).\n   * Default to false\n   *\n   * @default false\n   */\n  clone?: boolean | CloneFn<Raw>;\n  /**\n   * Serialize data into the history\n   */\n  dump?: (v: Raw) => Serialized;\n  /**\n   * Deserialize data from the history\n   */\n  parse?: (v: Serialized) => Raw;\n  /**\n   * set data source\n   */\n  setSource?: (source: Ref<Raw>, v: Raw) => void;\n}\ninterface UseManualRefHistoryReturn<Raw, Serialized> {\n  /**\n   * Bypassed tracking ref from the argument\n   */\n  source: Ref<Raw>;\n  /**\n   * An array of history records for undo, newest comes to first\n   */\n  history: Ref<UseRefHistoryRecord<Serialized>[]>;\n  /**\n   * Last history point, source can be different if paused\n   */\n  last: Ref<UseRefHistoryRecord<Serialized>>;\n  /**\n   * Same as {@link UseManualRefHistoryReturn.history | history}\n   */\n  undoStack: Ref<UseRefHistoryRecord<Serialized>[]>;\n  /**\n   * Records array for redo\n   */\n  redoStack: Ref<UseRefHistoryRecord<Serialized>[]>;\n  /**\n   * A ref representing if undo is possible (non empty undoStack)\n   */\n  canUndo: ComputedRef<boolean>;\n  /**\n   * A ref representing if redo is possible (non empty redoStack)\n   */\n  canRedo: ComputedRef<boolean>;\n  /**\n   * Undo changes\n   */\n  undo: () => void;\n  /**\n   * Redo changes\n   */\n  redo: () => void;\n  /**\n   * Clear all the history\n   */\n  clear: () => void;\n  /**\n   * Create a new history record\n   */\n  commit: () => void;\n  /**\n   * Reset ref's value with latest history\n   */\n  reset: () => void;\n}\n/**\n * Track the change history of a ref, also provides undo and redo functionality.\n *\n * @see https://vueuse.org/useManualRefHistory\n * @param source\n * @param options\n */\ndeclare function useManualRefHistory<Raw, Serialized = Raw>(source: Ref<Raw>, options?: UseManualRefHistoryOptions<Raw, Serialized>): UseManualRefHistoryReturn<Raw, Serialized>;\n//#endregion\n//#region useRefHistory/index.d.ts\ninterface UseRefHistoryOptions<Raw, Serialized = Raw> extends ConfigurableEventFilter, ConfigurableFlush {\n  /**\n   * Watch for deep changes, default to false\n   *\n   * When set to true, it will also create clones for values store in the history\n   *\n   * @default false\n   */\n  deep?: boolean;\n  /**\n   * Maximum number of history to be kept. Default to unlimited.\n   */\n  capacity?: number;\n  /**\n   * Clone when taking a snapshot, shortcut for dump: JSON.parse(JSON.stringify(value)).\n   * Default to false\n   *\n   * @default false\n   */\n  clone?: boolean | CloneFn<Raw>;\n  /**\n   * Serialize data into the history\n   */\n  dump?: (v: Raw) => Serialized;\n  /**\n   * Deserialize data from the history\n   */\n  parse?: (v: Serialized) => Raw;\n  /**\n   * Function to determine if the commit should proceed\n   * @param oldValue Previous value\n   * @param newValue New value\n   * @returns boolean indicating if commit should proceed\n   */\n  shouldCommit?: (oldValue: Raw | undefined, newValue: Raw) => boolean;\n}\ninterface UseRefHistoryReturn<Raw, Serialized> extends UseManualRefHistoryReturn<Raw, Serialized> {\n  /**\n   * A ref representing if the tracking is enabled\n   */\n  isTracking: Ref<boolean>;\n  /**\n   * Pause change tracking\n   */\n  pause: () => void;\n  /**\n   * Resume change tracking\n   *\n   * @param [commit] if true, a history record will be create after resuming\n   */\n  resume: (commit?: boolean) => void;\n  /**\n   * A sugar for auto pause and auto resuming within a function scope\n   *\n   * @param fn\n   */\n  batch: (fn: (cancel: Fn) => void) => void;\n  /**\n   * Clear the data and stop the watch\n   */\n  dispose: () => void;\n}\n/**\n * Track the change history of a ref, also provides undo and redo functionality.\n *\n * @see https://vueuse.org/useRefHistory\n * @param source\n * @param options\n */\ndeclare function useRefHistory<Raw, Serialized = Raw>(source: Ref<Raw>, options?: UseRefHistoryOptions<Raw, Serialized>): UseRefHistoryReturn<Raw, Serialized>;\n//#endregion\n//#region useDebouncedRefHistory/index.d.ts\n/**\n * Shorthand for [useRefHistory](https://vueuse.org/useRefHistory) with debounce filter.\n *\n * @see https://vueuse.org/useDebouncedRefHistory\n * @param source\n * @param options\n */\ndeclare function useDebouncedRefHistory<Raw, Serialized = Raw>(source: Ref<Raw>, options?: Omit<UseRefHistoryOptions<Raw, Serialized>, 'eventFilter'> & {\n  debounce?: MaybeRefOrGetter<number>;\n}): UseRefHistoryReturn<Raw, Serialized>;\n//#endregion\n//#region useDeviceMotion/index.d.ts\ninterface UseDeviceMotionOptions extends ConfigurableWindow, ConfigurableEventFilter {\n  /**\n   * Request for permissions immediately if it's not granted,\n   * otherwise label and deviceIds could be empty\n   *\n   * @default false\n   */\n  requestPermissions?: boolean;\n}\n/** @deprecated use {@link UseDeviceMotionOptions} instead */\ntype DeviceMotionOptions = UseDeviceMotionOptions;\ninterface UseDeviceMotionReturn extends Supportable {\n  acceleration: Ref<DeviceMotionEventAcceleration | null>;\n  accelerationIncludingGravity: Ref<DeviceMotionEventAcceleration | null>;\n  rotationRate: Ref<DeviceMotionEventRotationRate | null>;\n  interval: ShallowRef<number>;\n  requirePermissions: ComputedRef<boolean>;\n  ensurePermissions: () => Promise<void>;\n  permissionGranted: ShallowRef<boolean>;\n}\n/**\n * Reactive DeviceMotionEvent.\n *\n * @see https://vueuse.org/useDeviceMotion\n * @param options\n */\ndeclare function useDeviceMotion(options?: UseDeviceMotionOptions): UseDeviceMotionReturn;\n//#endregion\n//#region useDeviceOrientation/index.d.ts\ninterface UseDeviceOrientationOptions extends ConfigurableWindow {}\ninterface UseDeviceOrientationReturn extends Supportable {\n  isAbsolute: ShallowRef<boolean, boolean>;\n  alpha: Ref<number | null, number | null>;\n  beta: Ref<number | null, number | null>;\n  gamma: Ref<number | null, number | null>;\n}\n/**\n * Reactive DeviceOrientationEvent.\n *\n * @see https://vueuse.org/useDeviceOrientation\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useDeviceOrientation(options?: UseDeviceOrientationOptions): UseDeviceOrientationReturn;\n//#endregion\n//#region useDevicePixelRatio/index.d.ts\ninterface UseDevicePixelRatioOptions extends ConfigurableWindow {}\ninterface UseDevicePixelRatioReturn {\n  pixelRatio: ShallowRef<number>;\n  stop: WatchStopHandle;\n}\n/**\n * Reactively track `window.devicePixelRatio`.\n *\n * @see https://vueuse.org/useDevicePixelRatio\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useDevicePixelRatio(options?: UseDevicePixelRatioOptions): UseDevicePixelRatioReturn;\n//#endregion\n//#region useDevicesList/index.d.ts\ninterface UseDevicesListOptions extends ConfigurableNavigator {\n  onUpdated?: (devices: MediaDeviceInfo[]) => void;\n  /**\n   * Request for permissions immediately if it's not granted,\n   * otherwise label and deviceIds could be empty\n   *\n   * @default false\n   */\n  requestPermissions?: boolean;\n  /**\n   * Request for types of media permissions\n   *\n   * @default { audio: true, video: true }\n   */\n  constraints?: MediaStreamConstraints;\n}\ninterface UseDevicesListReturn extends Supportable {\n  /**\n   * All devices\n   */\n  devices: Ref<MediaDeviceInfo[]>;\n  videoInputs: ComputedRef<MediaDeviceInfo[]>;\n  audioInputs: ComputedRef<MediaDeviceInfo[]>;\n  audioOutputs: ComputedRef<MediaDeviceInfo[]>;\n  permissionGranted: ShallowRef<boolean>;\n  ensurePermissions: () => Promise<boolean>;\n}\n/**\n * Reactive `enumerateDevices` listing available input/output devices\n *\n * @see https://vueuse.org/useDevicesList\n * @param options\n */\ndeclare function useDevicesList(options?: UseDevicesListOptions): UseDevicesListReturn;\n//#endregion\n//#region useDisplayMedia/index.d.ts\ninterface UseDisplayMediaOptions extends ConfigurableNavigator {\n  /**\n   * If the stream is enabled\n   * @default false\n   */\n  enabled?: MaybeRef<boolean>;\n  /**\n   * If the stream video media constraints\n   */\n  video?: boolean | MediaTrackConstraints | undefined;\n  /**\n   * If the stream audio media constraints\n   */\n  audio?: boolean | MediaTrackConstraints | undefined;\n}\ninterface UseDisplayMediaReturn extends Supportable {\n  stream: ShallowRef<MediaStream | undefined>;\n  start: () => Promise<MediaStream | undefined>;\n  stop: () => void;\n  enabled: ShallowRef<boolean>;\n}\n/**\n * Reactive `mediaDevices.getDisplayMedia` streaming\n *\n * @see https://vueuse.org/useDisplayMedia\n * @param options\n */\ndeclare function useDisplayMedia(options?: UseDisplayMediaOptions): UseDisplayMediaReturn;\n//#endregion\n//#region useDocumentVisibility/index.d.ts\ninterface UseDocumentVisibilityOptions extends ConfigurableDocument {}\ntype UseDocumentVisibilityReturn = ShallowRef<DocumentVisibilityState>;\n/**\n * Reactively track `document.visibilityState`.\n *\n * @see https://vueuse.org/useDocumentVisibility\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useDocumentVisibility(options?: UseDocumentVisibilityOptions): UseDocumentVisibilityReturn;\n//#endregion\n//#region useDraggable/index.d.ts\ninterface UseDraggableOptions {\n  /**\n   * Only start the dragging when click on the element directly\n   *\n   * @default false\n   */\n  exact?: MaybeRefOrGetter<boolean>;\n  /**\n   * Prevent events defaults\n   *\n   * @default false\n   */\n  preventDefault?: MaybeRefOrGetter<boolean>;\n  /**\n   * Prevent events propagation\n   *\n   * @default false\n   */\n  stopPropagation?: MaybeRefOrGetter<boolean>;\n  /**\n   * Whether dispatch events in capturing phase\n   *\n   * @default true\n   */\n  capture?: boolean;\n  /**\n   * Element to attach `pointermove` and `pointerup` events to.\n   *\n   * @default window\n   */\n  draggingElement?: MaybeRefOrGetter<HTMLElement | SVGElement | Window | Document | null | undefined>;\n  /**\n   * Element for calculating bounds (If not set, it will use the event's target).\n   *\n   * @default undefined\n   */\n  containerElement?: MaybeRefOrGetter<HTMLElement | SVGElement | null | undefined>;\n  /**\n   * Handle that triggers the drag event\n   *\n   * @default target\n   */\n  handle?: MaybeRefOrGetter<HTMLElement | SVGElement | null | undefined>;\n  /**\n   * Pointer types that listen to.\n   *\n   * @default ['mouse', 'touch', 'pen']\n   */\n  pointerTypes?: PointerType[];\n  /**\n   * Initial position of the element.\n   *\n   * @default { x: 0, y: 0 }\n   */\n  initialValue?: MaybeRefOrGetter<Position>;\n  /**\n   * Callback when the dragging starts. Return `false` to prevent dragging.\n   */\n  onStart?: (position: Position, event: PointerEvent) => void | false;\n  /**\n   * Callback during dragging.\n   */\n  onMove?: (position: Position, event: PointerEvent) => void;\n  /**\n   * Callback when dragging end.\n   */\n  onEnd?: (position: Position, event: PointerEvent) => void;\n  /**\n   * Axis to drag on.\n   *\n   * @default 'both'\n   */\n  axis?: 'x' | 'y' | 'both';\n  /**\n   * Disabled drag and drop.\n   *\n   * @default false\n   */\n  disabled?: MaybeRefOrGetter<boolean>;\n  /**\n   * Mouse buttons that are allowed to trigger drag events.\n   *\n   * - `0`: Main button, usually the left button or the un-initialized state\n   * - `1`: Auxiliary button, usually the wheel button or the middle button (if present)\n   * - `2`: Secondary button, usually the right button\n   * - `3`: Fourth button, typically the Browser Back button\n   * - `4`: Fifth button, typically the Browser Forward button\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button#value\n   * @default [0]\n   */\n  buttons?: MaybeRefOrGetter<number[]>;\n  /**\n   * Whether to restrict dragging within the visible area of the container.\n   *\n   * If enabled, the draggable element will not leave the visible area of its container,\n   * ensuring it remains within the viewport of the container during the drag.\n   *\n   * @default false\n   */\n  restrictInView?: MaybeRefOrGetter<boolean>;\n  /**\n   * Whether to enable auto-scroll when dragging near the edges.\n   *\n   * @default false\n   */\n  autoScroll?: MaybeRefOrGetter<boolean | {\n    /**\n     * Speed of auto-scroll.\n     *\n     * @default 2\n     */\n    speed?: MaybeRefOrGetter<number | Position>;\n    /**\n     * Margin from the edge to trigger auto-scroll.\n     *\n     * @default 30\n     */\n    margin?: MaybeRefOrGetter<number | Position>;\n    /**\n     * Direction of auto-scroll.\n     *\n     * @default 'both'\n     */\n    direction?: 'x' | 'y' | 'both';\n  }>;\n}\ninterface UseDraggableReturn {\n  x: Ref<number>;\n  y: Ref<number>;\n  position: Ref<Position>;\n  isDragging: ComputedRef<boolean>;\n  style: ComputedRef<string>;\n}\n/**\n * Make elements draggable.\n *\n * @see https://vueuse.org/useDraggable\n * @param target\n * @param options\n */\ndeclare function useDraggable(target: MaybeRefOrGetter<HTMLElement | SVGElement | null | undefined>, options?: UseDraggableOptions): UseDraggableReturn;\n//#endregion\n//#region useDropZone/index.d.ts\ninterface UseDropZoneReturn {\n  files: ShallowRef<File[] | null>;\n  isOverDropZone: ShallowRef<boolean>;\n}\ninterface UseDropZoneOptions {\n  /**\n   * Allowed data types, if not set, all data types are allowed.\n   * Also can be a function to check the data types.\n   */\n  dataTypes?: MaybeRef<readonly string[]> | ((types: readonly string[]) => boolean);\n  /**\n   * Similar to dataTypes, but exposes the DataTransferItemList for custom validation.\n   * If provided, this function takes precedence over dataTypes.\n   */\n  checkValidity?: (items: DataTransferItemList) => boolean;\n  onDrop?: (files: File[] | null, event: DragEvent) => void;\n  onEnter?: (files: File[] | null, event: DragEvent) => void;\n  onLeave?: (files: File[] | null, event: DragEvent) => void;\n  onOver?: (files: File[] | null, event: DragEvent) => void;\n  /**\n   * Allow multiple files to be dropped. Defaults to true.\n   */\n  multiple?: boolean;\n  /**\n   * Prevent default behavior for unhandled events. Defaults to false.\n   */\n  preventDefaultForUnhandled?: boolean;\n}\ndeclare function useDropZone(target: MaybeRefOrGetter<HTMLElement | Document | null | undefined>, options?: UseDropZoneOptions | UseDropZoneOptions['onDrop']): UseDropZoneReturn;\n//#endregion\n//#region useElementBounding/index.d.ts\ninterface UseElementBoundingOptions {\n  /**\n   * Reset values to 0 on component unmounted\n   *\n   * @default true\n   */\n  reset?: boolean;\n  /**\n   * Listen to window resize event\n   *\n   * @default true\n   */\n  windowResize?: boolean;\n  /**\n   * Listen to window scroll event\n   *\n   * @default true\n   */\n  windowScroll?: boolean;\n  /**\n   * Immediately call update on component mounted\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Timing to recalculate the bounding box\n   *\n   * Setting to `next-frame` can be useful when using this together with something like {@link useBreakpoints}\n   * and therefore the layout (which influences the bounding box of the observed element) is not updated on the current tick.\n   *\n   * @default 'sync'\n   */\n  updateTiming?: 'sync' | 'next-frame';\n}\ninterface UseElementBoundingReturn {\n  height: ShallowRef<number>;\n  bottom: ShallowRef<number>;\n  left: ShallowRef<number>;\n  right: ShallowRef<number>;\n  top: ShallowRef<number>;\n  width: ShallowRef<number>;\n  x: ShallowRef<number>;\n  y: ShallowRef<number>;\n  update: () => void;\n}\n/**\n * Reactive bounding box of an HTML element.\n *\n * @see https://vueuse.org/useElementBounding\n * @param target\n */\ndeclare function useElementBounding(target: MaybeComputedElementRef, options?: UseElementBoundingOptions): UseElementBoundingReturn;\n//#endregion\n//#region useElementByPoint/index.d.ts\ninterface UseElementByPointOptions<Multiple extends boolean = false> extends ConfigurableDocument, ConfigurableScheduler {\n  x: MaybeRefOrGetter<number>;\n  y: MaybeRefOrGetter<number>;\n  multiple?: MaybeRefOrGetter<Multiple>;\n  /** @deprecated Please use `scheduler` option instead */\n  immediate?: boolean;\n  /** @deprecated Please use `scheduler` option instead */\n  interval?: 'requestAnimationFrame' | number;\n}\ninterface UseElementByPointReturn<Multiple extends boolean = false> extends Supportable, Pausable {\n  element: ShallowRef<Multiple extends true ? HTMLElement[] : HTMLElement | null>;\n}\n/**\n * Reactive element by point.\n *\n * @see https://vueuse.org/useElementByPoint\n * @param options - UseElementByPointOptions\n */\ndeclare function useElementByPoint<M extends boolean = false>(options: UseElementByPointOptions<M>): UseElementByPointReturn<M>;\n//#endregion\n//#region useElementHover/index.d.ts\ninterface UseElementHoverOptions extends ConfigurableWindow {\n  delayEnter?: number;\n  delayLeave?: number;\n  triggerOnRemoval?: boolean;\n}\ndeclare function useElementHover(el: MaybeRefOrGetter<EventTarget | null | undefined>, options?: UseElementHoverOptions): ShallowRef<boolean>;\n//#endregion\n//#region useResizeObserver/index.d.ts\n/**\n * @deprecated This interface is now available in the DOM lib.\n * Use the global {@link globalThis.ResizeObserverSize} instead.\n */\ninterface ResizeObserverSize {\n  readonly inlineSize: number;\n  readonly blockSize: number;\n}\n/**\n * @deprecated This interface is now available in the DOM lib.\n * Use the global {@link globalThis.ResizeObserverEntry} instead.\n */\ninterface ResizeObserverEntry {\n  readonly target: Element;\n  readonly contentRect: DOMRectReadOnly;\n  readonly borderBoxSize: ReadonlyArray<ResizeObserverSize>;\n  readonly contentBoxSize: ReadonlyArray<ResizeObserverSize>;\n  readonly devicePixelContentBoxSize: ReadonlyArray<ResizeObserverSize>;\n}\n/**\n * @deprecated This interface is now available in the DOM lib.\n * Use the global {@link globalThis.ResizeObserverCallback} instead.\n */\ntype ResizeObserverCallback = (entries: ReadonlyArray<ResizeObserverEntry>, observer: ResizeObserver) => void;\ninterface UseResizeObserverOptions extends ResizeObserverOptions, ConfigurableWindow {}\ninterface UseResizeObserverReturn extends Supportable {\n  stop: () => void;\n}\n/**\n * Reports changes to the dimensions of an Element's content or the border-box\n *\n * @see https://vueuse.org/useResizeObserver\n * @param target\n * @param callback\n * @param options\n */\ndeclare function useResizeObserver(target: MaybeComputedElementRef | MaybeComputedElementRef[] | MaybeRefOrGetter<MaybeElement[]>, callback: globalThis.ResizeObserverCallback, options?: UseResizeObserverOptions): UseResizeObserverReturn;\n//#endregion\n//#region useElementSize/index.d.ts\ninterface ElementSize {\n  width: number;\n  height: number;\n}\ninterface UseElementSizeOptions extends UseResizeObserverOptions {}\ninterface UseElementSizeReturn {\n  width: ShallowRef<number>;\n  height: ShallowRef<number>;\n  stop: () => void;\n}\n/**\n * Reactive size of an HTML element.\n *\n * @see https://vueuse.org/useElementSize\n */\ndeclare function useElementSize(target: MaybeComputedElementRef, initialSize?: ElementSize, options?: UseElementSizeOptions): UseElementSizeReturn;\n//#endregion\n//#region useIntersectionObserver/index.d.ts\ninterface UseIntersectionObserverOptions extends ConfigurableWindow {\n  /**\n   * Start the IntersectionObserver immediately on creation\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * The Element or Document whose bounds are used as the bounding box when testing for intersection.\n   */\n  root?: MaybeComputedElementRef | Document;\n  /**\n   * A string which specifies a set of offsets to add to the root's bounding_box when calculating intersections.\n   */\n  rootMargin?: MaybeRefOrGetter<string>;\n  /**\n   * Either a single number or an array of numbers between 0.0 and 1.\n   * @default 0\n   */\n  threshold?: number | number[];\n}\ninterface UseIntersectionObserverReturn extends Supportable, Pausable {\n  stop: () => void;\n}\n/**\n * Detects that a target element's visibility.\n *\n * @see https://vueuse.org/useIntersectionObserver\n * @param target\n * @param callback\n * @param options\n */\ndeclare function useIntersectionObserver(target: MaybeComputedElementRef | MaybeRefOrGetter<MaybeElement[]> | MaybeComputedElementRef[], callback: IntersectionObserverCallback, options?: UseIntersectionObserverOptions): UseIntersectionObserverReturn;\n//#endregion\n//#region useElementVisibility/index.d.ts\ninterface UseElementVisibilityOptions extends ConfigurableWindow, Pick<UseIntersectionObserverOptions, 'rootMargin' | 'threshold'> {\n  /**\n   * Initial value.\n   *\n   * @default false\n   */\n  initialValue?: boolean;\n  /**\n   * The element that is used as the viewport for checking visibility of the target.\n   */\n  scrollTarget?: UseIntersectionObserverOptions['root'];\n  /**\n   * Stop tracking when element visibility changes for the first time\n   *\n   * @default false\n   */\n  once?: boolean;\n}\ntype UseElementVisibilityReturn = ShallowRef<boolean>;\n/**\n * Tracks the visibility of an element within the viewport.\n *\n * @see https://vueuse.org/useElementVisibility\n */\ndeclare function useElementVisibility(element: MaybeComputedElementRef, options?: UseElementVisibilityOptions): UseElementVisibilityReturn;\n//#endregion\n//#region useEventBus/index.d.ts\ntype EventBusListener<T = unknown, P$1 = any> = (event: T, payload?: P$1) => void;\ntype EventBusEvents<T, P$1 = any> = Set<EventBusListener<T, P$1>>;\ninterface EventBusKey<T> extends Symbol {}\ntype EventBusIdentifier<T = unknown> = EventBusKey<T> | string | number;\ninterface UseEventBusReturn<T, P$1> {\n  /**\n   * Subscribe to an event. When calling emit, the listeners will execute.\n   * @param listener watch listener.\n   * @returns a stop function to remove the current callback.\n   */\n  on: (listener: EventBusListener<T, P$1>) => Fn;\n  /**\n   * Similar to `on`, but only fires once\n   * @param listener watch listener.\n   * @returns a stop function to remove the current callback.\n   */\n  once: (listener: EventBusListener<T, P$1>) => Fn;\n  /**\n   * Emit an event, the corresponding event listeners will execute.\n   * @param event data sent.\n   */\n  emit: (event?: T, payload?: P$1) => void;\n  /**\n   * Remove the corresponding listener.\n   * @param listener watch listener.\n   */\n  off: (listener: EventBusListener<T>) => void;\n  /**\n   * Clear all events\n   */\n  reset: () => void;\n}\ndeclare function useEventBus<T = unknown, P$1 = any>(key: EventBusIdentifier<T>): UseEventBusReturn<T, P$1>;\n//#endregion\n//#region useEventListener/index.d.ts\ninterface InferEventTarget<Events> {\n  addEventListener: (event: Events, fn?: any, options?: any) => any;\n  removeEventListener: (event: Events, fn?: any, options?: any) => any;\n}\ntype WindowEventName = keyof WindowEventMap;\ntype DocumentEventName = keyof DocumentEventMap;\ntype ShadowRootEventName = keyof ShadowRootEventMap;\ninterface GeneralEventListener<E = Event> {\n  (evt: E): void;\n}\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 1: Omitted Window target\n *\n * @see https://vueuse.org/useEventListener\n */\ndeclare function useEventListener<E extends keyof WindowEventMap>(event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Window, ev: WindowEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 2: Explicitly Window target\n *\n * @see https://vueuse.org/useEventListener\n * @param target\n * @param event\n * @param listener\n * @param options\n */\ndeclare function useEventListener<E extends keyof WindowEventMap>(target: Window, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Window, ev: WindowEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 3: Explicitly Document target\n *\n * @see https://vueuse.org/useEventListener\n */\ndeclare function useEventListener<E extends keyof DocumentEventMap>(target: Document, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Document, ev: DocumentEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 4: Explicitly ShadowRoot target\n *\n * @see https://vueuse.org/useEventListener\n */\ndeclare function useEventListener<E extends keyof ShadowRootEventMap>(target: MaybeRefOrGetter<Arrayable<ShadowRoot> | null | undefined>, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: ShadowRoot, ev: ShadowRootEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 5: Explicitly HTMLElement target\n *\n * @see https://vueuse.org/useEventListener\n */\ndeclare function useEventListener<E extends keyof HTMLElementEventMap>(target: MaybeRefOrGetter<Arrayable<HTMLElement> | null | undefined>, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<(this: HTMLElement, ev: HTMLElementEventMap[E]) => any>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 6: Custom event target with event type infer\n *\n * @see https://vueuse.org/useEventListener\n */\ndeclare function useEventListener<Names extends string, EventType = Event>(target: MaybeRefOrGetter<Arrayable<InferEventTarget<Names>> | null | undefined>, event: MaybeRefOrGetter<Arrayable<Names>>, listener: MaybeRef<Arrayable<GeneralEventListener<EventType>>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 7: Custom event target fallback\n *\n * @see https://vueuse.org/useEventListener\n */\ndeclare function useEventListener<EventType = Event>(target: MaybeRefOrGetter<Arrayable<EventTarget> | null | undefined>, event: MaybeRefOrGetter<Arrayable<string>>, listener: MaybeRef<Arrayable<GeneralEventListener<EventType>>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n//#endregion\n//#region useEventSource/index.d.ts\ntype EventSourceStatus = 'CONNECTING' | 'OPEN' | 'CLOSED';\ninterface UseEventSourceOptions<Data> extends EventSourceInit {\n  /**\n   * Enabled auto reconnect\n   *\n   * @default false\n   */\n  autoReconnect?: boolean | {\n    /**\n     * Maximum retry times.\n     *\n     * Or you can pass a predicate function (which returns true if you want to retry).\n     *\n     * @default -1\n     */\n    retries?: number | (() => boolean);\n    /**\n     * Delay for reconnect, in milliseconds\n     *\n     * @default 1000\n     */\n    delay?: number;\n    /**\n     * On maximum retry times reached.\n     */\n    onFailed?: Fn;\n  };\n  /**\n   * Immediately open the connection when calling this composable\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Automatically connect to the websocket when URL changes\n   *\n   * @default true\n   */\n  autoConnect?: boolean;\n  /**\n   * Custom data serialization\n   */\n  serializer?: {\n    read: (v?: string) => Data;\n  };\n}\ninterface UseEventSourceReturn<Events extends string[], Data = any> {\n  /**\n   * Reference to the latest data received via the EventSource,\n   * can be watched to respond to incoming messages\n   */\n  data: ShallowRef<Data | null>;\n  /**\n   * The current state of the connection, can be only one of:\n   * 'CONNECTING', 'OPEN' 'CLOSED'\n   */\n  status: ShallowRef<EventSourceStatus>;\n  /**\n   * The latest named event\n   */\n  event: ShallowRef<Events[number] | null>;\n  /**\n   * The current error\n   */\n  error: ShallowRef<Event | null>;\n  /**\n   * Closes the EventSource connection gracefully.\n   */\n  close: EventSource['close'];\n  /**\n   * Reopen the EventSource connection.\n   * If there the current one is active, will close it before opening a new one.\n   */\n  open: Fn;\n  /**\n   * Reference to the current EventSource instance.\n   */\n  eventSource: Ref<EventSource | null>;\n  /**\n   * The last event ID string, for server-sent events.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent/lastEventId\n   */\n  lastEventId: ShallowRef<string | null>;\n}\n/**\n * Reactive wrapper for EventSource.\n *\n * @see https://vueuse.org/useEventSource\n * @see https://developer.mozilla.org/en-US/docs/Web/API/EventSource/EventSource EventSource\n * @param url\n * @param events\n * @param options\n */\ndeclare function useEventSource<Events extends string[], Data = any>(url: MaybeRefOrGetter<string | URL | undefined>, events?: Events, options?: UseEventSourceOptions<Data>): UseEventSourceReturn<Events, Data>;\n//#endregion\n//#region useEyeDropper/index.d.ts\ninterface EyeDropperOpenOptions {\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal\n   */\n  signal?: AbortSignal;\n}\ninterface EyeDropper {\n  new (): EyeDropper;\n  open: (options?: EyeDropperOpenOptions) => Promise<{\n    sRGBHex: string;\n  }>;\n  [Symbol.toStringTag]: 'EyeDropper';\n}\ninterface UseEyeDropperOptions {\n  /**\n   * Initial sRGBHex.\n   *\n   * @default ''\n   */\n  initialValue?: string;\n}\ninterface UseEyeDropperReturn extends Supportable {\n  sRGBHex: ShallowRef<string>;\n  open: (openOptions?: EyeDropperOpenOptions) => Promise<{\n    sRGBHex: string;\n  } | undefined>;\n}\n/**\n * Reactive [EyeDropper API](https://developer.mozilla.org/en-US/docs/Web/API/EyeDropper_API)\n *\n * @see https://vueuse.org/useEyeDropper\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useEyeDropper(options?: UseEyeDropperOptions): UseEyeDropperReturn;\n//#endregion\n//#region useFavicon/index.d.ts\ninterface UseFaviconOptions extends ConfigurableDocument {\n  baseUrl?: string;\n  rel?: string;\n}\ntype UseFaviconReturn = ComputedRef<string | null | undefined> | Ref<string | null | undefined>;\n/**\n * Reactive favicon.\n *\n * @see https://vueuse.org/useFavicon\n * @param newIcon\n * @param options\n */\ndeclare function useFavicon(newIcon: ReadonlyRefOrGetter<string | null | undefined>, options?: UseFaviconOptions): ComputedRef<string | null | undefined>;\ndeclare function useFavicon(newIcon?: MaybeRef<string | null | undefined>, options?: UseFaviconOptions): Ref<string | null | undefined>;\n//#endregion\n//#region useFetch/index.d.ts\ninterface UseFetchReturn<T> {\n  /**\n   * Indicates if the fetch request has finished\n   */\n  isFinished: Readonly<ShallowRef<boolean>>;\n  /**\n   * The statusCode of the HTTP fetch response\n   */\n  statusCode: ShallowRef<number | null>;\n  /**\n   * The raw response of the fetch response\n   */\n  response: ShallowRef<Response | null>;\n  /**\n   * Any fetch errors that may have occurred\n   */\n  error: ShallowRef<any>;\n  /**\n   * The fetch response body on success, may either be JSON or text\n   */\n  data: ShallowRef<T | null>;\n  /**\n   * Indicates if the request is currently being fetched.\n   */\n  isFetching: Readonly<ShallowRef<boolean>>;\n  /**\n   * Indicates if the fetch request is able to be aborted\n   */\n  canAbort: ComputedRef<boolean>;\n  /**\n   * Indicates if the fetch request was aborted\n   */\n  aborted: ShallowRef<boolean>;\n  /**\n   * Abort the fetch request\n   */\n  abort: (reason?: any) => void;\n  /**\n   * Manually call the fetch\n   * (default not throwing error)\n   */\n  execute: (throwOnFailed?: boolean) => Promise<any>;\n  /**\n   * Fires after the fetch request has finished\n   */\n  onFetchResponse: EventHookOn<Response>;\n  /**\n   * Fires after a fetch request error\n   */\n  onFetchError: EventHookOn;\n  /**\n   * Fires after a fetch has completed\n   */\n  onFetchFinally: EventHookOn;\n  get: () => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  post: (payload?: MaybeRefOrGetter<unknown>, type?: string) => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  put: (payload?: MaybeRefOrGetter<unknown>, type?: string) => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  delete: (payload?: MaybeRefOrGetter<unknown>, type?: string) => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  patch: (payload?: MaybeRefOrGetter<unknown>, type?: string) => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  head: (payload?: MaybeRefOrGetter<unknown>, type?: string) => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  options: (payload?: MaybeRefOrGetter<unknown>, type?: string) => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  json: <JSON = any>() => UseFetchReturn<JSON> & PromiseLike<UseFetchReturn<JSON>>;\n  text: () => UseFetchReturn<string> & PromiseLike<UseFetchReturn<string>>;\n  blob: () => UseFetchReturn<Blob> & PromiseLike<UseFetchReturn<Blob>>;\n  arrayBuffer: () => UseFetchReturn<ArrayBuffer> & PromiseLike<UseFetchReturn<ArrayBuffer>>;\n  formData: () => UseFetchReturn<FormData> & PromiseLike<UseFetchReturn<FormData>>;\n}\ntype Combination = 'overwrite' | 'chain';\ninterface BeforeFetchContext {\n  /**\n   * The computed url of the current request\n   */\n  url: string;\n  /**\n   * The request options of the current request\n   */\n  options: RequestInit;\n  /**\n   * Cancels the current request\n   */\n  cancel: Fn;\n}\ninterface AfterFetchContext<T = any> {\n  response: Response;\n  data: T | null;\n  context: BeforeFetchContext;\n  execute: (throwOnFailed?: boolean) => Promise<any>;\n}\ninterface OnFetchErrorContext<T = any, E = any> {\n  error: E;\n  data: T | null;\n  response: Response | null;\n  context: BeforeFetchContext;\n  execute: (throwOnFailed?: boolean) => Promise<any>;\n}\ninterface UseFetchOptions {\n  /**\n   * Fetch function\n   */\n  fetch?: typeof window.fetch;\n  /**\n   * Will automatically run fetch when `useFetch` is used\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Will automatically refetch when:\n   * - the URL is changed if the URL is a ref\n   * - the payload is changed if the payload is a ref\n   *\n   * @default false\n   */\n  refetch?: MaybeRefOrGetter<boolean>;\n  /**\n   * Initial data before the request finished\n   *\n   * @default null\n   */\n  initialData?: any;\n  /**\n   * Timeout for abort request after number of millisecond\n   * `0` means use browser default\n   *\n   * @default 0\n   */\n  timeout?: number;\n  /**\n   * Allow update the `data` ref when fetch error whenever provided, or mutated in the `onFetchError` callback\n   *\n   * @default false\n   */\n  updateDataOnError?: boolean;\n  /**\n   * Will run immediately before the fetch request is dispatched\n   */\n  beforeFetch?: (ctx: BeforeFetchContext) => Promise<Partial<BeforeFetchContext> | void> | Partial<BeforeFetchContext> | void;\n  /**\n   * Will run immediately after the fetch request is returned.\n   * Runs after any 2xx response\n   */\n  afterFetch?: (ctx: AfterFetchContext) => Promise<Partial<AfterFetchContext>> | Partial<AfterFetchContext>;\n  /**\n   * Will run immediately after the fetch request is returned.\n   * Runs after any 4xx and 5xx response\n   */\n  onFetchError?: (ctx: OnFetchErrorContext) => Promise<Partial<OnFetchErrorContext>> | Partial<OnFetchErrorContext>;\n}\ninterface CreateFetchOptions {\n  /**\n   * The base URL that will be prefixed to all urls unless urls are absolute\n   */\n  baseUrl?: MaybeRefOrGetter<string>;\n  /**\n   * Determine the inherit behavior for beforeFetch, afterFetch, onFetchError\n   * @default 'chain'\n   */\n  combination?: Combination;\n  /**\n   * Default Options for the useFetch function\n   */\n  options?: UseFetchOptions;\n  /**\n   * Options for the fetch request\n   */\n  fetchOptions?: RequestInit;\n}\ndeclare function createFetch(config?: CreateFetchOptions): typeof useFetch;\ndeclare function useFetch<T>(url: MaybeRefOrGetter<string>): UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\ndeclare function useFetch<T>(url: MaybeRefOrGetter<string>, useFetchOptions: UseFetchOptions): UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\ndeclare function useFetch<T>(url: MaybeRefOrGetter<string>, options: RequestInit, useFetchOptions?: UseFetchOptions): UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n//#endregion\n//#region useFileDialog/index.d.ts\ninterface UseFileDialogOptions extends ConfigurableDocument {\n  /**\n   * @default true\n   */\n  multiple?: MaybeRef<boolean>;\n  /**\n   * @default '*'\n   */\n  accept?: MaybeRef<string>;\n  /**\n   * Select the input source for the capture file.\n   * @see [HTMLInputElement Capture](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/capture)\n   */\n  capture?: MaybeRef<string>;\n  /**\n   * Reset when open file dialog.\n   * @default false\n   */\n  reset?: MaybeRef<boolean>;\n  /**\n   * Select directories instead of files.\n   * @see [HTMLInputElement webkitdirectory](https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/webkitdirectory)\n   * @default false\n   */\n  directory?: MaybeRef<boolean>;\n  /**\n   * Initial files to set.\n   * @default null\n   */\n  initialFiles?: Array<File> | FileList;\n  /**\n   * The input element to use for file dialog.\n   * @default document.createElement('input')\n   */\n  input?: MaybeElementRef<HTMLInputElement>;\n}\ninterface UseFileDialogReturn {\n  files: Ref<FileList | null>;\n  open: (localOptions?: Partial<UseFileDialogOptions>) => void;\n  reset: () => void;\n  onChange: EventHookOn<FileList | null>;\n  onCancel: EventHookOn;\n}\n/**\n * Open file dialog with ease.\n *\n * @see https://vueuse.org/useFileDialog\n * @param options\n */\ndeclare function useFileDialog(options?: UseFileDialogOptions): UseFileDialogReturn;\n//#endregion\n//#region useFileSystemAccess/index.d.ts\n/**\n * window.showOpenFilePicker parameters\n * @see https://developer.mozilla.org/en-US/docs/Web/API/window/showOpenFilePicker#parameters\n */\ninterface FileSystemAccessShowOpenFileOptions {\n  multiple?: boolean;\n  types?: Array<{\n    description?: string;\n    accept: Record<string, string[]>;\n  }>;\n  excludeAcceptAllOption?: boolean;\n}\n/**\n * window.showSaveFilePicker parameters\n * @see https://developer.mozilla.org/en-US/docs/Web/API/window/showSaveFilePicker#parameters\n */\ninterface FileSystemAccessShowSaveFileOptions {\n  suggestedName?: string;\n  types?: Array<{\n    description?: string;\n    accept: Record<string, string[]>;\n  }>;\n  excludeAcceptAllOption?: boolean;\n}\n/**\n * FileHandle\n * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemFileHandle\n */\ninterface FileSystemFileHandle {\n  getFile: () => Promise<File>;\n  createWritable: () => FileSystemWritableFileStream;\n}\n/**\n * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream\n */\ninterface FileSystemWritableFileStream extends WritableStream {\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream/write\n   */\n  write: FileSystemWritableFileStreamWrite;\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream/seek\n   */\n  seek: (position: number) => Promise<void>;\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream/truncate\n   */\n  truncate: (size: number) => Promise<void>;\n}\n/**\n * FileStream.write\n * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream/write\n */\ninterface FileSystemWritableFileStreamWrite {\n  (data: string | BufferSource | Blob): Promise<void>;\n  (options: {\n    type: 'write';\n    position: number;\n    data: string | BufferSource | Blob;\n  }): Promise<void>;\n  (options: {\n    type: 'seek';\n    position: number;\n  }): Promise<void>;\n  (options: {\n    type: 'truncate';\n    size: number;\n  }): Promise<void>;\n}\n/**\n * FileStream.write\n * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream/write\n */\ntype FileSystemAccessWindow = Window & {\n  showSaveFilePicker: (options: FileSystemAccessShowSaveFileOptions) => Promise<FileSystemFileHandle>;\n  showOpenFilePicker: (options: FileSystemAccessShowOpenFileOptions) => Promise<FileSystemFileHandle[]>;\n};\ntype UseFileSystemAccessCommonOptions = Pick<FileSystemAccessShowOpenFileOptions, 'types' | 'excludeAcceptAllOption'>;\ntype UseFileSystemAccessShowSaveFileOptions = Pick<FileSystemAccessShowSaveFileOptions, 'suggestedName'>;\ntype UseFileSystemAccessOptions = ConfigurableWindow & UseFileSystemAccessCommonOptions & {\n  /**\n   * file data type\n   */\n  dataType?: MaybeRefOrGetter<'Text' | 'ArrayBuffer' | 'Blob'>;\n};\n/**\n * Create and read and write local files.\n * @see https://vueuse.org/useFileSystemAccess\n */\ndeclare function useFileSystemAccess(): UseFileSystemAccessReturn<string | ArrayBuffer | Blob>;\ndeclare function useFileSystemAccess(options: UseFileSystemAccessOptions & {\n  dataType: 'Text';\n}): UseFileSystemAccessReturn<string>;\ndeclare function useFileSystemAccess(options: UseFileSystemAccessOptions & {\n  dataType: 'ArrayBuffer';\n}): UseFileSystemAccessReturn<ArrayBuffer>;\ndeclare function useFileSystemAccess(options: UseFileSystemAccessOptions & {\n  dataType: 'Blob';\n}): UseFileSystemAccessReturn<Blob>;\ndeclare function useFileSystemAccess(options: UseFileSystemAccessOptions): UseFileSystemAccessReturn<string | ArrayBuffer | Blob>;\ninterface UseFileSystemAccessReturn<T = string> extends Supportable {\n  data: ShallowRef<T | undefined>;\n  file: ShallowRef<File | undefined>;\n  fileName: ComputedRef<string>;\n  fileMIME: ComputedRef<string>;\n  fileSize: ComputedRef<number>;\n  fileLastModified: ComputedRef<number>;\n  open: (_options?: UseFileSystemAccessCommonOptions) => Awaitable<void>;\n  create: (_options?: UseFileSystemAccessShowSaveFileOptions) => Awaitable<void>;\n  save: (_options?: UseFileSystemAccessShowSaveFileOptions) => Awaitable<void>;\n  saveAs: (_options?: UseFileSystemAccessShowSaveFileOptions) => Awaitable<void>;\n  updateData: () => Awaitable<void>;\n}\n//#endregion\n//#region useFocus/index.d.ts\ninterface UseFocusOptions extends ConfigurableWindow {\n  /**\n   * Initial value. If set true, then focus will be set on the target\n   *\n   * @default false\n   */\n  initialValue?: boolean;\n  /**\n   * Replicate the :focus-visible behavior of CSS\n   *\n   * @default false\n   */\n  focusVisible?: boolean;\n  /**\n   * Prevent scrolling to the element when it is focused.\n   *\n   * @default false\n   */\n  preventScroll?: boolean;\n}\ninterface UseFocusReturn {\n  /**\n   * If read as true, then the element has focus. If read as false, then the element does not have focus\n   * If set to true, then the element will be focused. If set to false, the element will be blurred.\n   */\n  focused: WritableComputedRef<boolean>;\n}\n/**\n * Track or set the focus state of a DOM element.\n *\n * @see https://vueuse.org/useFocus\n * @param target The target element for the focus and blur events.\n * @param options\n */\ndeclare function useFocus(target: MaybeElementRef, options?: UseFocusOptions): UseFocusReturn;\n//#endregion\n//#region useFocusWithin/index.d.ts\ninterface UseFocusWithinReturn {\n  /**\n   * True if the element or any of its descendants are focused\n   */\n  focused: ComputedRef<boolean>;\n}\n/**\n * Track if focus is contained within the target element\n *\n * @see https://vueuse.org/useFocusWithin\n * @param target The target element to track\n * @param options Focus within options\n */\ndeclare function useFocusWithin(target: MaybeElementRef, options?: ConfigurableWindow): UseFocusWithinReturn;\n//#endregion\n//#region useFps/index.d.ts\ninterface UseFpsOptions {\n  /**\n   * Calculate the FPS on every x frames.\n   * @default 10\n   */\n  every?: number;\n}\ndeclare function useFps(options?: UseFpsOptions): ShallowRef<number>;\n//#endregion\n//#region useFullscreen/index.d.ts\ninterface UseFullscreenOptions extends ConfigurableDocument {\n  /**\n   * Automatically exit fullscreen when component is unmounted\n   *\n   * @default false\n   */\n  autoExit?: boolean;\n}\ninterface UseFullscreenReturn extends Supportable {\n  isFullscreen: ShallowRef<boolean>;\n  enter: () => Promise<void>;\n  exit: () => Promise<void>;\n  toggle: () => Promise<void>;\n}\n/**\n * Reactive Fullscreen API.\n *\n * @see https://vueuse.org/useFullscreen\n * @param target\n * @param options\n */\ndeclare function useFullscreen(target?: MaybeElementRef, options?: UseFullscreenOptions): UseFullscreenReturn;\n//#endregion\n//#region useGamepad/index.d.ts\ninterface UseGamepadOptions extends ConfigurableWindow, ConfigurableNavigator {}\ninterface UseGamepadReturn extends Supportable, Pausable {\n  onConnected: EventHookOn<number>;\n  onDisconnected: EventHookOn<number>;\n  gamepads: Ref<Gamepad[]>;\n}\n/**\n * Maps a standard standard gamepad to an Xbox 360 Controller.\n */\ndeclare function mapGamepadToXbox360Controller(gamepad: Ref<Gamepad | undefined>): vue0.ComputedRef<{\n  buttons: {\n    a: GamepadButton;\n    b: GamepadButton;\n    x: GamepadButton;\n    y: GamepadButton;\n  };\n  bumper: {\n    left: GamepadButton;\n    right: GamepadButton;\n  };\n  triggers: {\n    left: GamepadButton;\n    right: GamepadButton;\n  };\n  stick: {\n    left: {\n      horizontal: number;\n      vertical: number;\n      button: GamepadButton;\n    };\n    right: {\n      horizontal: number;\n      vertical: number;\n      button: GamepadButton;\n    };\n  };\n  dpad: {\n    up: GamepadButton;\n    down: GamepadButton;\n    left: GamepadButton;\n    right: GamepadButton;\n  };\n  back: GamepadButton;\n  start: GamepadButton;\n} | null>;\ndeclare function useGamepad(options?: UseGamepadOptions): UseGamepadReturn;\n//#endregion\n//#region useGeolocation/index.d.ts\ninterface UseGeolocationOptions extends Partial<PositionOptions>, ConfigurableNavigator {\n  immediate?: boolean;\n}\ninterface UseGeolocationReturn extends Supportable {\n  coords: Ref<Omit<GeolocationPosition['coords'], 'toJSON'>>;\n  locatedAt: ShallowRef<number | null>;\n  error: ShallowRef<GeolocationPositionError | null>;\n  resume: () => void;\n  pause: () => void;\n}\n/**\n * Reactive Geolocation API.\n *\n * @see https://vueuse.org/useGeolocation\n * @param options\n */\ndeclare function useGeolocation(options?: UseGeolocationOptions): UseGeolocationReturn;\n//#endregion\n//#region useIdle/index.d.ts\ninterface UseIdleOptions extends ConfigurableWindow, ConfigurableEventFilter {\n  /**\n   * Event names that listen to for detected user activity\n   *\n   * @default ['mousemove', 'mousedown', 'resize', 'keydown', 'touchstart', 'wheel']\n   */\n  events?: WindowEventName[];\n  /**\n   * Listen for document visibility change\n   *\n   * @default true\n   */\n  listenForVisibilityChange?: boolean;\n  /**\n   * Initial state of the ref idle\n   *\n   * @default false\n   */\n  initialState?: boolean;\n}\ninterface UseIdleReturn extends Stoppable {\n  idle: ShallowRef<boolean>;\n  lastActive: ShallowRef<number>;\n  reset: () => void;\n}\n/**\n * Tracks whether the user is being inactive.\n *\n * @see https://vueuse.org/useIdle\n * @param timeout default to 1 minute\n * @param options IdleOptions\n */\ndeclare function useIdle(timeout?: number, options?: UseIdleOptions): UseIdleReturn;\n//#endregion\n//#region useImage/index.d.ts\ninterface UseImageOptions {\n  /** Address of the resource */\n  src: string;\n  /** Images to use in different situations, e.g., high-resolution displays, small monitors, etc. */\n  srcset?: string;\n  /** Image sizes for different page layouts */\n  sizes?: string;\n  /** Image alternative information */\n  alt?: string;\n  /** Image classes */\n  class?: string;\n  /** Image loading */\n  loading?: HTMLImageElement['loading'];\n  /** Image CORS settings */\n  crossorigin?: string;\n  /** Referrer policy for fetch https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy */\n  referrerPolicy?: HTMLImageElement['referrerPolicy'];\n  /** Image width */\n  width?: HTMLImageElement['width'];\n  /** Image height */\n  height?: HTMLImageElement['height'];\n  /** https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#decoding */\n  decoding?: HTMLImageElement['decoding'];\n  /** Provides a hint of the relative priority to use when fetching the image */\n  fetchPriority?: HTMLImageElement['fetchPriority'];\n  /** Provides a hint of the importance of the image */\n  ismap?: HTMLImageElement['isMap'];\n  /** The partial URL (starting with #) of an image map associated with the element */\n  usemap?: HTMLImageElement['useMap'];\n}\ntype UseImageReturn = UseAsyncStateReturn<HTMLImageElement | undefined, any[], true>;\n/**\n * Reactive load an image in the browser, you can wait the result to display it or show a fallback.\n *\n * @see https://vueuse.org/useImage\n * @param options Image attributes, as used in the <img> tag\n * @param asyncStateOptions\n */\ndeclare function useImage<Shallow extends true>(options: MaybeRefOrGetter<UseImageOptions>, asyncStateOptions?: UseAsyncStateOptions<Shallow>): UseImageReturn;\n//#endregion\n//#region useScroll/index.d.ts\ninterface UseScrollOptions extends ConfigurableWindow {\n  /**\n   * Throttle time for scroll event, it’s disabled by default.\n   *\n   * @default 0\n   */\n  throttle?: number;\n  /**\n   * The check time when scrolling ends.\n   * This configuration will be setting to (throttle + idle) when the `throttle` is configured.\n   *\n   * @default 200\n   */\n  idle?: number;\n  /**\n   * Offset arrived states by x pixels\n   *\n   */\n  offset?: {\n    left?: number;\n    right?: number;\n    top?: number;\n    bottom?: number;\n  };\n  /**\n   * Use MutationObserver to monitor specific DOM changes,\n   * such as attribute modifications, child node additions or removals, or subtree changes.\n   * @default { mutation: boolean }\n   */\n  observe?: boolean | {\n    mutation?: boolean;\n  };\n  /**\n   * Trigger it when scrolling.\n   *\n   */\n  onScroll?: (e: Event) => void;\n  /**\n   * Trigger it when scrolling ends.\n   *\n   */\n  onStop?: (e: Event) => void;\n  /**\n   * Listener options for scroll event.\n   *\n   * @default {capture: false, passive: true}\n   */\n  eventListenerOptions?: boolean | AddEventListenerOptions;\n  /**\n   * Optionally specify a scroll behavior of `auto` (default, not smooth scrolling) or\n   * `smooth` (for smooth scrolling) which takes effect when changing the `x` or `y` refs.\n   *\n   * @default 'auto'\n   */\n  behavior?: MaybeRefOrGetter<ScrollBehavior>;\n  /**\n   * On error callback\n   *\n   * Default log error to `console.error`\n   */\n  onError?: (error: unknown) => void;\n}\ninterface UseScrollReturn {\n  x: WritableComputedRef<number>;\n  y: WritableComputedRef<number>;\n  isScrolling: ShallowRef<boolean>;\n  arrivedState: {\n    left: boolean;\n    right: boolean;\n    top: boolean;\n    bottom: boolean;\n  };\n  directions: {\n    left: boolean;\n    right: boolean;\n    top: boolean;\n    bottom: boolean;\n  };\n  measure: () => void;\n}\n/**\n * Reactive scroll.\n *\n * @see https://vueuse.org/useScroll\n * @param element\n * @param options\n */\ndeclare function useScroll(element: MaybeRefOrGetter<HTMLElement | SVGElement | Window | Document | null | undefined>, options?: UseScrollOptions): UseScrollReturn;\n//#endregion\n//#region useInfiniteScroll/index.d.ts\ntype InfiniteScrollElement = HTMLElement | SVGElement | Window | Document | null | undefined;\ninterface UseInfiniteScrollOptions<T extends InfiniteScrollElement = InfiniteScrollElement> extends UseScrollOptions {\n  /**\n   * The minimum distance between the bottom of the element and the bottom of the viewport\n   *\n   * @default 0\n   */\n  distance?: number;\n  /**\n   * The direction in which to listen the scroll.\n   *\n   * @default 'bottom'\n   */\n  direction?: 'top' | 'bottom' | 'left' | 'right';\n  /**\n   * The interval time between two load more (to avoid too many invokes).\n   *\n   * @default 100\n   */\n  interval?: number;\n  /**\n   * A function that determines whether more content can be loaded for a specific element.\n   * Should return `true` if loading more content is allowed for the given element,\n   * and `false` otherwise.\n   */\n  canLoadMore?: (el: T) => boolean;\n}\ninterface UseInfiniteScrollReturn {\n  isLoading: ComputedRef<boolean>;\n  reset: () => void;\n}\n/**\n * Reactive infinite scroll.\n *\n * @see https://vueuse.org/useInfiniteScroll\n */\ndeclare function useInfiniteScroll<T extends InfiniteScrollElement>(element: MaybeRefOrGetter<T>, onLoadMore: (state: UnwrapNestedRefs<UseScrollReturn>) => Awaitable<void>, options?: UseInfiniteScrollOptions<T>): UseInfiniteScrollReturn;\n//#endregion\n//#region useKeyModifier/index.d.ts\ntype KeyModifier = 'Alt' | 'AltGraph' | 'CapsLock' | 'Control' | 'Fn' | 'FnLock' | 'Meta' | 'NumLock' | 'ScrollLock' | 'Shift' | 'Symbol' | 'SymbolLock';\ninterface UseModifierOptions<Initial> extends ConfigurableDocument {\n  /**\n   * Event names that will prompt update to modifier states\n   *\n   * @default ['mousedown', 'mouseup', 'keydown', 'keyup']\n   */\n  events?: WindowEventName[];\n  /**\n   * Initial value of the returned ref\n   *\n   * @default null\n   */\n  initial?: Initial;\n}\ntype UseKeyModifierReturn<Initial> = ShallowRef<Initial extends boolean ? boolean : boolean | null>;\ndeclare function useKeyModifier<Initial extends boolean | null>(modifier: KeyModifier, options?: UseModifierOptions<Initial>): UseKeyModifierReturn<Initial>;\n//#endregion\n//#region useLocalStorage/index.d.ts\ndeclare function useLocalStorage(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<string>, options?: UseStorageOptions<string>): RemovableRef<string>;\ndeclare function useLocalStorage(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<boolean>, options?: UseStorageOptions<boolean>): RemovableRef<boolean>;\ndeclare function useLocalStorage(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<number>, options?: UseStorageOptions<number>): RemovableRef<number>;\ndeclare function useLocalStorage<T>(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<T>, options?: UseStorageOptions<T>): RemovableRef<T>;\ndeclare function useLocalStorage<T = unknown>(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<null>, options?: UseStorageOptions<T>): RemovableRef<T>;\n//#endregion\n//#region useMagicKeys/aliasMap.d.ts\ndeclare const DefaultMagicKeysAliasMap: Readonly<Record<string, string>>;\n//#endregion\n//#region useMagicKeys/index.d.ts\ninterface UseMagicKeysOptions<Reactive extends boolean> {\n  /**\n   * Returns a reactive object instead of an object of refs\n   *\n   * @default false\n   */\n  reactive?: Reactive;\n  /**\n   * Target for listening events\n   *\n   * @default window\n   */\n  target?: MaybeRefOrGetter<EventTarget>;\n  /**\n   * Alias map for keys, all the keys should be lowercase\n   * { target: keycode }\n   *\n   * @example { ctrl: \"control\" }\n   * @default <predefined-map>\n   */\n  aliasMap?: Record<string, string>;\n  /**\n   * Register passive listener\n   *\n   * @default true\n   */\n  passive?: boolean;\n  /**\n   * Custom event handler for keydown/keyup event.\n   * Useful when you want to apply custom logic.\n   *\n   * When using `e.preventDefault()`, you will need to pass `passive: false` to useMagicKeys().\n   */\n  onEventFired?: (e: KeyboardEvent) => void | boolean;\n}\ninterface MagicKeysInternal {\n  /**\n   * A Set of currently pressed keys,\n   * Stores raw keyCodes.\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key\n   */\n  current: Set<string>;\n}\ntype UseMagicKeysReturn<Reactive extends boolean> = Readonly<Record<string, Reactive extends true ? boolean : ComputedRef<boolean>> & MagicKeysInternal>;\n/**\n * Reactive keys pressed state, with magical keys combination support.\n *\n * @see https://vueuse.org/useMagicKeys\n */\ndeclare function useMagicKeys<T extends boolean = false>(options?: UseMagicKeysOptions<T>): UseMagicKeysReturn<T>;\n//#endregion\n//#region useMediaControls/index.d.ts\n/**\n * Many of the jsdoc definitions here are modified version of the\n * documentation from MDN(https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)\n */\ninterface UseMediaSource {\n  /**\n   * The source url for the media\n   */\n  src: string;\n  /**\n   * The media codec type\n   */\n  type?: string;\n  /**\n   * Specifies the media query for the resource's intended media.\n   */\n  media?: string;\n}\ninterface UseMediaTextTrackSource {\n  /**\n   * Indicates that the track should be enabled unless the user's preferences indicate\n   * that another track is more appropriate\n   */\n  default?: boolean;\n  /**\n   * How the text track is meant to be used. If omitted the default kind is subtitles.\n   */\n  kind: TextTrackKind;\n  /**\n   * A user-readable title of the text track which is used by the browser\n   * when listing available text tracks.\n   */\n  label: string;\n  /**\n   * Address of the track (.vtt file). Must be a valid URL. This attribute\n   * must be specified and its URL value must have the same origin as the document\n   */\n  src: string;\n  /**\n   * Language of the track text data. It must be a valid BCP 47 language tag.\n   * If the kind attribute is set to subtitles, then srclang must be defined.\n   */\n  srcLang: string;\n}\ninterface UseMediaControlsOptions extends ConfigurableDocument {\n  /**\n   * The source for the media, may either be a string, a `UseMediaSource` object, or a list\n   * of `UseMediaSource` objects.\n   */\n  src?: MaybeRefOrGetter<string | UseMediaSource | UseMediaSource[]>;\n  /**\n   * A list of text tracks for the media\n   */\n  tracks?: MaybeRefOrGetter<UseMediaTextTrackSource[]>;\n}\ninterface UseMediaTextTrack {\n  /**\n   * The index of the text track\n   */\n  id: number;\n  /**\n   * The text track label\n   */\n  label: string;\n  /**\n   * Language of the track text data. It must be a valid BCP 47 language tag.\n   * If the kind attribute is set to subtitles, then srclang must be defined.\n   */\n  language: string;\n  /**\n   * Specifies the display mode of the text track, either `disabled`,\n   * `hidden`, or `showing`\n   */\n  mode: TextTrackMode;\n  /**\n   * How the text track is meant to be used. If omitted the default kind is subtitles.\n   */\n  kind: TextTrackKind;\n  /**\n   * Indicates the track's in-band metadata track dispatch type.\n   */\n  inBandMetadataTrackDispatchType: string;\n  /**\n   * A list of text track cues\n   */\n  cues: TextTrackCueList | null;\n  /**\n   * A list of active text track cues\n   */\n  activeCues: TextTrackCueList | null;\n}\ninterface UseMediaControlsReturn {\n  currentTime: ShallowRef<number>;\n  duration: ShallowRef<number>;\n  waiting: ShallowRef<boolean>;\n  seeking: ShallowRef<boolean>;\n  ended: ShallowRef<boolean>;\n  stalled: ShallowRef<boolean>;\n  buffered: Ref<[number, number][]>;\n  playing: ShallowRef<boolean>;\n  rate: ShallowRef<number>;\n  volume: ShallowRef<number>;\n  muted: ShallowRef<boolean>;\n  tracks: Ref<UseMediaTextTrack[]>;\n  selectedTrack: ShallowRef<number>;\n  enableTrack: (track: number | UseMediaTextTrack, disableTracks?: boolean) => void;\n  disableTrack: (track?: number | UseMediaTextTrack) => void;\n  supportsPictureInPicture: boolean;\n  togglePictureInPicture: () => Promise<PictureInPictureWindow | void>;\n  isPictureInPicture: ShallowRef<boolean>;\n  onSourceError: EventHookOn<Event>;\n  onPlaybackError: EventHookOn<Event>;\n}\ndeclare function useMediaControls(target: MaybeRef<HTMLMediaElement | null | undefined>, options?: UseMediaControlsOptions): UseMediaControlsReturn;\n//#endregion\n//#region useMediaQuery/index.d.ts\n/**\n * Reactive Media Query.\n *\n * @see https://vueuse.org/useMediaQuery\n * @param query\n * @param options\n */\ndeclare function useMediaQuery(query: MaybeRefOrGetter<string>, options?: ConfigurableWindow & {\n  ssrWidth?: number;\n}): vue0.ComputedRef<boolean>;\n//#endregion\n//#region useMemoize/index.d.ts\ntype CacheKey = any;\n/**\n * Custom memoize cache handler\n */\ninterface UseMemoizeCache<Key, Value> {\n  /**\n   * Get value for key\n   */\n  get: (key: Key) => Value | undefined;\n  /**\n   * Set value for key\n   */\n  set: (key: Key, value: Value) => void;\n  /**\n   * Return flag if key exists\n   */\n  has: (key: Key) => boolean;\n  /**\n   * Delete value for key\n   */\n  delete: (key: Key) => void;\n  /**\n   * Clear cache\n   */\n  clear: () => void;\n}\n/**\n * Memoized function\n */\ninterface UseMemoizeReturn<Result, Args extends unknown[]> {\n  /**\n   * Get result from cache or call memoized function\n   */\n  (...args: Args): Result;\n  /**\n   * Call memoized function and update cache\n   */\n  load: (...args: Args) => Result;\n  /**\n   * Delete cache of given arguments\n   */\n  delete: (...args: Args) => void;\n  /**\n   * Clear cache\n   */\n  clear: () => void;\n  /**\n   * Generate cache key for given arguments\n   */\n  generateKey: (...args: Args) => CacheKey;\n  /**\n   * Cache container\n   */\n  cache: UseMemoizeCache<CacheKey, Result>;\n}\ninterface UseMemoizeOptions<Result, Args extends unknown[]> {\n  getKey?: (...args: Args) => string | number;\n  cache?: UseMemoizeCache<CacheKey, Result>;\n}\n/**\n * Reactive function result cache based on arguments\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useMemoize<Result, Args extends unknown[]>(resolver: (...args: Args) => Result, options?: UseMemoizeOptions<Result, Args>): UseMemoizeReturn<Result, Args>;\n//#endregion\n//#region useMemory/index.d.ts\n/**\n * Performance.memory\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Performance/memory\n */\ninterface MemoryInfo {\n  /**\n   * The maximum size of the heap, in bytes, that is available to the context.\n   */\n  readonly jsHeapSizeLimit: number;\n  /**\n   *  The total allocated heap size, in bytes.\n   */\n  readonly totalJSHeapSize: number;\n  /**\n   * The currently active segment of JS heap, in bytes.\n   */\n  readonly usedJSHeapSize: number;\n  [Symbol.toStringTag]: 'MemoryInfo';\n}\ninterface UseMemoryOptions extends ConfigurableScheduler {\n  /**\n   * Start the timer immediately\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Execute the callback immediately after calling `resume`\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default false\n   */\n  immediateCallback?: boolean;\n  /** @deprecated Please use `scheduler` option instead */\n  interval?: number;\n}\ninterface UseMemoryReturn extends Supportable {\n  memory: Ref<MemoryInfo | undefined>;\n}\n/**\n * Reactive Memory Info.\n *\n * @see https://vueuse.org/useMemory\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useMemory(options?: UseMemoryOptions): UseMemoryReturn;\n//#endregion\n//#region useMounted/index.d.ts\n/**\n * Mounted state in ref.\n *\n * @see https://vueuse.org/useMounted\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useMounted(): vue0.ShallowRef<boolean, boolean>;\n//#endregion\n//#region useMouse/index.d.ts\ntype UseMouseCoordType = 'page' | 'client' | 'screen' | 'movement';\ntype UseMouseSourceType = 'mouse' | 'touch' | null;\ntype UseMouseEventExtractor = (event: MouseEvent | Touch) => [x: number, y: number] | null | undefined;\ninterface UseMouseOptions extends ConfigurableWindow, ConfigurableEventFilter {\n  /**\n   * Mouse position based by page, client, screen, or relative to previous position\n   *\n   * @default 'page'\n   */\n  type?: UseMouseCoordType | UseMouseEventExtractor;\n  /**\n   * Listen events on `target` element\n   *\n   * @default 'Window'\n   */\n  target?: MaybeRefOrGetter<Window | EventTarget | null | undefined>;\n  /**\n   * Listen to `touchmove` events\n   *\n   * @default true\n   */\n  touch?: boolean;\n  /**\n   * Listen to `scroll` events on window, only effective on type `page`\n   *\n   * @default true\n   */\n  scroll?: boolean;\n  /**\n   * Reset to initial value when `touchend` event fired\n   *\n   * @default false\n   */\n  resetOnTouchEnds?: boolean;\n  /**\n   * Initial values\n   */\n  initialValue?: Position;\n}\ninterface UseMouseReturn {\n  x: ShallowRef<number>;\n  y: ShallowRef<number>;\n  sourceType: ShallowRef<UseMouseSourceType>;\n}\n/**\n * Reactive mouse position.\n *\n * @see https://vueuse.org/useMouse\n * @param options\n */\ndeclare function useMouse(options?: UseMouseOptions): UseMouseReturn;\n//#endregion\n//#region useMouseInElement/index.d.ts\ninterface MouseInElementOptions extends UseMouseOptions {\n  /**\n   * Whether to handle mouse events when the cursor is outside the target element.\n   * When enabled, mouse position will continue to be tracked even when outside the element bounds.\n   *\n   * @default true\n   */\n  handleOutside?: boolean;\n  /**\n   * Listen to window resize event\n   *\n   * @default true\n   */\n  windowScroll?: boolean;\n  /**\n   * Listen to window scroll event\n   *\n   * @default true\n   */\n  windowResize?: boolean;\n}\ninterface UseMouseInElementReturn extends UseMouseReturn {\n  elementX: ShallowRef<number>;\n  elementY: ShallowRef<number>;\n  elementPositionX: ShallowRef<number>;\n  elementPositionY: ShallowRef<number>;\n  elementHeight: ShallowRef<number>;\n  elementWidth: ShallowRef<number>;\n  isOutside: ShallowRef<boolean>;\n  stop: () => void;\n}\n/**\n * Reactive mouse position related to an element.\n *\n * @see https://vueuse.org/useMouseInElement\n * @param target\n * @param options\n */\ndeclare function useMouseInElement(target?: MaybeElementRef, options?: MouseInElementOptions): {\n  x: ShallowRef<number>;\n  y: ShallowRef<number>;\n  sourceType: ShallowRef<UseMouseSourceType>;\n  elementX: ShallowRef<number, number>;\n  elementY: ShallowRef<number, number>;\n  elementPositionX: ShallowRef<number, number>;\n  elementPositionY: ShallowRef<number, number>;\n  elementHeight: ShallowRef<number, number>;\n  elementWidth: ShallowRef<number, number>;\n  isOutside: ShallowRef<boolean, boolean>;\n  stop: () => void;\n};\n//#endregion\n//#region useMousePressed/index.d.ts\ninterface UseMousePressedOptions extends ConfigurableWindow {\n  /**\n   * Listen to `touchstart` `touchend` events\n   *\n   * @default true\n   */\n  touch?: boolean;\n  /**\n   * Listen to `dragstart` `drop` and `dragend` events\n   *\n   * @default true\n   */\n  drag?: boolean;\n  /**\n   * Add event listeners with the `capture` option set to `true`\n   * (see [MDN](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#capture))\n   *\n   * @default false\n   */\n  capture?: boolean;\n  /**\n   * Initial values\n   *\n   * @default false\n   */\n  initialValue?: boolean;\n  /**\n   * Element target to be capture the click\n   */\n  target?: MaybeComputedElementRef;\n  /**\n   * Callback to be called when the mouse is pressed\n   *\n   * @param event\n   */\n  onPressed?: (event: MouseEvent | TouchEvent | DragEvent) => void;\n  /**\n   * Callback to be called when the mouse is released\n   *\n   * @param event\n   */\n  onReleased?: (event: MouseEvent | TouchEvent | DragEvent) => void;\n}\n/** @deprecated use {@link UseMousePressedOptions} instead */\ntype MousePressedOptions = UseMousePressedOptions;\ninterface UseMousePressedReturn {\n  pressed: ShallowRef<boolean>;\n  sourceType: ShallowRef<UseMouseSourceType>;\n}\n/**\n * Reactive mouse pressing state.\n *\n * @see https://vueuse.org/useMousePressed\n * @param options\n */\ndeclare function useMousePressed(options?: UseMousePressedOptions): UseMousePressedReturn;\n//#endregion\n//#region useMutationObserver/index.d.ts\ninterface UseMutationObserverOptions extends MutationObserverInit, ConfigurableWindow {}\ninterface UseMutationObserverReturn extends Supportable {\n  stop: () => void;\n  takeRecords: () => MutationRecord[] | undefined;\n}\n/**\n * Watch for changes being made to the DOM tree.\n *\n * @see https://vueuse.org/useMutationObserver\n * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver MutationObserver MDN\n * @param target\n * @param callback\n * @param options\n */\ndeclare function useMutationObserver(target: MaybeComputedElementRef | MaybeComputedElementRef[] | MaybeRefOrGetter<MaybeElement[]>, callback: MutationCallback, options?: UseMutationObserverOptions): UseMutationObserverReturn;\n//#endregion\n//#region useNavigatorLanguage/index.d.ts\ninterface NavigatorLanguageState extends Supportable {\n  /**\n   *\n   * ISO 639-1 standard Language Code\n   *\n   * @info The detected user agent language preference as a language tag\n   * (which is sometimes referred to as a \"locale identifier\").\n   * This consists of a 2-3 letter base language tag that indicates a\n   * language, optionally followed by additional subtags separated by\n   * '-'. The most common extra information is the country or region\n   * variant (like 'en-US' or 'fr-CA').\n   *\n   *\n   * @see https://www.iso.org/iso-639-language-codes.html\n   * @see https://www.loc.gov/standards/iso639-2/php/code_list.php\n   *\n   */\n  language: ShallowRef<string | undefined>;\n}\ninterface UseNavigatorLanguageOptions extends ConfigurableWindow {}\ntype UseNavigatorLanguageReturn = Readonly<NavigatorLanguageState>;\n/**\n *\n * Reactive useNavigatorLanguage\n *\n * Detects the currently selected user language and returns a reactive language\n * @see https://vueuse.org/useNavigatorLanguage\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useNavigatorLanguage(options?: UseNavigatorLanguageOptions): UseNavigatorLanguageReturn;\n//#endregion\n//#region useNetwork/index.d.ts\ninterface UseNetworkOptions extends ConfigurableWindow {}\ntype NetworkType = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown';\ntype NetworkEffectiveType = 'slow-2g' | '2g' | '3g' | '4g' | undefined;\ninterface NetworkState extends Supportable {\n  /**\n   * If the user is currently connected.\n   */\n  isOnline: Readonly<ShallowRef<boolean>>;\n  /**\n   * The time since the user was last connected.\n   */\n  offlineAt: Readonly<ShallowRef<number | undefined>>;\n  /**\n   * At this time, if the user is offline and reconnects\n   */\n  onlineAt: Readonly<ShallowRef<number | undefined>>;\n  /**\n   * The download speed in Mbps.\n   */\n  downlink: Readonly<ShallowRef<number | undefined>>;\n  /**\n   * The max reachable download speed in Mbps.\n   */\n  downlinkMax: Readonly<ShallowRef<number | undefined>>;\n  /**\n   * The detected effective speed type.\n   */\n  effectiveType: Readonly<ShallowRef<NetworkEffectiveType | undefined>>;\n  /**\n   * The estimated effective round-trip time of the current connection.\n   */\n  rtt: Readonly<ShallowRef<number | undefined>>;\n  /**\n   * If the user activated data saver mode.\n   */\n  saveData: Readonly<ShallowRef<boolean | undefined>>;\n  /**\n   * The detected connection/network type.\n   */\n  type: Readonly<ShallowRef<NetworkType>>;\n}\ntype UseNetworkReturn = Readonly<NetworkState>;\n/**\n * Reactive Network status.\n *\n * @see https://vueuse.org/useNetwork\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useNetwork(options?: UseNetworkOptions): UseNetworkReturn;\n//#endregion\n//#region useNow/index.d.ts\ninterface UseNowOptions<Controls extends boolean> extends ConfigurableScheduler {\n  /**\n   * Expose more controls\n   *\n   * @default false\n   */\n  controls?: Controls;\n  /**\n   * Start the clock immediately\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Update interval in milliseconds, or use requestAnimationFrame\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default requestAnimationFrame\n   */\n  interval?: 'requestAnimationFrame' | number;\n}\ntype UseNowReturn<Controls extends boolean> = Controls extends true ? ({\n  now: Ref<Date>;\n} & Pausable) : Ref<Date>;\n/**\n * Reactive current Date instance.\n *\n * @see https://vueuse.org/useNow\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useNow(options?: UseNowOptions<false>): Ref<Date>;\ndeclare function useNow(options: UseNowOptions<true>): {\n  now: Ref<Date>;\n} & Pausable;\n//#endregion\n//#region useObjectUrl/index.d.ts\n/**\n * Reactive URL representing an object.\n *\n * @see https://vueuse.org/useObjectUrl\n * @param object\n */\ndeclare function useObjectUrl(object: MaybeRefOrGetter<Blob | MediaSource | null | undefined>): Readonly<vue0.Ref<string | undefined, string | undefined>>;\n//#endregion\n//#region useOffsetPagination/index.d.ts\ninterface UseOffsetPaginationOptions {\n  /**\n   * Total number of items.\n   */\n  total?: MaybeRefOrGetter<number>;\n  /**\n   * The number of items to display per page.\n   * @default 10\n   */\n  pageSize?: MaybeRefOrGetter<number>;\n  /**\n   * The current page number.\n   * @default 1\n   */\n  page?: MaybeRef<number>;\n  /**\n   * Callback when the `page` change.\n   */\n  onPageChange?: (returnValue: UnwrapNestedRefs<UseOffsetPaginationReturn>) => unknown;\n  /**\n   * Callback when the `pageSize` change.\n   */\n  onPageSizeChange?: (returnValue: UnwrapNestedRefs<UseOffsetPaginationReturn>) => unknown;\n  /**\n   * Callback when the `pageCount` change.\n   */\n  onPageCountChange?: (returnValue: UnwrapNestedRefs<UseOffsetPaginationReturn>) => unknown;\n}\ninterface UseOffsetPaginationReturn {\n  currentPage: Ref<number>;\n  currentPageSize: Ref<number>;\n  pageCount: ComputedRef<number>;\n  isFirstPage: ComputedRef<boolean>;\n  isLastPage: ComputedRef<boolean>;\n  prev: () => void;\n  next: () => void;\n}\ntype UseOffsetPaginationInfinityPageReturn = Omit<UseOffsetPaginationReturn, 'isLastPage'>;\ndeclare function useOffsetPagination(options: Omit<UseOffsetPaginationOptions, 'total'>): UseOffsetPaginationInfinityPageReturn;\ndeclare function useOffsetPagination(options: UseOffsetPaginationOptions): UseOffsetPaginationReturn;\n//#endregion\n//#region useOnline/index.d.ts\n/**\n * Reactive online state.\n *\n * @see https://vueuse.org/useOnline\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useOnline(options?: ConfigurableWindow): Readonly<vue0.ShallowRef<boolean>>;\n//#endregion\n//#region usePageLeave/index.d.ts\ninterface UsePageLeaveOptions extends ConfigurableWindow {}\ntype UsePageLeaveReturn = ShallowRef<boolean>;\n/**\n * Reactive state to show whether mouse leaves the page.\n *\n * @see https://vueuse.org/usePageLeave\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePageLeave(options?: UsePageLeaveOptions): UsePageLeaveReturn;\n//#endregion\n//#region useParallax/index.d.ts\ninterface UseParallaxOptions extends ConfigurableWindow {\n  deviceOrientationTiltAdjust?: (i: number) => number;\n  deviceOrientationRollAdjust?: (i: number) => number;\n  mouseTiltAdjust?: (i: number) => number;\n  mouseRollAdjust?: (i: number) => number;\n}\ninterface UseParallaxReturn {\n  /**\n   * Roll value. Scaled to `-0.5 ~ 0.5`\n   */\n  roll: ComputedRef<number>;\n  /**\n   * Tilt value. Scaled to `-0.5 ~ 0.5`\n   */\n  tilt: ComputedRef<number>;\n  /**\n   * Sensor source, can be `mouse` or `deviceOrientation`\n   */\n  source: ComputedRef<'deviceOrientation' | 'mouse'>;\n}\n/**\n * Create parallax effect easily. It uses `useDeviceOrientation` and fallback to `useMouse`\n * if orientation is not supported.\n *\n * @param target\n * @param options\n */\ndeclare function useParallax(target: MaybeElementRef, options?: UseParallaxOptions): UseParallaxReturn;\n//#endregion\n//#region useParentElement/index.d.ts\ndeclare function useParentElement(element?: MaybeRefOrGetter<HTMLElement | SVGElement | null | undefined>): Readonly<ShallowRef<HTMLElement | SVGElement | null | undefined>>;\n//#endregion\n//#region usePerformanceObserver/index.d.ts\ntype UsePerformanceObserverOptions = PerformanceObserverInit & ConfigurableWindow & {\n  /**\n   * Start the observer immediate.\n   *\n   * @default true\n   */\n  immediate?: boolean;\n};\n/**\n * Observe performance metrics.\n *\n * @see https://vueuse.org/usePerformanceObserver\n * @param options\n */\ndeclare function usePerformanceObserver(options: UsePerformanceObserverOptions, callback: PerformanceObserverCallback): {\n  isSupported: UseSupportedReturn;\n  start: () => void;\n  stop: () => void;\n};\n//#endregion\n//#region usePermission/index.d.ts\ntype DescriptorNamePolyfill = 'accelerometer' | 'accessibility-events' | 'ambient-light-sensor' | 'background-sync' | 'camera' | 'clipboard-read' | 'clipboard-write' | 'gyroscope' | 'magnetometer' | 'microphone' | 'notifications' | 'payment-handler' | 'persistent-storage' | 'push' | 'speaker' | 'local-fonts';\ntype GeneralPermissionDescriptor = PermissionDescriptor | {\n  name: DescriptorNamePolyfill;\n};\ninterface UsePermissionOptions<Controls extends boolean> extends ConfigurableNavigator {\n  /**\n   * Expose more controls\n   *\n   * @default false\n   */\n  controls?: Controls;\n}\ntype UsePermissionReturn = Readonly<ShallowRef<PermissionState | undefined>>;\ninterface UsePermissionReturnWithControls extends Supportable {\n  state: UsePermissionReturn;\n  query: () => Promise<PermissionStatus | undefined>;\n}\n/**\n * Reactive Permissions API.\n *\n * @see https://vueuse.org/usePermission\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePermission(permissionDesc: GeneralPermissionDescriptor | GeneralPermissionDescriptor['name'], options?: UsePermissionOptions<false>): UsePermissionReturn;\ndeclare function usePermission(permissionDesc: GeneralPermissionDescriptor | GeneralPermissionDescriptor['name'], options: UsePermissionOptions<true>): UsePermissionReturnWithControls;\n//#endregion\n//#region usePointer/index.d.ts\ninterface UsePointerState extends Position {\n  pressure: number;\n  pointerId: number;\n  tiltX: number;\n  tiltY: number;\n  width: number;\n  height: number;\n  twist: number;\n  pointerType: PointerType | null;\n}\ninterface UsePointerOptions extends ConfigurableWindow {\n  /**\n   * Pointer types that listen to.\n   *\n   * @default ['mouse', 'touch', 'pen']\n   */\n  pointerTypes?: PointerType[];\n  /**\n   * Initial values\n   */\n  initialValue?: MaybeRef<Partial<UsePointerState>>;\n  /**\n   * @default window\n   */\n  target?: MaybeRef<EventTarget | null | undefined> | Document | Window;\n}\ninterface UsePointerReturn {\n  pressure: Ref<number>;\n  pointerId: Ref<number>;\n  tiltX: Ref<number>;\n  tiltY: Ref<number>;\n  width: Ref<number>;\n  height: Ref<number>;\n  twist: Ref<number>;\n  pointerType: Ref<PointerType | null>;\n  x: Ref<number>;\n  y: Ref<number>;\n  isInside: ShallowRef<boolean>;\n}\n/**\n * Reactive pointer state.\n *\n * @see https://vueuse.org/usePointer\n * @param options\n */\ndeclare function usePointer(options?: UsePointerOptions): UsePointerReturn;\n//#endregion\n//#region usePointerLock/index.d.ts\ninterface UsePointerLockOptions extends ConfigurableDocument {}\ninterface UsePointerLockReturn extends Supportable {\n  element: ShallowRef<MaybeElement>;\n  triggerElement: ShallowRef<MaybeElement>;\n  lock: (e: MaybeElementRef | Event) => Promise<MaybeElement>;\n  unlock: () => Promise<boolean>;\n}\n/**\n * Reactive pointer lock.\n *\n * @see https://vueuse.org/usePointerLock\n * @param target\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePointerLock(target?: MaybeElementRef, options?: UsePointerLockOptions): UsePointerLockReturn;\n//#endregion\n//#region useSwipe/index.d.ts\ntype UseSwipeDirection = 'up' | 'down' | 'left' | 'right' | 'none';\ninterface UseSwipeOptions extends ConfigurableWindow {\n  /**\n   * Register events as passive\n   *\n   * @default true\n   */\n  passive?: boolean;\n  /**\n   * @default 50\n   */\n  threshold?: number;\n  /**\n   * Callback on swipe start\n   */\n  onSwipeStart?: (e: TouchEvent) => void;\n  /**\n   * Callback on swipe moves\n   */\n  onSwipe?: (e: TouchEvent) => void;\n  /**\n   * Callback on swipe ends\n   */\n  onSwipeEnd?: (e: TouchEvent, direction: UseSwipeDirection) => void;\n}\ninterface UseSwipeReturn {\n  isSwiping: ShallowRef<boolean>;\n  direction: ComputedRef<UseSwipeDirection>;\n  coordsStart: Readonly<Position>;\n  coordsEnd: Readonly<Position>;\n  lengthX: ComputedRef<number>;\n  lengthY: ComputedRef<number>;\n  stop: () => void;\n}\n/**\n * Reactive swipe detection.\n *\n * @see https://vueuse.org/useSwipe\n * @param target\n * @param options\n */\ndeclare function useSwipe(target: MaybeRefOrGetter<EventTarget | null | undefined>, options?: UseSwipeOptions): UseSwipeReturn;\n//#endregion\n//#region usePointerSwipe/index.d.ts\ninterface UsePointerSwipeOptions {\n  /**\n   * @default 50\n   */\n  threshold?: number;\n  /**\n   * Callback on swipe start.\n   */\n  onSwipeStart?: (e: PointerEvent) => void;\n  /**\n   * Callback on swipe move.\n   */\n  onSwipe?: (e: PointerEvent) => void;\n  /**\n   * Callback on swipe end.\n   */\n  onSwipeEnd?: (e: PointerEvent, direction: UseSwipeDirection) => void;\n  /**\n   * Pointer types to listen to.\n   *\n   * @default ['mouse', 'touch', 'pen']\n   */\n  pointerTypes?: PointerType[];\n  /**\n   * Disable text selection on swipe.\n   *\n   * @default false\n   */\n  disableTextSelect?: boolean;\n}\ninterface UsePointerSwipeReturn {\n  readonly isSwiping: ShallowRef<boolean>;\n  direction: Readonly<ShallowRef<UseSwipeDirection>>;\n  readonly posStart: Position;\n  readonly posEnd: Position;\n  distanceX: Readonly<ComputedRef<number>>;\n  distanceY: Readonly<ComputedRef<number>>;\n  stop: () => void;\n}\n/**\n * Reactive swipe detection based on PointerEvents.\n *\n * @see https://vueuse.org/usePointerSwipe\n * @param target\n * @param options\n */\ndeclare function usePointerSwipe(target: MaybeRefOrGetter<HTMLElement | null | undefined>, options?: UsePointerSwipeOptions): UsePointerSwipeReturn;\n//#endregion\n//#region usePreferredColorScheme/index.d.ts\ntype ColorSchemeType = 'dark' | 'light' | 'no-preference';\n/**\n * Reactive prefers-color-scheme media query.\n *\n * @see https://vueuse.org/usePreferredColorScheme\n * @param [options]\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePreferredColorScheme(options?: ConfigurableWindow): vue0.ComputedRef<ColorSchemeType>;\n//#endregion\n//#region usePreferredContrast/index.d.ts\ntype ContrastType = 'more' | 'less' | 'custom' | 'no-preference';\n/**\n * Reactive prefers-contrast media query.\n *\n * @see https://vueuse.org/usePreferredContrast\n * @param [options]\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePreferredContrast(options?: ConfigurableWindow): vue0.ComputedRef<ContrastType>;\n//#endregion\n//#region usePreferredDark/index.d.ts\n/**\n * Reactive dark theme preference.\n *\n * @see https://vueuse.org/usePreferredDark\n * @param [options]\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePreferredDark(options?: ConfigurableWindow): vue0.ComputedRef<boolean>;\n//#endregion\n//#region usePreferredLanguages/index.d.ts\n/**\n * Reactive Navigator Languages.\n *\n * @see https://vueuse.org/usePreferredLanguages\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePreferredLanguages(options?: ConfigurableWindow): ShallowRef<readonly string[]>;\n//#endregion\n//#region usePreferredReducedMotion/index.d.ts\ntype ReducedMotionType = 'reduce' | 'no-preference';\n/**\n * Reactive prefers-reduced-motion media query.\n *\n * @see https://vueuse.org/usePreferredReducedMotion\n * @param [options]\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePreferredReducedMotion(options?: ConfigurableWindow): vue0.ComputedRef<ReducedMotionType>;\n//#endregion\n//#region usePreferredReducedTransparency/index.d.ts\ntype ReducedTransparencyType = 'reduce' | 'no-preference';\n/**\n * Reactive prefers-reduced-transparency media query.\n *\n * @see https://vueuse.org/usePreferredReducedTransparency\n * @param [options]\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePreferredReducedTransparency(options?: ConfigurableWindow): vue0.ComputedRef<ReducedTransparencyType>;\n//#endregion\n//#region usePrevious/index.d.ts\n/**\n * Holds the previous value of a ref.\n *\n * @see   {@link https://vueuse.org/usePrevious}\n */\ndeclare function usePrevious<T>(value: MaybeRefOrGetter<T>): Readonly<ShallowRef<T | undefined>>;\ndeclare function usePrevious<T>(value: MaybeRefOrGetter<T>, initialValue: T): Readonly<ShallowRef<T>>;\n//#endregion\n//#region useRafFn/index.d.ts\ninterface UseRafFnCallbackArguments {\n  /**\n   * Time elapsed between this and the last frame.\n   */\n  delta: number;\n  /**\n   * Time elapsed since the creation of the web page. See {@link https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp#the_time_origin Time origin}.\n   */\n  timestamp: DOMHighResTimeStamp;\n}\ninterface UseRafFnOptions extends ConfigurableWindow {\n  /**\n   * Start the requestAnimationFrame loop immediately on creation\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * The maximum frame per second to execute the function.\n   * Set to `null` to disable the limit.\n   *\n   * @default null\n   */\n  fpsLimit?: MaybeRefOrGetter<number | null>;\n  /**\n   * After the requestAnimationFrame loop executed once, it will be automatically stopped.\n   *\n   * @default false\n   */\n  once?: boolean;\n}\n/**\n * Call function on every `requestAnimationFrame`. With controls of pausing and resuming.\n *\n * @see https://vueuse.org/useRafFn\n * @param fn\n * @param options\n */\ndeclare function useRafFn(fn: (args: UseRafFnCallbackArguments) => void, options?: UseRafFnOptions): Pausable;\n//#endregion\n//#region useSSRWidth/index.d.ts\ndeclare function useSSRWidth(): number | undefined;\ndeclare function provideSSRWidth(width: number | null, app?: App<unknown>): void;\n//#endregion\n//#region useScreenOrientation/index.d.ts\ntype OrientationType = 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary';\ntype OrientationLockType = 'any' | 'natural' | 'landscape' | 'portrait' | 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary';\ninterface ScreenOrientation extends EventTarget {\n  lock: (orientation: OrientationLockType) => Promise<void>;\n  unlock: () => void;\n  readonly type: OrientationType;\n  readonly angle: number;\n  addEventListener: (type: 'change', listener: (this: this, ev: Event) => any, useCapture?: boolean) => void;\n}\ninterface UseScreenOrientationOptions extends ConfigurableWindow {}\ninterface UseScreenOrientationReturn extends Supportable {\n  orientation: Ref<OrientationType | undefined>;\n  angle: ShallowRef<number>;\n  lockOrientation: (type: OrientationLockType) => Promise<void>;\n  unlockOrientation: () => void;\n}\n/**\n * Reactive screen orientation\n *\n * @see https://vueuse.org/useScreenOrientation\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useScreenOrientation(options?: UseScreenOrientationOptions): UseScreenOrientationReturn;\n//#endregion\n//#region useScreenSafeArea/index.d.ts\ninterface UseScreenSafeAreaReturn {\n  top: ShallowRef<string>;\n  right: ShallowRef<string>;\n  bottom: ShallowRef<string>;\n  left: ShallowRef<string>;\n  update: () => void;\n}\n/**\n * Reactive `env(safe-area-inset-*)`\n *\n * @see https://vueuse.org/useScreenSafeArea\n */\ndeclare function useScreenSafeArea(): UseScreenSafeAreaReturn;\n//#endregion\n//#region useScriptTag/index.d.ts\ninterface UseScriptTagOptions extends ConfigurableDocument {\n  /**\n   * Load the script immediately\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Add `async` attribute to the script tag\n   *\n   * @default true\n   */\n  async?: boolean;\n  /**\n   * Script type\n   *\n   * @default 'text/javascript'\n   */\n  type?: string;\n  /**\n   * Manual controls the timing of loading and unloading\n   *\n   * @default false\n   */\n  manual?: boolean;\n  crossOrigin?: 'anonymous' | 'use-credentials';\n  referrerPolicy?: 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';\n  noModule?: boolean;\n  defer?: boolean;\n  /**\n   * Add custom attribute to the script tag\n   *\n   */\n  attrs?: Record<string, string>;\n  /**\n   * Nonce value for CSP (Content Security Policy)\n   * @default undefined\n   */\n  nonce?: string;\n}\ninterface UseScriptTagReturn {\n  scriptTag: ShallowRef<HTMLScriptElement | null>;\n  load: (waitForScriptLoad?: boolean) => Promise<HTMLScriptElement | boolean>;\n  unload: () => void;\n}\n/**\n * Async script tag loading.\n *\n * @see https://vueuse.org/useScriptTag\n * @param src\n * @param onLoaded\n * @param options\n */\ndeclare function useScriptTag(src: MaybeRefOrGetter<string>, onLoaded?: (el: HTMLScriptElement) => void, options?: UseScriptTagOptions): UseScriptTagReturn;\n//#endregion\n//#region useScrollLock/index.d.ts\n/**\n * Lock scrolling of the element.\n *\n * @see https://vueuse.org/useScrollLock\n * @param element\n */\ndeclare function useScrollLock(element: MaybeRefOrGetter<HTMLElement | SVGElement | Window | Document | null | undefined>, initialState?: boolean): vue0.WritableComputedRef<boolean, boolean>;\n//#endregion\n//#region useSessionStorage/index.d.ts\ndeclare function useSessionStorage(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<string>, options?: UseStorageOptions<string>): RemovableRef<string>;\ndeclare function useSessionStorage(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<boolean>, options?: UseStorageOptions<boolean>): RemovableRef<boolean>;\ndeclare function useSessionStorage(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<number>, options?: UseStorageOptions<number>): RemovableRef<number>;\ndeclare function useSessionStorage<T>(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<T>, options?: UseStorageOptions<T>): RemovableRef<T>;\ndeclare function useSessionStorage<T = unknown>(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<null>, options?: UseStorageOptions<T>): RemovableRef<T>;\n//#endregion\n//#region useShare/index.d.ts\ninterface UseShareOptions {\n  title?: string;\n  files?: File[];\n  text?: string;\n  url?: string;\n}\ninterface UseShareReturn extends Supportable {\n  share: (overrideOptions?: MaybeRefOrGetter<UseShareOptions>) => Promise<void>;\n}\n/**\n * Reactive Web Share API.\n *\n * @see https://vueuse.org/useShare\n * @param shareOptions\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useShare(shareOptions?: MaybeRefOrGetter<UseShareOptions>, options?: ConfigurableNavigator): UseShareReturn;\n//#endregion\n//#region useSorted/index.d.ts\ntype UseSortedCompareFn<T = any> = (a: T, b: T) => number;\ntype UseSortedFn<T = any> = (arr: T[], compareFn: UseSortedCompareFn<T>) => T[];\ninterface UseSortedOptions<T = any> {\n  /**\n   * sort algorithm\n   */\n  sortFn?: UseSortedFn<T>;\n  /**\n   * compare function\n   */\n  compareFn?: UseSortedCompareFn<T>;\n  /**\n   * change the value of the source array\n   * @default false\n   */\n  dirty?: boolean;\n}\n/**\n * reactive sort array\n *\n * @see https://vueuse.org/useSorted\n */\ndeclare function useSorted<T = any>(source: MaybeRefOrGetter<T[]>, compareFn?: UseSortedCompareFn<T>): Ref<T[]>;\ndeclare function useSorted<T = any>(source: MaybeRefOrGetter<T[]>, options?: UseSortedOptions<T>): Ref<T[]>;\ndeclare function useSorted<T = any>(source: MaybeRefOrGetter<T[]>, compareFn?: UseSortedCompareFn<T>, options?: Omit<UseSortedOptions<T>, 'compareFn'>): Ref<T[]>;\n//#endregion\n//#region useSpeechRecognition/types.d.ts\ntype SpeechRecognitionErrorCode = 'aborted' | 'audio-capture' | 'bad-grammar' | 'language-not-supported' | 'network' | 'no-speech' | 'not-allowed' | 'service-not-allowed';\ninterface SpeechGrammar {\n  src: string;\n  weight: number;\n}\ninterface SpeechGrammarList {\n  readonly length: number;\n  addFromString: (string: string, weight?: number) => void;\n  addFromURI: (src: string, weight?: number) => void;\n  item: (index: number) => SpeechGrammar;\n  [index: number]: SpeechGrammar;\n}\ninterface SpeechRecognitionErrorEvent extends Event {\n  readonly error: SpeechRecognitionErrorCode;\n  readonly message: string;\n}\ninterface SpeechRecognitionEvent extends Event {\n  readonly resultIndex: number;\n  readonly results: SpeechRecognitionResultList;\n}\ninterface SpeechRecognitionEventMap {\n  audioend: Event;\n  audiostart: Event;\n  end: Event;\n  error: SpeechRecognitionErrorEvent;\n  nomatch: SpeechRecognitionEvent;\n  result: SpeechRecognitionEvent;\n  soundend: Event;\n  soundstart: Event;\n  speechend: Event;\n  speechstart: Event;\n  start: Event;\n}\ninterface SpeechRecognition extends EventTarget {\n  continuous: boolean;\n  grammars: SpeechGrammarList;\n  interimResults: boolean;\n  lang: string;\n  maxAlternatives: number;\n  onaudioend: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onaudiostart: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onend: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onerror: ((this: SpeechRecognition, ev: SpeechRecognitionErrorEvent) => any) | null;\n  onnomatch: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;\n  onresult: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;\n  onsoundend: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onsoundstart: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onspeechend: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onspeechstart: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onstart: ((this: SpeechRecognition, ev: Event) => any) | null;\n  abort: () => void;\n  start: () => void;\n  stop: () => void;\n  addEventListener: (<K$1 extends keyof SpeechRecognitionEventMap>(type: K$1, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K$1]) => any, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);\n  removeEventListener: (<K$1 extends keyof SpeechRecognitionEventMap>(type: K$1, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K$1]) => any, options?: boolean | EventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions) => void);\n}\n//#endregion\n//#region useSpeechRecognition/index.d.ts\ninterface UseSpeechRecognitionOptions extends ConfigurableWindow {\n  /**\n   * Controls whether continuous results are returned for each recognition, or only a single result.\n   *\n   * @default true\n   */\n  continuous?: boolean;\n  /**\n   * Controls whether interim results should be returned (true) or not (false.) Interim results are results that are not yet final\n   *\n   * @default true\n   */\n  interimResults?: boolean;\n  /**\n   * Language for SpeechRecognition\n   *\n   * @default 'en-US'\n   */\n  lang?: MaybeRefOrGetter<string>;\n  /**\n   * A number representing the maximum returned alternatives for each result.\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition/maxAlternatives\n   * @default 1\n   */\n  maxAlternatives?: number;\n}\ninterface UseSpeechRecognitionReturn extends Supportable {\n  isListening: ShallowRef<boolean>;\n  isFinal: ShallowRef<boolean>;\n  recognition: SpeechRecognition | undefined;\n  result: ShallowRef<string>;\n  error: ShallowRef<SpeechRecognitionErrorEvent | Error | undefined>;\n  toggle: (value?: boolean) => void;\n  start: () => void;\n  stop: () => void;\n}\n/**\n * Reactive SpeechRecognition.\n *\n * @see https://vueuse.org/useSpeechRecognition\n * @see https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition SpeechRecognition\n * @param options\n */\ndeclare function useSpeechRecognition(options?: UseSpeechRecognitionOptions): UseSpeechRecognitionReturn;\n//#endregion\n//#region useSpeechSynthesis/index.d.ts\ntype UseSpeechSynthesisStatus = 'init' | 'play' | 'pause' | 'end';\ninterface UseSpeechSynthesisOptions extends ConfigurableWindow {\n  /**\n   * Language for SpeechSynthesis\n   *\n   * @default 'en-US'\n   */\n  lang?: MaybeRefOrGetter<string>;\n  /**\n   * Gets and sets the pitch at which the utterance will be spoken at.\n   *\n   * @default 1\n   */\n  pitch?: MaybeRefOrGetter<SpeechSynthesisUtterance['pitch']>;\n  /**\n   * Gets and sets the speed at which the utterance will be spoken at.\n   *\n   * @default 1\n   */\n  rate?: MaybeRefOrGetter<SpeechSynthesisUtterance['rate']>;\n  /**\n   * Gets and sets the voice that will be used to speak the utterance.\n   */\n  voice?: MaybeRef<SpeechSynthesisVoice>;\n  /**\n   * Gets and sets the volume that the utterance will be spoken at.\n   *\n   * @default 1\n   */\n  volume?: MaybeRefOrGetter<SpeechSynthesisUtterance['volume']>;\n  /**\n   * Callback function that is called when the boundary event is triggered.\n   */\n  onBoundary?: (event: SpeechSynthesisEvent) => void;\n}\ninterface UseSpeechSynthesisReturn extends Supportable {\n  isPlaying: ShallowRef<boolean>;\n  status: ShallowRef<UseSpeechSynthesisStatus>;\n  utterance: ComputedRef<SpeechSynthesisUtterance>;\n  error: ShallowRef<SpeechSynthesisErrorEvent | undefined>;\n  stop: () => void;\n  toggle: (value?: boolean) => void;\n  speak: () => void;\n}\n/**\n * Reactive SpeechSynthesis.\n *\n * @see https://vueuse.org/useSpeechSynthesis\n * @see https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesis SpeechSynthesis\n */\ndeclare function useSpeechSynthesis(text: MaybeRefOrGetter<string>, options?: UseSpeechSynthesisOptions): UseSpeechSynthesisReturn;\n//#endregion\n//#region useStepper/index.d.ts\ninterface UseStepperReturn<StepName, Steps, Step> {\n  /** List of steps. */\n  steps: Readonly<Ref<Steps>>;\n  /** List of step names. */\n  stepNames: Readonly<Ref<StepName[]>>;\n  /** Index of the current step. */\n  index: Ref<number>;\n  /** Current step. */\n  current: ComputedRef<Step>;\n  /** Next step, or undefined if the current step is the last one. */\n  next: ComputedRef<StepName | undefined>;\n  /** Previous step, or undefined if the current step is the first one. */\n  previous: ComputedRef<StepName | undefined>;\n  /** Whether the current step is the first one. */\n  isFirst: ComputedRef<boolean>;\n  /** Whether the current step is the last one. */\n  isLast: ComputedRef<boolean>;\n  /** Get the step at the specified index. */\n  at: (index: number) => Step | undefined;\n  /** Get a step by the specified name. */\n  get: (step: StepName) => Step | undefined;\n  /** Go to the specified step. */\n  goTo: (step: StepName) => void;\n  /** Go to the next step. Does nothing if the current step is the last one. */\n  goToNext: () => void;\n  /** Go to the previous step. Does nothing if the current step is the previous one. */\n  goToPrevious: () => void;\n  /** Go back to the given step, only if the current step is after. */\n  goBackTo: (step: StepName) => void;\n  /** Checks whether the given step is the next step. */\n  isNext: (step: StepName) => boolean;\n  /** Checks whether the given step is the previous step. */\n  isPrevious: (step: StepName) => boolean;\n  /** Checks whether the given step is the current step. */\n  isCurrent: (step: StepName) => boolean;\n  /** Checks if the current step is before the given step. */\n  isBefore: (step: StepName) => boolean;\n  /** Checks if the current step is after the given step. */\n  isAfter: (step: StepName) => boolean;\n}\ndeclare function useStepper<T extends string | number>(steps: MaybeRef<T[]>, initialStep?: T): UseStepperReturn<T, T[], T>;\ndeclare function useStepper<T extends Record<string, any>>(steps: MaybeRef<T>, initialStep?: keyof T): UseStepperReturn<Exclude<keyof T, symbol>, T, T[keyof T]>;\n//#endregion\n//#region useStorageAsync/index.d.ts\ninterface UseStorageAsyncOptions<T> extends Omit<UseStorageOptions<T>, 'serializer'> {\n  /**\n   * Custom data serialization\n   */\n  serializer?: SerializerAsync<T>;\n  /**\n   * On first value loaded hook.\n   */\n  onReady?: (value: T) => void;\n}\ndeclare function useStorageAsync(key: string, initialValue: MaybeRefOrGetter<string>, storage?: StorageLikeAsync, options?: UseStorageAsyncOptions<string>): RemovableRef<string> & Promise<RemovableRef<string>>;\ndeclare function useStorageAsync(key: string, initialValue: MaybeRefOrGetter<boolean>, storage?: StorageLikeAsync, options?: UseStorageAsyncOptions<boolean>): RemovableRef<boolean> & Promise<RemovableRef<boolean>>;\ndeclare function useStorageAsync(key: string, initialValue: MaybeRefOrGetter<number>, storage?: StorageLikeAsync, options?: UseStorageAsyncOptions<number>): RemovableRef<number> & Promise<RemovableRef<number>>;\ndeclare function useStorageAsync<T>(key: string, initialValue: MaybeRefOrGetter<T>, storage?: StorageLikeAsync, options?: UseStorageAsyncOptions<T>): RemovableRef<T> & Promise<RemovableRef<T>>;\ndeclare function useStorageAsync<T = unknown>(key: string, initialValue: MaybeRefOrGetter<null>, storage?: StorageLikeAsync, options?: UseStorageAsyncOptions<T>): RemovableRef<T> & Promise<RemovableRef<T>>;\n//#endregion\n//#region useStyleTag/index.d.ts\ninterface UseStyleTagOptions extends ConfigurableDocument {\n  /**\n   * Media query for styles to apply\n   */\n  media?: string;\n  /**\n   * Load the style immediately\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Manual controls the timing of loading and unloading\n   *\n   * @default false\n   */\n  manual?: boolean;\n  /**\n   * DOM id of the style tag\n   *\n   * @default auto-incremented\n   */\n  id?: string;\n  /**\n   * Nonce value for CSP (Content Security Policy)\n   *\n   * @default undefined\n   */\n  nonce?: string;\n}\ninterface UseStyleTagReturn {\n  id: string;\n  css: ShallowRef<string>;\n  load: () => void;\n  unload: () => void;\n  isLoaded: Readonly<ShallowRef<boolean>>;\n}\n/**\n * Inject <style> element in head.\n *\n * Overload: Omitted id\n *\n * @see https://vueuse.org/useStyleTag\n * @param css\n * @param options\n */\ndeclare function useStyleTag(css: MaybeRef<string>, options?: UseStyleTagOptions): UseStyleTagReturn;\n//#endregion\n//#region useSupported/index.d.ts\ntype UseSupportedReturn = ComputedRef<boolean>;\ndeclare function useSupported(callback: () => unknown): UseSupportedReturn;\n//#endregion\n//#region useTemplateRefsList/index.d.ts\ntype TemplateRefsList<T> = T[] & {\n  set: (el: object | null) => void;\n};\ndeclare function useTemplateRefsList<T = Element>(): Readonly<Ref<Readonly<TemplateRefsList<T>>>>;\n//#endregion\n//#region useTextDirection/index.d.ts\ntype UseTextDirectionValue = 'ltr' | 'rtl' | 'auto';\ninterface UseTextDirectionOptions extends ConfigurableDocument {\n  /**\n   * CSS Selector for the target element applying to\n   *\n   * @default 'html'\n   */\n  selector?: string;\n  /**\n   * Observe `document.querySelector(selector)` changes using MutationObserve\n   *\n   * @default false\n   */\n  observe?: boolean;\n  /**\n   * Initial value\n   *\n   * @default 'ltr'\n   */\n  initialValue?: UseTextDirectionValue;\n}\n/**\n * Reactive dir of the element's text.\n *\n * @see https://vueuse.org/useTextDirection\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useTextDirection(options?: UseTextDirectionOptions): vue0.WritableComputedRef<UseTextDirectionValue, UseTextDirectionValue>;\n//#endregion\n//#region useTextSelection/index.d.ts\ninterface UseTextSelectionOptions extends ConfigurableWindow {}\ninterface UseTextSelectionReturn {\n  text: ComputedRef<string>;\n  rects: ComputedRef<DOMRect[]>;\n  ranges: ComputedRef<Range[]>;\n  selection: ShallowRef<Selection | null>;\n}\n/**\n * Reactively track user text selection based on [`Window.getSelection`](https://developer.mozilla.org/en-US/docs/Web/API/Window/getSelection).\n *\n * @see https://vueuse.org/useTextSelection\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useTextSelection(options?: UseTextSelectionOptions): UseTextSelectionReturn;\n//#endregion\n//#region useTextareaAutosize/index.d.ts\ninterface UseTextareaAutosizeOptions extends ConfigurableWindow {\n  /** Textarea element to autosize. */\n  element?: MaybeRef<HTMLTextAreaElement | undefined | null>;\n  /** Textarea content. */\n  input?: MaybeRef<string>;\n  /** Watch sources that should trigger a textarea resize. */\n  watch?: WatchSource | MultiWatchSources;\n  /** Function called when the textarea size changes. */\n  onResize?: () => void;\n  /** Specify style target to apply the height based on textarea content. If not provided it will use textarea it self.  */\n  styleTarget?: MaybeRef<HTMLElement | undefined>;\n  /** Specify the style property that will be used to manipulate height. Can be `height | minHeight`. Default value is `height`. */\n  styleProp?: 'height' | 'minHeight';\n}\ninterface UseTextareaAutosizeReturn {\n  textarea: Ref<HTMLTextAreaElement | undefined | null>;\n  input: Ref<string>;\n  triggerResize: () => void;\n}\ndeclare function useTextareaAutosize(options?: UseTextareaAutosizeOptions): UseTextareaAutosizeReturn;\n//#endregion\n//#region useThrottledRefHistory/index.d.ts\ntype UseThrottledRefHistoryOptions<Raw, Serialized = Raw> = Omit<UseRefHistoryOptions<Raw, Serialized>, 'eventFilter'> & {\n  throttle?: MaybeRef<number>;\n  trailing?: boolean;\n};\ntype UseThrottledRefHistoryReturn<Raw, Serialized = Raw> = UseRefHistoryReturn<Raw, Serialized>;\n/**\n * Shorthand for [useRefHistory](https://vueuse.org/useRefHistory) with throttled filter.\n *\n * @see https://vueuse.org/useThrottledRefHistory\n * @param source\n * @param options\n */\ndeclare function useThrottledRefHistory<Raw, Serialized = Raw>(source: Ref<Raw>, options?: UseThrottledRefHistoryOptions<Raw, Serialized>): UseThrottledRefHistoryReturn<Raw, Serialized>;\n//#endregion\n//#region useTimeAgo/index.d.ts\ntype UseTimeAgoFormatter<T = number> = (value: T, isPast: boolean) => string;\ntype UseTimeAgoUnitNamesDefault = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';\ninterface UseTimeAgoMessagesBuiltIn {\n  justNow: string;\n  past: string | UseTimeAgoFormatter<string>;\n  future: string | UseTimeAgoFormatter<string>;\n  invalid: string;\n}\ntype UseTimeAgoMessages<UnitNames extends string = UseTimeAgoUnitNamesDefault> = UseTimeAgoMessagesBuiltIn & Record<UnitNames, string | UseTimeAgoFormatter<number>>;\ninterface FormatTimeAgoOptions<UnitNames extends string = UseTimeAgoUnitNamesDefault> {\n  /**\n   * Maximum unit (of diff in milliseconds) to display the full date instead of relative\n   *\n   * @default undefined\n   */\n  max?: UnitNames | number;\n  /**\n   * Formatter for full date\n   */\n  fullDateFormatter?: (date: Date) => string;\n  /**\n   * Messages for formatting the string\n   */\n  messages?: UseTimeAgoMessages<UnitNames>;\n  /**\n   * Minimum display time unit (default is minute)\n   *\n   * @default false\n   */\n  showSecond?: boolean;\n  /**\n   * Rounding method to apply.\n   *\n   * @default 'round'\n   */\n  rounding?: 'round' | 'ceil' | 'floor' | number;\n  /**\n   * Custom units\n   */\n  units?: UseTimeAgoUnit<UnitNames>[];\n}\ninterface UseTimeAgoOptions<Controls extends boolean, UnitNames extends string = UseTimeAgoUnitNamesDefault> extends FormatTimeAgoOptions<UnitNames>, ConfigurableScheduler {\n  /**\n   * Expose more controls\n   *\n   * @default false\n   */\n  controls?: Controls;\n  /**\n   * Intervals to update, set 0 to disable auto update\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default 30_000\n   */\n  updateInterval?: number;\n}\ninterface UseTimeAgoUnit<Unit extends string = UseTimeAgoUnitNamesDefault> {\n  max: number;\n  value: number;\n  name: Unit;\n}\ntype UseTimeAgoReturn<Controls extends boolean = false> = Controls extends true ? {\n  timeAgo: ComputedRef<string>;\n} & Pausable : ComputedRef<string>;\n/**\n * Reactive time ago formatter.\n *\n * @see https://vueuse.org/useTimeAgo\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useTimeAgo<UnitNames extends string = UseTimeAgoUnitNamesDefault>(time: MaybeRefOrGetter<Date | number | string>, options?: UseTimeAgoOptions<false, UnitNames>): UseTimeAgoReturn<false>;\ndeclare function useTimeAgo<UnitNames extends string = UseTimeAgoUnitNamesDefault>(time: MaybeRefOrGetter<Date | number | string>, options: UseTimeAgoOptions<true, UnitNames>): UseTimeAgoReturn<true>;\ndeclare function formatTimeAgo<UnitNames extends string = UseTimeAgoUnitNamesDefault>(from: Date, options?: FormatTimeAgoOptions<UnitNames>, now?: Date | number): string;\n//#endregion\n//#region useTimeAgoIntl/index.d.ts\ntype Locale = Intl.UnicodeBCP47LocaleIdentifier | Intl.Locale;\ninterface FormatTimeAgoIntlOptions {\n  /**\n   * The locale to format with\n   *\n   * @default undefined\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#locales\n   */\n  locale?: Locale;\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#options\n   */\n  relativeTimeFormatOptions?: Intl.RelativeTimeFormatOptions;\n  /**\n   * Whether to insert spaces between parts.\n   *\n   * Ignored if `joinParts` is provided.\n   *\n   * @default true\n   */\n  insertSpace?: boolean;\n  /**\n   * Custom function to join the parts returned by `Intl.RelativeTimeFormat.formatToParts`.\n   *\n   * If provided, it will be used instead of the default join logic.\n   */\n  joinParts?: (parts: Intl.RelativeTimeFormatPart[], locale?: Intl.UnicodeBCP47LocaleIdentifier | Intl.Locale) => string;\n  /**\n   * Custom units\n   */\n  units?: TimeAgoUnit[];\n}\ninterface UseTimeAgoIntlOptions<Controls extends boolean> extends FormatTimeAgoIntlOptions, ConfigurableScheduler {\n  /**\n   * Expose more controls and the raw `parts` result.\n   *\n   * @default false\n   */\n  controls?: Controls;\n  /**\n   * Update interval in milliseconds, set 0 to disable auto update\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default 30_000\n   */\n  updateInterval?: number;\n}\ntype UseTimeAgoReturn$1<Controls extends boolean = false> = Controls extends true ? {\n  timeAgoIntl: ComputedRef<string>;\n  parts: ComputedRef<Intl.RelativeTimeFormatPart[]>;\n} & Pausable : ComputedRef<string>;\ninterface TimeAgoUnit {\n  name: Intl.RelativeTimeFormatUnit;\n  ms: number;\n}\n/**\n * A reactive wrapper for `Intl.RelativeTimeFormat`.\n */\ndeclare function useTimeAgoIntl(time: MaybeRefOrGetter<Date | number | string>, options?: UseTimeAgoIntlOptions<false>): UseTimeAgoReturn$1<false>;\ndeclare function useTimeAgoIntl(time: MaybeRefOrGetter<Date | number | string>, options: UseTimeAgoIntlOptions<true>): UseTimeAgoReturn$1<true>;\n/**\n * Non-reactive version of useTimeAgoIntl\n */\ndeclare function formatTimeAgoIntl(from: Date, options?: FormatTimeAgoIntlOptions, now?: Date | number): string;\n/**\n * Format parts into a string\n */\ndeclare function formatTimeAgoIntlParts(parts: Intl.RelativeTimeFormatPart[], options?: FormatTimeAgoIntlOptions): string;\n//#endregion\n//#region useTimeoutPoll/index.d.ts\ninterface UseTimeoutPollOptions {\n  /**\n   * Start the timer immediately\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Execute the callback immediately after calling `resume`\n   *\n   * @default false\n   */\n  immediateCallback?: boolean;\n}\ndeclare function useTimeoutPoll(fn: () => Awaitable<void>, interval: MaybeRefOrGetter<number>, options?: UseTimeoutFnOptions): Pausable;\n//#endregion\n//#region useTimestamp/index.d.ts\ninterface UseTimestampOptions<Controls extends boolean> extends ConfigurableScheduler {\n  /**\n   * Expose more controls\n   *\n   * @default false\n   */\n  controls?: Controls;\n  /**\n   * Offset value adding to the value\n   *\n   * @default 0\n   */\n  offset?: number;\n  /**\n   * Update the timestamp immediately\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Update interval, or use requestAnimationFrame\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default requestAnimationFrame\n   */\n  interval?: 'requestAnimationFrame' | number;\n  /**\n   * Callback on each update\n   */\n  callback?: (timestamp: number) => void;\n}\ntype UseTimestampReturn<Controls extends boolean> = Controls extends true ? ({\n  timestamp: ShallowRef<number>;\n} & Pausable) : ShallowRef<number>;\n/**\n * Reactive current timestamp.\n *\n * @see https://vueuse.org/useTimestamp\n * @param options\n */\ndeclare function useTimestamp(options?: UseTimestampOptions<false>): ShallowRef<number>;\ndeclare function useTimestamp(options: UseTimestampOptions<true>): {\n  timestamp: ShallowRef<number>;\n} & Pausable;\n//#endregion\n//#region useTitle/index.d.ts\ntype UseTitleOptionsBase = {\n  /**\n   * Restore the original title when unmounted\n   * @param originTitle original title\n   * @returns restored title\n   */\n  restoreOnUnmount?: false | ((originalTitle: string, currentTitle: string) => string | null | undefined);\n} & ({\n  /**\n   * Observe `document.title` changes using MutationObserve\n   * Cannot be used together with `titleTemplate` option.\n   *\n   * @default false\n   */\n  observe?: boolean;\n} | {\n  /**\n   * The template string to parse the title (e.g., '%s | My Website')\n   * Cannot be used together with `observe` option.\n   *\n   * @default '%s'\n   */\n  titleTemplate?: MaybeRef<string> | ((title: string) => string);\n});\ntype UseTitleOptions = ConfigurableDocument & UseTitleOptionsBase;\ntype UseTitleReturn = ComputedRef<string | null | undefined> | Ref<string | null | undefined>;\n/**\n * Reactive document title.\n *\n * @see https://vueuse.org/useTitle\n * @param newTitle\n * @param options\n * @description It's not SSR compatible. Your value will be applied only on client-side.\n */\ndeclare function useTitle(newTitle: ReadonlyRefOrGetter<string | null | undefined>, options?: UseTitleOptions): ComputedRef<string | null | undefined>;\ndeclare function useTitle(newTitle?: MaybeRef<string | null | undefined>, options?: UseTitleOptions): Ref<string | null | undefined>;\n//#endregion\n//#region useTransition/index.d.ts\n/**\n * Cubic bezier points\n */\ntype CubicBezierPoints = [number, number, number, number];\n/**\n * Easing function\n */\ntype EasingFunction = (n: number) => number;\n/**\n * Interpolation function\n */\ntype InterpolationFunction<T> = (from: T, to: T, t: number) => T;\n/**\n * Transition options\n */\ninterface TransitionOptions<T> extends ConfigurableWindow {\n  /**\n   * Manually abort a transition\n   */\n  abort?: () => any;\n  /**\n   * Transition duration in milliseconds\n   */\n  duration?: MaybeRef<number>;\n  /**\n   * Easing function or cubic bezier points to calculate transition progress\n   */\n  easing?: MaybeRef<EasingFunction | CubicBezierPoints>;\n  /**\n   * Custom interpolation function\n   */\n  interpolation?: InterpolationFunction<T>;\n  /**\n   * Easing function or cubic bezier points to calculate transition progress\n   * @deprecated The `transition` option is deprecated, use `easing` instead.\n   */\n  transition?: MaybeRef<EasingFunction | CubicBezierPoints>;\n}\ninterface UseTransitionOptions<T> extends TransitionOptions<T> {\n  /**\n   * Milliseconds to wait before starting transition\n   */\n  delay?: MaybeRef<number>;\n  /**\n   * Disables the transition\n   */\n  disabled?: MaybeRef<boolean>;\n  /**\n   * Callback to execute after transition finishes\n   */\n  onFinished?: () => void;\n  /**\n   * Callback to execute after transition starts\n   */\n  onStarted?: () => void;\n}\ndeclare const _TransitionPresets: {\n  readonly easeInSine: readonly [0.12, 0, 0.39, 0];\n  readonly easeOutSine: readonly [0.61, 1, 0.88, 1];\n  readonly easeInOutSine: readonly [0.37, 0, 0.63, 1];\n  readonly easeInQuad: readonly [0.11, 0, 0.5, 0];\n  readonly easeOutQuad: readonly [0.5, 1, 0.89, 1];\n  readonly easeInOutQuad: readonly [0.45, 0, 0.55, 1];\n  readonly easeInCubic: readonly [0.32, 0, 0.67, 0];\n  readonly easeOutCubic: readonly [0.33, 1, 0.68, 1];\n  readonly easeInOutCubic: readonly [0.65, 0, 0.35, 1];\n  readonly easeInQuart: readonly [0.5, 0, 0.75, 0];\n  readonly easeOutQuart: readonly [0.25, 1, 0.5, 1];\n  readonly easeInOutQuart: readonly [0.76, 0, 0.24, 1];\n  readonly easeInQuint: readonly [0.64, 0, 0.78, 0];\n  readonly easeOutQuint: readonly [0.22, 1, 0.36, 1];\n  readonly easeInOutQuint: readonly [0.83, 0, 0.17, 1];\n  readonly easeInExpo: readonly [0.7, 0, 0.84, 0];\n  readonly easeOutExpo: readonly [0.16, 1, 0.3, 1];\n  readonly easeInOutExpo: readonly [0.87, 0, 0.13, 1];\n  readonly easeInCirc: readonly [0.55, 0, 1, 0.45];\n  readonly easeOutCirc: readonly [0, 0.55, 0.45, 1];\n  readonly easeInOutCirc: readonly [0.85, 0, 0.15, 1];\n  readonly easeInBack: readonly [0.36, 0, 0.66, -0.56];\n  readonly easeOutBack: readonly [0.34, 1.56, 0.64, 1];\n  readonly easeInOutBack: readonly [0.68, -0.6, 0.32, 1.6];\n};\n/**\n * Common transitions\n *\n * @see https://easings.net\n */\ndeclare const TransitionPresets: Record<keyof typeof _TransitionPresets, CubicBezierPoints> & {\n  linear: EasingFunction;\n};\n/**\n * Transition from one value to another.\n *\n * @param source\n * @param from\n * @param to\n * @param options\n */\ndeclare function transition<T>(source: Ref<T>, from: MaybeRefOrGetter<T>, to: MaybeRefOrGetter<T>, options?: TransitionOptions<T>): PromiseLike<void>;\n/**\n * Transition from one value to another.\n * @deprecated The `executeTransition` function is deprecated, use `transition` instead.\n *\n * @param source\n * @param from\n * @param to\n * @param options\n */\ndeclare function executeTransition<T>(source: Ref<T>, from: MaybeRefOrGetter<T>, to: MaybeRefOrGetter<T>, options?: TransitionOptions<T>): PromiseLike<void>;\ndeclare function useTransition<T extends MaybeRefOrGetter<number>[]>(source: [...T], options?: UseTransitionOptions<T>): ComputedRef<{ [K in keyof T]: number }>;\ndeclare function useTransition<T extends MaybeRefOrGetter<number[]>>(source: T, options?: UseTransitionOptions<T>): ComputedRef<number[]>;\ndeclare function useTransition<T>(source: MaybeRefOrGetter<T>, options?: UseTransitionOptions<T>): ComputedRef<T>;\n//#endregion\n//#region useUrlSearchParams/index.d.ts\ntype UrlParams = Record<string, string[] | string>;\ninterface UseUrlSearchParamsOptions<T> extends ConfigurableWindow {\n  /**\n   * @default true\n   */\n  removeNullishValues?: boolean;\n  /**\n   * @default false\n   */\n  removeFalsyValues?: boolean;\n  /**\n   * @default {}\n   */\n  initialValue?: T;\n  /**\n   * Write back to `window.history` automatically\n   *\n   * @default true\n   */\n  write?: boolean;\n  /**\n   * Write mode for `window.history` when `write` is enabled\n   * - `replace`: replace the current history entry\n   * - `push`: push a new history entry\n   * @default 'replace'\n   */\n  writeMode?: 'replace' | 'push';\n  /**\n   * Custom function to serialize URL parameters\n   * When provided, this function will be used instead of the default URLSearchParams.toString()\n   * @param params The URLSearchParams object to serialize\n   * @returns The serialized query string (should not include the leading '?' or '#')\n   */\n  stringify?: (params: URLSearchParams) => string;\n}\n/**\n * Reactive URLSearchParams\n *\n * @see https://vueuse.org/useUrlSearchParams\n * @param mode\n * @param options\n */\ndeclare function useUrlSearchParams<T extends Record<string, any> = UrlParams>(mode?: 'history' | 'hash' | 'hash-params', options?: UseUrlSearchParamsOptions<T>): T;\n//#endregion\n//#region useUserMedia/index.d.ts\ninterface UseUserMediaOptions extends ConfigurableNavigator {\n  /**\n   * If the stream is enabled\n   * @default false\n   */\n  enabled?: MaybeRef<boolean>;\n  /**\n   * Recreate stream when deviceIds or constraints changed\n   *\n   * @default true\n   */\n  autoSwitch?: MaybeRef<boolean>;\n  /**\n   * MediaStreamConstraints to be applied to the requested MediaStream\n   * If provided, the constraints will override videoDeviceId and audioDeviceId\n   *\n   * @default {}\n   */\n  constraints?: MaybeRef<MediaStreamConstraints>;\n}\ninterface UseUserMediaReturn extends Supportable {\n  stream: Ref<MediaStream | undefined>;\n  start: () => Promise<MediaStream | undefined>;\n  stop: () => void;\n  restart: () => Promise<MediaStream | undefined>;\n  constraints: Ref<MediaStreamConstraints | undefined>;\n  enabled: ShallowRef<boolean>;\n  autoSwitch: ShallowRef<boolean>;\n}\n/**\n * Reactive `mediaDevices.getUserMedia` streaming\n *\n * @see https://vueuse.org/useUserMedia\n * @param options\n */\ndeclare function useUserMedia(options?: UseUserMediaOptions): UseUserMediaReturn;\n//#endregion\n//#region useVModel/index.d.ts\ninterface UseVModelOptions<T, Passive extends boolean = false> {\n  /**\n   * When passive is set to `true`, it will use `watch` to sync with props and ref.\n   * Instead of relying on the `v-model` or `.sync` to work.\n   *\n   * @default false\n   */\n  passive?: Passive;\n  /**\n   * When eventName is set, it's value will be used to overwrite the emit event name.\n   *\n   * @default undefined\n   */\n  eventName?: string;\n  /**\n   * Attempting to check for changes of properties in a deeply nested object or array.\n   * Apply only when `passive` option is set to `true`\n   *\n   * @default false\n   */\n  deep?: boolean;\n  /**\n   * Defining default value for return ref when no value is passed.\n   *\n   * @default undefined\n   */\n  defaultValue?: T;\n  /**\n   * Clone the props.\n   * Accepts a custom clone function.\n   * When setting to `true`, it will use `JSON.parse(JSON.stringify(value))` to clone.\n   *\n   * @default false\n   */\n  clone?: boolean | CloneFn<T>;\n  /**\n   * The hook before triggering the emit event can be used for form validation.\n   * if false is returned, the emit event will not be triggered.\n   *\n   * @default undefined\n   */\n  shouldEmit?: (v: T) => boolean;\n}\n/**\n * Shorthand for v-model binding, props + emit -> ref\n *\n * @see https://vueuse.org/useVModel\n * @param props\n * @param key (default 'modelValue')\n * @param emit\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useVModel<P$1 extends object, K$1 extends keyof P$1, Name extends string>(props: P$1, key?: K$1, emit?: (name: Name, ...args: any[]) => void, options?: UseVModelOptions<P$1[K$1], false>): WritableComputedRef<P$1[K$1]>;\ndeclare function useVModel<P$1 extends object, K$1 extends keyof P$1, Name extends string>(props: P$1, key?: K$1, emit?: (name: Name, ...args: any[]) => void, options?: UseVModelOptions<P$1[K$1], true>): Ref<UnwrapRef<P$1[K$1]>>;\n//#endregion\n//#region useVModels/index.d.ts\n/**\n * Shorthand for props v-model binding. Think like `toRefs(props)` but changes will also emit out.\n *\n * @see https://vueuse.org/useVModels\n * @param props\n * @param emit\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useVModels<P$1 extends object, Name extends string>(props: P$1, emit?: (name: Name, ...args: any[]) => void, options?: UseVModelOptions<any, true>): ToRefs<P$1>;\ndeclare function useVModels<P$1 extends object, Name extends string>(props: P$1, emit?: (name: Name, ...args: any[]) => void, options?: UseVModelOptions<any, false>): ToRefs<P$1>;\n//#endregion\n//#region useVibrate/index.d.ts\ninterface UseVibrateOptions extends ConfigurableNavigator, ConfigurableScheduler {\n  /**\n   *\n   * Vibration Pattern\n   *\n   * An array of values describes alternating periods in which the\n   * device is vibrating and not vibrating. Each value in the array\n   * is converted to an integer, then interpreted alternately as\n   * the number of milliseconds the device should vibrate and the\n   * number of milliseconds it should not be vibrating\n   *\n   * @default []\n   *\n   */\n  pattern?: MaybeRefOrGetter<Arrayable<number>>;\n  /**\n   * Interval to run a persistent vibration, in ms\n   *\n   * Pass `0` to disable\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default 0\n   *\n   */\n  interval: number;\n}\ninterface UseVibrateReturn extends Supportable {\n  pattern: MaybeRefOrGetter<Arrayable<number>>;\n  intervalControls?: Pausable;\n  vibrate: (pattern?: Arrayable<number>) => void;\n  stop: () => void;\n}\n/**\n * Reactive vibrate\n *\n * @see https://vueuse.org/useVibrate\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Vibration_API\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useVibrate(options?: UseVibrateOptions): UseVibrateReturn;\n//#endregion\n//#region useVirtualList/index.d.ts\ntype UseVirtualListItemSize = number | ((index: number) => number);\ninterface UseHorizontalVirtualListOptions extends UseVirtualListOptionsBase {\n  /**\n   * item width, accept a pixel value or a function that returns the width\n   *\n   * @default 0\n   */\n  itemWidth: UseVirtualListItemSize;\n}\ninterface UseVerticalVirtualListOptions extends UseVirtualListOptionsBase {\n  /**\n   * item height, accept a pixel value or a function that returns the height\n   *\n   * @default 0\n   */\n  itemHeight: UseVirtualListItemSize;\n}\ninterface UseVirtualListOptionsBase {\n  /**\n   * the extra buffer items outside of the view area\n   *\n   * @default 5\n   */\n  overscan?: number;\n}\ntype UseVirtualListOptions = UseHorizontalVirtualListOptions | UseVerticalVirtualListOptions;\ninterface UseVirtualListItem<T> {\n  data: T;\n  index: number;\n}\ninterface UseVirtualListReturn<T> {\n  list: Ref<UseVirtualListItem<T>[]>;\n  scrollTo: (index: number) => void;\n  containerProps: {\n    ref: Ref<HTMLElement | null>;\n    onScroll: () => void;\n    style: StyleValue;\n  };\n  wrapperProps: ComputedRef<{\n    style: {\n      width: string;\n      height: string;\n      marginTop: string;\n    } | {\n      width: string;\n      height: string;\n      marginLeft: string;\n      display: string;\n    };\n  }>;\n}\n/**\n * Please consider using [`vue-virtual-scroller`](https://github.com/Akryum/vue-virtual-scroller) if you are looking for more features.\n */\ndeclare function useVirtualList<T = any>(list: MaybeRef<readonly T[]>, options: UseVirtualListOptions): UseVirtualListReturn<T>;\n//#endregion\n//#region useWakeLock/index.d.ts\ntype WakeLockType = 'screen';\ninterface WakeLockSentinel extends EventTarget {\n  type: WakeLockType;\n  released: boolean;\n  release: () => Promise<void>;\n}\ntype UseWakeLockOptions = ConfigurableNavigator & ConfigurableDocument;\ninterface UseWakeLockReturn extends Supportable {\n  sentinel: ShallowRef<WakeLockSentinel | null>;\n  isActive: ComputedRef<boolean>;\n  request: (type: WakeLockType) => Promise<void>;\n  forceRequest: (type: WakeLockType) => Promise<void>;\n  release: () => Promise<void>;\n}\n/**\n * Reactive Screen Wake Lock API.\n *\n * @see https://vueuse.org/useWakeLock\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useWakeLock(options?: UseWakeLockOptions): UseWakeLockReturn;\n//#endregion\n//#region useWebNotification/index.d.ts\ninterface WebNotificationOptions {\n  /**\n   * The title read-only property of the Notification interface indicates\n   * the title of the notification\n   *\n   * @default ''\n   */\n  title?: string;\n  /**\n   * The body string of the notification as specified in the constructor's\n   * options parameter.\n   *\n   * @default ''\n   */\n  body?: string;\n  /**\n   * The text direction of the notification as specified in the constructor's\n   * options parameter.\n   *\n   * @default ''\n   */\n  dir?: 'auto' | 'ltr' | 'rtl';\n  /**\n   * The language code of the notification as specified in the constructor's\n   * options parameter.\n   *\n   * @default DOMString\n   */\n  lang?: string;\n  /**\n   * The ID of the notification(if any) as specified in the constructor's options\n   * parameter.\n   *\n   * @default ''\n   */\n  tag?: string;\n  /**\n   * The URL of the image used as an icon of the notification as specified\n   * in the constructor's options parameter.\n   *\n   * @default ''\n   */\n  icon?: string;\n  /**\n   * Specifies whether the user should be notified after a new notification\n   * replaces an old one.\n   *\n   * @default false\n   */\n  renotify?: boolean;\n  /**\n   * A boolean value indicating that a notification should remain active until the\n   * user clicks or dismisses it, rather than closing automatically.\n   *\n   * @default false\n   */\n  requireInteraction?: boolean;\n  /**\n   * The silent read-only property of the Notification interface specifies\n   * whether the notification should be silent, i.e., no sounds or vibrations\n   * should be issued, regardless of the device settings.\n   *\n   * @default false\n   */\n  silent?: boolean;\n  /**\n   * Specifies a vibration pattern for devices with vibration hardware to emit.\n   * A vibration pattern, as specified in the Vibration API spec\n   *\n   * @see https://w3c.github.io/vibration/\n   */\n  vibrate?: number[];\n}\ninterface UseWebNotificationOptions extends ConfigurableWindow, WebNotificationOptions {\n  /**\n   * Request for permissions onMounted if it's not granted.\n   *\n   * Can be disabled and calling `ensurePermissions` to grant afterwords.\n   *\n   * @default true\n   */\n  requestPermissions?: boolean;\n}\ninterface UseWebNotificationReturn extends Supportable {\n  notification: Ref<Notification | null>;\n  ensurePermissions: () => Promise<boolean | undefined>;\n  permissionGranted: ShallowRef<boolean>;\n  show: (overrides?: WebNotificationOptions) => Promise<Notification | undefined>;\n  close: () => void;\n  onClick: EventHookOn<Event>;\n  onShow: EventHookOn<Event>;\n  onError: EventHookOn<Event>;\n  onClose: EventHookOn<Event>;\n}\n/**\n * Reactive useWebNotification\n *\n * @see https://vueuse.org/useWebNotification\n * @see https://developer.mozilla.org/en-US/docs/Web/API/notification\n */\ndeclare function useWebNotification(options?: UseWebNotificationOptions): UseWebNotificationReturn;\n//#endregion\n//#region useWebSocket/index.d.ts\ntype WebSocketStatus = 'OPEN' | 'CONNECTING' | 'CLOSED';\ntype WebSocketHeartbeatMessage = string | ArrayBuffer | Blob;\ninterface UseWebSocketOptions {\n  onConnected?: (ws: WebSocket) => void;\n  onDisconnected?: (ws: WebSocket, event: CloseEvent) => void;\n  onError?: (ws: WebSocket, event: Event) => void;\n  onMessage?: (ws: WebSocket, event: MessageEvent) => void;\n  /**\n   * Send heartbeat for every x milliseconds passed\n   *\n   * @default false\n   */\n  heartbeat?: boolean | ConfigurableScheduler & {\n    /**\n     * Message for the heartbeat\n     *\n     * @default 'ping'\n     */\n    message?: MaybeRefOrGetter<WebSocketHeartbeatMessage>;\n    /**\n     * Response message for the heartbeat, if undefined the message will be used\n     */\n    responseMessage?: MaybeRefOrGetter<WebSocketHeartbeatMessage>;\n    /**\n     * Interval, in milliseconds\n     *\n     * @deprecated Please use `scheduler` option instead\n     * @default 1000\n     */\n    interval?: number;\n    /**\n     * Heartbeat response timeout, in milliseconds\n     *\n     * @default 1000\n     */\n    pongTimeout?: number;\n  };\n  /**\n   * Enabled auto reconnect\n   *\n   * @default false\n   */\n  autoReconnect?: boolean | {\n    /**\n     * Maximum retry times.\n     *\n     * Or you can pass a predicate function (which returns true if you want to retry).\n     *\n     * @default -1\n     */\n    retries?: number | ((retried: number) => boolean);\n    /**\n     * Delay for reconnect, in milliseconds\n     *\n     * Or you can pass a function to calculate the delay based on the number of retries.\n     *\n     * @default 1000\n     */\n    delay?: number | ((retries: number) => number);\n    /**\n     * On maximum retry times reached.\n     */\n    onFailed?: Fn;\n  };\n  /**\n   * Immediately open the connection when calling this composable\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Automatically connect to the websocket when URL changes\n   *\n   * @default true\n   */\n  autoConnect?: boolean;\n  /**\n   * Automatically close a connection\n   *\n   * @default true\n   */\n  autoClose?: boolean;\n  /**\n   * List of one or more sub-protocol strings\n   *\n   * @default []\n   */\n  protocols?: string[];\n}\ninterface UseWebSocketReturn<T> {\n  /**\n   * Reference to the latest data received via the websocket,\n   * can be watched to respond to incoming messages\n   */\n  data: Ref<T | null>;\n  /**\n   * The current websocket status, can be only one of:\n   * 'OPEN', 'CONNECTING', 'CLOSED'\n   */\n  status: ShallowRef<WebSocketStatus>;\n  /**\n   * Closes the websocket connection gracefully.\n   */\n  close: WebSocket['close'];\n  /**\n   * Reopen the websocket connection.\n   * If there the current one is active, will close it before opening a new one.\n   */\n  open: Fn;\n  /**\n   * Sends data through the websocket connection.\n   *\n   * @param data\n   * @param useBuffer when the socket is not yet open, store the data into the buffer and sent them one connected. Default to true.\n   */\n  send: (data: string | ArrayBuffer | Blob, useBuffer?: boolean) => boolean;\n  /**\n   * Reference to the WebSocket instance.\n   */\n  ws: Ref<WebSocket | undefined>;\n}\n/**\n * Reactive WebSocket client.\n *\n * @see https://vueuse.org/useWebSocket\n * @param url\n */\ndeclare function useWebSocket<Data = any>(url: MaybeRefOrGetter<string | URL | undefined>, options?: UseWebSocketOptions): UseWebSocketReturn<Data>;\n//#endregion\n//#region useWebWorker/index.d.ts\ntype PostMessage = typeof Worker.prototype['postMessage'];\ninterface UseWebWorkerReturn<Data = any> {\n  data: Ref<Data>;\n  post: PostMessage;\n  terminate: () => void;\n  worker: ShallowRef<Worker | undefined>;\n}\ntype WorkerFn = (...args: unknown[]) => Worker;\n/**\n * Simple Web Workers registration and communication.\n *\n * @see https://vueuse.org/useWebWorker\n * @param url\n * @param workerOptions\n * @param options\n */\ndeclare function useWebWorker<T = any>(url: string, workerOptions?: WorkerOptions, options?: ConfigurableWindow): UseWebWorkerReturn<T>;\n/**\n * Simple Web Workers registration and communication.\n *\n * @see https://vueuse.org/useWebWorker\n */\ndeclare function useWebWorker<T = any>(worker: Worker | WorkerFn): UseWebWorkerReturn<T>;\n//#endregion\n//#region useWebWorkerFn/index.d.ts\ntype WebWorkerStatus = 'PENDING' | 'SUCCESS' | 'RUNNING' | 'ERROR' | 'TIMEOUT_EXPIRED';\ninterface UseWebWorkerOptions extends ConfigurableWindow {\n  /**\n   * Number of milliseconds before killing the worker\n   *\n   * @default undefined\n   */\n  timeout?: number;\n  /**\n   * An array that contains the external dependencies needed to run the worker\n   */\n  dependencies?: string[];\n  /**\n   * An array that contains the local dependencies needed to run the worker\n   */\n  localDependencies?: Function[];\n}\ninterface UseWebWorkerFnReturn<T extends (...fnArgs: any[]) => any> {\n  workerFn: (...fnArgs: Parameters<T>) => Promise<ReturnType<T>>;\n  workerStatus: ShallowRef<WebWorkerStatus>;\n  workerTerminate: (status?: WebWorkerStatus) => void;\n}\n/**\n * Run expensive function without blocking the UI, using a simple syntax that makes use of Promise.\n *\n * @see https://vueuse.org/useWebWorkerFn\n * @param fn\n * @param options\n */\ndeclare function useWebWorkerFn<T extends (...fnArgs: any[]) => any>(fn: T, options?: UseWebWorkerOptions): UseWebWorkerFnReturn<T>;\n//#endregion\n//#region useWindowFocus/index.d.ts\n/**\n * Reactively track window focus with `window.onfocus` and `window.onblur`.\n *\n * @see https://vueuse.org/useWindowFocus\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useWindowFocus(options?: ConfigurableWindow): ShallowRef<boolean>;\n//#endregion\n//#region useWindowScroll/index.d.ts\ninterface UseWindowScrollOptions extends ConfigurableWindow, UseScrollOptions {}\ninterface UseWindowScrollReturn extends UseScrollReturn {}\n/**\n * Reactive window scroll.\n *\n * @see https://vueuse.org/useWindowScroll\n * @param options\n */\ndeclare function useWindowScroll(options?: UseWindowScrollOptions): UseWindowScrollReturn;\n//#endregion\n//#region useWindowSize/index.d.ts\ninterface UseWindowSizeOptions extends ConfigurableWindow {\n  initialWidth?: number;\n  initialHeight?: number;\n  /**\n   * Listen to window `orientationchange` event\n   *\n   * @default true\n   */\n  listenOrientation?: boolean;\n  /**\n   * Whether the scrollbar should be included in the width and height\n   * Only effective when `type` is `'inner'`\n   *\n   * @default true\n   */\n  includeScrollbar?: boolean;\n  /**\n   * Use `window.innerWidth` or `window.outerWidth` or `window.visualViewport`\n   * visualViewport documentation from MDN(https://developer.mozilla.org/zh-CN/docs/Web/API/VisualViewport)\n   * @default 'inner'\n   */\n  type?: 'inner' | 'outer' | 'visual';\n}\ninterface UseWindowSizeReturn {\n  width: ShallowRef<number>;\n  height: ShallowRef<number>;\n}\n/**\n * Reactive window size.\n *\n * @see https://vueuse.org/useWindowSize\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useWindowSize(options?: UseWindowSizeOptions): UseWindowSizeReturn;\n//#endregion\nexport { AfterFetchContext, AsyncComputedOnCancel, AsyncComputedOptions, BasicColorMode, BasicColorSchema, BatteryManager, BeforeFetchContext, Breakpoints, BrowserLocationState, CloneFn, ColorSchemeType, ComputedInjectGetter, ComputedInjectGetterWithDefault, ComputedInjectSetter, ConfigurableDeepRefs, ConfigurableDocument, ConfigurableDocumentOrShadowRoot, ConfigurableLocation, ConfigurableNavigator, ConfigurableScheduler, ConfigurableWindow, ContrastType, CreateFetchOptions, CreateReusableTemplateOptions, CubicBezierPoints, DefaultMagicKeysAliasMap, DefineTemplateComponent, DeviceMotionOptions, DocumentEventName, EasingFunction, ElementSize, EventBusEvents, EventBusIdentifier, EventBusKey, EventBusListener, EventSourceStatus, EyeDropper, EyeDropperOpenOptions, FileSystemAccessShowOpenFileOptions, FileSystemAccessShowSaveFileOptions, FileSystemAccessWindow, FileSystemFileHandle, FormatTimeAgoIntlOptions, FormatTimeAgoOptions, GeneralEventListener, GeneralPermissionDescriptor, InterpolationFunction, KeyFilter, KeyModifier, KeyPredicate, KeyStrokeEventName, MagicKeysInternal, MaybeComputedElementRef, MaybeElement, MaybeElementRef, MemoryInfo, MouseInElementOptions, MousePressedOptions, NavigatorLanguageState, NetworkEffectiveType, NetworkState, NetworkType, OnClickOutsideHandler, OnClickOutsideOptions, OnClickOutsideReturn, OnElementRemovalOptions, OnFetchErrorContext, OnKeyStrokeOptions, OnLongPressModifiers, OnLongPressOptions, OnLongPressReturn, OrientationLockType, OrientationType, PointerType, Position, ReducedMotionType, ReducedTransparencyType, RenderableComponent, ResizeObserverCallback, ResizeObserverEntry, ResizeObserverSize, ReusableTemplatePair, ReuseTemplateComponent, SSRHandlersMap, ScreenOrientation, Serializer, SerializerAsync, ShadowRootEventName, StorageEventLike, StorageLike, StorageLikeAsync, StorageSerializers, Supportable, TemplatePromise, TemplatePromiseOptions, TemplatePromiseProps, TemplateRefsList, TimeAgoUnit, ToDataURLOptions, TransitionOptions, TransitionPresets, UnRefElementReturn, UnrefFn, UrlParams, UseActiveElementOptions, UseActiveElementReturn, UseAnimateKeyframes, UseAnimateOptions, UseAnimateReturn, UseAsyncQueueOptions, UseAsyncQueueResult, UseAsyncQueueReturn, UseAsyncQueueTask, UseAsyncStateOptions, UseAsyncStateReturn, UseAsyncStateReturnBase, UseBase64ObjectOptions, UseBase64Options, UseBase64Return, UseBatteryOptions, UseBatteryReturn, UseBluetoothOptions, UseBluetoothRequestDeviceOptions, UseBluetoothReturn, UseBreakpointReturn, UseBreakpointsOptions, UseBroadcastChannelOptions, UseBroadcastChannelReturn, UseBrowserLocationOptions, UseBrowserLocationReturn, UseCachedOptions, UseCachedReturn, UseClipboardItemsOptions, UseClipboardItemsReturn, UseClipboardOptions, UseClipboardReturn, UseClonedOptions, UseClonedReturn, UseColorModeOptions, UseColorModeReturn, UseConfirmDialogReturn, UseConfirmDialogRevealResult, UseCountdownOptions, UseCountdownReturn, UseCssSupportsOptions, UseCssSupportsReturn, UseCssVarOptions, UseCycleListOptions, UseCycleListReturn, UseDarkOptions, UseDarkReturn, UseDeviceMotionOptions, UseDeviceMotionReturn, UseDeviceOrientationOptions, UseDeviceOrientationReturn, UseDevicePixelRatioOptions, UseDevicePixelRatioReturn, UseDevicesListOptions, UseDevicesListReturn, UseDisplayMediaOptions, UseDisplayMediaReturn, UseDocumentVisibilityOptions, UseDocumentVisibilityReturn, UseDraggableOptions, UseDraggableReturn, UseDropZoneOptions, UseDropZoneReturn, UseElementBoundingOptions, UseElementBoundingReturn, UseElementByPointOptions, UseElementByPointReturn, UseElementHoverOptions, UseElementSizeOptions, UseElementSizeReturn, UseElementVisibilityOptions, UseElementVisibilityReturn, UseEventBusReturn, UseEventSourceOptions, UseEventSourceReturn, UseEyeDropperOptions, UseEyeDropperReturn, UseFaviconOptions, UseFaviconReturn, UseFetchOptions, UseFetchReturn, UseFileDialogOptions, UseFileDialogReturn, UseFileSystemAccessCommonOptions, UseFileSystemAccessOptions, UseFileSystemAccessReturn, UseFileSystemAccessShowSaveFileOptions, UseFocusOptions, UseFocusReturn, UseFocusWithinReturn, UseFpsOptions, UseFullscreenOptions, UseFullscreenReturn, UseGamepadOptions, UseGamepadReturn, UseGeolocationOptions, UseGeolocationReturn, UseHorizontalVirtualListOptions, UseIdleOptions, UseIdleReturn, UseImageOptions, UseImageReturn, UseInfiniteScrollOptions, UseInfiniteScrollReturn, UseIntersectionObserverOptions, UseIntersectionObserverReturn, UseKeyModifierReturn, UseMagicKeysOptions, UseMagicKeysReturn, UseManualRefHistoryOptions, UseManualRefHistoryReturn, UseMediaControlsReturn, UseMediaSource, UseMediaTextTrack, UseMediaTextTrackSource, UseMemoizeCache, UseMemoizeOptions, UseMemoizeReturn, UseMemoryOptions, UseMemoryReturn, UseModifierOptions, UseMouseCoordType, UseMouseEventExtractor, UseMouseInElementReturn, UseMouseOptions, UseMousePressedOptions, UseMousePressedReturn, UseMouseReturn, UseMouseSourceType, UseMutationObserverOptions, UseMutationObserverReturn, UseNavigatorLanguageOptions, UseNavigatorLanguageReturn, UseNetworkOptions, UseNetworkReturn, UseNowOptions, UseNowReturn, UseOffsetPaginationInfinityPageReturn, UseOffsetPaginationOptions, UseOffsetPaginationReturn, UseOnLongPressReturn, UsePageLeaveOptions, UsePageLeaveReturn, UseParallaxOptions, UseParallaxReturn, UsePerformanceObserverOptions, UsePermissionOptions, UsePermissionReturn, UsePermissionReturnWithControls, UsePointerLockOptions, UsePointerLockReturn, UsePointerOptions, UsePointerReturn, UsePointerState, UsePointerSwipeOptions, UsePointerSwipeReturn, UseRafFnCallbackArguments, UseRafFnOptions, UseRefHistoryOptions, UseRefHistoryRecord, UseRefHistoryReturn, UseResizeObserverOptions, UseResizeObserverReturn, UseScreenOrientationOptions, UseScreenOrientationReturn, UseScreenSafeAreaReturn, UseScriptTagOptions, UseScriptTagReturn, UseScrollOptions, UseScrollReturn, UseShareOptions, UseShareReturn, UseSortedCompareFn, UseSortedFn, UseSortedOptions, UseSpeechRecognitionOptions, UseSpeechRecognitionReturn, UseSpeechSynthesisOptions, UseSpeechSynthesisReturn, UseSpeechSynthesisStatus, UseStepperReturn, UseStorageAsyncOptions, UseStorageOptions, UseStyleTagOptions, UseStyleTagReturn, UseSupportedReturn, UseSwipeDirection, UseSwipeOptions, UseSwipeReturn, UseTextDirectionOptions, UseTextDirectionValue, UseTextSelectionOptions, UseTextSelectionReturn, UseTextareaAutosizeOptions, UseTextareaAutosizeReturn, UseThrottledRefHistoryOptions, UseThrottledRefHistoryReturn, UseTimeAgoFormatter, UseTimeAgoIntlOptions, UseTimeAgoMessages, UseTimeAgoMessagesBuiltIn, UseTimeAgoOptions, UseTimeAgoReturn, UseTimeAgoUnit, UseTimeAgoUnitNamesDefault, UseTimeoutPollOptions, UseTimestampOptions, UseTimestampReturn, UseTitleOptions, UseTitleOptionsBase, UseTitleReturn, UseTransitionOptions, UseUrlSearchParamsOptions, UseUserMediaOptions, UseUserMediaReturn, UseVModelOptions, UseVerticalVirtualListOptions, UseVibrateOptions, UseVibrateReturn, UseVirtualListItem, UseVirtualListOptions, UseVirtualListOptionsBase, UseVirtualListReturn, UseWakeLockOptions, UseWakeLockReturn, UseWebNotificationOptions, UseWebNotificationReturn, UseWebSocketOptions, UseWebSocketReturn, UseWebWorkerFnReturn, UseWebWorkerOptions, UseWebWorkerReturn, UseWindowScrollOptions, UseWindowScrollReturn, UseWindowSizeOptions, UseWindowSizeReturn, VueInstance, WakeLockSentinel, WebNotificationOptions, WebSocketHeartbeatMessage, WebSocketStatus, WebWorkerStatus, WindowEventName, WritableComputedInjectOptions, WritableComputedInjectOptionsWithDefault, asyncComputed, breakpointsAntDesign, breakpointsBootstrapV5, breakpointsElement, breakpointsMasterCss, breakpointsPrimeFlex, breakpointsQuasar, breakpointsSematic, breakpointsTailwind, breakpointsVuetify, breakpointsVuetifyV2, breakpointsVuetifyV3, cloneFnJSON, computedAsync, computedInject, createFetch, createReusableTemplate, createTemplatePromise, createUnrefFn, customStorageEventName, defaultDocument, defaultLocation, defaultNavigator, defaultWindow, executeTransition, formatTimeAgo, formatTimeAgoIntl, formatTimeAgoIntlParts, getSSRHandler, mapGamepadToXbox360Controller, onClickOutside, onElementRemoval, onKeyDown, onKeyPressed, onKeyStroke, onKeyUp, onLongPress, onStartTyping, provideSSRWidth, setSSRHandler, templateRef, transition, unrefElement, useActiveElement, useAnimate, useAsyncQueue, useAsyncState, useBase64, useBattery, useBluetooth, useBreakpoints, useBroadcastChannel, useBrowserLocation, useCached, useClipboard, useClipboardItems, useCloned, useColorMode, useConfirmDialog, useCountdown, useCssSupports, useCssVar, useCurrentElement, useCycleList, useDark, useDebouncedRefHistory, useDeviceMotion, useDeviceOrientation, useDevicePixelRatio, useDevicesList, useDisplayMedia, useDocumentVisibility, useDraggable, useDropZone, useElementBounding, useElementByPoint, useElementHover, useElementSize, useElementVisibility, useEventBus, useEventListener, useEventSource, useEyeDropper, useFavicon, useFetch, useFileDialog, useFileSystemAccess, useFocus, useFocusWithin, useFps, useFullscreen, useGamepad, useGeolocation, useIdle, useImage, useInfiniteScroll, useIntersectionObserver, useKeyModifier, useLocalStorage, useMagicKeys, useManualRefHistory, useMediaControls, useMediaQuery, useMemoize, useMemory, useMounted, useMouse, useMouseInElement, useMousePressed, useMutationObserver, useNavigatorLanguage, useNetwork, useNow, useObjectUrl, useOffsetPagination, useOnline, usePageLeave, useParallax, useParentElement, usePerformanceObserver, usePermission, usePointer, usePointerLock, usePointerSwipe, usePreferredColorScheme, usePreferredContrast, usePreferredDark, usePreferredLanguages, usePreferredReducedMotion, usePreferredReducedTransparency, usePrevious, useRafFn, useRefHistory, useResizeObserver, useSSRWidth, useScreenOrientation, useScreenSafeArea, useScriptTag, useScroll, useScrollLock, useSessionStorage, useShare, useSorted, useSpeechRecognition, useSpeechSynthesis, useStepper, useStorage, useStorageAsync, useStyleTag, useSupported, useSwipe, useTemplateRefsList, useTextDirection, useTextSelection, useTextareaAutosize, useThrottledRefHistory, useTimeAgo, useTimeAgoIntl, useTimeoutPoll, useTimestamp, useTitle, useTransition, useUrlSearchParams, useUserMedia, useVModel, useVModels, useVibrate, useVirtualList, useWakeLock, useWebNotification, useWebSocket, useWebWorker, useWebWorkerFn, useWindowFocus, useWindowScroll, useWindowSize };","export declare function useBreakpoints(): import(\"@vueuse/core\").UseBreakpointReturn<\"sm\" | \"md\" | \"lg\" | \"xl\" | \"2xl\">;\n","import type { MaybeRef } from 'vue';\nexport interface RGB {\n    r: number;\n    g: number;\n    b: number;\n}\nexport interface RGBA extends RGB {\n    a: number;\n}\nexport interface HSL {\n    h: number;\n    s: number;\n    l: number;\n}\nexport interface OKLCH {\n    l: number;\n    c: number;\n    h: number;\n}\nexport declare function extracRGB(color: string): RGB;\nexport declare function extractRGBA(color: string): RGBA;\nexport declare function hexToRGB(hex: string): RGB;\nexport declare function hslToRgb(hsl: string): RGB;\nexport declare function rgbToHsl(r: number, g: number, b: number): HSL;\nexport declare function rgbToHex(r: number, g: number, b: number): string;\nexport declare function rgbaToString(rgba: RGBA): string;\nexport declare function extractOKLCH(color: string): OKLCH;\nexport declare function oklchToRgb(color: string): RGB;\nexport declare function rgbToOklch(r: number, g: number, b: number): OKLCH;\nexport declare function useColorType(payload?: MaybeRef<string | null | undefined>): import(\"vue\").WritableComputedRef<string | null, string | null>;\nexport declare function useRGB(payload?: MaybeRef<string | null | undefined>): import(\"vue\").WritableComputedRef<RGB | null, RGB | null>;\nexport declare function useRGBA(payload?: MaybeRef<string | null | undefined>): import(\"vue\").WritableComputedRef<RGBA | null, RGBA | null>;\nexport declare function useHSL(payload?: MaybeRef<string | null | undefined>): import(\"vue\").WritableComputedRef<HSL | null, HSL | null>;\nexport declare function useHex(payload?: MaybeRef<string | null | undefined>): import(\"vue\").WritableComputedRef<string | null, string | null>;\nexport declare function useColor(payload?: MaybeRef<string | null | undefined>): {\n    type: import(\"vue\").WritableComputedRef<string | null, string | null>;\n    color: import(\"vue\").Ref<string | null | undefined, string | null | undefined>;\n    hex: import(\"vue\").WritableComputedRef<string | null, string | null>;\n    rgb: import(\"vue\").WritableComputedRef<RGB | null, RGB | null>;\n    hsl: import(\"vue\").WritableComputedRef<HSL | null, HSL | null>;\n    oklch: import(\"vue\").WritableComputedRef<OKLCH | null, OKLCH | null>;\n    rgba: import(\"vue\").WritableComputedRef<RGBA | null, RGBA | null>;\n};\n","import LoggerService from './LoggerService.ts';\nexport interface EmmitterListenerOptions {\n    event: string;\n}\nexport interface EmmitterListener {\n    (data: any, options: EmmitterListenerOptions): void;\n}\ninterface EmmitterHandler {\n    id: string;\n    event: string;\n    listener: EmmitterListener;\n    originalListener?: EmmitterListener;\n}\ninterface OnOptions {\n    id?: string;\n    unique?: boolean;\n}\ninterface OnDebounceOptions extends OnOptions {\n    debounce?: number;\n}\nexport interface EmmitterServiceOptions {\n    debug?: boolean;\n    logger?: LoggerService;\n}\nexport default class EmmitterService<Events extends Record<string, any> = Record<string, any>> {\n    static __container_entry_key: string;\n    handlers: EmmitterHandler[];\n    debug: boolean;\n    logger: LoggerService;\n    constructor(options?: EmmitterServiceOptions);\n    static create<Events extends Record<string, any> = Record<string, any>>(options?: EmmitterServiceOptions): EmmitterService<Events>;\n    setDebug(debug: boolean): void;\n    setLogger(logger: LoggerService): void;\n    on<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler;\n    on(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler;\n    once<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler;\n    once(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler;\n    onDebounce<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnDebounceOptions): EmmitterHandler;\n    onDebounce(event: string, listener: (args: any) => void, options?: OnDebounceOptions): EmmitterHandler;\n    onAnyOf<K extends keyof Events>(events: K[], listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler[];\n    onAnyOf(events: string[], listener: (args: any) => void, options?: OnOptions): EmmitterHandler[];\n    off(event: string, listener: EmmitterHandler['listener']): void;\n    emit<K extends keyof Events>(event: K, args: Events[K]): void;\n    emit(event: string, args?: any): void;\n    emitAndWait<K extends keyof Events>(event: K, args: Events[K]): Promise<void>;\n    emitAndWait(event: string, args?: any): Promise<void>;\n    list(): EmmitterHandler[];\n    listByEvent(event: string): EmmitterHandler[];\n    remove(payload: string | string[]): void;\n    clear(): void;\n    hasHandlers(): boolean;\n}\nexport {};\n","export interface DashboardGridUnit {\n    base?: number;\n    sm?: number;\n    md?: number;\n    lg?: number;\n    xl?: number;\n}\nexport default class DashboardWidgetData {\n    id: string;\n    name: string;\n    definition_id: string;\n    columns: DashboardGridUnit;\n    rows: DashboardGridUnit;\n    x: DashboardGridUnit;\n    y: DashboardGridUnit;\n    order: number;\n    options: Record<string, any>;\n    constructor(data: Partial<DashboardWidgetData>);\n}\n","export interface DashboardWidgetAction {\n    props?: Record<string, any>;\n    component: any;\n}\nexport default class DashboardWidgetDefinition {\n    id: string;\n    name: string;\n    description?: string;\n    icon?: string;\n    constructor();\n    component(): any;\n    actions(): DashboardWidgetAction[];\n}\n","import EmmitterService from '#shared/services/EmmitterService.ts';\nimport type DashboardWidgetData from './DashboardWidgetData';\nimport DashboardWidgetDefinition from './DashboardWidgetDefinition';\nexport declare const DASHBOARD_ROW_HEIGHT = 80;\ninterface DashboardWidgetOptions {\n    data: DashboardWidgetData;\n    definition: DashboardWidgetDefinition;\n}\ninterface StylesOptions {\n    contianerWidth: number;\n    breakpoint?: 'base' | 'sm' | 'md' | 'xl';\n}\nexport default class DashboardWidget {\n    data: DashboardWidgetData;\n    definition: DashboardWidgetDefinition;\n    emmitter: EmmitterService;\n    constructor({ data, definition }: DashboardWidgetOptions);\n    static fromData(data: DashboardWidgetData): DashboardWidget;\n    setEmmitter(emmitter: EmmitterService): void;\n    get id(): string;\n    get name(): string;\n    set name(value: string);\n    get options(): DashboardWidgetData['options'];\n    get definition_id(): string;\n    component(): any;\n    actions(): import(\"./DashboardWidgetDefinition\").DashboardWidgetAction[];\n    get columns(): DashboardWidgetData['columns'];\n    set columns(payload: DashboardWidgetData['columns']);\n    get rows(): DashboardWidgetData['rows'];\n    set rows(payload: DashboardWidgetData['rows']);\n    get x(): DashboardWidgetData['x'];\n    set x(payload: DashboardWidgetData['x']);\n    get y(): DashboardWidgetData['y'];\n    set y(payload: DashboardWidgetData['y']);\n    get classes(): string;\n    computeStyles(options: StylesOptions): string;\n    update(payload: Partial<DashboardWidgetData>): void;\n    setOption(key: string, value: any): void;\n    setX(breakpoint: 'base' | 'sm' | 'md' | 'lg' | 'xl', value?: number | undefined): void;\n    setY(breakpoint: 'base' | 'sm' | 'md' | 'lg' | 'xl', value?: number | undefined): void;\n    setColumn(breakpoint: 'base' | 'sm' | 'md' | 'lg' | 'xl', value?: number | undefined): void;\n    setRow(breakpoint: 'base' | 'sm' | 'md' | 'lg' | 'xl', value?: number | undefined): void;\n}\nexport {};\n","import * as v from 'valibot';\nexport declare const number: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>;\nexport declare const boolean: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>], undefined>, v.TransformAction<string | boolean, boolean>]>;\nexport declare const date: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, Date>, v.TransformAction<Date, string>]>;\nexport declare const datetime: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, string | null>]>;\nexport declare const array: <T extends v.BaseSchema<any, any, any>>(schema?: T) => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<T, undefined>]>;\nexport declare const arrayNumber: () => v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.BaseSchema<any, any, any>, undefined>]>, v.TransformAction<any[], number[]>]>;\nexport declare const object: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>], undefined>, v.TransformAction<string | {\n    [x: string]: any;\n}, {\n    [x: string]: any;\n}>, v.TransformAction<{\n    [x: string]: any;\n}, Record<string, any>>]>;\nexport declare function url(): v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>], undefined>, v.TransformAction<string | {\n    [x: string]: any;\n}, {\n    [x: string]: any;\n}>, v.TransformAction<{\n    [x: string]: any;\n}, Record<string, any>>]>;\nexport declare namespace url {\n    var number: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>;\n    var boolean: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>], undefined>, v.TransformAction<string | boolean, boolean>]>;\n    var date: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, Date>, v.TransformAction<Date, string>]>;\n    var datetime: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, string | null>]>;\n    var array: <T extends v.BaseSchema<any, any, any>>(schema?: T) => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<T, undefined>]>;\n    var arrayNumber: () => v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.BaseSchema<any, any, any>, undefined>]>, v.TransformAction<any[], number[]>]>;\n    var object: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>], undefined>, v.TransformAction<string | {\n        [x: string]: any;\n    }, {\n        [x: string]: any;\n    }>, v.TransformAction<{\n        [x: string]: any;\n    }, Record<string, any>>]>;\n}\n","import * as v from 'valibot';\nexport declare const keyValue: () => v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TransformAction<string, Record<string, any>>]>;\n","import * as v from 'valibot';\nexport interface PaginationParams {\n    maxLimit?: number;\n    orderFields?: string[];\n}\nexport declare const base: (options?: PaginationParams) => v.ObjectSchema<{\n    readonly page: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, 1>;\n    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, number>;\n    readonly orderBy: v.NullishSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.PicklistSchema<string[], undefined>, undefined>]> | v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.StringSchema<undefined>, undefined>]>, readonly []>;\n    readonly orderDirection: v.NullishSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.UnionSchema<[v.LiteralSchema<\"asc\", undefined>, v.LiteralSchema<\"desc\", undefined>], undefined>, undefined>]>, readonly []>;\n}, undefined>;\nexport declare function pagination(options?: PaginationParams): v.ObjectSchema<{\n    readonly page: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, 1>;\n    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, number>;\n    readonly orderBy: v.NullishSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.PicklistSchema<string[], undefined>, undefined>]> | v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.StringSchema<undefined>, undefined>]>, readonly []>;\n    readonly orderDirection: v.NullishSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.UnionSchema<[v.LiteralSchema<\"asc\", undefined>, v.LiteralSchema<\"desc\", undefined>], undefined>, undefined>]>, readonly []>;\n}, undefined>;\nexport declare namespace pagination {\n    var base: (options?: PaginationParams) => v.ObjectSchema<{\n        readonly page: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, 1>;\n        readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, number>;\n        readonly orderBy: v.NullishSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.PicklistSchema<string[], undefined>, undefined>]> | v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.StringSchema<undefined>, undefined>]>, readonly []>;\n        readonly orderDirection: v.NullishSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.UnionSchema<[v.LiteralSchema<\"asc\", undefined>, v.LiteralSchema<\"desc\", undefined>], undefined>, undefined>]>, readonly []>;\n    }, undefined>;\n}\n","export * from './urlValidator.ts';\nexport * from './keyValueValidator.ts';\nexport * from './paginationValidator.ts';\n","import * as v from 'valibot';\nimport * as extras from '#shared/validators/index.ts';\nexport type Valibot = typeof v & {\n    extras: typeof extras;\n};\nexport type ValibotSchema = v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>;\nexport type ValibotObjectSchema = v.ObjectSchema<any, any>;\nexport type ValibotSchemaAsync = v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>;\nexport interface ValidatorCallback<T extends ValibotSchema> {\n    (_v: Valibot): T;\n}\nexport type ValidatorCallbackAsync<T extends ValibotSchemaAsync> = {\n    (_v: Valibot): T;\n};\nexport type ValidatorResult<T extends v.BaseSchema<any, any, any>> = v.InferOutput<T>;\nexport type ValidatePayload<T extends ValibotSchema = ValibotSchema> = ValidatorCallback<T> | T;\nexport type ValidateResult<T extends ValidatePayload> = T extends ValibotSchema ? v.InferOutput<T> : T extends ValidatorCallback<infer U> ? v.InferOutput<U> : unknown;\nexport default class ValidatorService {\n    static __container_entry_key: string;\n    v: Valibot;\n    create<T extends ValibotSchema>(cb: ValidatorCallback<T>): T;\n    validate<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): v.InferOutput<T>;\n    validateAsync<T extends ValibotSchemaAsync>(payload: any, cb: ValidatorCallbackAsync<T> | T): Promise<v.InferOutput<T>>;\n    isValid<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): boolean;\n}\n","import type { ValidatorResult } from '#shared/services/ValidatorService.ts';\nexport type DashboardSchema = ValidatorResult<ReturnType<typeof dashboardSchema>>;\nexport declare function dashboardSchema(): import(\"valibot\").ObjectSchema<{\n    readonly id: import(\"valibot\").NumberSchema<undefined>;\n    readonly name: import(\"valibot\").StringSchema<undefined>;\n    readonly description: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n    readonly created_at: import(\"valibot\").StringSchema<undefined>;\n    readonly updated_at: import(\"valibot\").StringSchema<undefined>;\n    readonly deleted_at: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n    readonly metas: import(\"valibot\").OptionalSchema<import(\"valibot\").RecordSchema<import(\"valibot\").StringSchema<undefined>, import(\"valibot\").AnySchema, undefined>, undefined>;\n}, undefined>;\nexport declare namespace dashboardSchema {\n    var create: Omit<import(\"valibot\").ObjectSchema<{\n        readonly id: import(\"valibot\").NumberSchema<undefined>;\n        readonly name: import(\"valibot\").StringSchema<undefined>;\n        readonly description: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n        readonly created_at: import(\"valibot\").StringSchema<undefined>;\n        readonly updated_at: import(\"valibot\").StringSchema<undefined>;\n        readonly deleted_at: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n        readonly metas: import(\"valibot\").OptionalSchema<import(\"valibot\").RecordSchema<import(\"valibot\").StringSchema<undefined>, import(\"valibot\").AnySchema, undefined>, undefined>;\n    }, undefined>, \"entries\" | \"~types\" | \"~run\" | \"~standard\"> & {\n        readonly entries: Pick<{\n            readonly id: import(\"valibot\").NumberSchema<undefined>;\n            readonly name: import(\"valibot\").StringSchema<undefined>;\n            readonly description: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n            readonly created_at: import(\"valibot\").StringSchema<undefined>;\n            readonly updated_at: import(\"valibot\").StringSchema<undefined>;\n            readonly deleted_at: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n            readonly metas: import(\"valibot\").OptionalSchema<import(\"valibot\").RecordSchema<import(\"valibot\").StringSchema<undefined>, import(\"valibot\").AnySchema, undefined>, undefined>;\n        }, \"description\" | \"name\">;\n        readonly \"~standard\": import(\"valibot\").StandardProps<{\n            description: string | null;\n            name: string;\n        }, {\n            description: string | null;\n            name: string;\n        }>;\n        readonly \"~run\": (dataset: import(\"valibot\").UnknownDataset, config: import(\"valibot\").Config<import(\"valibot\").BaseIssue<unknown>>) => import(\"valibot\").OutputDataset<{\n            description: string | null;\n            name: string;\n        }, import(\"valibot\").ObjectIssue | import(\"valibot\").StringIssue>;\n        readonly \"~types\"?: {\n            readonly input: {\n                description: string | null;\n                name: string;\n            };\n            readonly output: {\n                description: string | null;\n                name: string;\n            };\n            readonly issue: import(\"valibot\").ObjectIssue | import(\"valibot\").StringIssue;\n        } | undefined;\n    };\n    var update: Omit<Omit<import(\"valibot\").ObjectSchema<{\n        readonly id: import(\"valibot\").NumberSchema<undefined>;\n        readonly name: import(\"valibot\").StringSchema<undefined>;\n        readonly description: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n        readonly created_at: import(\"valibot\").StringSchema<undefined>;\n        readonly updated_at: import(\"valibot\").StringSchema<undefined>;\n        readonly deleted_at: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n        readonly metas: import(\"valibot\").OptionalSchema<import(\"valibot\").RecordSchema<import(\"valibot\").StringSchema<undefined>, import(\"valibot\").AnySchema, undefined>, undefined>;\n    }, undefined>, \"entries\" | \"~types\" | \"~run\" | \"~standard\"> & {\n        readonly entries: Pick<{\n            readonly id: import(\"valibot\").NumberSchema<undefined>;\n            readonly name: import(\"valibot\").StringSchema<undefined>;\n            readonly description: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n            readonly created_at: import(\"valibot\").StringSchema<undefined>;\n            readonly updated_at: import(\"valibot\").StringSchema<undefined>;\n            readonly deleted_at: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n            readonly metas: import(\"valibot\").OptionalSchema<import(\"valibot\").RecordSchema<import(\"valibot\").StringSchema<undefined>, import(\"valibot\").AnySchema, undefined>, undefined>;\n        }, \"description\" | \"name\">;\n        readonly \"~standard\": import(\"valibot\").StandardProps<{\n            description: string | null;\n            name: string;\n        }, {\n            description: string | null;\n            name: string;\n        }>;\n        readonly \"~run\": (dataset: import(\"valibot\").UnknownDataset, config: import(\"valibot\").Config<import(\"valibot\").BaseIssue<unknown>>) => import(\"valibot\").OutputDataset<{\n            description: string | null;\n            name: string;\n        }, import(\"valibot\").ObjectIssue | import(\"valibot\").StringIssue>;\n        readonly \"~types\"?: {\n            readonly input: {\n                description: string | null;\n                name: string;\n            };\n            readonly output: {\n                description: string | null;\n                name: string;\n            };\n            readonly issue: import(\"valibot\").ObjectIssue | import(\"valibot\").StringIssue;\n        } | undefined;\n    }, \"entries\" | \"~types\" | \"~run\" | \"~standard\"> & {\n        readonly entries: {\n            readonly description: import(\"valibot\").OptionalSchema<import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>, undefined>;\n            readonly name: import(\"valibot\").OptionalSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n        };\n        readonly \"~standard\": import(\"valibot\").StandardProps<{\n            description?: string | null | undefined;\n            name?: string | undefined;\n        }, {\n            description?: string | null | undefined;\n            name?: string | undefined;\n        }>;\n        readonly \"~run\": (dataset: import(\"valibot\").UnknownDataset, config: import(\"valibot\").Config<import(\"valibot\").BaseIssue<unknown>>) => import(\"valibot\").OutputDataset<{\n            description?: string | null | undefined;\n            name?: string | undefined;\n        }, import(\"valibot\").ObjectIssue | import(\"valibot\").StringIssue>;\n        readonly \"~types\"?: {\n            readonly input: {\n                description?: string | null | undefined;\n                name?: string | undefined;\n            };\n            readonly output: {\n                description?: string | null | undefined;\n                name?: string | undefined;\n            };\n            readonly issue: import(\"valibot\").ObjectIssue | import(\"valibot\").StringIssue;\n        } | undefined;\n    };\n}\n","import EmmitterService from '#shared/services/EmmitterService.ts';\nimport DashboardWidgetData from './DashboardWidgetData';\nimport DashboardWidget from './DashboardWidget';\nimport type { DashboardSchema } from '#shared/schemas/dashboardSchema.ts';\nexport interface DashboardOptions {\n    dashboard: DashboardSchema;\n    widgets?: DashboardWidgetData[];\n}\nexport default class Dashboard {\n    name: DashboardSchema['name'];\n    description: DashboardSchema['description'];\n    widgets: DashboardWidget[];\n    emmitter: EmmitterService;\n    containerWidth: number;\n    constructor();\n    setName(name: string): this;\n    setDescription(description: string): this;\n    setContainerWidth(width: number): this;\n    setWidgets(widgets: DashboardWidgetData[]): this;\n    findLastRow(): number;\n    addWidget(payload?: Partial<DashboardWidgetData>): void;\n    removeWidget(index: number): void;\n    removeWidgetById(id: string): void;\n    updateWidget(index: number, widget: DashboardWidget): void;\n    duplicateWidget(index: number): void;\n}\n","import type { Ref } from 'vue';\nimport type DashboardEntity from '#client/entities/Dashboard.ts';\nexport declare function provideDashboard(entity: Ref<DashboardEntity>): void;\nexport declare function useDashboard(): Ref<DashboardEntity>;\n","import type { Ref } from 'vue';\nimport type DashboardWidget from '#client/entities/DashboardWidget.ts';\nexport declare function provideDashboardWidget(entity: Ref<DashboardWidget>): void;\nexport declare function useDashboardWidget(): Ref<DashboardWidget>;\n","import type { MaybeRef, Ref } from 'vue';\nexport interface UseFetchPaginationOptions {\n    key?: string;\n    query?: MaybeRef<Record<string, any>>;\n    page?: MaybeRef<number>;\n    serialize?: (item: any) => any;\n    refine?: (items: any[]) => any[];\n    limit?: number;\n    orderBy?: string | string[] | null;\n    orderDirection?: 'asc' | 'desc' | ('asc' | 'desc')[] | null;\n    debounce?: number;\n    immediate?: boolean;\n}\nexport declare function useFetchPagination<T = any>(url: string, options?: UseFetchPaginationOptions): {\n    page: Ref<number, number>;\n    limit: Ref<number, number>;\n    orderBy: Ref<string | string[] | null, string | string[] | null>;\n    orderDirection: Ref<\"asc\" | \"desc\" | (\"asc\" | \"desc\")[] | null, \"asc\" | \"desc\" | (\"asc\" | \"desc\")[] | null>;\n    total: import(\"vue\").ComputedRef<number>;\n    totalPages: import(\"vue\").ComputedRef<number>;\n    items: import(\"vue\").ComputedRef<T[]>;\n    loading: Ref<boolean, boolean>;\n    load: () => Promise<void>;\n    reset: () => Promise<void>;\n    query: Ref<Record<string, any>, Record<string, any>>;\n    hydrate: () => Promise<void>;\n};\n","interface Entry {\n    key: string;\n    value: any;\n    source: string;\n}\nexport default class ConfigService {\n    static __container_entry_key: string;\n    entries: Map<string, Entry>;\n    constructor();\n    list(): Entry[];\n    parseValue(value: any): any;\n    loadFromRecord(record: Record<string, any>, source?: string): void;\n    loadFromEntries(entries: [string, any][], source?: string): void;\n    toRecord(): Record<string, any>;\n    has(key: string): boolean;\n    get<T = any | undefined>(key: string, defaultValue?: any): T;\n    getOne<T = any | undefined>(keys: string[], defaultValue?: any): T;\n    set(key: string, value: any, source?: string): void;\n    unset(key: string): void;\n    clear(): void;\n    dump(): Record<string, any>;\n}\nexport {};\n","type Constructor<T = object> = new (...args: any[]) => T;\ntype EntryKey = string | symbol | Constructor;\nexport default class ContainerService {\n    private entries;\n    loadFromRecord(record: Record<string, any>): void;\n    toRecord(): Record<string, any>;\n    private getKey;\n    set(payload: EntryKey, value: any): this;\n    has(payload: EntryKey): boolean;\n    get<T>(payload: EntryKey): T;\n    unset(payload: EntryKey): void;\n    singleton<T>(classConstructor: Constructor<T>): T;\n    load(entries: Record<any, any>): void;\n    proxy<T = unknown>(key: EntryKey): T;\n    keys(): EntryKey[];\n}\nexport {};\n","export declare function createId(prefix?: string): string;\n","import { defineAbility } from '@casl/ability';\nimport Permission from './PermissionEntity.ts';\nimport LoggerService from '#shared/services/LoggerService.ts';\nexport default class AclEntity {\n    static __container_entry_key: string;\n    ability: ReturnType<typeof defineAbility>;\n    permissions: Permission[];\n    debug: boolean;\n    logger: LoggerService;\n    constructor(data?: Partial<AclEntity>);\n    can(action: string, subject: any, object?: Record<string, any>): boolean;\n    cannot(action: string, subject: any, object?: Record<string, any>): boolean;\n    subject(subject: string, object: Record<string, any>): Record<string, any> & import(\"@casl/ability\").ForcedSubject<string>;\n}\n","export interface ModuleManifestBuildImport {\n    from: string;\n    to?: string;\n    type: 'global_import';\n}\nexport interface ModuleManifestBuild {\n    imports?: ModuleManifestBuildImport[];\n}\ndeclare const ModuleManifest_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor;\nexport default class ModuleManifest extends ModuleManifest_base {\n    id: string;\n    name: string;\n    version: string;\n    description?: string;\n    enabled: boolean;\n    author?: string;\n    dependencies?: Record<string, string>;\n    build?: ModuleManifestBuild;\n    [key: string]: any;\n}\nexport {};\n","import type ModuleManifest from './ModuleManifestEntity.ts';\nimport LifecycleHook from '#shared/entities/LifecycleHook.ts';\ninterface ModuleUpgradeInfo {\n    source: 'git' | 'zip';\n    [key: string]: any;\n}\ndeclare const Module_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor & import(\"#shared/utils/compose.ts\").Constructor<{}> & typeof LifecycleHook;\nexport default class Module extends Module_base {\n    id: string;\n    name: string;\n    enabled: boolean;\n    dependencies: Record<string, any>;\n    build: ModuleManifest['build'];\n    directory: string;\n    upgrade_info?: ModuleUpgradeInfo;\n    setData(data: Partial<Module | ModuleManifest>): void;\n}\nexport {};\n","declare const PluginEntity_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor;\nexport default class PluginEntity extends PluginEntity_base {\n    id: string;\n    name: string;\n    version: string;\n    enabled: boolean;\n    aliases: string[];\n    version_channel: string;\n    version_available_channels: string[];\n}\nexport {};\n","import { type ValibotObjectSchema, type ValibotSchema, type ValidatePayload, type ValidatorResult } from '#shared/index.ts';\nimport { toTypedSchema as veeValidateToTypedSchema } from '@vee-validate/valibot';\nimport { type FormContext, type FormOptions, type GenericObject } from 'vee-validate';\nexport interface ValibotFormOptions<T extends ValibotSchema = ValibotSchema> extends Omit<FormOptions<ValidatePayload<T>, ValidatorResult<T>>, 'validationSchema'> {\n}\nexport interface ValibotFormResultObject<T extends ValibotObjectSchema> extends GenericObject, FormContext<ValidatorResult<T>> {\n}\nexport declare const useForm: typeof useValibotForm;\nexport declare const toTypedSchema: typeof veeValidateToTypedSchema;\nexport declare function useValibotForm<T extends ValibotObjectSchema = ValibotObjectSchema>(schema: T, options?: ValibotFormOptions<T>): FormContext<ValidatorResult<T>>;\n","export declare function useLayoutOptions(): import(\"vue\").Ref<any, any>;\n","import type { Ref } from 'vue';\ninterface Options {\n    timeout?: number;\n}\ninterface LoadingRef extends Ref<boolean> {\n    set: (value: boolean) => void;\n}\nexport declare function useLoading(defaultValue?: boolean, options?: Options): LoadingRef;\nexport {};\n","export interface MenuBase {\n    id: string;\n    label: string;\n    order?: number;\n}\nexport interface MenuSingle extends MenuBase {\n    icon: string;\n    to: string;\n    target?: '_blank' | '_self' | '_parent' | '_top';\n}\nexport interface MenuWithChildren extends MenuBase {\n    icon: string;\n    children: Omit<MenuSingle, 'icon'>[];\n}\nexport interface MenuGroup extends MenuBase {\n    group: boolean;\n    items: MenuItem[];\n}\nexport interface MenuItem {\n    id: string;\n    label: string;\n    to?: string;\n    target?: '_blank' | '_self' | '_parent' | '_top';\n    group?: string;\n    order?: number;\n    icon?: string;\n    parent?: string;\n    layout?: string;\n}\nexport type UseMenu = ReturnType<typeof useMenu>;\nexport declare function useMenu(): {\n    items: import(\"vue\").ComputedRef<{\n        id: string;\n        label: string;\n        to?: string | undefined;\n        target?: \"_blank\" | \"_self\" | \"_parent\" | \"_top\" | undefined;\n        group?: string | undefined;\n        order?: number | undefined;\n        icon?: string | undefined;\n        parent?: string | undefined;\n        layout?: string | undefined;\n    }[]>;\n    add: (...item: MenuItem[]) => void;\n    remove: (item: MenuItem | MenuItem[\"id\"]) => void;\n    removeGroup: (groupId: string) => void;\n    removeMany: (itemIds: string[]) => void;\n    removeManyGroup: (groupIds: string[]) => void;\n    clear: () => void;\n};\n","import { useRouteQuery as vueUserRouteQuery } from '@vueuse/router';\nexport declare const useRouteQuery: typeof vueUserRouteQuery;\n","import type { Ref } from 'vue';\nexport interface UseStateOptions {\n    default?: () => any;\n    transform?: (value: any) => any;\n}\nexport declare function useState<T>(key: string, options?: UseStateOptions): Ref<T>;\n","import AclEntity from '#shared/entities/AclEntity.ts';\ndeclare const acl: AclEntity;\nexport default acl;\n","import AuthService from '#client/services/AuthService.ts';\ndeclare const auth: AuthService;\nexport default auth;\n","import ConfigService from '#shared/services/ConfigService.ts';\ndeclare const config: ConfigService;\nexport default config;\n","import ContainerService from \"#shared/services/ContainerService.ts\";\ndeclare const _default: ContainerService;\nexport default _default;\n","import type DashboardWidgetDefinition from '#client/entities/DashboardWidgetDefinition.ts';\nexport default class DashboardWidgetRegistry {\n    static __container_entry_key: string;\n    private definitions;\n    register(...definition: DashboardWidgetDefinition[]): void;\n    get(id: string): DashboardWidgetDefinition | null;\n    list(): DashboardWidgetDefinition[];\n}\n","import DashboardWidgetRegistry from '#client/registry/DashboardWidgetRegistry.ts';\ndeclare const dashboardRegistry: DashboardWidgetRegistry;\nexport default dashboardRegistry;\n","import { EmmitterService } from '#shared/index.ts';\ndeclare const emmitter: EmmitterService<Record<string, any>>;\nexport default emmitter;\n","import FetchService from '#client/services/FetchService.ts';\ndeclare const fetcher: FetchService;\nexport default fetcher;\n","declare const layout: any;\nexport default layout;\n","import LifecycleService from '#client/services/LifecycleService.ts';\ndeclare const lifecycle: LifecycleService;\nexport default lifecycle;\n","import LoggerService from '#shared/services/LoggerService.ts';\ndeclare const logger: LoggerService;\nexport default logger;\n","import MenuService from '#client/services/MenuService.ts';\ndeclare const menu: MenuService;\nexport default menu;\n","import type { RouteLocationNormalizedGeneric } from 'vue-router';\ndeclare const route: RouteLocationNormalizedGeneric;\nexport default route;\n","import type { Router } from '#client/services/RouterService.ts';\ndeclare const router: Router;\nexport default router;\n","import ToastService from '#client/services/ToastService.ts';\ndeclare const toast: ToastService;\nexport default toast;\n","import * as VeeValidate from 'vee-validate';\nexport declare const VEE_VALIDATE_CONTAINER_KEY = \"vee-validate\";\ndeclare const veeValidate: typeof VeeValidate;\nexport default veeValidate;\n","import * as Vue from 'vue';\nexport declare const VUE_CONTAINER_KEY = \"Vue\";\ndeclare const vue: typeof Vue;\nexport default vue;\n","import * as VueRouter from 'vue-router';\nexport declare const VUE_ROUTER_CONTAINER_KEY = \"VueRouter\";\ndeclare const vueRouter: typeof VueRouter;\nexport default vueRouter;\n","import DashboardWidgetDefinition from './DashboardWidgetDefinition';\nimport type DashboardWidgetData from './DashboardWidgetData';\n/**\n    * Component to be used for chart widgets in the dashboard.\n    * Plugins can extend this class to create their own chart widgets.\n    * @example\n    * class MyChartWidget extends DashboardWidgetDefinitionChart {\n    *     constructor() {\n    *         super()\n    *         this.name = 'My Chart Widget'\n    *         this.id = 'my-chart-widget'\n    *     }\n    * }\n    */\nexport default class DashboardWidgetDefinitionChart extends DashboardWidgetDefinition {\n    private static renderer;\n    constructor();\n    static setRenderer(renderer: any): void;\n    component(): any;\n    chartOptions(payload: DashboardWidgetData['options']): Promise<any>;\n}\n","import Base from '#shared/entities/ModuleEntity.ts';\ndeclare const Module_base: typeof Base;\nexport default class Module extends Module_base {\n}\nexport {};\n","import Base from '#shared/entities/PluginEntity.ts';\nimport type { AutoOptions } from '#client/services/RouterService.ts';\ndeclare const PluginEntity_base: typeof Base;\nexport default class PluginEntity extends PluginEntity_base {\n    addPagesFolder(imports: any, options?: AutoOptions): void;\n    load(): Promise<void>;\n}\nexport {};\n","import type { AutoOptions } from '#client/services/RouterService.ts';\nimport type { DefineComponent } from 'vue';\nimport type { RouteRecordRaw } from 'vue-router';\n/** @deprecated Use auto from RouterService instead */\nexport declare function autoRoutes(imports: Record<string, DefineComponent | (() => Promise<DefineComponent>)>, options?: AutoOptions): RouteRecordRaw[];\n","export interface DataTableColumn<T extends Record<string, any> = Record<string, any>> {\n    id?: string;\n    label?: string;\n    field?: keyof T | ((row: T) => any) | (string & {});\n    sortable?: boolean;\n    width?: string | number;\n}\nexport declare function defineColumns<T extends Record<string, any>>(columns: DataTableColumn<T>[]): DataTableColumn<T>[];\n","export interface DefineFormField {\n    component: 'text-field' | 'textarea' | 'select' | 'autocomplete' | 'switch' | 'file-upload' | 'image-upload' | 'color-picker' | 'string-list-input' | 'json-input' | 'date-picker' | 'hidden';\n    [key: string]: any;\n}\nexport declare function defineFormFields(field: Record<string, DefineFormField>): Record<string, DefineFormField>;\n","/** @deprecated Use fetcher facade */\nexport declare const $fetch: import(\"..\").FetchService;\n","interface PickOptions {\n    accept?: string;\n    multiple?: boolean;\n}\ntype PickResult<T extends PickOptions> = T['multiple'] extends true ? File[] : File | null;\ndeclare function pick<T extends PickOptions>(options: T): Promise<PickResult<T>>;\ndeclare function toUint8Array(file: File): Promise<Uint8Array>;\ninterface UploadOptions {\n    driveId: string;\n    file: File;\n    directory?: string;\n}\ndeclare function upload(options: UploadOptions): Promise<any>;\nexport declare const $file: {\n    pick: typeof pick;\n    upload: typeof upload;\n    toUint8Array: typeof toUint8Array;\n};\nexport {};\n","export declare function parseTo(to: string): string;\n","export declare const $toast: ((message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number) & {\n    success: (message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n    info: (message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n    warning: (message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n    error: (message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n    custom: (component: import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n    message: (message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n    promise: <ToastData>(promise: Promise<ToastData> | (() => Promise<ToastData>), data?: ({\n        id?: number | string | undefined;\n        icon?: import(\"vue\").Component | undefined;\n        toasterId?: string | undefined;\n        component?: import(\"vue\").Component | undefined;\n        componentProps?: any;\n        richColors?: boolean | undefined;\n        invert?: boolean | undefined;\n        closeButton?: boolean | undefined;\n        dismissible?: boolean | undefined;\n        duration?: number | undefined;\n        important?: boolean | undefined;\n        action?: (import(\"vue-sonner\").Action | import(\"vue\").Component) | undefined;\n        cancel?: (import(\"vue-sonner\").Action | import(\"vue\").Component) | undefined;\n        onDismiss?: ((toast: import(\"vue-sonner\").ToastT) => void) | undefined;\n        onAutoClose?: ((toast: import(\"vue-sonner\").ToastT) => void) | undefined;\n        cancelButtonStyle?: import(\"vue\").CSSProperties | undefined;\n        actionButtonStyle?: import(\"vue\").CSSProperties | undefined;\n        style?: import(\"vue\").CSSProperties | undefined;\n        unstyled?: boolean | undefined;\n        class?: string | undefined;\n        classes?: import(\"vue-sonner\").ToastClasses | undefined;\n        descriptionClass?: string | undefined;\n        position?: (\"top-left\" | \"top-right\" | \"bottom-left\" | \"bottom-right\" | \"top-center\" | \"bottom-center\") | undefined;\n        closeButtonPosition?: (\"top-left\" | \"top-right\" | \"bottom-left\" | \"bottom-right\") | undefined;\n        testId?: string | undefined;\n    } & {\n        loading?: string | import(\"vue\").Component;\n        success?: (string | import(\"vue\").Component | ((data: ToastData) => import(\"vue\").Component | string | Promise<import(\"vue\").Component | string>)) | (import(\"vue-sonner\").PromiseIExtendedResult | ((data: ToastData) => import(\"vue-sonner\").PromiseIExtendedResult | Promise<import(\"vue-sonner\").PromiseIExtendedResult>)) | undefined;\n        error?: (string | import(\"vue\").Component | ((data: any) => import(\"vue\").Component | string | Promise<import(\"vue\").Component | string>)) | (import(\"vue-sonner\").PromiseIExtendedResult | ((data: any) => import(\"vue-sonner\").PromiseIExtendedResult | Promise<import(\"vue-sonner\").PromiseIExtendedResult>));\n        description?: string | import(\"vue\").Component | ((data: any) => import(\"vue\").Component | string | Promise<import(\"vue\").Component | string>);\n        finally?: () => void | Promise<void>;\n    }) | undefined) => (string & {\n        unwrap: () => Promise<ToastData>;\n    }) | (number & {\n        unwrap: () => Promise<ToastData>;\n    }) | {\n        unwrap: () => Promise<ToastData>;\n    } | undefined;\n    dismiss: (id?: number | string) => string | number | undefined;\n    loading: (message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n} & {\n    getHistory: () => (import(\"vue-sonner\").ToastT<import(\"vue\").Component> | import(\"vue-sonner\").ToastToDismiss)[];\n    getToasts: () => (import(\"vue-sonner\").ToastT<import(\"vue\").Component> | import(\"vue-sonner\").ToastToDismiss)[];\n};\n","import type { NavigationGuard, RouteLocationNormalized } from 'vue-router';\nexport interface AuthGuardOptions {\n    redirect: string | ((to: RouteLocationNormalized) => string);\n    exclude?: string[];\n}\nexport declare function createAuthGuard(options: AuthGuardOptions): NavigationGuard;\ndeclare const authGuard: NavigationGuard;\nexport default authGuard;\n","export interface GuestGuardOptions {\n    redirect: string;\n}\nexport declare function createGuestGuard(options: GuestGuardOptions): () => string | undefined;\ndeclare const guestGuard: () => string | undefined;\nexport default guestGuard;\n","import type { NavigationGuard } from 'vue-router';\ndeclare const setupGuard: NavigationGuard;\nexport default setupGuard;\n"],"x_google_ignoreList":[17],"mappings":";;;;;;;;;;;;;;;AAEA,IAAW,gBAAc;CAAC;EAAK,MAAG,CAAG,EAAE;CAAE;EAAC;EAAI;EAAE;EAAK;CAAC;;;;ACDtD,IAAI,wBAAsB;CAAA;EAAA,MAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC1B,IAAI,mBAAgB;CAAA;OAAU,CAAM,QAAQ,sBAAgB;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACD5D,IAAI,YAAY;CAAC;EAAK,MAAI;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC1B,IAAI,OAAI;CAAA;OAAY,CAAA,UAAU;CAAM;EAAC;EAAE;EAAM;EAAG;EAAA;CAAA;;;;ACChD,IAAI,kBAAkB;CAAC;EAAG,MAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC1B,IAAI,aAAU;CAAI;OAAW;EAAC;EAAM;EAAY;EAAM;EAAM;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACH5D,IAAA,gBAAU;CAAA;OAAc,EAAA;CAAA,CAAA,GAAA;CAAA;AACxB,IAAI,cAAW;CAAA;OAAM;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACFrB,IAAO,eAAU;CAAA;OAAa;EAAO;EAAC;EAAY;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAClD,IAAI,eAAe;CAAA;EAAA,MAAQ;EAAA;EAAI;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACC/B,IAAA,sBAAqB;CAAA;EAAA,MAAA;EAAA;EAA4B;EAAA;EAAa;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACA9D,IAAA,mBAAqB;CAAA;EAAA,MAAA;EAAA;EAAyB;EAAA;EAAa;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACD3D,IAAA,gBAAoB;CAAC;OAAA;EAAA;EAAc;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACDnC,IAAA,gBAAoB;CAAC;OAAA,CAAA,OAAc,cAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACAnC,IAAA,gBAAoB;CAAC;OAAA;EAAA;EAAc;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACGnC,IAAI,kBAAkB;CAAC;OAAW,EAAE;CAAC,EAAA;CAAI;AACzC,IAAA,cAAU;CAAA;OAAY,EAAA;CAAA,CAAA,IAAA,GAAA;CAAA;AACtB,IAAW,0BAAoB;CAAA;OAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC/B,IAAI,qBAAmB;CAAA;OAAQ;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACL/B,IAAA,mBAAqB;CAAA;OAAA,CAAA,QAAiB,mBAAQ;CAAoB;EAAC;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACAnE,IAAI,gBAAc;CAAG;EAAK,MAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC1B,IAAI,aAAU;CAAA;OAAa,CAAC,cAAc;CAAE;EAAC;EAAG;EAAA;EAAS;EAAG;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACD5D,IAAO,aAAU;CAAA;OAAW,EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC5B,IAAI,cAAS;CAAM;OAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACCnB,IAAO,SAAU;CAAA;OAAO,CAAO,MAAC,SAAU;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC1C,IAAU,cAAW;CAAA;OAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACrB,IAAA,OAAA;CAAA;OAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACA,IAAO,eAAU;CAAA;OAAY,CAAA,OAAA;CAAA,CAAA,GAAA;CAAA;;;;ACN7B,IAAA,eAAe;CAAK;OAAC,CAAA,QAAa,OAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACiIlC,IAAI,sBAAkB;CAAA;EAAU,QAAC;EAAA;EAAS;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;;;;;;;;;AE/H1C,IAAO,MAAM;CAAA;OAAA,EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACb,IAAO,OAAM;CAAA;OAAA,CAAA,IAAA;CAAA,CAAA,IAAA,GAAA;CAAA;AACb,IAAO,MAAM;CAAA;OAAA,EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACb,IAAA,QAAA;CAAA;OAAA,EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACA,IAAO,YAAe;CAAA;OAAY,CAAA,IAAA;CAAA,CAAA,IAAA,GAAA;CAAA;AAClC,IAAO,cAAM;CAAA;OAAA,CAAA,KAAA;CAAA,CAAA,IAAA,GAAA;CAAA;AACb,IAAA,WAAA;CAAA;OAAA,CAAA,IAAA;CAAA,CAAA,IAAA,GAAA;CAAA;AACA,IAAO,WAAc;CAAA;OAAA,CAAA,IAAA;CAAA,CAAA,IAAA,GAAA;CAAA;AACrB,IAAO,WAAM;CAAA;OAAA,CAAA,IAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACb,IAAO,WAAM;CAAA;OAAA,EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACb,IAAO,eAAM;CAAA;OAAA,CAAA,KAAA;CAAA,CAAA,IAAA,GAAA;CAAA;AACb,IAAA,eAAA;CAAA;OAAA,CAAA,MAAA;CAAA,CAAA,IAAA,GAAA;CAAA;AACA,IAAO,aAAgB;CAAA;OAAA,CAAA,IAAA;CAAA,CAAA,IAAA,GAAA;CAAA;AACvB,IAAO,aAAM;CAAA;OAAA,CAAA,MAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACb,IAAO,eAAM;CAAA;OAAA,CAAA,UAAA,MAAA,oBAAA;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACb,IAAO,SAAM;CAAA;OAAA;EAAA;EAAA;EAAA;EAAA,MAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACb,IAAA,UAAA;CAAA;OAAA;EAAA;EAAA;EAAA;EAAA,MAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACA,IAAO,SAAQ;CAAA;OAAS;EAAA;EAAiB;EAAM;EAAG,MAAG;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACrD,IAAO,SAAQ;CAAA;OAAS,CAAA,UAAkB,MAAC,oBAAa;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACxD,IAAO,WAAQ;CAAQ;OAAU;EAAA;EAAW,MAAM;EAAA,MAAA;EAAA,MAAA;EAAA;EAAA;EAAA,MAAA;EAAA;EAAA;EAAA,MAAA;EAAA;EAAA;EAAA,MAAA;EAAA;EAAA;EAAA,MAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACpBlD,IAAO,0BAAU;CAAA;OAAwB,EAAA;CAAA,CAAA,GAAA;CAAA;AACzC,IAAW,mBAAM;CAAA;OAAA,CAAA,wBAAA;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACjB,IAAA,kBAAA;CAAA;OAAA,CAAA,kBAAA,iBAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACA,IAAA,YAAgB;CAAC;OAAA,EAAA;CAAA,CAAgB,IAAC,GAAA;CAAA;AAClC,IAAI,oBAAoB;CAAC;OAAA,CAAA,UAAA;CAAwB,CAAC,IAAC,GAAI;CAAA;AACvD,IAAA,yBAAA;CAAA;OAAA,CAAA,cAAA;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACA,IAAA,kBAAU;CAAA;EAAgB,QAAA,MAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACP1B,IAAO,oBAAU;CAAA;OAAkB,EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACnC,IAAI,sBAAa;CAAA;OAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACDjB,IAAO,wBAAU;CAAA;OAAsB,CAAA,OAAA;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACvC,IAAI,4BAA2B;CAAA;OAAA,CAAA,sBAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACG/B,IAAU,uBAAuB;CAAA;OAAA,EAAA;CAAA,EAAA;CAAA;AACjC,IAAI,yBAAyB;CAAA;OAAA,CAAA,qBAAA,0BAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC7B,IAAI,gBAAY;CAAA;OAAA,EAAA;CAAA,CAAA,IAAyB,GAAA;CAAA;AACzC,IAAA,kBAAA;CAAA;OAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACNA,IAAO,SAAa;CAAC;OAAY;EAAC,EAAE;EAAC,EAAe;EAAY,EAAA;EAAe,EAAA;EAAa,EAAU;EAAI,EAAa;EAAa;CAAA;EAAA;EAAS;EAAI;EAAC;EAAA;EAAA;EAAe;EAAI;EAAE;EAAM;EAAI;EAAC;EAAA;CAAA;AAClL,IAAO,UAAc;CAAA;OAAa;EAAC,EAAE;EAAC,EAAe;EAAY,EAAA;EAAe,EAAA;EAAsB,EAAE;EAAG;CAAc;EAAA;EAAA;EAAS;EAAI;EAAA;EAAA;EAAY;EAAE;EAAA;EAAA;EAAA;CAAA;AACpJ,IAAO,OAAQ;CAAA;OAAgB;EAAC,EAAE;EAAC,EAAe;EAAY,EAAA;EAAe;EAAA;EAAY,EAAC;EAAc;EAAU,EAAC;EAAa,EAAA;EAAc;CAAA;EAAA;EAAe;EAAC;EAAO;EAAE;EAAM;EAAI;EAAI;EAAC;EAAA;EAAA;EAAe;EAAC;EAAM;EAAA;EAAQ;CAAC;AACrN,IAAO,WAAc;CAAA;OAAc;EAAC,EAAE;EAAC,EAAe;EAAY,EAAA;EAAe;EAAA,EAAA;EAAyB,EAAE;EAAW;CAAA;EAAA;EAAW;EAAE;EAAA;EAAU;EAAI;EAAA;EAAA;EAAA;EAAgB;EAAA;EAAO;CAAC;AAC1K,IAAO,QAAQ;CAAK;EAAM,MAAK;EAAA,EAAA;EAAU;EAAA,EAAU;EAAc,EAAE;EAAc,EAAE;EAAE,EAAA;EAA0B,EAAC;EAAe;EAAA,EAAA;EAAa,EAAU;EAAe;CAAE;EAAC;EAAA;EAAA;EAAY;EAAC;EAAA;EAAW;EAAC;EAAA;EAAW;EAAE;EAAA;EAAU;EAAI;EAAA;EAAA;EAAA;EAAgB;EAAA;EAAQ;EAAC;CAAA;AACrP,IAAO,cAAc;CAAA;OAAiB;EAAC,EAAE;EAAC,EAAe;EAAY,EAAA;EAAe,EAAA;EAAY,EAAA;EAAe,EAAA;EAAuB,EAAE;EAAa,EAAE;EAAc,EAAA;EAAqB,EAAE;EAAe;CAAC;EAAA;EAAA;EAAA;EAAA;EAAgB;EAAM;EAAG;EAAA;EAAS;EAAC;EAAO;EAAI;EAAE;EAAA;EAAA;EAAc;EAAA;EAAA;EAAW;EAAK;EAAG;CAAC;AAC9R,IAAO,SAAa;CAAC;OAAY;EAAC,EAAE;EAAC,EAAe;EAAY,EAAA;EAAe,EAAA;EAAa,EAAA;EAAc,EAAA;EAAe;EAAa,EAAA;EAAc,EAAU;EAAc;CAAA;EAAA;EAAA;EAAY;EAAE;EAAA;EAAA;EAAA;EAAgB;EAAM;EAAG;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACnN,IAAQ,MAAS;CAAA;OAAG;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACpB,IAAG,MAAA;CAAA;EAAA,MAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACRH,IAAO,WAAc;CAAA;OAAc;EAAC,EAAE;EAAC;EAAe,EAAQ;EAAiB,EAAA;EAAc;CAAA;EAAA;EAAA;EAAA;EAAgB;EAAM;EAAE;EAAM;EAAC;CAAA;;;;ACA5H,IAAO,mBAAU;CAAA;OAAiB,EAAA;CAAA,CAAA,IAAA,GAAA;CAAA;AAClC,IAAI,OAAW;CAAA;OAAM;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACrB,IAAI,aAAoB;CAAC;OAAC;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC1B,IAAA,aAAA;CAAA;OAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;;;;;;;;;;;;;;;;;;AEFA,IAAW,UAAU;CAAC;OAAW,CAAA,GAAA,gBAAA;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACjC,IAAW,gBAAc;CAAA;OAAA,CAAA,EAAA,WAAA,EAAA,WAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACzB,IAAC,sBAAA;CAAA;OAAA,CAAA,EAAA,aAAA;CAAA,CAAA,IAAA,GAAA;CAAA;AAED,IAAW,oBAAoB;CAAC;EAAI,MAAA;EAAA;EAAsB;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAE1D,IAAO,kBAAU;CAAA;EAAkB,MAAE;EAAA,EAAA;EAAQ;EAAa,EAAE;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC5D,IAAS,kBAAW;CAAA;EAAA,MAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACPpB,IAAO,kBAAiB;CAAA;OAAiB;EAAC;EAAiB;EAAE;EAAa;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC1E,IAAI,kBAAqB;CAAA;OAAU;EAAA,EAAa;EAAU,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC1D,IAAI,kBAAuB;CAAA;OAAU;EAAA,EAAa;EAAU,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAA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"}
1175
+ export { $fetch, $file, $toast, AuthGuardOptions, AuthService, AutoOptions, DASHBOARD_ROW_HEIGHT, Dashboard, DashboardGridUnit, DashboardOptions, DashboardWidget, DashboardWidgetAction, DashboardWidgetData, DashboardWidgetDefinition, DashboardWidgetDefinitionChart, DashboardWidgetRegistry, DataTableColumn, DefineFormField, FetchBrowserService, FetchNodeService, FetchOptions, FetchService, GuestGuardOptions, HSL, LayoutService, LifecycleService, ListFilter, MenuBase, MenuGroup, MenuItem, MenuItem$1 as MenuItemEntity, MenuService, MenuSingle, MenuWithChildren, Module as ModuleEntity, OKLCH, PluginEntity, RGB, RGBA, Router, ToastService, UNHEAD_VUE_CONTAINER_KEY, UseFetchPaginationOptions, UseMenu, UseStateOptions, VEE_VALIDATE_CONTAINER_KEY, VUE_CONTAINER_KEY, VUE_ROUTER_CONTAINER_KEY, ValibotFormOptions, ValibotFormResultObject, acl, auth, authGuard, auto, autoRoutes, clsx, cn, config, _default as container, createAuthGuard, createGuestGuard, createId, createRouter, dashboardRegistry, defineColumns, defineFormFields, emmitter, extracRGB, extractOKLCH, extractRGBA, fetcher, guestGuard, hexToRGB, hslToRgb, layout, lifecycle, logger, menu, oklchToRgb, parseTo, provideDashboard, provideDashboardWidget, rgbToHex, rgbToHsl, rgbToOklch, rgbaToString, route, router, setupGuard, toTypedSchema, toast, twMerge, unheadVue, useBreakpoints, useColor, useColorType, useDashboard, useDashboardWidget, useFetchPagination, useForm, useHSL, useHead, useHex, useLayoutOptions, useLoading, useMenu, useRGB, useRGBA, useRouteQuery, useState, useValibotForm, veeValidate, vue, vueRouter };
1176
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/shared/utils/compose.d.ts","../../src/shared/entities/PermissionEntity.d.ts","../../src/shared/entities/RoleEntity.d.ts","../../src/shared/entities/UserEntity.d.ts","../../src/client/services/AuthService.d.ts","../../src/client/services/FetchService.d.ts","../../src/client/services/FetchBrowserService.d.ts","../../src/client/services/FetchNodeService.d.ts","../../src/client/services/LayoutService.d.ts","../../src/shared/services/LoggerService.d.ts","../../src/shared/entities/LifecycleHook.d.ts","../../src/shared/services/LifecycleService.d.ts","../../src/client/services/LifecycleService.d.ts","../../src/client/entities/MenuItemEntity.d.ts","../../src/client/services/MenuService.d.ts","../../src/client/services/RouterService.d.ts","../../src/client/services/ToastService.d.ts","../../node_modules/@vueuse/core/dist/index.d.ts","../../src/client/composables/useBreakpoint.d.ts","../../src/client/composables/useColor.d.ts","../../src/shared/services/EmmitterService.d.ts","../../src/client/entities/DashboardWidgetData.d.ts","../../src/client/entities/DashboardWidgetDefinition.d.ts","../../src/client/entities/DashboardWidget.d.ts","../../src/shared/validators/urlValidator.d.ts","../../src/shared/validators/keyValueValidator.d.ts","../../src/shared/validators/paginationValidator.d.ts","../../src/shared/validators/index.d.ts","../../src/shared/services/ValidatorService.d.ts","../../src/shared/schemas/dashboardSchema.d.ts","../../src/client/entities/Dashboard.d.ts","../../src/client/composables/useDashboard.d.ts","../../src/client/composables/useDashboardWidget.d.ts","../../src/client/composables/useFetchPagination.d.ts","../../src/shared/services/ConfigService.d.ts","../../src/shared/services/ContainerService.d.ts","../../src/shared/utils/createId.d.ts","../../src/shared/entities/AclEntity.d.ts","../../src/shared/entities/ModuleManifestEntity.d.ts","../../src/shared/entities/ModuleEntity.d.ts","../../src/shared/entities/PluginEntity.d.ts","../../src/client/composables/useForm.d.ts","../../src/client/facades/unheadVue.d.ts","../../src/client/composables/useHead.d.ts","../../src/client/composables/useLayoutOptions.d.ts","../../src/client/composables/useLoading.d.ts","../../src/client/composables/useMenu.d.ts","../../src/client/composables/useRouteQuery.d.ts","../../src/client/composables/useState.d.ts","../../src/client/facades/acl.d.ts","../../src/client/facades/auth.d.ts","../../src/client/facades/config.d.ts","../../src/client/facades/container.d.ts","../../src/client/registry/DashboardWidgetRegistry.d.ts","../../src/client/facades/dashboardRegistry.d.ts","../../src/client/facades/emmitter.d.ts","../../src/client/facades/fetcher.d.ts","../../src/client/facades/layout.d.ts","../../src/client/facades/lifecycle.d.ts","../../src/client/facades/logger.d.ts","../../src/client/facades/menu.d.ts","../../src/client/facades/route.d.ts","../../src/client/facades/router.d.ts","../../src/client/facades/toast.d.ts","../../src/client/facades/veeValidate.d.ts","../../src/client/facades/vue.d.ts","../../src/client/facades/vueRouter.d.ts","../../src/client/entities/DashboardWidgetDefinitionChart.d.ts","../../src/client/entities/ModuleEntity.d.ts","../../src/client/entities/PluginEntity.d.ts","../../src/client/utils/autoPages.d.ts","../../src/client/utils/defineColumns.d.ts","../../src/client/utils/defineFormFields.d.ts","../../src/client/utils/fetcher.d.ts","../../src/client/utils/file.d.ts","../../src/client/utils/parseTo.d.ts","../../src/client/utils/toast.d.ts","../../src/client/utils/twMerge.d.ts","../../src/client/guards/authGuard.d.ts","../../src/client/guards/guestGuard.d.ts","../../src/client/guards/setupGuard.d.ts"],"sourcesContent":["import type { UnionToIntersection } from './typing.ts';\nexport type AnyClass = new (...args: any[]) => any;\nexport type Constructor<T = {}> = new (...args: any[]) => T;\nexport type Mixin<T> = (base: Constructor) => Constructor<T>;\n/**\n * Composes multiple mixins into a single class that can be extended.\n * Allows for multiple inheritance-like behavior by applying mixins sequentially.\n *\n * @param mixins - Array of mixin functions to compose\n * @returns A class constructor that includes all mixin functionality\n *\n * @example\n * ```typescript\n * class User extends compose(Timestamp, SoftDelete) {\n *   constructor(public name: string) {\n *     super()\n *   }\n * }\n * ```\n */\nexport declare function compose<M extends Array<(base: Constructor<any>) => Constructor<any>>>(...mixins: M): UnionToIntersection<ReturnType<M[number]>>;\n/**\n * Alternative compose function that starts with a base class\n *\n * @param baseClass - The base class to start with\n * @param mixins - Array of mixin functions to apply\n * @returns A class constructor that extends the base class with all mixin functionality\n *\n * @example\n * ```typescript\n * class User extends composeWith(BaseEntity, Timestamp, SoftDelete) {\n *   constructor(public name: string) {\n *     super()\n *   }\n * }\n * ```\n */\nexport declare function composeWith<TBase extends Constructor, M extends Array<(base: Constructor) => Constructor<any>>>(baseClass: TBase, ...mixins: M): TBase & UnionToIntersection<ReturnType<M[number]>>;\nexport declare function mixin<TBase extends Constructor>(Source: TBase): <TTarget extends Constructor>(Target: TTarget) => TTarget & TBase;\n","declare const PermissionEntity_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor;\nexport default class PermissionEntity extends PermissionEntity_base {\n    id: number;\n    name: string;\n    description: string | null;\n    origin: string;\n    subject: string;\n    action: string;\n    conditions: string | null | Record<string, any>;\n    get editable(): boolean;\n    get parsedConditions(): any;\n}\nexport {};\n","declare const Role_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor & {\n    new (...args: any[]): {\n        created_at: Date | string;\n        updated_at: Date | string;\n    };\n} & {\n    new (...args: any[]): {\n        deleted_at: Date | string | null;\n    };\n};\nexport default class Role extends Role_base {\n    id: number;\n    name: string;\n    description?: string;\n}\nexport {};\n","import type Permission from './PermissionEntity.ts';\nimport type Role from './RoleEntity.ts';\ndeclare const UserEntity_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor & {\n    new (...args: any[]): {\n        created_at: Date | string;\n        updated_at: Date | string;\n    };\n} & {\n    new (...args: any[]): {\n        deleted_at: Date | string | null;\n    };\n};\nexport default class UserEntity extends UserEntity_base {\n    id: number;\n    email: string;\n    name: string;\n    username: string;\n    password?: string;\n    verified_at?: Date | string | null;\n    permissions?: Permission[];\n    roles?: Role[];\n    get initials(): string;\n}\nexport {};\n","import User from '#shared/entities/UserEntity.ts';\ninterface LogoutOptions {\n    redirect?: string;\n}\nexport default class AuthService {\n    static __container_entry_key: string;\n    user: User | null;\n    constructor(data?: Partial<AuthService>);\n    logout(options?: LogoutOptions): Promise<void>;\n}\nexport {};\n","export interface FetchOptions extends RequestInit {\n    query?: Record<string, any>;\n    data?: Record<string, any>;\n}\nexport default class FetchService {\n    static __container_entry_key: string;\n    protected handleError(response: Response): Promise<any>;\n    protected buildUrl(url: string, query?: Record<string, any>): string;\n    protected buildRequestInit(options: FetchOptions): RequestInit;\n    protected parseResponse<T>(response: Response): Promise<T>;\n    fetch<T>(_url: string, _options?: FetchOptions): Promise<T>;\n    try<T = any>(url: string, options?: FetchOptions): Promise<[Error, null] | [null, Awaited<T>]>;\n    get<T = any>(url: string, options?: FetchOptions): Promise<T>;\n    post<T = any>(url: string, options?: FetchOptions): Promise<T>;\n    put<T = any>(url: string, options?: FetchOptions): Promise<T>;\n    delete<T = any>(url: string, options?: FetchOptions): Promise<T>;\n}\n","import type { FetchOptions } from './FetchService.ts';\nimport FetchService from './FetchService.ts';\nexport default class FetchBrowserService extends FetchService {\n    fetch<T>(url: string, options?: FetchOptions): Promise<T>;\n}\n","import type { FetchOptions } from './FetchService.ts';\nimport FetchService from './FetchService.ts';\nexport default class FetchNodeService extends FetchService {\n    fetch<T>(url: string, options?: FetchOptions): Promise<T>;\n    protected fetchExternal<T>(url: string, options?: FetchOptions): Promise<T>;\n    protected fetchInternal<T>(url: string, options?: FetchOptions): Promise<T>;\n}\n","import type { DefineComponent } from \"vue\";\nexport default class LayoutService {\n    static __container_entry_key: string;\n    components: Map<string, DefineComponent>;\n    options: Record<string, any>;\n    currendId: string | null;\n    setCurrent(id: string): void;\n    add(name: string, component: DefineComponent, options?: any): void;\n    has(name: string): boolean;\n    get(name: string): DefineComponent;\n    getOptions(): Record<string, any>;\n    getCurrent(): DefineComponent | null;\n    setOptions(options?: any): void;\n}\n","export default class LoggerService {\n    static __container_entry_key: string;\n    info(message: string, meta?: any): void;\n    debug(message: string, meta?: any): void;\n    warn(message: string, meta?: any): void;\n    error(message: string | Error, meta?: any): void;\n    child(options: any): LoggerService;\n}\n","export default class LifecycleHook {\n    hook_id: string;\n    hook_aliases?: string[];\n    order?: number;\n    subhooks?: LifecycleHook[];\n    register(): Promise<void>;\n    load(): Promise<void>;\n    boot(): Promise<void>;\n    shutdown(): Promise<void>;\n    /** @deprecated Use register */\n    onRegister(): Promise<void>;\n    /** @deprecated Use load */\n    onLoad(): Promise<void>;\n    /** @deprecated Use boot */\n    onBoot(): Promise<void>;\n    /** @deprecated Use shutdown */\n    onShutdown(): Promise<void>;\n}\n","import LoggerService from './LoggerService.ts';\nimport LifecycleHook from '#shared/entities/LifecycleHook.ts';\nimport type { Constructor } from '#shared/utils/compose.ts';\ntype LifecycleMethod = 'register' | 'load' | 'boot' | 'shutdown';\ninterface ListOptions {\n    include?: string | string[];\n    exclude?: string | string[];\n}\nexport interface LifecycleServiceOptions {\n    debug?: boolean;\n    hooks?: Map<string, LifecycleHook>;\n    logger?: LoggerService;\n    onError?: (error: Error, context: {\n        hookId: string;\n        method: LifecycleMethod;\n    }) => void;\n}\nexport default class LifecycleService {\n    static __container_entry_key: string;\n    hooks: Map<string, LifecycleHook>;\n    logger: LoggerService;\n    debug: boolean;\n    constructor(data?: LifecycleServiceOptions);\n    setOnError(handler: Required<LifecycleServiceOptions>['onError']): void;\n    onError(error: Error, context: {\n        hookId: string;\n        method: LifecycleMethod;\n    }): void;\n    mapAliases(args: string[]): string[];\n    list(options?: ListOptions): LifecycleHook[];\n    add(...payload: (LifecycleHook | Constructor<LifecycleHook>)[]): void;\n    emitMethod(method: LifecycleMethod, options?: ListOptions): Promise<void>;\n    emit(payload: LifecycleMethod | LifecycleMethod[], options?: ListOptions): Promise<void>;\n    on(method: LifecycleMethod, handler: () => Promise<void>): void;\n    register(options?: ListOptions): Promise<void>;\n    load(options?: ListOptions): Promise<void>;\n    boot(options?: ListOptions): Promise<void>;\n    shutdown(options?: ListOptions): Promise<void>;\n    clear(): void;\n}\nexport {};\n","import BaseLifecycleService from '#shared/services/LifecycleService.ts';\nexport default class LifecycleService extends BaseLifecycleService {\n    addImports(imports: Record<string, any>): void;\n}\n","declare const MenuItem_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor;\nexport default class MenuItem extends MenuItem_base {\n    id: string;\n    label: string;\n    layout: string;\n    to?: string;\n    target?: '_blank' | '_self' | '_parent' | '_top';\n    group?: string;\n    order?: number;\n    icon?: string;\n    parent?: string;\n}\nexport {};\n","import MenuItem from '#client/entities/MenuItemEntity.ts';\nexport interface ListFilter {\n    layout?: string;\n    group?: string;\n    parent?: string;\n    allowed?: boolean;\n}\nexport default class MenuService {\n    static __container_entry_key: string;\n    items: Map<string, MenuItem>;\n    add(...item: Omit<Partial<MenuItem>, 'merge' | 'from'>[]): void;\n    remove(id: MenuItem['id']): void;\n    list(filter?: ListFilter): MenuItem[];\n    clear(): void;\n}\n","import type { NavigationGuard, Router as VueRouter } from 'vue-router';\nimport type { RouteRecordRaw } from 'vue-router';\nimport type { DefineComponent } from 'vue';\nexport interface Router extends VueRouter {\n    auto: typeof auto;\n}\nexport interface AutoOptions {\n    guards?: NavigationGuard[] | ((record: RouteRecordRaw) => NavigationGuard[]);\n    strip?: (string | RegExp)[];\n    exclude?: (string | RegExp)[];\n    prefix?: string;\n    refine?: (records: RouteRecordRaw[]) => RouteRecordRaw[];\n}\nexport declare function auto(imports: Record<string, DefineComponent | (() => Promise<DefineComponent>)>, options?: AutoOptions): RouteRecordRaw[];\nexport declare function createRouter(): Router;\n","export default class ToastService {\n    static __container_entry_key: string;\n    success(message: string, options?: Record<string, any>): void;\n    error(message: string, options?: Record<string, any>): void;\n}\n","import * as _vueuse_shared0 from \"@vueuse/shared\";\nimport { Arrayable, Awaitable, ConfigurableEventFilter, ConfigurableFlush, ConfigurableFlushSync, EventHookOn, Fn, IsAny, Pausable, ReadonlyRefOrGetter, RemovableRef, ShallowOrDeepRef, Stoppable, UseTimeoutFnOptions } from \"@vueuse/shared\";\nimport * as vue0 from \"vue\";\nimport { App, Component, ComponentObjectPropsOptions, ComponentPublicInstance, ComputedRef, DefineComponent, InjectionKey, MaybeRef, MaybeRefOrGetter, MultiWatchSources, Ref, ShallowRef, Slot, StyleValue, ToRefs, TransitionGroupProps, UnwrapNestedRefs, UnwrapRef, WatchOptions, WatchOptionsBase, WatchSource, WatchStopHandle, WritableComputedRef } from \"vue\";\nexport * from \"@vueuse/shared\";\n\n//#region computedAsync/index.d.ts\n/**\n * Handle overlapping async evaluations.\n *\n * @param cancelCallback The provided callback is invoked when a re-evaluation of the computed value is triggered before the previous one finished\n */\ntype AsyncComputedOnCancel = (cancelCallback: Fn) => void;\ninterface AsyncComputedOptions<Lazy = boolean> extends ConfigurableFlushSync {\n  /**\n   * Should value be evaluated lazily\n   *\n   * @default false\n   */\n  lazy?: Lazy;\n  /**\n   * Ref passed to receive the updated of async evaluation\n   */\n  evaluating?: Ref<boolean>;\n  /**\n   * Use shallowRef\n   *\n   * @default true\n   */\n  shallow?: boolean;\n  /**\n   * Callback when error is caught.\n   */\n  onError?: (e: unknown) => void;\n}\n/**\n * Create an asynchronous computed dependency.\n *\n * @see https://vueuse.org/computedAsync\n * @param evaluationCallback     The promise-returning callback which generates the computed value\n * @param initialState           The initial state, used until the first evaluation finishes\n * @param optionsOrRef           Additional options or a ref passed to receive the updates of the async evaluation\n */\ndeclare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: T, optionsOrRef: AsyncComputedOptions<true>): ComputedRef<T>;\ndeclare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: undefined, optionsOrRef: AsyncComputedOptions<true>): ComputedRef<T | undefined>;\ndeclare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: T, optionsOrRef?: Ref<boolean> | AsyncComputedOptions): Ref<T>;\ndeclare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState?: undefined, optionsOrRef?: Ref<boolean> | AsyncComputedOptions): Ref<T | undefined>;\n/** @deprecated use `computedAsync` instead */\ndeclare const asyncComputed: typeof computedAsync;\n//#endregion\n//#region computedInject/index.d.ts\ntype ComputedInjectGetter<T, K$1> = (source: T | undefined, oldValue?: K$1) => K$1;\ntype ComputedInjectGetterWithDefault<T, K$1> = (source: T, oldValue?: K$1) => K$1;\ntype ComputedInjectSetter<T> = (v: T) => void;\ninterface WritableComputedInjectOptions<T, K$1> {\n  get: ComputedInjectGetter<T, K$1>;\n  set: ComputedInjectSetter<K$1>;\n}\ninterface WritableComputedInjectOptionsWithDefault<T, K$1> {\n  get: ComputedInjectGetterWithDefault<T, K$1>;\n  set: ComputedInjectSetter<K$1>;\n}\ndeclare function computedInject<T, K$1 = any>(key: InjectionKey<T> | string, getter: ComputedInjectGetter<T, K$1>): ComputedRef<K$1 | undefined>;\ndeclare function computedInject<T, K$1 = any>(key: InjectionKey<T> | string, options: WritableComputedInjectOptions<T, K$1>): ComputedRef<K$1 | undefined>;\ndeclare function computedInject<T, K$1 = any>(key: InjectionKey<T> | string, getter: ComputedInjectGetterWithDefault<T, K$1>, defaultSource: T, treatDefaultAsFactory?: false): ComputedRef<K$1>;\ndeclare function computedInject<T, K$1 = any>(key: InjectionKey<T> | string, options: WritableComputedInjectOptionsWithDefault<T, K$1>, defaultSource: T | (() => T), treatDefaultAsFactory: true): ComputedRef<K$1>;\n//#endregion\n//#region createReusableTemplate/index.d.ts\ntype ObjectLiteralWithPotentialObjectLiterals = Record<string, Record<string, any> | undefined>;\ntype GenerateSlotsFromSlotMap<T extends ObjectLiteralWithPotentialObjectLiterals> = { [K in keyof T]: Slot<T[K]> };\ntype DefineTemplateComponent<Bindings extends Record<string, any>, MapSlotNameToSlotProps extends ObjectLiteralWithPotentialObjectLiterals> = DefineComponent & {\n  new (): {\n    $slots: {\n      default: (_: Bindings & {\n        $slots: GenerateSlotsFromSlotMap<MapSlotNameToSlotProps>;\n      }) => any;\n    };\n  };\n};\ntype ReuseTemplateComponent<Bindings extends Record<string, any>, MapSlotNameToSlotProps extends ObjectLiteralWithPotentialObjectLiterals> = DefineComponent<Bindings> & {\n  new (): {\n    $slots: GenerateSlotsFromSlotMap<MapSlotNameToSlotProps>;\n  };\n};\ntype ReusableTemplatePair<Bindings extends Record<string, any>, MapSlotNameToSlotProps extends ObjectLiteralWithPotentialObjectLiterals> = [DefineTemplateComponent<Bindings, MapSlotNameToSlotProps>, ReuseTemplateComponent<Bindings, MapSlotNameToSlotProps>] & {\n  define: DefineTemplateComponent<Bindings, MapSlotNameToSlotProps>;\n  reuse: ReuseTemplateComponent<Bindings, MapSlotNameToSlotProps>;\n};\ninterface CreateReusableTemplateOptions<Props extends Record<string, any>> {\n  /**\n   * Inherit attrs from reuse component.\n   *\n   * @default true\n   */\n  inheritAttrs?: boolean;\n  /**\n   * Props definition for reuse component.\n   */\n  props?: ComponentObjectPropsOptions<Props>;\n}\n/**\n * This function creates `define` and `reuse` components in pair,\n * It also allow to pass a generic to bind with type.\n *\n * @see https://vueuse.org/createReusableTemplate\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function createReusableTemplate<Bindings extends Record<string, any>, MapSlotNameToSlotProps extends ObjectLiteralWithPotentialObjectLiterals = Record<'default', undefined>>(options?: CreateReusableTemplateOptions<Bindings>): ReusableTemplatePair<Bindings, MapSlotNameToSlotProps>;\n//#endregion\n//#region createTemplatePromise/index.d.ts\ninterface TemplatePromiseProps<Return, Args extends any[] = []> {\n  /**\n   * The promise instance.\n   */\n  promise: Promise<Return> | undefined;\n  /**\n   * Resolve the promise.\n   */\n  resolve: (v: Return | Promise<Return>) => void;\n  /**\n   * Reject the promise.\n   */\n  reject: (v: any) => void;\n  /**\n   * Arguments passed to TemplatePromise.start()\n   */\n  args: Args;\n  /**\n   * Indicates if the promise is resolving.\n   * When passing another promise to `resolve`, this will be set to `true` until the promise is resolved.\n   */\n  isResolving: boolean;\n  /**\n   * Options passed to createTemplatePromise()\n   */\n  options: TemplatePromiseOptions;\n  /**\n   * Unique key for list rendering.\n   */\n  key: number;\n}\ninterface TemplatePromiseOptions {\n  /**\n   * Determines if the promise can be called only once at a time.\n   *\n   * @default false\n   */\n  singleton?: boolean;\n  /**\n   * Transition props for the promise.\n   */\n  transition?: TransitionGroupProps;\n}\ntype TemplatePromise<Return, Args extends any[] = []> = DefineComponent<object> & {\n  new (): {\n    $slots: {\n      default: (_: TemplatePromiseProps<Return, Args>) => any;\n    };\n  };\n} & {\n  start: (...args: Args) => Promise<Return>;\n};\n/**\n * Creates a template promise component.\n *\n * @see https://vueuse.org/createTemplatePromise\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function createTemplatePromise<Return, Args extends any[] = []>(options?: TemplatePromiseOptions): TemplatePromise<Return, Args>;\n//#endregion\n//#region createUnrefFn/index.d.ts\ntype UnrefFn<T> = T extends ((...args: infer A) => infer R) ? (...args: { [K in keyof A]: MaybeRef<A[K]> }) => R : never;\n/**\n * Make a plain function accepting ref and raw values as arguments.\n * Returns the same value the unconverted function returns, with proper typing.\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function createUnrefFn<T extends Function>(fn: T): UnrefFn<T>;\n//#endregion\n//#region _configurable.d.ts\ninterface ConfigurableWindow {\n  window?: Window;\n}\ninterface ConfigurableDocument {\n  document?: Document;\n}\ninterface ConfigurableDocumentOrShadowRoot {\n  document?: DocumentOrShadowRoot;\n}\ninterface ConfigurableNavigator {\n  navigator?: Navigator;\n}\ninterface ConfigurableLocation {\n  location?: Location;\n}\ndeclare const defaultWindow: (Window & typeof globalThis) | undefined;\ndeclare const defaultDocument: Document | undefined;\ndeclare const defaultNavigator: Navigator | undefined;\ndeclare const defaultLocation: Location | undefined;\ninterface ConfigurableDeepRefs<D extends boolean> {\n  /**\n   * Return deep refs instead of shallow refs.\n   *\n   * @default true - will be changed to `false` by default in the next major\n   */\n  deepRefs?: D;\n}\ninterface ConfigurableScheduler {\n  /**\n   * Custom scheduler to use for interval execution.\n   */\n  scheduler?: (cb: Fn) => Pausable;\n}\n//#endregion\n//#region unrefElement/index.d.ts\ntype VueInstance = ComponentPublicInstance;\ntype MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>;\ntype MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeRefOrGetter<T>;\ntype MaybeElement = HTMLElement | SVGElement | VueInstance | undefined | null;\ntype UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends VueInstance ? Exclude<MaybeElement, VueInstance> : T | undefined;\n/**\n * Get the dom element of a ref of element or Vue component instance\n *\n * @param elRef\n */\ndeclare function unrefElement<T extends MaybeElement>(elRef: MaybeComputedElementRef<T>): UnRefElementReturn<T>;\n//#endregion\n//#region onClickOutside/index.d.ts\ninterface OnClickOutsideOptions<Controls extends boolean = false> extends ConfigurableWindow {\n  /**\n   * List of elements that should not trigger the event,\n   * provided as Refs or CSS Selectors.\n   */\n  ignore?: MaybeRefOrGetter<(MaybeElementRef | string)[]>;\n  /**\n   * Use capturing phase for internal event listener.\n   * @default true\n   */\n  capture?: boolean;\n  /**\n   * Run handler function if focus moves to an iframe.\n   * @default false\n   */\n  detectIframe?: boolean;\n  /**\n   * Use controls to cancel/trigger listener.\n   * @default false\n   */\n  controls?: Controls;\n}\ntype OnClickOutsideHandler<T extends OnClickOutsideOptions<boolean> = OnClickOutsideOptions> = (event: (T['detectIframe'] extends true ? FocusEvent : never) | (T['controls'] extends true ? Event : never) | PointerEvent) => void;\ntype OnClickOutsideReturn<Controls extends boolean = false> = Controls extends false ? Fn : {\n  stop: Fn;\n  cancel: Fn;\n  trigger: (event: Event) => void;\n};\n/**\n * Listen for clicks outside of an element.\n *\n * @see https://vueuse.org/onClickOutside\n * @param target\n * @param handler\n * @param options\n */\ndeclare function onClickOutside<T extends OnClickOutsideOptions>(target: MaybeComputedElementRef, handler: OnClickOutsideHandler<T>, options?: T): Fn;\ndeclare function onClickOutside<T extends OnClickOutsideOptions<true>>(target: MaybeComputedElementRef, handler: OnClickOutsideHandler<T>, options: T): {\n  stop: Fn;\n  cancel: Fn;\n  trigger: (event: Event) => void;\n};\n//#endregion\n//#region onElementRemoval/index.d.ts\ninterface OnElementRemovalOptions extends ConfigurableWindow, ConfigurableDocumentOrShadowRoot, WatchOptionsBase {}\n/**\n * Fires when the element or any element containing it is removed.\n *\n * @param target\n * @param callback\n * @param options\n */\ndeclare function onElementRemoval(target: MaybeElementRef, callback: (mutationRecords: MutationRecord[]) => void, options?: OnElementRemovalOptions): Fn;\n//#endregion\n//#region onKeyStroke/index.d.ts\ntype KeyPredicate = (event: KeyboardEvent) => boolean;\ntype KeyFilter = true | string | string[] | KeyPredicate;\ntype KeyStrokeEventName = 'keydown' | 'keypress' | 'keyup';\ninterface OnKeyStrokeOptions {\n  eventName?: KeyStrokeEventName;\n  target?: MaybeRefOrGetter<EventTarget | null | undefined>;\n  passive?: boolean;\n  /**\n   * Set to `true` to ignore repeated events when the key is being held down.\n   *\n   * @default false\n   */\n  dedupe?: MaybeRefOrGetter<boolean>;\n}\n/**\n * Listen for keyboard keystrokes.\n *\n * @see https://vueuse.org/onKeyStroke\n */\ndeclare function onKeyStroke(key: KeyFilter, handler: (event: KeyboardEvent) => void, options?: OnKeyStrokeOptions): () => void;\ndeclare function onKeyStroke(handler: (event: KeyboardEvent) => void, options?: OnKeyStrokeOptions): () => void;\n/**\n * Listen to the keydown event of the given key.\n *\n * @see https://vueuse.org/onKeyStroke\n * @param key\n * @param handler\n * @param options\n */\ndeclare function onKeyDown(key: KeyFilter, handler: (event: KeyboardEvent) => void, options?: Omit<OnKeyStrokeOptions, 'eventName'>): () => void;\n/**\n * Listen to the keypress event of the given key.\n *\n * @see https://vueuse.org/onKeyStroke\n * @param key\n * @param handler\n * @param options\n */\ndeclare function onKeyPressed(key: KeyFilter, handler: (event: KeyboardEvent) => void, options?: Omit<OnKeyStrokeOptions, 'eventName'>): () => void;\n/**\n * Listen to the keyup event of the given key.\n *\n * @see https://vueuse.org/onKeyStroke\n * @param key\n * @param handler\n * @param options\n */\ndeclare function onKeyUp(key: KeyFilter, handler: (event: KeyboardEvent) => void, options?: Omit<OnKeyStrokeOptions, 'eventName'>): () => void;\n//#endregion\n//#region onLongPress/index.d.ts\ninterface OnLongPressOptions {\n  /**\n   * Time in ms till `longpress` gets called\n   *\n   * @default 500\n   */\n  delay?: number | ((ev: PointerEvent) => number);\n  modifiers?: OnLongPressModifiers;\n  /**\n   * Allowance of moving distance in pixels,\n   * The action will get canceled When moving too far from the pointerdown position.\n   * @default 10\n   */\n  distanceThreshold?: number | false;\n  /**\n   * Function called when the ref element is released.\n   * @param duration how long the element was pressed in ms\n   * @param distance distance from the pointerdown position\n   * @param isLongPress whether the action was a long press or not\n   */\n  onMouseUp?: (duration: number, distance: number, isLongPress: boolean) => void;\n}\ninterface OnLongPressModifiers {\n  stop?: boolean;\n  once?: boolean;\n  prevent?: boolean;\n  capture?: boolean;\n  self?: boolean;\n}\ntype OnLongPressReturn = () => void;\n/** @deprecated use {@link OnLongPressReturn} instead */\ntype UseOnLongPressReturn = OnLongPressReturn;\ndeclare function onLongPress(target: MaybeElementRef, handler: (evt: PointerEvent) => void, options?: OnLongPressOptions): OnLongPressReturn;\n//#endregion\n//#region onStartTyping/index.d.ts\n/**\n * Fires when users start typing on non-editable elements.\n *\n * @see https://vueuse.org/onStartTyping\n * @param callback\n * @param options\n */\ndeclare function onStartTyping(callback: (event: KeyboardEvent) => void, options?: ConfigurableDocument): void;\n//#endregion\n//#region templateRef/index.d.ts\n/**\n * @deprecated Use Vue's built-in `useTemplateRef` instead.\n *\n * Shorthand for binding ref to template element.\n *\n * @see https://vueuse.org/templateRef\n * @param key\n * @param initialValue\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function templateRef<T extends HTMLElement | SVGElement | Component | null, Keys extends string = string>(key: Keys, initialValue?: T | null): Readonly<Ref<T>>;\n//#endregion\n//#region useActiveElement/index.d.ts\ninterface UseActiveElementOptions extends ConfigurableWindow, ConfigurableDocumentOrShadowRoot {\n  /**\n   * Search active element deeply inside shadow dom\n   *\n   * @default true\n   */\n  deep?: boolean;\n  /**\n   * Track active element when it's removed from the DOM\n   * Using a MutationObserver under the hood\n   * @default false\n   */\n  triggerOnRemoval?: boolean;\n}\ntype UseActiveElementReturn<T extends HTMLElement = HTMLElement> = ShallowRef<T | null | undefined>;\n/**\n * Reactive `document.activeElement`\n *\n * @see https://vueuse.org/useActiveElement\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useActiveElement<T extends HTMLElement>(options?: UseActiveElementOptions): UseActiveElementReturn<T>;\n//#endregion\n//#region types.d.ts\ninterface Position {\n  x: number;\n  y: number;\n}\ninterface RenderableComponent {\n  /**\n   * The element that the component should be rendered as\n   *\n   * @default 'div'\n   */\n  as?: object | string;\n}\ntype PointerType = 'mouse' | 'touch' | 'pen';\ninterface Supportable {\n  isSupported: ComputedRef<boolean>;\n}\n//#endregion\n//#region useAnimate/index.d.ts\ninterface UseAnimateOptions extends KeyframeAnimationOptions, ConfigurableWindow {\n  /**\n   * Will automatically run play when `useAnimate` is used\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Whether to commits the end styling state of an animation to the element being animated\n   * In general, you should use `fill` option with this.\n   *\n   * @default false\n   */\n  commitStyles?: boolean;\n  /**\n   * Whether to persists the animation\n   *\n   * @default false\n   */\n  persist?: boolean;\n  /**\n   * Executed after animation initialization\n   */\n  onReady?: (animate: Animation) => void;\n  /**\n   * Callback when error is caught.\n   */\n  onError?: (e: unknown) => void;\n}\ntype UseAnimateKeyframes = MaybeRef<Keyframe[] | PropertyIndexedKeyframes | null>;\ninterface UseAnimateReturn extends Supportable {\n  animate: ShallowRef<Animation | undefined>;\n  play: () => void;\n  pause: () => void;\n  reverse: () => void;\n  finish: () => void;\n  cancel: () => void;\n  pending: ComputedRef<boolean>;\n  playState: ComputedRef<AnimationPlayState>;\n  replaceState: ComputedRef<AnimationReplaceState>;\n  startTime: WritableComputedRef<CSSNumberish | number | null>;\n  currentTime: WritableComputedRef<CSSNumberish | null>;\n  timeline: WritableComputedRef<AnimationTimeline | null>;\n  playbackRate: WritableComputedRef<number>;\n}\n/**\n * Reactive Web Animations API\n *\n * @see https://vueuse.org/useAnimate\n * @param target\n * @param keyframes\n * @param options\n */\ndeclare function useAnimate(target: MaybeComputedElementRef, keyframes: UseAnimateKeyframes, options?: number | UseAnimateOptions): UseAnimateReturn;\n//#endregion\n//#region useAsyncQueue/index.d.ts\ntype UseAsyncQueueTask<T> = (...args: any[]) => T | Promise<T>;\ntype MapQueueTask<T extends any[]> = { [K in keyof T]: UseAsyncQueueTask<T[K]> };\ninterface UseAsyncQueueResult<T> {\n  state: 'aborted' | 'fulfilled' | 'pending' | 'rejected';\n  data: T | null;\n}\ninterface UseAsyncQueueReturn<T> {\n  activeIndex: ShallowRef<number>;\n  result: T;\n}\ninterface UseAsyncQueueOptions {\n  /**\n   * Interrupt tasks when current task fails.\n   *\n   * @default true\n   */\n  interrupt?: boolean;\n  /**\n   * Trigger it when the tasks fails.\n   *\n   */\n  onError?: () => void;\n  /**\n   * Trigger it when the tasks ends.\n   *\n   */\n  onFinished?: () => void;\n  /**\n   * A AbortSignal that can be used to abort the task.\n   */\n  signal?: AbortSignal;\n}\n/**\n * Asynchronous queue task controller.\n *\n * @see https://vueuse.org/useAsyncQueue\n * @param tasks\n * @param options\n */\ndeclare function useAsyncQueue<T extends any[], S = MapQueueTask<T>>(tasks: S & Array<UseAsyncQueueTask<any>>, options?: UseAsyncQueueOptions): UseAsyncQueueReturn<{ [P in keyof T]: UseAsyncQueueResult<T[P]> }>;\n//#endregion\n//#region useAsyncState/index.d.ts\ninterface UseAsyncStateReturnBase<Data, Params extends any[], Shallow extends boolean> {\n  state: Shallow extends true ? Ref<Data> : Ref<UnwrapRef<Data>>;\n  isReady: Ref<boolean>;\n  isLoading: Ref<boolean>;\n  error: Ref<unknown>;\n  execute: (delay?: number, ...args: Params) => Promise<Data | undefined>;\n  executeImmediate: (...args: Params) => Promise<Data | undefined>;\n}\ntype UseAsyncStateReturn<Data, Params extends any[], Shallow extends boolean> = UseAsyncStateReturnBase<Data, Params, Shallow> & PromiseLike<UseAsyncStateReturnBase<Data, Params, Shallow>>;\ninterface UseAsyncStateOptions<Shallow extends boolean, D = any> {\n  /**\n   * Delay for the first execution of the promise when \"immediate\" is true. In milliseconds.\n   *\n   * @default 0\n   */\n  delay?: number;\n  /**\n   * Execute the promise right after the function is invoked.\n   * Will apply the delay if any.\n   *\n   * When set to false, you will need to execute it manually.\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Callback when error is caught.\n   */\n  onError?: (e: unknown) => void;\n  /**\n   * Callback when success is caught.\n   * @param {D} data\n   */\n  onSuccess?: (data: D) => void;\n  /**\n   * Sets the state to initialState before executing the promise.\n   *\n   * This can be useful when calling the execute function more than once (for\n   * example, to refresh data). When set to false, the current state remains\n   * unchanged until the promise resolves.\n   *\n   * @default true\n   */\n  resetOnExecute?: boolean;\n  /**\n   * Use shallowRef.\n   *\n   * @default true\n   */\n  shallow?: Shallow;\n  /**\n   *\n   * An error is thrown when executing the execute function\n   *\n   * @default false\n   */\n  throwError?: boolean;\n}\n/**\n * Reactive async state. Will not block your setup function and will trigger changes once\n * the promise is ready.\n *\n * @see https://vueuse.org/useAsyncState\n * @param promise         The promise / async function to be resolved\n * @param initialState    The initial state, used until the first evaluation finishes\n * @param options\n */\ndeclare 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>;\n//#endregion\n//#region useBase64/index.d.ts\ninterface UseBase64Options {\n  /**\n   * Output as Data URL format\n   *\n   * @default true\n   */\n  dataUrl?: boolean;\n}\ninterface ToDataURLOptions extends UseBase64Options {\n  /**\n   * MIME type\n   */\n  type?: string | undefined;\n  /**\n   * Image quality of jpeg or webp\n   */\n  quality?: any;\n}\ninterface UseBase64ObjectOptions<T> extends UseBase64Options {\n  serializer?: (v: T) => string;\n}\ninterface UseBase64Return {\n  base64: ShallowRef<string>;\n  promise: ShallowRef<Promise<string>>;\n  execute: () => Promise<string>;\n}\ndeclare function useBase64(target: MaybeRefOrGetter<string | undefined>, options?: UseBase64Options): UseBase64Return;\ndeclare function useBase64(target: MaybeRefOrGetter<Blob | undefined>, options?: UseBase64Options): UseBase64Return;\ndeclare function useBase64(target: MaybeRefOrGetter<ArrayBuffer | undefined>, options?: UseBase64Options): UseBase64Return;\ndeclare function useBase64(target: MaybeRefOrGetter<HTMLCanvasElement | undefined>, options?: ToDataURLOptions): UseBase64Return;\ndeclare function useBase64(target: MaybeRefOrGetter<HTMLImageElement | undefined>, options?: ToDataURLOptions): UseBase64Return;\ndeclare function useBase64<T extends Record<string, unknown>>(target: MaybeRefOrGetter<T>, options?: UseBase64ObjectOptions<T>): UseBase64Return;\ndeclare function useBase64<T extends Map<string, unknown>>(target: MaybeRefOrGetter<T>, options?: UseBase64ObjectOptions<T>): UseBase64Return;\ndeclare function useBase64<T extends Set<unknown>>(target: MaybeRefOrGetter<T>, options?: UseBase64ObjectOptions<T>): UseBase64Return;\ndeclare function useBase64<T>(target: MaybeRefOrGetter<T[]>, options?: UseBase64ObjectOptions<T[]>): UseBase64Return;\n//#endregion\n//#region useBattery/index.d.ts\ninterface UseBatteryOptions extends ConfigurableNavigator {}\ninterface UseBatteryReturn extends Supportable {\n  charging: ShallowRef<boolean>;\n  chargingTime: ShallowRef<number>;\n  dischargingTime: ShallowRef<number>;\n  level: ShallowRef<number>;\n}\ninterface BatteryManager extends EventTarget {\n  charging: boolean;\n  chargingTime: number;\n  dischargingTime: number;\n  level: number;\n}\n/**\n * Reactive Battery Status API.\n *\n * @see https://vueuse.org/useBattery\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useBattery(options?: UseBatteryOptions): UseBatteryReturn;\n//#endregion\n//#region useBluetooth/index.d.ts\ninterface UseBluetoothRequestDeviceOptions {\n  /**\n   *\n   * An array of BluetoothScanFilters. This filter consists of an array\n   * of BluetoothServiceUUIDs, a name parameter, and a namePrefix parameter.\n   *\n   */\n  filters?: BluetoothLEScanFilter[] | undefined;\n  /**\n   *\n   * An array of BluetoothServiceUUIDs.\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/BluetoothRemoteGATTService/uuid\n   *\n   */\n  optionalServices?: BluetoothServiceUUID[] | undefined;\n}\ninterface UseBluetoothOptions extends UseBluetoothRequestDeviceOptions, ConfigurableNavigator {\n  /**\n   *\n   * A boolean value indicating that the requesting script can accept all Bluetooth\n   * devices. The default is false.\n   *\n   * !! This may result in a bunch of unrelated devices being shown\n   * in the chooser and energy being wasted as there are no filters.\n   *\n   *\n   * Use it with caution.\n   *\n   * @default false\n   *\n   */\n  acceptAllDevices?: boolean;\n}\ndeclare function useBluetooth(options?: UseBluetoothOptions): UseBluetoothReturn;\ninterface UseBluetoothReturn extends Supportable {\n  isConnected: Readonly<ShallowRef<boolean>>;\n  device: ShallowRef<BluetoothDevice | undefined>;\n  requestDevice: () => Promise<void>;\n  server: ShallowRef<BluetoothRemoteGATTServer | undefined>;\n  error: ShallowRef<unknown | null>;\n}\n//#endregion\n//#region useBreakpoints/breakpoints.d.ts\n/**\n * Breakpoints from Tailwind V2\n *\n * @see https://tailwindcss.com/docs/breakpoints\n */\ndeclare const breakpointsTailwind: {\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n  '2xl': number;\n};\n/**\n * Breakpoints from Bootstrap V5\n *\n * @see https://getbootstrap.com/docs/5.0/layout/breakpoints\n */\ndeclare const breakpointsBootstrapV5: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n  xxl: number;\n};\n/**\n * Breakpoints from Vuetify V2\n *\n * @see https://v2.vuetifyjs.com/en/features/breakpoints/\n */\ndeclare const breakpointsVuetifyV2: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n};\n/**\n * Breakpoints from Vuetify V3\n *\n * @see https://vuetifyjs.com/en/styles/float/#overview\n */\ndeclare const breakpointsVuetifyV3: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n  xxl: number;\n};\n/**\n * Alias to `breakpointsVuetifyV2`\n *\n * @deprecated explictly use `breakpointsVuetifyV2` or `breakpointsVuetifyV3` instead\n */\ndeclare const breakpointsVuetify: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n};\n/**\n * Breakpoints from Ant Design\n *\n * @see https://ant.design/components/layout/#breakpoint-width\n */\ndeclare const breakpointsAntDesign: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n  xxl: number;\n};\n/**\n * Breakpoints from Quasar V2\n *\n * @see https://quasar.dev/style/breakpoints\n */\ndeclare const breakpointsQuasar: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n};\n/**\n * Sematic Breakpoints\n */\ndeclare const breakpointsSematic: {\n  mobileS: number;\n  mobileM: number;\n  mobileL: number;\n  tablet: number;\n  laptop: number;\n  laptopL: number;\n  desktop4K: number;\n};\n/**\n * Breakpoints from Master CSS\n *\n * @see https://docs.master.co/css/breakpoints\n */\ndeclare const breakpointsMasterCss: {\n  '3xs': number;\n  '2xs': number;\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n  '2xl': number;\n  '3xl': number;\n  '4xl': number;\n};\n/**\n * Breakpoints from PrimeFlex\n *\n * @see https://primeflex.org/installation\n */\ndeclare const breakpointsPrimeFlex: {\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n};\n/**\n * Breakpoints from ElementUI/ElementPlus\n *\n * @see https://element.eleme.io/#/en-US/component/layout\n * @see https://element-plus.org/en-US/component/layout.html\n */\ndeclare const breakpointsElement: {\n  xs: number;\n  sm: number;\n  md: number;\n  lg: number;\n  xl: number;\n};\n//#endregion\n//#region useBreakpoints/index.d.ts\ntype Breakpoints<K$1 extends string = string> = Record<K$1, MaybeRefOrGetter<number | string>>;\ninterface UseBreakpointsOptions extends ConfigurableWindow {\n  /**\n   * The query strategy to use for the generated shortcut methods like `.lg`\n   *\n   * 'min-width' - .lg will be true when the viewport is greater than or equal to the lg breakpoint (mobile-first)\n   * 'max-width' - .lg will be true when the viewport is smaller than the xl breakpoint (desktop-first)\n   *\n   * @default \"min-width\"\n   */\n  strategy?: 'min-width' | 'max-width';\n  ssrWidth?: number;\n}\ntype UseBreakpointReturn<K$1 extends string = string> = Record<K$1, ComputedRef<boolean>> & {\n  greaterOrEqual: (k: MaybeRefOrGetter<K$1>) => ComputedRef<boolean>;\n  smallerOrEqual: (k: MaybeRefOrGetter<K$1>) => ComputedRef<boolean>;\n  greater: (k: MaybeRefOrGetter<K$1>) => ComputedRef<boolean>;\n  smaller: (k: MaybeRefOrGetter<K$1>) => ComputedRef<boolean>;\n  between: (a: MaybeRefOrGetter<K$1>, b: MaybeRefOrGetter<K$1>) => ComputedRef<boolean>;\n  isGreater: (k: MaybeRefOrGetter<K$1>) => boolean;\n  isGreaterOrEqual: (k: MaybeRefOrGetter<K$1>) => boolean;\n  isSmaller: (k: MaybeRefOrGetter<K$1>) => boolean;\n  isSmallerOrEqual: (k: MaybeRefOrGetter<K$1>) => boolean;\n  isInBetween: (a: MaybeRefOrGetter<K$1>, b: MaybeRefOrGetter<K$1>) => boolean;\n  current: () => ComputedRef<K$1[]>;\n  active: () => ComputedRef<K$1 | ''>;\n};\n/**\n * Reactively viewport breakpoints\n *\n * @see https://vueuse.org/useBreakpoints\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useBreakpoints<K$1 extends string>(breakpoints: Breakpoints<K$1>, options?: UseBreakpointsOptions): UseBreakpointReturn<K$1>;\n//#endregion\n//#region useBroadcastChannel/index.d.ts\ninterface UseBroadcastChannelOptions extends ConfigurableWindow {\n  /**\n   * The name of the channel.\n   */\n  name: string;\n}\n/**\n * Reactive BroadcastChannel\n *\n * @see https://vueuse.org/useBroadcastChannel\n * @see https://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel\n * @param options\n *\n */\ndeclare function useBroadcastChannel<D, P$1>(options: UseBroadcastChannelOptions): UseBroadcastChannelReturn<D, P$1>;\ninterface UseBroadcastChannelReturn<D, P$1> extends Supportable {\n  channel: Ref<BroadcastChannel | undefined>;\n  data: Ref<D>;\n  post: (data: P$1) => void;\n  close: () => void;\n  error: ShallowRef<Event | null>;\n  isClosed: ShallowRef<boolean>;\n}\n//#endregion\n//#region useBrowserLocation/index.d.ts\ninterface UseBrowserLocationOptions extends ConfigurableWindow {}\ninterface BrowserLocationState {\n  readonly trigger: string;\n  readonly state?: any;\n  readonly length?: number;\n  readonly origin?: string;\n  hash?: string;\n  host?: string;\n  hostname?: string;\n  href?: string;\n  pathname?: string;\n  port?: string;\n  protocol?: string;\n  search?: string;\n}\ntype UseBrowserLocationReturn = Ref<BrowserLocationState>;\n/**\n * Reactive browser location.\n *\n * @see https://vueuse.org/useBrowserLocation\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useBrowserLocation(options?: UseBrowserLocationOptions): UseBrowserLocationReturn;\n//#endregion\n//#region useCached/index.d.ts\ninterface UseCachedOptions<D extends boolean = true> extends ConfigurableDeepRefs<D>, WatchOptions {}\ndeclare function useCached<T, D extends boolean = true>(refValue: Ref<T>, comparator?: (a: T, b: T) => boolean, options?: UseCachedOptions<D>): UseCachedReturn<T, D>;\ntype UseCachedReturn<T = any, D extends boolean = true> = ShallowOrDeepRef<T, D>;\n//#endregion\n//#region useClipboard/index.d.ts\ninterface UseClipboardOptions<Source> extends ConfigurableNavigator {\n  /**\n   * Enabled reading for clipboard\n   *\n   * @default false\n   */\n  read?: boolean;\n  /**\n   * Copy source\n   */\n  source?: Source;\n  /**\n   * Milliseconds to reset state of `copied` ref\n   *\n   * @default 1500\n   */\n  copiedDuring?: number;\n  /**\n   * Whether fallback to document.execCommand('copy') if clipboard is undefined.\n   *\n   * @default false\n   */\n  legacy?: boolean;\n}\ninterface UseClipboardReturn<Optional> extends Supportable {\n  text: Readonly<ShallowRef<string>>;\n  copied: Readonly<ShallowRef<boolean>>;\n  copy: Optional extends true ? (text?: string) => Promise<void> : (text: string) => Promise<void>;\n}\n/**\n * Reactive Clipboard API.\n *\n * @see https://vueuse.org/useClipboard\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useClipboard(options?: UseClipboardOptions<undefined>): UseClipboardReturn<false>;\ndeclare function useClipboard(options: UseClipboardOptions<MaybeRefOrGetter<string>>): UseClipboardReturn<true>;\n//#endregion\n//#region useClipboardItems/index.d.ts\ninterface UseClipboardItemsOptions<Source> extends ConfigurableNavigator {\n  /**\n   * Enabled reading for clipboard\n   *\n   * @default false\n   */\n  read?: boolean;\n  /**\n   * Copy source\n   */\n  source?: Source;\n  /**\n   * Milliseconds to reset state of `copied` ref\n   *\n   * @default 1500\n   */\n  copiedDuring?: number;\n}\ninterface UseClipboardItemsReturn<Optional> extends Supportable {\n  content: Readonly<Ref<ClipboardItems>>;\n  copied: Readonly<ShallowRef<boolean>>;\n  copy: Optional extends true ? (content?: ClipboardItems) => Promise<void> : (text: ClipboardItems) => Promise<void>;\n  read: () => void;\n}\n/**\n * Reactive Clipboard API.\n *\n * @see https://vueuse.org/useClipboardItems\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useClipboardItems(options?: UseClipboardItemsOptions<undefined>): UseClipboardItemsReturn<false>;\ndeclare function useClipboardItems(options: UseClipboardItemsOptions<MaybeRefOrGetter<ClipboardItems>>): UseClipboardItemsReturn<true>;\n//#endregion\n//#region useCloned/index.d.ts\ninterface UseClonedOptions<T = any> extends WatchOptions {\n  /**\n   * Custom clone function.\n   *\n   * By default, it use `JSON.parse(JSON.stringify(value))` to clone.\n   */\n  clone?: (source: T) => T;\n  /**\n   * Manually sync the ref\n   *\n   * @default false\n   */\n  manual?: boolean;\n}\ninterface UseClonedReturn<T> {\n  /**\n   * Cloned ref\n   */\n  cloned: Ref<T>;\n  /**\n   * Ref indicates whether the cloned data is modified\n   */\n  isModified: Ref<boolean>;\n  /**\n   * Sync cloned data with source manually\n   */\n  sync: () => void;\n}\ntype CloneFn<F, T = F> = (x: F) => T;\ndeclare function cloneFnJSON<T>(source: T): T;\ndeclare function useCloned<T>(source: MaybeRefOrGetter<T>, options?: UseClonedOptions): UseClonedReturn<T>;\n//#endregion\n//#region ssr-handlers.d.ts\ninterface StorageLikeAsync {\n  getItem: (key: string) => Awaitable<string | null>;\n  setItem: (key: string, value: string) => Awaitable<void>;\n  removeItem: (key: string) => Awaitable<void>;\n}\ninterface StorageLike {\n  getItem: (key: string) => string | null;\n  setItem: (key: string, value: string) => void;\n  removeItem: (key: string) => void;\n}\n/**\n * @experimental The API is not finalized yet. It might not follow semver.\n */\ninterface SSRHandlersMap {\n  getDefaultStorage: () => StorageLike | undefined;\n  getDefaultStorageAsync: () => StorageLikeAsync | undefined;\n  updateHTMLAttrs: (selector: string | MaybeElementRef, attribute: string, value: string) => void;\n}\ndeclare function getSSRHandler<T extends keyof SSRHandlersMap>(key: T, fallback: SSRHandlersMap[T]): SSRHandlersMap[T];\ndeclare function getSSRHandler<T extends keyof SSRHandlersMap>(key: T, fallback: SSRHandlersMap[T] | undefined): SSRHandlersMap[T] | undefined;\ndeclare function setSSRHandler<T extends keyof SSRHandlersMap>(key: T, fn: SSRHandlersMap[T]): void;\n//#endregion\n//#region useStorage/index.d.ts\ninterface Serializer<T> {\n  read: (raw: string) => T;\n  write: (value: T) => string;\n}\ninterface SerializerAsync<T> {\n  read: (raw: string) => Awaitable<T>;\n  write: (value: T) => Awaitable<string>;\n}\ndeclare const StorageSerializers: Record<'boolean' | 'object' | 'number' | 'any' | 'string' | 'map' | 'set' | 'date', Serializer<any>>;\ndeclare const customStorageEventName = \"vueuse-storage\";\ninterface StorageEventLike {\n  storageArea: StorageLike | null;\n  key: StorageEvent['key'];\n  oldValue: StorageEvent['oldValue'];\n  newValue: StorageEvent['newValue'];\n}\ninterface UseStorageOptions<T> extends ConfigurableEventFilter, ConfigurableWindow, ConfigurableFlush {\n  /**\n   * Watch for deep changes\n   *\n   * @default true\n   */\n  deep?: boolean;\n  /**\n   * Listen to storage changes, useful for multiple tabs application\n   *\n   * @default true\n   */\n  listenToStorageChanges?: boolean;\n  /**\n   * Write the default value to the storage when it does not exist\n   *\n   * @default true\n   */\n  writeDefaults?: boolean;\n  /**\n   * Merge the default value with the value read from the storage.\n   *\n   * When setting it to true, it will perform a **shallow merge** for objects.\n   * You can pass a function to perform custom merge (e.g. deep merge), for example:\n   *\n   * @default false\n   */\n  mergeDefaults?: boolean | ((storageValue: T, defaults: T) => T);\n  /**\n   * Custom data serialization\n   */\n  serializer?: Serializer<T>;\n  /**\n   * On error callback\n   *\n   * Default log error to `console.error`\n   */\n  onError?: (error: unknown) => void;\n  /**\n   * Use shallow ref as reference\n   *\n   * @default false\n   */\n  shallow?: boolean;\n  /**\n   * Wait for the component to be mounted before reading the storage.\n   *\n   * @default false\n   */\n  initOnMounted?: boolean;\n}\ndeclare function useStorage(key: MaybeRefOrGetter<string>, defaults: MaybeRefOrGetter<string>, storage?: StorageLike, options?: UseStorageOptions<string>): RemovableRef<string>;\ndeclare function useStorage(key: MaybeRefOrGetter<string>, defaults: MaybeRefOrGetter<boolean>, storage?: StorageLike, options?: UseStorageOptions<boolean>): RemovableRef<boolean>;\ndeclare function useStorage(key: MaybeRefOrGetter<string>, defaults: MaybeRefOrGetter<number>, storage?: StorageLike, options?: UseStorageOptions<number>): RemovableRef<number>;\ndeclare function useStorage<T>(key: MaybeRefOrGetter<string>, defaults: MaybeRefOrGetter<T>, storage?: StorageLike, options?: UseStorageOptions<T>): RemovableRef<T>;\ndeclare function useStorage<T = unknown>(key: MaybeRefOrGetter<string>, defaults: MaybeRefOrGetter<null>, storage?: StorageLike, options?: UseStorageOptions<T>): RemovableRef<T>;\n//#endregion\n//#region useColorMode/index.d.ts\ntype BasicColorMode = 'light' | 'dark';\ntype BasicColorSchema = BasicColorMode | 'auto';\ninterface UseColorModeOptions<T extends string = BasicColorMode> extends UseStorageOptions<T | BasicColorMode> {\n  /**\n   * CSS Selector for the target element applying to\n   *\n   * @default 'html'\n   */\n  selector?: string | MaybeElementRef;\n  /**\n   * HTML attribute applying the target element\n   *\n   * @default 'class'\n   */\n  attribute?: string;\n  /**\n   * The initial color mode\n   *\n   * @default 'auto'\n   */\n  initialValue?: MaybeRefOrGetter<T | BasicColorSchema>;\n  /**\n   * Prefix when adding value to the attribute\n   */\n  modes?: Partial<Record<T | BasicColorSchema, string>>;\n  /**\n   * A custom handler for handle the updates.\n   * When specified, the default behavior will be overridden.\n   *\n   * @default undefined\n   */\n  onChanged?: (mode: T | BasicColorMode, defaultHandler: ((mode: T | BasicColorMode) => void)) => void;\n  /**\n   * Custom storage ref\n   *\n   * When provided, `useStorage` will be skipped\n   */\n  storageRef?: Ref<T | BasicColorSchema>;\n  /**\n   * Key to persist the data into localStorage/sessionStorage.\n   *\n   * Pass `null` to disable persistence\n   *\n   * @default 'vueuse-color-scheme'\n   */\n  storageKey?: string | null;\n  /**\n   * Storage object, can be localStorage or sessionStorage\n   *\n   * @default localStorage\n   */\n  storage?: StorageLike;\n  /**\n   * Emit `auto` mode from state\n   *\n   * When set to `true`, preferred mode won't be translated into `light` or `dark`.\n   * This is useful when the fact that `auto` mode was selected needs to be known.\n   *\n   * @default undefined\n   * @deprecated use `store.value` when `auto` mode needs to be known\n   * @see https://vueuse.org/core/useColorMode/#advanced-usage\n   */\n  emitAuto?: boolean;\n  /**\n   * Disable transition on switch\n   *\n   * @see https://paco.me/writing/disable-theme-transitions\n   * @default true\n   */\n  disableTransition?: boolean;\n}\ntype UseColorModeReturn<T extends string = BasicColorMode> = Ref<T | BasicColorSchema> & {\n  store: Ref<T | BasicColorSchema>;\n  system: ComputedRef<BasicColorMode>;\n  state: ComputedRef<T | BasicColorMode>;\n};\n/**\n * Reactive color mode with auto data persistence.\n *\n * @see https://vueuse.org/useColorMode\n * @param options\n */\ndeclare function useColorMode<T extends string = BasicColorMode>(options?: UseColorModeOptions<T>): UseColorModeReturn<T>;\n//#endregion\n//#region useConfirmDialog/index.d.ts\ntype UseConfirmDialogRevealResult<C, D> = {\n  data?: C;\n  isCanceled: false;\n} | {\n  data?: D;\n  isCanceled: true;\n};\ninterface UseConfirmDialogReturn<RevealData, ConfirmData, CancelData> {\n  /**\n   * Revealing state\n   */\n  isRevealed: ComputedRef<boolean>;\n  /**\n   * Opens the dialog.\n   * Create promise and return it. Triggers `onReveal` hook.\n   */\n  reveal: (data?: RevealData) => Promise<UseConfirmDialogRevealResult<ConfirmData, CancelData>>;\n  /**\n   * Confirms and closes the dialog. Triggers a callback inside `onConfirm` hook.\n   * Resolves promise from `reveal()` with `data` and `isCanceled` ref with `false` value.\n   * Can accept any data and to pass it to `onConfirm` hook.\n   */\n  confirm: (data?: ConfirmData) => void;\n  /**\n   * Cancels and closes the dialog. Triggers a callback inside `onCancel` hook.\n   * Resolves promise from `reveal()` with `data` and `isCanceled` ref with `true` value.\n   * Can accept any data and to pass it to `onCancel` hook.\n   */\n  cancel: (data?: CancelData) => void;\n  /**\n   * Event Hook to be triggered right before dialog creating.\n   */\n  onReveal: EventHookOn<RevealData>;\n  /**\n   * Event Hook to be called on `confirm()`.\n   * Gets data object from `confirm` function.\n   */\n  onConfirm: EventHookOn<ConfirmData>;\n  /**\n   * Event Hook to be called on `cancel()`.\n   * Gets data object from `cancel` function.\n   */\n  onCancel: EventHookOn<CancelData>;\n}\n/**\n * Hooks for creating confirm dialogs. Useful for modal windows, popups and logins.\n *\n * @see https://vueuse.org/useConfirmDialog/\n * @param revealed `boolean` `ref` that handles a modal window\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useConfirmDialog<RevealData = any, ConfirmData = any, CancelData = any>(revealed?: ShallowRef<boolean>): UseConfirmDialogReturn<RevealData, ConfirmData, CancelData>;\n//#endregion\n//#region useCountdown/index.d.ts\ninterface UseCountdownOptions extends ConfigurableScheduler {\n  /**\n   *  Interval for the countdown in milliseconds. Default is 1000ms.\n   *\n   * @deprecated Please use `scheduler` option instead\n   */\n  interval?: MaybeRefOrGetter<number>;\n  /**\n   * Callback function called when the countdown reaches 0.\n   */\n  onComplete?: () => void;\n  /**\n   * Callback function called on each tick of the countdown.\n   */\n  onTick?: () => void;\n  /**\n   * Start the countdown immediately\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default false\n   */\n  immediate?: boolean;\n}\ninterface UseCountdownReturn extends Pausable {\n  /**\n   * Current countdown value.\n   */\n  remaining: ShallowRef<number>;\n  /**\n   * Resets the countdown and repeatsLeft to their initial values.\n   */\n  reset: (countdown?: MaybeRefOrGetter<number>) => void;\n  /**\n   * Stops the countdown and resets its state.\n   */\n  stop: () => void;\n  /**\n   * Reset the countdown and start it again.\n   */\n  start: (countdown?: MaybeRefOrGetter<number>) => void;\n}\n/**\n * Reactive countdown timer in seconds.\n *\n * @param initialCountdown\n * @param options\n *\n * @see https://vueuse.org/useCountdown\n */\ndeclare function useCountdown(initialCountdown: MaybeRefOrGetter<number>, options?: UseCountdownOptions): UseCountdownReturn;\n//#endregion\n//#region useCssSupports/index.d.ts\ninterface UseCssSupportsOptions extends ConfigurableWindow {\n  ssrValue?: boolean;\n}\ninterface UseCssSupportsReturn extends Supportable {}\ndeclare function useCssSupports(property: MaybeRefOrGetter<string>, value: MaybeRefOrGetter<string>, options?: UseCssSupportsOptions): UseCssSupportsReturn;\ndeclare function useCssSupports(conditionText: MaybeRefOrGetter<string>, options?: UseCssSupportsOptions): UseCssSupportsReturn;\n//#endregion\n//#region useCssVar/index.d.ts\ninterface UseCssVarOptions extends ConfigurableWindow {\n  initialValue?: string;\n  /**\n   * Use MutationObserver to monitor variable changes\n   * @default false\n   */\n  observe?: boolean;\n}\n/**\n * Manipulate CSS variables.\n *\n * @see https://vueuse.org/useCssVar\n * @param prop\n * @param target\n * @param options\n */\ndeclare function useCssVar(prop: MaybeRefOrGetter<string | null | undefined>, target?: MaybeElementRef, options?: UseCssVarOptions): vue0.ShallowRef<string | undefined, string | undefined>;\n//#endregion\n//#region useCurrentElement/index.d.ts\ndeclare function useCurrentElement<T extends MaybeElement = MaybeElement, R$1 extends VueInstance = VueInstance, E extends MaybeElement = (MaybeElement extends T ? IsAny<R$1['$el']> extends false ? R$1['$el'] : T : T)>(rootComponent?: MaybeElementRef<R$1>): _vueuse_shared0.ComputedRefWithControl<E>;\n//#endregion\n//#region useCycleList/index.d.ts\ninterface UseCycleListOptions<T> {\n  /**\n   * The initial value of the state.\n   * A ref can be provided to reuse.\n   */\n  initialValue?: MaybeRef<T>;\n  /**\n   * The default index when\n   */\n  fallbackIndex?: number;\n  /**\n   * Custom function to get the index of the current value.\n   */\n  getIndexOf?: (value: T, list: T[]) => number;\n}\n/**\n * Cycle through a list of items\n *\n * @see https://vueuse.org/useCycleList\n */\ndeclare function useCycleList<T>(list: MaybeRefOrGetter<T[]>, options?: UseCycleListOptions<T>): UseCycleListReturn<T>;\ninterface UseCycleListReturn<T> {\n  state: ShallowRef<T>;\n  index: WritableComputedRef<number>;\n  next: (n?: number) => T;\n  prev: (n?: number) => T;\n  /**\n   * Go to a specific index\n   */\n  go: (i: number) => T;\n}\n//#endregion\n//#region useDark/index.d.ts\ninterface UseDarkOptions extends Omit<UseColorModeOptions<BasicColorSchema>, 'modes' | 'onChanged'> {\n  /**\n   * Value applying to the target element when isDark=true\n   *\n   * @default 'dark'\n   */\n  valueDark?: string;\n  /**\n   * Value applying to the target element when isDark=false\n   *\n   * @default ''\n   */\n  valueLight?: string;\n  /**\n   * A custom handler for handle the updates.\n   * When specified, the default behavior will be overridden.\n   *\n   * @default undefined\n   */\n  onChanged?: (isDark: boolean, defaultHandler: ((mode: BasicColorSchema) => void), mode: BasicColorSchema) => void;\n}\ntype UseDarkReturn = WritableComputedRef<boolean>;\n/**\n * Reactive dark mode with auto data persistence.\n *\n * @see https://vueuse.org/useDark\n * @param options\n */\ndeclare function useDark(options?: UseDarkOptions): UseDarkReturn;\n//#endregion\n//#region useManualRefHistory/index.d.ts\ninterface UseRefHistoryRecord<T> {\n  snapshot: T;\n  timestamp: number;\n}\ninterface UseManualRefHistoryOptions<Raw, Serialized = Raw> {\n  /**\n   * Maximum number of history to be kept. Default to unlimited.\n   */\n  capacity?: number;\n  /**\n   * Clone when taking a snapshot, shortcut for dump: JSON.parse(JSON.stringify(value)).\n   * Default to false\n   *\n   * @default false\n   */\n  clone?: boolean | CloneFn<Raw>;\n  /**\n   * Serialize data into the history\n   */\n  dump?: (v: Raw) => Serialized;\n  /**\n   * Deserialize data from the history\n   */\n  parse?: (v: Serialized) => Raw;\n  /**\n   * set data source\n   */\n  setSource?: (source: Ref<Raw>, v: Raw) => void;\n}\ninterface UseManualRefHistoryReturn<Raw, Serialized> {\n  /**\n   * Bypassed tracking ref from the argument\n   */\n  source: Ref<Raw>;\n  /**\n   * An array of history records for undo, newest comes to first\n   */\n  history: Ref<UseRefHistoryRecord<Serialized>[]>;\n  /**\n   * Last history point, source can be different if paused\n   */\n  last: Ref<UseRefHistoryRecord<Serialized>>;\n  /**\n   * Same as {@link UseManualRefHistoryReturn.history | history}\n   */\n  undoStack: Ref<UseRefHistoryRecord<Serialized>[]>;\n  /**\n   * Records array for redo\n   */\n  redoStack: Ref<UseRefHistoryRecord<Serialized>[]>;\n  /**\n   * A ref representing if undo is possible (non empty undoStack)\n   */\n  canUndo: ComputedRef<boolean>;\n  /**\n   * A ref representing if redo is possible (non empty redoStack)\n   */\n  canRedo: ComputedRef<boolean>;\n  /**\n   * Undo changes\n   */\n  undo: () => void;\n  /**\n   * Redo changes\n   */\n  redo: () => void;\n  /**\n   * Clear all the history\n   */\n  clear: () => void;\n  /**\n   * Create a new history record\n   */\n  commit: () => void;\n  /**\n   * Reset ref's value with latest history\n   */\n  reset: () => void;\n}\n/**\n * Track the change history of a ref, also provides undo and redo functionality.\n *\n * @see https://vueuse.org/useManualRefHistory\n * @param source\n * @param options\n */\ndeclare function useManualRefHistory<Raw, Serialized = Raw>(source: Ref<Raw>, options?: UseManualRefHistoryOptions<Raw, Serialized>): UseManualRefHistoryReturn<Raw, Serialized>;\n//#endregion\n//#region useRefHistory/index.d.ts\ninterface UseRefHistoryOptions<Raw, Serialized = Raw> extends ConfigurableEventFilter, ConfigurableFlush {\n  /**\n   * Watch for deep changes, default to false\n   *\n   * When set to true, it will also create clones for values store in the history\n   *\n   * @default false\n   */\n  deep?: boolean;\n  /**\n   * Maximum number of history to be kept. Default to unlimited.\n   */\n  capacity?: number;\n  /**\n   * Clone when taking a snapshot, shortcut for dump: JSON.parse(JSON.stringify(value)).\n   * Default to false\n   *\n   * @default false\n   */\n  clone?: boolean | CloneFn<Raw>;\n  /**\n   * Serialize data into the history\n   */\n  dump?: (v: Raw) => Serialized;\n  /**\n   * Deserialize data from the history\n   */\n  parse?: (v: Serialized) => Raw;\n  /**\n   * Function to determine if the commit should proceed\n   * @param oldValue Previous value\n   * @param newValue New value\n   * @returns boolean indicating if commit should proceed\n   */\n  shouldCommit?: (oldValue: Raw | undefined, newValue: Raw) => boolean;\n}\ninterface UseRefHistoryReturn<Raw, Serialized> extends UseManualRefHistoryReturn<Raw, Serialized> {\n  /**\n   * A ref representing if the tracking is enabled\n   */\n  isTracking: Ref<boolean>;\n  /**\n   * Pause change tracking\n   */\n  pause: () => void;\n  /**\n   * Resume change tracking\n   *\n   * @param [commit] if true, a history record will be create after resuming\n   */\n  resume: (commit?: boolean) => void;\n  /**\n   * A sugar for auto pause and auto resuming within a function scope\n   *\n   * @param fn\n   */\n  batch: (fn: (cancel: Fn) => void) => void;\n  /**\n   * Clear the data and stop the watch\n   */\n  dispose: () => void;\n}\n/**\n * Track the change history of a ref, also provides undo and redo functionality.\n *\n * @see https://vueuse.org/useRefHistory\n * @param source\n * @param options\n */\ndeclare function useRefHistory<Raw, Serialized = Raw>(source: Ref<Raw>, options?: UseRefHistoryOptions<Raw, Serialized>): UseRefHistoryReturn<Raw, Serialized>;\n//#endregion\n//#region useDebouncedRefHistory/index.d.ts\n/**\n * Shorthand for [useRefHistory](https://vueuse.org/useRefHistory) with debounce filter.\n *\n * @see https://vueuse.org/useDebouncedRefHistory\n * @param source\n * @param options\n */\ndeclare function useDebouncedRefHistory<Raw, Serialized = Raw>(source: Ref<Raw>, options?: Omit<UseRefHistoryOptions<Raw, Serialized>, 'eventFilter'> & {\n  debounce?: MaybeRefOrGetter<number>;\n}): UseRefHistoryReturn<Raw, Serialized>;\n//#endregion\n//#region useDeviceMotion/index.d.ts\ninterface UseDeviceMotionOptions extends ConfigurableWindow, ConfigurableEventFilter {\n  /**\n   * Request for permissions immediately if it's not granted,\n   * otherwise label and deviceIds could be empty\n   *\n   * @default false\n   */\n  requestPermissions?: boolean;\n}\n/** @deprecated use {@link UseDeviceMotionOptions} instead */\ntype DeviceMotionOptions = UseDeviceMotionOptions;\ninterface UseDeviceMotionReturn extends Supportable {\n  acceleration: Ref<DeviceMotionEventAcceleration | null>;\n  accelerationIncludingGravity: Ref<DeviceMotionEventAcceleration | null>;\n  rotationRate: Ref<DeviceMotionEventRotationRate | null>;\n  interval: ShallowRef<number>;\n  requirePermissions: ComputedRef<boolean>;\n  ensurePermissions: () => Promise<void>;\n  permissionGranted: ShallowRef<boolean>;\n}\n/**\n * Reactive DeviceMotionEvent.\n *\n * @see https://vueuse.org/useDeviceMotion\n * @param options\n */\ndeclare function useDeviceMotion(options?: UseDeviceMotionOptions): UseDeviceMotionReturn;\n//#endregion\n//#region useDeviceOrientation/index.d.ts\ninterface UseDeviceOrientationOptions extends ConfigurableWindow {}\ninterface UseDeviceOrientationReturn extends Supportable {\n  isAbsolute: ShallowRef<boolean, boolean>;\n  alpha: Ref<number | null, number | null>;\n  beta: Ref<number | null, number | null>;\n  gamma: Ref<number | null, number | null>;\n}\n/**\n * Reactive DeviceOrientationEvent.\n *\n * @see https://vueuse.org/useDeviceOrientation\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useDeviceOrientation(options?: UseDeviceOrientationOptions): UseDeviceOrientationReturn;\n//#endregion\n//#region useDevicePixelRatio/index.d.ts\ninterface UseDevicePixelRatioOptions extends ConfigurableWindow {}\ninterface UseDevicePixelRatioReturn {\n  pixelRatio: ShallowRef<number>;\n  stop: WatchStopHandle;\n}\n/**\n * Reactively track `window.devicePixelRatio`.\n *\n * @see https://vueuse.org/useDevicePixelRatio\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useDevicePixelRatio(options?: UseDevicePixelRatioOptions): UseDevicePixelRatioReturn;\n//#endregion\n//#region useDevicesList/index.d.ts\ninterface UseDevicesListOptions extends ConfigurableNavigator {\n  onUpdated?: (devices: MediaDeviceInfo[]) => void;\n  /**\n   * Request for permissions immediately if it's not granted,\n   * otherwise label and deviceIds could be empty\n   *\n   * @default false\n   */\n  requestPermissions?: boolean;\n  /**\n   * Request for types of media permissions\n   *\n   * @default { audio: true, video: true }\n   */\n  constraints?: MediaStreamConstraints;\n}\ninterface UseDevicesListReturn extends Supportable {\n  /**\n   * All devices\n   */\n  devices: Ref<MediaDeviceInfo[]>;\n  videoInputs: ComputedRef<MediaDeviceInfo[]>;\n  audioInputs: ComputedRef<MediaDeviceInfo[]>;\n  audioOutputs: ComputedRef<MediaDeviceInfo[]>;\n  permissionGranted: ShallowRef<boolean>;\n  ensurePermissions: () => Promise<boolean>;\n}\n/**\n * Reactive `enumerateDevices` listing available input/output devices\n *\n * @see https://vueuse.org/useDevicesList\n * @param options\n */\ndeclare function useDevicesList(options?: UseDevicesListOptions): UseDevicesListReturn;\n//#endregion\n//#region useDisplayMedia/index.d.ts\ninterface UseDisplayMediaOptions extends ConfigurableNavigator {\n  /**\n   * If the stream is enabled\n   * @default false\n   */\n  enabled?: MaybeRef<boolean>;\n  /**\n   * If the stream video media constraints\n   */\n  video?: boolean | MediaTrackConstraints | undefined;\n  /**\n   * If the stream audio media constraints\n   */\n  audio?: boolean | MediaTrackConstraints | undefined;\n}\ninterface UseDisplayMediaReturn extends Supportable {\n  stream: ShallowRef<MediaStream | undefined>;\n  start: () => Promise<MediaStream | undefined>;\n  stop: () => void;\n  enabled: ShallowRef<boolean>;\n}\n/**\n * Reactive `mediaDevices.getDisplayMedia` streaming\n *\n * @see https://vueuse.org/useDisplayMedia\n * @param options\n */\ndeclare function useDisplayMedia(options?: UseDisplayMediaOptions): UseDisplayMediaReturn;\n//#endregion\n//#region useDocumentVisibility/index.d.ts\ninterface UseDocumentVisibilityOptions extends ConfigurableDocument {}\ntype UseDocumentVisibilityReturn = ShallowRef<DocumentVisibilityState>;\n/**\n * Reactively track `document.visibilityState`.\n *\n * @see https://vueuse.org/useDocumentVisibility\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useDocumentVisibility(options?: UseDocumentVisibilityOptions): UseDocumentVisibilityReturn;\n//#endregion\n//#region useDraggable/index.d.ts\ninterface UseDraggableOptions {\n  /**\n   * Only start the dragging when click on the element directly\n   *\n   * @default false\n   */\n  exact?: MaybeRefOrGetter<boolean>;\n  /**\n   * Prevent events defaults\n   *\n   * @default false\n   */\n  preventDefault?: MaybeRefOrGetter<boolean>;\n  /**\n   * Prevent events propagation\n   *\n   * @default false\n   */\n  stopPropagation?: MaybeRefOrGetter<boolean>;\n  /**\n   * Whether dispatch events in capturing phase\n   *\n   * @default true\n   */\n  capture?: boolean;\n  /**\n   * Element to attach `pointermove` and `pointerup` events to.\n   *\n   * @default window\n   */\n  draggingElement?: MaybeRefOrGetter<HTMLElement | SVGElement | Window | Document | null | undefined>;\n  /**\n   * Element for calculating bounds (If not set, it will use the event's target).\n   *\n   * @default undefined\n   */\n  containerElement?: MaybeRefOrGetter<HTMLElement | SVGElement | null | undefined>;\n  /**\n   * Handle that triggers the drag event\n   *\n   * @default target\n   */\n  handle?: MaybeRefOrGetter<HTMLElement | SVGElement | null | undefined>;\n  /**\n   * Pointer types that listen to.\n   *\n   * @default ['mouse', 'touch', 'pen']\n   */\n  pointerTypes?: PointerType[];\n  /**\n   * Initial position of the element.\n   *\n   * @default { x: 0, y: 0 }\n   */\n  initialValue?: MaybeRefOrGetter<Position>;\n  /**\n   * Callback when the dragging starts. Return `false` to prevent dragging.\n   */\n  onStart?: (position: Position, event: PointerEvent) => void | false;\n  /**\n   * Callback during dragging.\n   */\n  onMove?: (position: Position, event: PointerEvent) => void;\n  /**\n   * Callback when dragging end.\n   */\n  onEnd?: (position: Position, event: PointerEvent) => void;\n  /**\n   * Axis to drag on.\n   *\n   * @default 'both'\n   */\n  axis?: 'x' | 'y' | 'both';\n  /**\n   * Disabled drag and drop.\n   *\n   * @default false\n   */\n  disabled?: MaybeRefOrGetter<boolean>;\n  /**\n   * Mouse buttons that are allowed to trigger drag events.\n   *\n   * - `0`: Main button, usually the left button or the un-initialized state\n   * - `1`: Auxiliary button, usually the wheel button or the middle button (if present)\n   * - `2`: Secondary button, usually the right button\n   * - `3`: Fourth button, typically the Browser Back button\n   * - `4`: Fifth button, typically the Browser Forward button\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button#value\n   * @default [0]\n   */\n  buttons?: MaybeRefOrGetter<number[]>;\n  /**\n   * Whether to restrict dragging within the visible area of the container.\n   *\n   * If enabled, the draggable element will not leave the visible area of its container,\n   * ensuring it remains within the viewport of the container during the drag.\n   *\n   * @default false\n   */\n  restrictInView?: MaybeRefOrGetter<boolean>;\n  /**\n   * Whether to enable auto-scroll when dragging near the edges.\n   *\n   * @default false\n   */\n  autoScroll?: MaybeRefOrGetter<boolean | {\n    /**\n     * Speed of auto-scroll.\n     *\n     * @default 2\n     */\n    speed?: MaybeRefOrGetter<number | Position>;\n    /**\n     * Margin from the edge to trigger auto-scroll.\n     *\n     * @default 30\n     */\n    margin?: MaybeRefOrGetter<number | Position>;\n    /**\n     * Direction of auto-scroll.\n     *\n     * @default 'both'\n     */\n    direction?: 'x' | 'y' | 'both';\n  }>;\n}\ninterface UseDraggableReturn {\n  x: Ref<number>;\n  y: Ref<number>;\n  position: Ref<Position>;\n  isDragging: ComputedRef<boolean>;\n  style: ComputedRef<string>;\n}\n/**\n * Make elements draggable.\n *\n * @see https://vueuse.org/useDraggable\n * @param target\n * @param options\n */\ndeclare function useDraggable(target: MaybeRefOrGetter<HTMLElement | SVGElement | null | undefined>, options?: UseDraggableOptions): UseDraggableReturn;\n//#endregion\n//#region useDropZone/index.d.ts\ninterface UseDropZoneReturn {\n  files: ShallowRef<File[] | null>;\n  isOverDropZone: ShallowRef<boolean>;\n}\ninterface UseDropZoneOptions {\n  /**\n   * Allowed data types, if not set, all data types are allowed.\n   * Also can be a function to check the data types.\n   */\n  dataTypes?: MaybeRef<readonly string[]> | ((types: readonly string[]) => boolean);\n  /**\n   * Similar to dataTypes, but exposes the DataTransferItemList for custom validation.\n   * If provided, this function takes precedence over dataTypes.\n   */\n  checkValidity?: (items: DataTransferItemList) => boolean;\n  onDrop?: (files: File[] | null, event: DragEvent) => void;\n  onEnter?: (files: File[] | null, event: DragEvent) => void;\n  onLeave?: (files: File[] | null, event: DragEvent) => void;\n  onOver?: (files: File[] | null, event: DragEvent) => void;\n  /**\n   * Allow multiple files to be dropped. Defaults to true.\n   */\n  multiple?: boolean;\n  /**\n   * Prevent default behavior for unhandled events. Defaults to false.\n   */\n  preventDefaultForUnhandled?: boolean;\n}\ndeclare function useDropZone(target: MaybeRefOrGetter<HTMLElement | Document | null | undefined>, options?: UseDropZoneOptions | UseDropZoneOptions['onDrop']): UseDropZoneReturn;\n//#endregion\n//#region useElementBounding/index.d.ts\ninterface UseElementBoundingOptions {\n  /**\n   * Reset values to 0 on component unmounted\n   *\n   * @default true\n   */\n  reset?: boolean;\n  /**\n   * Listen to window resize event\n   *\n   * @default true\n   */\n  windowResize?: boolean;\n  /**\n   * Listen to window scroll event\n   *\n   * @default true\n   */\n  windowScroll?: boolean;\n  /**\n   * Immediately call update on component mounted\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Timing to recalculate the bounding box\n   *\n   * Setting to `next-frame` can be useful when using this together with something like {@link useBreakpoints}\n   * and therefore the layout (which influences the bounding box of the observed element) is not updated on the current tick.\n   *\n   * @default 'sync'\n   */\n  updateTiming?: 'sync' | 'next-frame';\n}\ninterface UseElementBoundingReturn {\n  height: ShallowRef<number>;\n  bottom: ShallowRef<number>;\n  left: ShallowRef<number>;\n  right: ShallowRef<number>;\n  top: ShallowRef<number>;\n  width: ShallowRef<number>;\n  x: ShallowRef<number>;\n  y: ShallowRef<number>;\n  update: () => void;\n}\n/**\n * Reactive bounding box of an HTML element.\n *\n * @see https://vueuse.org/useElementBounding\n * @param target\n */\ndeclare function useElementBounding(target: MaybeComputedElementRef, options?: UseElementBoundingOptions): UseElementBoundingReturn;\n//#endregion\n//#region useElementByPoint/index.d.ts\ninterface UseElementByPointOptions<Multiple extends boolean = false> extends ConfigurableDocument, ConfigurableScheduler {\n  x: MaybeRefOrGetter<number>;\n  y: MaybeRefOrGetter<number>;\n  multiple?: MaybeRefOrGetter<Multiple>;\n  /** @deprecated Please use `scheduler` option instead */\n  immediate?: boolean;\n  /** @deprecated Please use `scheduler` option instead */\n  interval?: 'requestAnimationFrame' | number;\n}\ninterface UseElementByPointReturn<Multiple extends boolean = false> extends Supportable, Pausable {\n  element: ShallowRef<Multiple extends true ? HTMLElement[] : HTMLElement | null>;\n}\n/**\n * Reactive element by point.\n *\n * @see https://vueuse.org/useElementByPoint\n * @param options - UseElementByPointOptions\n */\ndeclare function useElementByPoint<M extends boolean = false>(options: UseElementByPointOptions<M>): UseElementByPointReturn<M>;\n//#endregion\n//#region useElementHover/index.d.ts\ninterface UseElementHoverOptions extends ConfigurableWindow {\n  delayEnter?: number;\n  delayLeave?: number;\n  triggerOnRemoval?: boolean;\n}\ndeclare function useElementHover(el: MaybeRefOrGetter<EventTarget | null | undefined>, options?: UseElementHoverOptions): ShallowRef<boolean>;\n//#endregion\n//#region useResizeObserver/index.d.ts\n/**\n * @deprecated This interface is now available in the DOM lib.\n * Use the global {@link globalThis.ResizeObserverSize} instead.\n */\ninterface ResizeObserverSize {\n  readonly inlineSize: number;\n  readonly blockSize: number;\n}\n/**\n * @deprecated This interface is now available in the DOM lib.\n * Use the global {@link globalThis.ResizeObserverEntry} instead.\n */\ninterface ResizeObserverEntry {\n  readonly target: Element;\n  readonly contentRect: DOMRectReadOnly;\n  readonly borderBoxSize: ReadonlyArray<ResizeObserverSize>;\n  readonly contentBoxSize: ReadonlyArray<ResizeObserverSize>;\n  readonly devicePixelContentBoxSize: ReadonlyArray<ResizeObserverSize>;\n}\n/**\n * @deprecated This interface is now available in the DOM lib.\n * Use the global {@link globalThis.ResizeObserverCallback} instead.\n */\ntype ResizeObserverCallback = (entries: ReadonlyArray<ResizeObserverEntry>, observer: ResizeObserver) => void;\ninterface UseResizeObserverOptions extends ResizeObserverOptions, ConfigurableWindow {}\ninterface UseResizeObserverReturn extends Supportable {\n  stop: () => void;\n}\n/**\n * Reports changes to the dimensions of an Element's content or the border-box\n *\n * @see https://vueuse.org/useResizeObserver\n * @param target\n * @param callback\n * @param options\n */\ndeclare function useResizeObserver(target: MaybeComputedElementRef | MaybeComputedElementRef[] | MaybeRefOrGetter<MaybeElement[]>, callback: globalThis.ResizeObserverCallback, options?: UseResizeObserverOptions): UseResizeObserverReturn;\n//#endregion\n//#region useElementSize/index.d.ts\ninterface ElementSize {\n  width: number;\n  height: number;\n}\ninterface UseElementSizeOptions extends UseResizeObserverOptions {}\ninterface UseElementSizeReturn {\n  width: ShallowRef<number>;\n  height: ShallowRef<number>;\n  stop: () => void;\n}\n/**\n * Reactive size of an HTML element.\n *\n * @see https://vueuse.org/useElementSize\n */\ndeclare function useElementSize(target: MaybeComputedElementRef, initialSize?: ElementSize, options?: UseElementSizeOptions): UseElementSizeReturn;\n//#endregion\n//#region useIntersectionObserver/index.d.ts\ninterface UseIntersectionObserverOptions extends ConfigurableWindow {\n  /**\n   * Start the IntersectionObserver immediately on creation\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * The Element or Document whose bounds are used as the bounding box when testing for intersection.\n   */\n  root?: MaybeComputedElementRef | Document;\n  /**\n   * A string which specifies a set of offsets to add to the root's bounding_box when calculating intersections.\n   */\n  rootMargin?: MaybeRefOrGetter<string>;\n  /**\n   * Either a single number or an array of numbers between 0.0 and 1.\n   * @default 0\n   */\n  threshold?: number | number[];\n}\ninterface UseIntersectionObserverReturn extends Supportable, Pausable {\n  stop: () => void;\n}\n/**\n * Detects that a target element's visibility.\n *\n * @see https://vueuse.org/useIntersectionObserver\n * @param target\n * @param callback\n * @param options\n */\ndeclare function useIntersectionObserver(target: MaybeComputedElementRef | MaybeRefOrGetter<MaybeElement[]> | MaybeComputedElementRef[], callback: IntersectionObserverCallback, options?: UseIntersectionObserverOptions): UseIntersectionObserverReturn;\n//#endregion\n//#region useElementVisibility/index.d.ts\ninterface UseElementVisibilityOptions extends ConfigurableWindow, Pick<UseIntersectionObserverOptions, 'rootMargin' | 'threshold'> {\n  /**\n   * Initial value.\n   *\n   * @default false\n   */\n  initialValue?: boolean;\n  /**\n   * The element that is used as the viewport for checking visibility of the target.\n   */\n  scrollTarget?: UseIntersectionObserverOptions['root'];\n  /**\n   * Stop tracking when element visibility changes for the first time\n   *\n   * @default false\n   */\n  once?: boolean;\n}\ntype UseElementVisibilityReturn = ShallowRef<boolean>;\n/**\n * Tracks the visibility of an element within the viewport.\n *\n * @see https://vueuse.org/useElementVisibility\n */\ndeclare function useElementVisibility(element: MaybeComputedElementRef, options?: UseElementVisibilityOptions): UseElementVisibilityReturn;\n//#endregion\n//#region useEventBus/index.d.ts\ntype EventBusListener<T = unknown, P$1 = any> = (event: T, payload?: P$1) => void;\ntype EventBusEvents<T, P$1 = any> = Set<EventBusListener<T, P$1>>;\ninterface EventBusKey<T> extends Symbol {}\ntype EventBusIdentifier<T = unknown> = EventBusKey<T> | string | number;\ninterface UseEventBusReturn<T, P$1> {\n  /**\n   * Subscribe to an event. When calling emit, the listeners will execute.\n   * @param listener watch listener.\n   * @returns a stop function to remove the current callback.\n   */\n  on: (listener: EventBusListener<T, P$1>) => Fn;\n  /**\n   * Similar to `on`, but only fires once\n   * @param listener watch listener.\n   * @returns a stop function to remove the current callback.\n   */\n  once: (listener: EventBusListener<T, P$1>) => Fn;\n  /**\n   * Emit an event, the corresponding event listeners will execute.\n   * @param event data sent.\n   */\n  emit: (event?: T, payload?: P$1) => void;\n  /**\n   * Remove the corresponding listener.\n   * @param listener watch listener.\n   */\n  off: (listener: EventBusListener<T>) => void;\n  /**\n   * Clear all events\n   */\n  reset: () => void;\n}\ndeclare function useEventBus<T = unknown, P$1 = any>(key: EventBusIdentifier<T>): UseEventBusReturn<T, P$1>;\n//#endregion\n//#region useEventListener/index.d.ts\ninterface InferEventTarget<Events> {\n  addEventListener: (event: Events, fn?: any, options?: any) => any;\n  removeEventListener: (event: Events, fn?: any, options?: any) => any;\n}\ntype WindowEventName = keyof WindowEventMap;\ntype DocumentEventName = keyof DocumentEventMap;\ntype ShadowRootEventName = keyof ShadowRootEventMap;\ninterface GeneralEventListener<E = Event> {\n  (evt: E): void;\n}\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 1: Omitted Window target\n *\n * @see https://vueuse.org/useEventListener\n */\ndeclare function useEventListener<E extends keyof WindowEventMap>(event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Window, ev: WindowEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 2: Explicitly Window target\n *\n * @see https://vueuse.org/useEventListener\n * @param target\n * @param event\n * @param listener\n * @param options\n */\ndeclare function useEventListener<E extends keyof WindowEventMap>(target: Window, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Window, ev: WindowEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 3: Explicitly Document target\n *\n * @see https://vueuse.org/useEventListener\n */\ndeclare function useEventListener<E extends keyof DocumentEventMap>(target: Document, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Document, ev: DocumentEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 4: Explicitly ShadowRoot target\n *\n * @see https://vueuse.org/useEventListener\n */\ndeclare function useEventListener<E extends keyof ShadowRootEventMap>(target: MaybeRefOrGetter<Arrayable<ShadowRoot> | null | undefined>, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: ShadowRoot, ev: ShadowRootEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 5: Explicitly HTMLElement target\n *\n * @see https://vueuse.org/useEventListener\n */\ndeclare function useEventListener<E extends keyof HTMLElementEventMap>(target: MaybeRefOrGetter<Arrayable<HTMLElement> | null | undefined>, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<(this: HTMLElement, ev: HTMLElementEventMap[E]) => any>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 6: Custom event target with event type infer\n *\n * @see https://vueuse.org/useEventListener\n */\ndeclare function useEventListener<Names extends string, EventType = Event>(target: MaybeRefOrGetter<Arrayable<InferEventTarget<Names>> | null | undefined>, event: MaybeRefOrGetter<Arrayable<Names>>, listener: MaybeRef<Arrayable<GeneralEventListener<EventType>>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n/**\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\n *\n * Overload 7: Custom event target fallback\n *\n * @see https://vueuse.org/useEventListener\n */\ndeclare function useEventListener<EventType = Event>(target: MaybeRefOrGetter<Arrayable<EventTarget> | null | undefined>, event: MaybeRefOrGetter<Arrayable<string>>, listener: MaybeRef<Arrayable<GeneralEventListener<EventType>>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;\n//#endregion\n//#region useEventSource/index.d.ts\ntype EventSourceStatus = 'CONNECTING' | 'OPEN' | 'CLOSED';\ninterface UseEventSourceOptions<Data> extends EventSourceInit {\n  /**\n   * Enabled auto reconnect\n   *\n   * @default false\n   */\n  autoReconnect?: boolean | {\n    /**\n     * Maximum retry times.\n     *\n     * Or you can pass a predicate function (which returns true if you want to retry).\n     *\n     * @default -1\n     */\n    retries?: number | (() => boolean);\n    /**\n     * Delay for reconnect, in milliseconds\n     *\n     * @default 1000\n     */\n    delay?: number;\n    /**\n     * On maximum retry times reached.\n     */\n    onFailed?: Fn;\n  };\n  /**\n   * Immediately open the connection when calling this composable\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Automatically connect to the websocket when URL changes\n   *\n   * @default true\n   */\n  autoConnect?: boolean;\n  /**\n   * Custom data serialization\n   */\n  serializer?: {\n    read: (v?: string) => Data;\n  };\n}\ninterface UseEventSourceReturn<Events extends string[], Data = any> {\n  /**\n   * Reference to the latest data received via the EventSource,\n   * can be watched to respond to incoming messages\n   */\n  data: ShallowRef<Data | null>;\n  /**\n   * The current state of the connection, can be only one of:\n   * 'CONNECTING', 'OPEN' 'CLOSED'\n   */\n  status: ShallowRef<EventSourceStatus>;\n  /**\n   * The latest named event\n   */\n  event: ShallowRef<Events[number] | null>;\n  /**\n   * The current error\n   */\n  error: ShallowRef<Event | null>;\n  /**\n   * Closes the EventSource connection gracefully.\n   */\n  close: EventSource['close'];\n  /**\n   * Reopen the EventSource connection.\n   * If there the current one is active, will close it before opening a new one.\n   */\n  open: Fn;\n  /**\n   * Reference to the current EventSource instance.\n   */\n  eventSource: Ref<EventSource | null>;\n  /**\n   * The last event ID string, for server-sent events.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent/lastEventId\n   */\n  lastEventId: ShallowRef<string | null>;\n}\n/**\n * Reactive wrapper for EventSource.\n *\n * @see https://vueuse.org/useEventSource\n * @see https://developer.mozilla.org/en-US/docs/Web/API/EventSource/EventSource EventSource\n * @param url\n * @param events\n * @param options\n */\ndeclare function useEventSource<Events extends string[], Data = any>(url: MaybeRefOrGetter<string | URL | undefined>, events?: Events, options?: UseEventSourceOptions<Data>): UseEventSourceReturn<Events, Data>;\n//#endregion\n//#region useEyeDropper/index.d.ts\ninterface EyeDropperOpenOptions {\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal\n   */\n  signal?: AbortSignal;\n}\ninterface EyeDropper {\n  new (): EyeDropper;\n  open: (options?: EyeDropperOpenOptions) => Promise<{\n    sRGBHex: string;\n  }>;\n  [Symbol.toStringTag]: 'EyeDropper';\n}\ninterface UseEyeDropperOptions {\n  /**\n   * Initial sRGBHex.\n   *\n   * @default ''\n   */\n  initialValue?: string;\n}\ninterface UseEyeDropperReturn extends Supportable {\n  sRGBHex: ShallowRef<string>;\n  open: (openOptions?: EyeDropperOpenOptions) => Promise<{\n    sRGBHex: string;\n  } | undefined>;\n}\n/**\n * Reactive [EyeDropper API](https://developer.mozilla.org/en-US/docs/Web/API/EyeDropper_API)\n *\n * @see https://vueuse.org/useEyeDropper\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useEyeDropper(options?: UseEyeDropperOptions): UseEyeDropperReturn;\n//#endregion\n//#region useFavicon/index.d.ts\ninterface UseFaviconOptions extends ConfigurableDocument {\n  baseUrl?: string;\n  rel?: string;\n}\ntype UseFaviconReturn = ComputedRef<string | null | undefined> | Ref<string | null | undefined>;\n/**\n * Reactive favicon.\n *\n * @see https://vueuse.org/useFavicon\n * @param newIcon\n * @param options\n */\ndeclare function useFavicon(newIcon: ReadonlyRefOrGetter<string | null | undefined>, options?: UseFaviconOptions): ComputedRef<string | null | undefined>;\ndeclare function useFavicon(newIcon?: MaybeRef<string | null | undefined>, options?: UseFaviconOptions): Ref<string | null | undefined>;\n//#endregion\n//#region useFetch/index.d.ts\ninterface UseFetchReturn<T> {\n  /**\n   * Indicates if the fetch request has finished\n   */\n  isFinished: Readonly<ShallowRef<boolean>>;\n  /**\n   * The statusCode of the HTTP fetch response\n   */\n  statusCode: ShallowRef<number | null>;\n  /**\n   * The raw response of the fetch response\n   */\n  response: ShallowRef<Response | null>;\n  /**\n   * Any fetch errors that may have occurred\n   */\n  error: ShallowRef<any>;\n  /**\n   * The fetch response body on success, may either be JSON or text\n   */\n  data: ShallowRef<T | null>;\n  /**\n   * Indicates if the request is currently being fetched.\n   */\n  isFetching: Readonly<ShallowRef<boolean>>;\n  /**\n   * Indicates if the fetch request is able to be aborted\n   */\n  canAbort: ComputedRef<boolean>;\n  /**\n   * Indicates if the fetch request was aborted\n   */\n  aborted: ShallowRef<boolean>;\n  /**\n   * Abort the fetch request\n   */\n  abort: (reason?: any) => void;\n  /**\n   * Manually call the fetch\n   * (default not throwing error)\n   */\n  execute: (throwOnFailed?: boolean) => Promise<any>;\n  /**\n   * Fires after the fetch request has finished\n   */\n  onFetchResponse: EventHookOn<Response>;\n  /**\n   * Fires after a fetch request error\n   */\n  onFetchError: EventHookOn;\n  /**\n   * Fires after a fetch has completed\n   */\n  onFetchFinally: EventHookOn;\n  get: () => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  post: (payload?: MaybeRefOrGetter<unknown>, type?: string) => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  put: (payload?: MaybeRefOrGetter<unknown>, type?: string) => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  delete: (payload?: MaybeRefOrGetter<unknown>, type?: string) => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  patch: (payload?: MaybeRefOrGetter<unknown>, type?: string) => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  head: (payload?: MaybeRefOrGetter<unknown>, type?: string) => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  options: (payload?: MaybeRefOrGetter<unknown>, type?: string) => UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n  json: <JSON = any>() => UseFetchReturn<JSON> & PromiseLike<UseFetchReturn<JSON>>;\n  text: () => UseFetchReturn<string> & PromiseLike<UseFetchReturn<string>>;\n  blob: () => UseFetchReturn<Blob> & PromiseLike<UseFetchReturn<Blob>>;\n  arrayBuffer: () => UseFetchReturn<ArrayBuffer> & PromiseLike<UseFetchReturn<ArrayBuffer>>;\n  formData: () => UseFetchReturn<FormData> & PromiseLike<UseFetchReturn<FormData>>;\n}\ntype Combination = 'overwrite' | 'chain';\ninterface BeforeFetchContext {\n  /**\n   * The computed url of the current request\n   */\n  url: string;\n  /**\n   * The request options of the current request\n   */\n  options: RequestInit;\n  /**\n   * Cancels the current request\n   */\n  cancel: Fn;\n}\ninterface AfterFetchContext<T = any> {\n  response: Response;\n  data: T | null;\n  context: BeforeFetchContext;\n  execute: (throwOnFailed?: boolean) => Promise<any>;\n}\ninterface OnFetchErrorContext<T = any, E = any> {\n  error: E;\n  data: T | null;\n  response: Response | null;\n  context: BeforeFetchContext;\n  execute: (throwOnFailed?: boolean) => Promise<any>;\n}\ninterface UseFetchOptions {\n  /**\n   * Fetch function\n   */\n  fetch?: typeof window.fetch;\n  /**\n   * Will automatically run fetch when `useFetch` is used\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Will automatically refetch when:\n   * - the URL is changed if the URL is a ref\n   * - the payload is changed if the payload is a ref\n   *\n   * @default false\n   */\n  refetch?: MaybeRefOrGetter<boolean>;\n  /**\n   * Initial data before the request finished\n   *\n   * @default null\n   */\n  initialData?: any;\n  /**\n   * Timeout for abort request after number of millisecond\n   * `0` means use browser default\n   *\n   * @default 0\n   */\n  timeout?: number;\n  /**\n   * Allow update the `data` ref when fetch error whenever provided, or mutated in the `onFetchError` callback\n   *\n   * @default false\n   */\n  updateDataOnError?: boolean;\n  /**\n   * Will run immediately before the fetch request is dispatched\n   */\n  beforeFetch?: (ctx: BeforeFetchContext) => Promise<Partial<BeforeFetchContext> | void> | Partial<BeforeFetchContext> | void;\n  /**\n   * Will run immediately after the fetch request is returned.\n   * Runs after any 2xx response\n   */\n  afterFetch?: (ctx: AfterFetchContext) => Promise<Partial<AfterFetchContext>> | Partial<AfterFetchContext>;\n  /**\n   * Will run immediately after the fetch request is returned.\n   * Runs after any 4xx and 5xx response\n   */\n  onFetchError?: (ctx: OnFetchErrorContext) => Promise<Partial<OnFetchErrorContext>> | Partial<OnFetchErrorContext>;\n}\ninterface CreateFetchOptions {\n  /**\n   * The base URL that will be prefixed to all urls unless urls are absolute\n   */\n  baseUrl?: MaybeRefOrGetter<string>;\n  /**\n   * Determine the inherit behavior for beforeFetch, afterFetch, onFetchError\n   * @default 'chain'\n   */\n  combination?: Combination;\n  /**\n   * Default Options for the useFetch function\n   */\n  options?: UseFetchOptions;\n  /**\n   * Options for the fetch request\n   */\n  fetchOptions?: RequestInit;\n}\ndeclare function createFetch(config?: CreateFetchOptions): typeof useFetch;\ndeclare function useFetch<T>(url: MaybeRefOrGetter<string>): UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\ndeclare function useFetch<T>(url: MaybeRefOrGetter<string>, useFetchOptions: UseFetchOptions): UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\ndeclare function useFetch<T>(url: MaybeRefOrGetter<string>, options: RequestInit, useFetchOptions?: UseFetchOptions): UseFetchReturn<T> & PromiseLike<UseFetchReturn<T>>;\n//#endregion\n//#region useFileDialog/index.d.ts\ninterface UseFileDialogOptions extends ConfigurableDocument {\n  /**\n   * @default true\n   */\n  multiple?: MaybeRef<boolean>;\n  /**\n   * @default '*'\n   */\n  accept?: MaybeRef<string>;\n  /**\n   * Select the input source for the capture file.\n   * @see [HTMLInputElement Capture](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/capture)\n   */\n  capture?: MaybeRef<string>;\n  /**\n   * Reset when open file dialog.\n   * @default false\n   */\n  reset?: MaybeRef<boolean>;\n  /**\n   * Select directories instead of files.\n   * @see [HTMLInputElement webkitdirectory](https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/webkitdirectory)\n   * @default false\n   */\n  directory?: MaybeRef<boolean>;\n  /**\n   * Initial files to set.\n   * @default null\n   */\n  initialFiles?: Array<File> | FileList;\n  /**\n   * The input element to use for file dialog.\n   * @default document.createElement('input')\n   */\n  input?: MaybeElementRef<HTMLInputElement>;\n}\ninterface UseFileDialogReturn {\n  files: Ref<FileList | null>;\n  open: (localOptions?: Partial<UseFileDialogOptions>) => void;\n  reset: () => void;\n  onChange: EventHookOn<FileList | null>;\n  onCancel: EventHookOn;\n}\n/**\n * Open file dialog with ease.\n *\n * @see https://vueuse.org/useFileDialog\n * @param options\n */\ndeclare function useFileDialog(options?: UseFileDialogOptions): UseFileDialogReturn;\n//#endregion\n//#region useFileSystemAccess/index.d.ts\n/**\n * window.showOpenFilePicker parameters\n * @see https://developer.mozilla.org/en-US/docs/Web/API/window/showOpenFilePicker#parameters\n */\ninterface FileSystemAccessShowOpenFileOptions {\n  multiple?: boolean;\n  types?: Array<{\n    description?: string;\n    accept: Record<string, string[]>;\n  }>;\n  excludeAcceptAllOption?: boolean;\n}\n/**\n * window.showSaveFilePicker parameters\n * @see https://developer.mozilla.org/en-US/docs/Web/API/window/showSaveFilePicker#parameters\n */\ninterface FileSystemAccessShowSaveFileOptions {\n  suggestedName?: string;\n  types?: Array<{\n    description?: string;\n    accept: Record<string, string[]>;\n  }>;\n  excludeAcceptAllOption?: boolean;\n}\n/**\n * FileHandle\n * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemFileHandle\n */\ninterface FileSystemFileHandle {\n  getFile: () => Promise<File>;\n  createWritable: () => FileSystemWritableFileStream;\n}\n/**\n * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream\n */\ninterface FileSystemWritableFileStream extends WritableStream {\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream/write\n   */\n  write: FileSystemWritableFileStreamWrite;\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream/seek\n   */\n  seek: (position: number) => Promise<void>;\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream/truncate\n   */\n  truncate: (size: number) => Promise<void>;\n}\n/**\n * FileStream.write\n * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream/write\n */\ninterface FileSystemWritableFileStreamWrite {\n  (data: string | BufferSource | Blob): Promise<void>;\n  (options: {\n    type: 'write';\n    position: number;\n    data: string | BufferSource | Blob;\n  }): Promise<void>;\n  (options: {\n    type: 'seek';\n    position: number;\n  }): Promise<void>;\n  (options: {\n    type: 'truncate';\n    size: number;\n  }): Promise<void>;\n}\n/**\n * FileStream.write\n * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream/write\n */\ntype FileSystemAccessWindow = Window & {\n  showSaveFilePicker: (options: FileSystemAccessShowSaveFileOptions) => Promise<FileSystemFileHandle>;\n  showOpenFilePicker: (options: FileSystemAccessShowOpenFileOptions) => Promise<FileSystemFileHandle[]>;\n};\ntype UseFileSystemAccessCommonOptions = Pick<FileSystemAccessShowOpenFileOptions, 'types' | 'excludeAcceptAllOption'>;\ntype UseFileSystemAccessShowSaveFileOptions = Pick<FileSystemAccessShowSaveFileOptions, 'suggestedName'>;\ntype UseFileSystemAccessOptions = ConfigurableWindow & UseFileSystemAccessCommonOptions & {\n  /**\n   * file data type\n   */\n  dataType?: MaybeRefOrGetter<'Text' | 'ArrayBuffer' | 'Blob'>;\n};\n/**\n * Create and read and write local files.\n * @see https://vueuse.org/useFileSystemAccess\n */\ndeclare function useFileSystemAccess(): UseFileSystemAccessReturn<string | ArrayBuffer | Blob>;\ndeclare function useFileSystemAccess(options: UseFileSystemAccessOptions & {\n  dataType: 'Text';\n}): UseFileSystemAccessReturn<string>;\ndeclare function useFileSystemAccess(options: UseFileSystemAccessOptions & {\n  dataType: 'ArrayBuffer';\n}): UseFileSystemAccessReturn<ArrayBuffer>;\ndeclare function useFileSystemAccess(options: UseFileSystemAccessOptions & {\n  dataType: 'Blob';\n}): UseFileSystemAccessReturn<Blob>;\ndeclare function useFileSystemAccess(options: UseFileSystemAccessOptions): UseFileSystemAccessReturn<string | ArrayBuffer | Blob>;\ninterface UseFileSystemAccessReturn<T = string> extends Supportable {\n  data: ShallowRef<T | undefined>;\n  file: ShallowRef<File | undefined>;\n  fileName: ComputedRef<string>;\n  fileMIME: ComputedRef<string>;\n  fileSize: ComputedRef<number>;\n  fileLastModified: ComputedRef<number>;\n  open: (_options?: UseFileSystemAccessCommonOptions) => Awaitable<void>;\n  create: (_options?: UseFileSystemAccessShowSaveFileOptions) => Awaitable<void>;\n  save: (_options?: UseFileSystemAccessShowSaveFileOptions) => Awaitable<void>;\n  saveAs: (_options?: UseFileSystemAccessShowSaveFileOptions) => Awaitable<void>;\n  updateData: () => Awaitable<void>;\n}\n//#endregion\n//#region useFocus/index.d.ts\ninterface UseFocusOptions extends ConfigurableWindow {\n  /**\n   * Initial value. If set true, then focus will be set on the target\n   *\n   * @default false\n   */\n  initialValue?: boolean;\n  /**\n   * Replicate the :focus-visible behavior of CSS\n   *\n   * @default false\n   */\n  focusVisible?: boolean;\n  /**\n   * Prevent scrolling to the element when it is focused.\n   *\n   * @default false\n   */\n  preventScroll?: boolean;\n}\ninterface UseFocusReturn {\n  /**\n   * If read as true, then the element has focus. If read as false, then the element does not have focus\n   * If set to true, then the element will be focused. If set to false, the element will be blurred.\n   */\n  focused: WritableComputedRef<boolean>;\n}\n/**\n * Track or set the focus state of a DOM element.\n *\n * @see https://vueuse.org/useFocus\n * @param target The target element for the focus and blur events.\n * @param options\n */\ndeclare function useFocus(target: MaybeElementRef, options?: UseFocusOptions): UseFocusReturn;\n//#endregion\n//#region useFocusWithin/index.d.ts\ninterface UseFocusWithinReturn {\n  /**\n   * True if the element or any of its descendants are focused\n   */\n  focused: ComputedRef<boolean>;\n}\n/**\n * Track if focus is contained within the target element\n *\n * @see https://vueuse.org/useFocusWithin\n * @param target The target element to track\n * @param options Focus within options\n */\ndeclare function useFocusWithin(target: MaybeElementRef, options?: ConfigurableWindow): UseFocusWithinReturn;\n//#endregion\n//#region useFps/index.d.ts\ninterface UseFpsOptions {\n  /**\n   * Calculate the FPS on every x frames.\n   * @default 10\n   */\n  every?: number;\n}\ndeclare function useFps(options?: UseFpsOptions): ShallowRef<number>;\n//#endregion\n//#region useFullscreen/index.d.ts\ninterface UseFullscreenOptions extends ConfigurableDocument {\n  /**\n   * Automatically exit fullscreen when component is unmounted\n   *\n   * @default false\n   */\n  autoExit?: boolean;\n}\ninterface UseFullscreenReturn extends Supportable {\n  isFullscreen: ShallowRef<boolean>;\n  enter: () => Promise<void>;\n  exit: () => Promise<void>;\n  toggle: () => Promise<void>;\n}\n/**\n * Reactive Fullscreen API.\n *\n * @see https://vueuse.org/useFullscreen\n * @param target\n * @param options\n */\ndeclare function useFullscreen(target?: MaybeElementRef, options?: UseFullscreenOptions): UseFullscreenReturn;\n//#endregion\n//#region useGamepad/index.d.ts\ninterface UseGamepadOptions extends ConfigurableWindow, ConfigurableNavigator {}\ninterface UseGamepadReturn extends Supportable, Pausable {\n  onConnected: EventHookOn<number>;\n  onDisconnected: EventHookOn<number>;\n  gamepads: Ref<Gamepad[]>;\n}\n/**\n * Maps a standard standard gamepad to an Xbox 360 Controller.\n */\ndeclare function mapGamepadToXbox360Controller(gamepad: Ref<Gamepad | undefined>): vue0.ComputedRef<{\n  buttons: {\n    a: GamepadButton;\n    b: GamepadButton;\n    x: GamepadButton;\n    y: GamepadButton;\n  };\n  bumper: {\n    left: GamepadButton;\n    right: GamepadButton;\n  };\n  triggers: {\n    left: GamepadButton;\n    right: GamepadButton;\n  };\n  stick: {\n    left: {\n      horizontal: number;\n      vertical: number;\n      button: GamepadButton;\n    };\n    right: {\n      horizontal: number;\n      vertical: number;\n      button: GamepadButton;\n    };\n  };\n  dpad: {\n    up: GamepadButton;\n    down: GamepadButton;\n    left: GamepadButton;\n    right: GamepadButton;\n  };\n  back: GamepadButton;\n  start: GamepadButton;\n} | null>;\ndeclare function useGamepad(options?: UseGamepadOptions): UseGamepadReturn;\n//#endregion\n//#region useGeolocation/index.d.ts\ninterface UseGeolocationOptions extends Partial<PositionOptions>, ConfigurableNavigator {\n  immediate?: boolean;\n}\ninterface UseGeolocationReturn extends Supportable {\n  coords: Ref<Omit<GeolocationPosition['coords'], 'toJSON'>>;\n  locatedAt: ShallowRef<number | null>;\n  error: ShallowRef<GeolocationPositionError | null>;\n  resume: () => void;\n  pause: () => void;\n}\n/**\n * Reactive Geolocation API.\n *\n * @see https://vueuse.org/useGeolocation\n * @param options\n */\ndeclare function useGeolocation(options?: UseGeolocationOptions): UseGeolocationReturn;\n//#endregion\n//#region useIdle/index.d.ts\ninterface UseIdleOptions extends ConfigurableWindow, ConfigurableEventFilter {\n  /**\n   * Event names that listen to for detected user activity\n   *\n   * @default ['mousemove', 'mousedown', 'resize', 'keydown', 'touchstart', 'wheel']\n   */\n  events?: WindowEventName[];\n  /**\n   * Listen for document visibility change\n   *\n   * @default true\n   */\n  listenForVisibilityChange?: boolean;\n  /**\n   * Initial state of the ref idle\n   *\n   * @default false\n   */\n  initialState?: boolean;\n}\ninterface UseIdleReturn extends Stoppable {\n  idle: ShallowRef<boolean>;\n  lastActive: ShallowRef<number>;\n  reset: () => void;\n}\n/**\n * Tracks whether the user is being inactive.\n *\n * @see https://vueuse.org/useIdle\n * @param timeout default to 1 minute\n * @param options IdleOptions\n */\ndeclare function useIdle(timeout?: number, options?: UseIdleOptions): UseIdleReturn;\n//#endregion\n//#region useImage/index.d.ts\ninterface UseImageOptions {\n  /** Address of the resource */\n  src: string;\n  /** Images to use in different situations, e.g., high-resolution displays, small monitors, etc. */\n  srcset?: string;\n  /** Image sizes for different page layouts */\n  sizes?: string;\n  /** Image alternative information */\n  alt?: string;\n  /** Image classes */\n  class?: string;\n  /** Image loading */\n  loading?: HTMLImageElement['loading'];\n  /** Image CORS settings */\n  crossorigin?: string;\n  /** Referrer policy for fetch https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy */\n  referrerPolicy?: HTMLImageElement['referrerPolicy'];\n  /** Image width */\n  width?: HTMLImageElement['width'];\n  /** Image height */\n  height?: HTMLImageElement['height'];\n  /** https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#decoding */\n  decoding?: HTMLImageElement['decoding'];\n  /** Provides a hint of the relative priority to use when fetching the image */\n  fetchPriority?: HTMLImageElement['fetchPriority'];\n  /** Provides a hint of the importance of the image */\n  ismap?: HTMLImageElement['isMap'];\n  /** The partial URL (starting with #) of an image map associated with the element */\n  usemap?: HTMLImageElement['useMap'];\n}\ntype UseImageReturn = UseAsyncStateReturn<HTMLImageElement | undefined, any[], true>;\n/**\n * Reactive load an image in the browser, you can wait the result to display it or show a fallback.\n *\n * @see https://vueuse.org/useImage\n * @param options Image attributes, as used in the <img> tag\n * @param asyncStateOptions\n */\ndeclare function useImage<Shallow extends true>(options: MaybeRefOrGetter<UseImageOptions>, asyncStateOptions?: UseAsyncStateOptions<Shallow>): UseImageReturn;\n//#endregion\n//#region useScroll/index.d.ts\ninterface UseScrollOptions extends ConfigurableWindow {\n  /**\n   * Throttle time for scroll event, it’s disabled by default.\n   *\n   * @default 0\n   */\n  throttle?: number;\n  /**\n   * The check time when scrolling ends.\n   * This configuration will be setting to (throttle + idle) when the `throttle` is configured.\n   *\n   * @default 200\n   */\n  idle?: number;\n  /**\n   * Offset arrived states by x pixels\n   *\n   */\n  offset?: {\n    left?: number;\n    right?: number;\n    top?: number;\n    bottom?: number;\n  };\n  /**\n   * Use MutationObserver to monitor specific DOM changes,\n   * such as attribute modifications, child node additions or removals, or subtree changes.\n   * @default { mutation: boolean }\n   */\n  observe?: boolean | {\n    mutation?: boolean;\n  };\n  /**\n   * Trigger it when scrolling.\n   *\n   */\n  onScroll?: (e: Event) => void;\n  /**\n   * Trigger it when scrolling ends.\n   *\n   */\n  onStop?: (e: Event) => void;\n  /**\n   * Listener options for scroll event.\n   *\n   * @default {capture: false, passive: true}\n   */\n  eventListenerOptions?: boolean | AddEventListenerOptions;\n  /**\n   * Optionally specify a scroll behavior of `auto` (default, not smooth scrolling) or\n   * `smooth` (for smooth scrolling) which takes effect when changing the `x` or `y` refs.\n   *\n   * @default 'auto'\n   */\n  behavior?: MaybeRefOrGetter<ScrollBehavior>;\n  /**\n   * On error callback\n   *\n   * Default log error to `console.error`\n   */\n  onError?: (error: unknown) => void;\n}\ninterface UseScrollReturn {\n  x: WritableComputedRef<number>;\n  y: WritableComputedRef<number>;\n  isScrolling: ShallowRef<boolean>;\n  arrivedState: {\n    left: boolean;\n    right: boolean;\n    top: boolean;\n    bottom: boolean;\n  };\n  directions: {\n    left: boolean;\n    right: boolean;\n    top: boolean;\n    bottom: boolean;\n  };\n  measure: () => void;\n}\n/**\n * Reactive scroll.\n *\n * @see https://vueuse.org/useScroll\n * @param element\n * @param options\n */\ndeclare function useScroll(element: MaybeRefOrGetter<HTMLElement | SVGElement | Window | Document | null | undefined>, options?: UseScrollOptions): UseScrollReturn;\n//#endregion\n//#region useInfiniteScroll/index.d.ts\ntype InfiniteScrollElement = HTMLElement | SVGElement | Window | Document | null | undefined;\ninterface UseInfiniteScrollOptions<T extends InfiniteScrollElement = InfiniteScrollElement> extends UseScrollOptions {\n  /**\n   * The minimum distance between the bottom of the element and the bottom of the viewport\n   *\n   * @default 0\n   */\n  distance?: number;\n  /**\n   * The direction in which to listen the scroll.\n   *\n   * @default 'bottom'\n   */\n  direction?: 'top' | 'bottom' | 'left' | 'right';\n  /**\n   * The interval time between two load more (to avoid too many invokes).\n   *\n   * @default 100\n   */\n  interval?: number;\n  /**\n   * A function that determines whether more content can be loaded for a specific element.\n   * Should return `true` if loading more content is allowed for the given element,\n   * and `false` otherwise.\n   */\n  canLoadMore?: (el: T) => boolean;\n}\ninterface UseInfiniteScrollReturn {\n  isLoading: ComputedRef<boolean>;\n  reset: () => void;\n}\n/**\n * Reactive infinite scroll.\n *\n * @see https://vueuse.org/useInfiniteScroll\n */\ndeclare function useInfiniteScroll<T extends InfiniteScrollElement>(element: MaybeRefOrGetter<T>, onLoadMore: (state: UnwrapNestedRefs<UseScrollReturn>) => Awaitable<void>, options?: UseInfiniteScrollOptions<T>): UseInfiniteScrollReturn;\n//#endregion\n//#region useKeyModifier/index.d.ts\ntype KeyModifier = 'Alt' | 'AltGraph' | 'CapsLock' | 'Control' | 'Fn' | 'FnLock' | 'Meta' | 'NumLock' | 'ScrollLock' | 'Shift' | 'Symbol' | 'SymbolLock';\ninterface UseModifierOptions<Initial> extends ConfigurableDocument {\n  /**\n   * Event names that will prompt update to modifier states\n   *\n   * @default ['mousedown', 'mouseup', 'keydown', 'keyup']\n   */\n  events?: WindowEventName[];\n  /**\n   * Initial value of the returned ref\n   *\n   * @default null\n   */\n  initial?: Initial;\n}\ntype UseKeyModifierReturn<Initial> = ShallowRef<Initial extends boolean ? boolean : boolean | null>;\ndeclare function useKeyModifier<Initial extends boolean | null>(modifier: KeyModifier, options?: UseModifierOptions<Initial>): UseKeyModifierReturn<Initial>;\n//#endregion\n//#region useLocalStorage/index.d.ts\ndeclare function useLocalStorage(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<string>, options?: UseStorageOptions<string>): RemovableRef<string>;\ndeclare function useLocalStorage(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<boolean>, options?: UseStorageOptions<boolean>): RemovableRef<boolean>;\ndeclare function useLocalStorage(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<number>, options?: UseStorageOptions<number>): RemovableRef<number>;\ndeclare function useLocalStorage<T>(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<T>, options?: UseStorageOptions<T>): RemovableRef<T>;\ndeclare function useLocalStorage<T = unknown>(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<null>, options?: UseStorageOptions<T>): RemovableRef<T>;\n//#endregion\n//#region useMagicKeys/aliasMap.d.ts\ndeclare const DefaultMagicKeysAliasMap: Readonly<Record<string, string>>;\n//#endregion\n//#region useMagicKeys/index.d.ts\ninterface UseMagicKeysOptions<Reactive extends boolean> {\n  /**\n   * Returns a reactive object instead of an object of refs\n   *\n   * @default false\n   */\n  reactive?: Reactive;\n  /**\n   * Target for listening events\n   *\n   * @default window\n   */\n  target?: MaybeRefOrGetter<EventTarget>;\n  /**\n   * Alias map for keys, all the keys should be lowercase\n   * { target: keycode }\n   *\n   * @example { ctrl: \"control\" }\n   * @default <predefined-map>\n   */\n  aliasMap?: Record<string, string>;\n  /**\n   * Register passive listener\n   *\n   * @default true\n   */\n  passive?: boolean;\n  /**\n   * Custom event handler for keydown/keyup event.\n   * Useful when you want to apply custom logic.\n   *\n   * When using `e.preventDefault()`, you will need to pass `passive: false` to useMagicKeys().\n   */\n  onEventFired?: (e: KeyboardEvent) => void | boolean;\n}\ninterface MagicKeysInternal {\n  /**\n   * A Set of currently pressed keys,\n   * Stores raw keyCodes.\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key\n   */\n  current: Set<string>;\n}\ntype UseMagicKeysReturn<Reactive extends boolean> = Readonly<Record<string, Reactive extends true ? boolean : ComputedRef<boolean>> & MagicKeysInternal>;\n/**\n * Reactive keys pressed state, with magical keys combination support.\n *\n * @see https://vueuse.org/useMagicKeys\n */\ndeclare function useMagicKeys<T extends boolean = false>(options?: UseMagicKeysOptions<T>): UseMagicKeysReturn<T>;\n//#endregion\n//#region useMediaControls/index.d.ts\n/**\n * Many of the jsdoc definitions here are modified version of the\n * documentation from MDN(https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)\n */\ninterface UseMediaSource {\n  /**\n   * The source url for the media\n   */\n  src: string;\n  /**\n   * The media codec type\n   */\n  type?: string;\n  /**\n   * Specifies the media query for the resource's intended media.\n   */\n  media?: string;\n}\ninterface UseMediaTextTrackSource {\n  /**\n   * Indicates that the track should be enabled unless the user's preferences indicate\n   * that another track is more appropriate\n   */\n  default?: boolean;\n  /**\n   * How the text track is meant to be used. If omitted the default kind is subtitles.\n   */\n  kind: TextTrackKind;\n  /**\n   * A user-readable title of the text track which is used by the browser\n   * when listing available text tracks.\n   */\n  label: string;\n  /**\n   * Address of the track (.vtt file). Must be a valid URL. This attribute\n   * must be specified and its URL value must have the same origin as the document\n   */\n  src: string;\n  /**\n   * Language of the track text data. It must be a valid BCP 47 language tag.\n   * If the kind attribute is set to subtitles, then srclang must be defined.\n   */\n  srcLang: string;\n}\ninterface UseMediaControlsOptions extends ConfigurableDocument {\n  /**\n   * The source for the media, may either be a string, a `UseMediaSource` object, or a list\n   * of `UseMediaSource` objects.\n   */\n  src?: MaybeRefOrGetter<string | UseMediaSource | UseMediaSource[]>;\n  /**\n   * A list of text tracks for the media\n   */\n  tracks?: MaybeRefOrGetter<UseMediaTextTrackSource[]>;\n}\ninterface UseMediaTextTrack {\n  /**\n   * The index of the text track\n   */\n  id: number;\n  /**\n   * The text track label\n   */\n  label: string;\n  /**\n   * Language of the track text data. It must be a valid BCP 47 language tag.\n   * If the kind attribute is set to subtitles, then srclang must be defined.\n   */\n  language: string;\n  /**\n   * Specifies the display mode of the text track, either `disabled`,\n   * `hidden`, or `showing`\n   */\n  mode: TextTrackMode;\n  /**\n   * How the text track is meant to be used. If omitted the default kind is subtitles.\n   */\n  kind: TextTrackKind;\n  /**\n   * Indicates the track's in-band metadata track dispatch type.\n   */\n  inBandMetadataTrackDispatchType: string;\n  /**\n   * A list of text track cues\n   */\n  cues: TextTrackCueList | null;\n  /**\n   * A list of active text track cues\n   */\n  activeCues: TextTrackCueList | null;\n}\ninterface UseMediaControlsReturn {\n  currentTime: ShallowRef<number>;\n  duration: ShallowRef<number>;\n  waiting: ShallowRef<boolean>;\n  seeking: ShallowRef<boolean>;\n  ended: ShallowRef<boolean>;\n  stalled: ShallowRef<boolean>;\n  buffered: Ref<[number, number][]>;\n  playing: ShallowRef<boolean>;\n  rate: ShallowRef<number>;\n  volume: ShallowRef<number>;\n  muted: ShallowRef<boolean>;\n  tracks: Ref<UseMediaTextTrack[]>;\n  selectedTrack: ShallowRef<number>;\n  enableTrack: (track: number | UseMediaTextTrack, disableTracks?: boolean) => void;\n  disableTrack: (track?: number | UseMediaTextTrack) => void;\n  supportsPictureInPicture: boolean;\n  togglePictureInPicture: () => Promise<PictureInPictureWindow | void>;\n  isPictureInPicture: ShallowRef<boolean>;\n  onSourceError: EventHookOn<Event>;\n  onPlaybackError: EventHookOn<Event>;\n}\ndeclare function useMediaControls(target: MaybeRef<HTMLMediaElement | null | undefined>, options?: UseMediaControlsOptions): UseMediaControlsReturn;\n//#endregion\n//#region useMediaQuery/index.d.ts\n/**\n * Reactive Media Query.\n *\n * @see https://vueuse.org/useMediaQuery\n * @param query\n * @param options\n */\ndeclare function useMediaQuery(query: MaybeRefOrGetter<string>, options?: ConfigurableWindow & {\n  ssrWidth?: number;\n}): vue0.ComputedRef<boolean>;\n//#endregion\n//#region useMemoize/index.d.ts\ntype CacheKey = any;\n/**\n * Custom memoize cache handler\n */\ninterface UseMemoizeCache<Key, Value> {\n  /**\n   * Get value for key\n   */\n  get: (key: Key) => Value | undefined;\n  /**\n   * Set value for key\n   */\n  set: (key: Key, value: Value) => void;\n  /**\n   * Return flag if key exists\n   */\n  has: (key: Key) => boolean;\n  /**\n   * Delete value for key\n   */\n  delete: (key: Key) => void;\n  /**\n   * Clear cache\n   */\n  clear: () => void;\n}\n/**\n * Memoized function\n */\ninterface UseMemoizeReturn<Result, Args extends unknown[]> {\n  /**\n   * Get result from cache or call memoized function\n   */\n  (...args: Args): Result;\n  /**\n   * Call memoized function and update cache\n   */\n  load: (...args: Args) => Result;\n  /**\n   * Delete cache of given arguments\n   */\n  delete: (...args: Args) => void;\n  /**\n   * Clear cache\n   */\n  clear: () => void;\n  /**\n   * Generate cache key for given arguments\n   */\n  generateKey: (...args: Args) => CacheKey;\n  /**\n   * Cache container\n   */\n  cache: UseMemoizeCache<CacheKey, Result>;\n}\ninterface UseMemoizeOptions<Result, Args extends unknown[]> {\n  getKey?: (...args: Args) => string | number;\n  cache?: UseMemoizeCache<CacheKey, Result>;\n}\n/**\n * Reactive function result cache based on arguments\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useMemoize<Result, Args extends unknown[]>(resolver: (...args: Args) => Result, options?: UseMemoizeOptions<Result, Args>): UseMemoizeReturn<Result, Args>;\n//#endregion\n//#region useMemory/index.d.ts\n/**\n * Performance.memory\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Performance/memory\n */\ninterface MemoryInfo {\n  /**\n   * The maximum size of the heap, in bytes, that is available to the context.\n   */\n  readonly jsHeapSizeLimit: number;\n  /**\n   *  The total allocated heap size, in bytes.\n   */\n  readonly totalJSHeapSize: number;\n  /**\n   * The currently active segment of JS heap, in bytes.\n   */\n  readonly usedJSHeapSize: number;\n  [Symbol.toStringTag]: 'MemoryInfo';\n}\ninterface UseMemoryOptions extends ConfigurableScheduler {\n  /**\n   * Start the timer immediately\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Execute the callback immediately after calling `resume`\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default false\n   */\n  immediateCallback?: boolean;\n  /** @deprecated Please use `scheduler` option instead */\n  interval?: number;\n}\ninterface UseMemoryReturn extends Supportable {\n  memory: Ref<MemoryInfo | undefined>;\n}\n/**\n * Reactive Memory Info.\n *\n * @see https://vueuse.org/useMemory\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useMemory(options?: UseMemoryOptions): UseMemoryReturn;\n//#endregion\n//#region useMounted/index.d.ts\n/**\n * Mounted state in ref.\n *\n * @see https://vueuse.org/useMounted\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useMounted(): vue0.ShallowRef<boolean, boolean>;\n//#endregion\n//#region useMouse/index.d.ts\ntype UseMouseCoordType = 'page' | 'client' | 'screen' | 'movement';\ntype UseMouseSourceType = 'mouse' | 'touch' | null;\ntype UseMouseEventExtractor = (event: MouseEvent | Touch) => [x: number, y: number] | null | undefined;\ninterface UseMouseOptions extends ConfigurableWindow, ConfigurableEventFilter {\n  /**\n   * Mouse position based by page, client, screen, or relative to previous position\n   *\n   * @default 'page'\n   */\n  type?: UseMouseCoordType | UseMouseEventExtractor;\n  /**\n   * Listen events on `target` element\n   *\n   * @default 'Window'\n   */\n  target?: MaybeRefOrGetter<Window | EventTarget | null | undefined>;\n  /**\n   * Listen to `touchmove` events\n   *\n   * @default true\n   */\n  touch?: boolean;\n  /**\n   * Listen to `scroll` events on window, only effective on type `page`\n   *\n   * @default true\n   */\n  scroll?: boolean;\n  /**\n   * Reset to initial value when `touchend` event fired\n   *\n   * @default false\n   */\n  resetOnTouchEnds?: boolean;\n  /**\n   * Initial values\n   */\n  initialValue?: Position;\n}\ninterface UseMouseReturn {\n  x: ShallowRef<number>;\n  y: ShallowRef<number>;\n  sourceType: ShallowRef<UseMouseSourceType>;\n}\n/**\n * Reactive mouse position.\n *\n * @see https://vueuse.org/useMouse\n * @param options\n */\ndeclare function useMouse(options?: UseMouseOptions): UseMouseReturn;\n//#endregion\n//#region useMouseInElement/index.d.ts\ninterface MouseInElementOptions extends UseMouseOptions {\n  /**\n   * Whether to handle mouse events when the cursor is outside the target element.\n   * When enabled, mouse position will continue to be tracked even when outside the element bounds.\n   *\n   * @default true\n   */\n  handleOutside?: boolean;\n  /**\n   * Listen to window resize event\n   *\n   * @default true\n   */\n  windowScroll?: boolean;\n  /**\n   * Listen to window scroll event\n   *\n   * @default true\n   */\n  windowResize?: boolean;\n}\ninterface UseMouseInElementReturn extends UseMouseReturn {\n  elementX: ShallowRef<number>;\n  elementY: ShallowRef<number>;\n  elementPositionX: ShallowRef<number>;\n  elementPositionY: ShallowRef<number>;\n  elementHeight: ShallowRef<number>;\n  elementWidth: ShallowRef<number>;\n  isOutside: ShallowRef<boolean>;\n  stop: () => void;\n}\n/**\n * Reactive mouse position related to an element.\n *\n * @see https://vueuse.org/useMouseInElement\n * @param target\n * @param options\n */\ndeclare function useMouseInElement(target?: MaybeElementRef, options?: MouseInElementOptions): {\n  x: ShallowRef<number>;\n  y: ShallowRef<number>;\n  sourceType: ShallowRef<UseMouseSourceType>;\n  elementX: ShallowRef<number, number>;\n  elementY: ShallowRef<number, number>;\n  elementPositionX: ShallowRef<number, number>;\n  elementPositionY: ShallowRef<number, number>;\n  elementHeight: ShallowRef<number, number>;\n  elementWidth: ShallowRef<number, number>;\n  isOutside: ShallowRef<boolean, boolean>;\n  stop: () => void;\n};\n//#endregion\n//#region useMousePressed/index.d.ts\ninterface UseMousePressedOptions extends ConfigurableWindow {\n  /**\n   * Listen to `touchstart` `touchend` events\n   *\n   * @default true\n   */\n  touch?: boolean;\n  /**\n   * Listen to `dragstart` `drop` and `dragend` events\n   *\n   * @default true\n   */\n  drag?: boolean;\n  /**\n   * Add event listeners with the `capture` option set to `true`\n   * (see [MDN](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#capture))\n   *\n   * @default false\n   */\n  capture?: boolean;\n  /**\n   * Initial values\n   *\n   * @default false\n   */\n  initialValue?: boolean;\n  /**\n   * Element target to be capture the click\n   */\n  target?: MaybeComputedElementRef;\n  /**\n   * Callback to be called when the mouse is pressed\n   *\n   * @param event\n   */\n  onPressed?: (event: MouseEvent | TouchEvent | DragEvent) => void;\n  /**\n   * Callback to be called when the mouse is released\n   *\n   * @param event\n   */\n  onReleased?: (event: MouseEvent | TouchEvent | DragEvent) => void;\n}\n/** @deprecated use {@link UseMousePressedOptions} instead */\ntype MousePressedOptions = UseMousePressedOptions;\ninterface UseMousePressedReturn {\n  pressed: ShallowRef<boolean>;\n  sourceType: ShallowRef<UseMouseSourceType>;\n}\n/**\n * Reactive mouse pressing state.\n *\n * @see https://vueuse.org/useMousePressed\n * @param options\n */\ndeclare function useMousePressed(options?: UseMousePressedOptions): UseMousePressedReturn;\n//#endregion\n//#region useMutationObserver/index.d.ts\ninterface UseMutationObserverOptions extends MutationObserverInit, ConfigurableWindow {}\ninterface UseMutationObserverReturn extends Supportable {\n  stop: () => void;\n  takeRecords: () => MutationRecord[] | undefined;\n}\n/**\n * Watch for changes being made to the DOM tree.\n *\n * @see https://vueuse.org/useMutationObserver\n * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver MutationObserver MDN\n * @param target\n * @param callback\n * @param options\n */\ndeclare function useMutationObserver(target: MaybeComputedElementRef | MaybeComputedElementRef[] | MaybeRefOrGetter<MaybeElement[]>, callback: MutationCallback, options?: UseMutationObserverOptions): UseMutationObserverReturn;\n//#endregion\n//#region useNavigatorLanguage/index.d.ts\ninterface NavigatorLanguageState extends Supportable {\n  /**\n   *\n   * ISO 639-1 standard Language Code\n   *\n   * @info The detected user agent language preference as a language tag\n   * (which is sometimes referred to as a \"locale identifier\").\n   * This consists of a 2-3 letter base language tag that indicates a\n   * language, optionally followed by additional subtags separated by\n   * '-'. The most common extra information is the country or region\n   * variant (like 'en-US' or 'fr-CA').\n   *\n   *\n   * @see https://www.iso.org/iso-639-language-codes.html\n   * @see https://www.loc.gov/standards/iso639-2/php/code_list.php\n   *\n   */\n  language: ShallowRef<string | undefined>;\n}\ninterface UseNavigatorLanguageOptions extends ConfigurableWindow {}\ntype UseNavigatorLanguageReturn = Readonly<NavigatorLanguageState>;\n/**\n *\n * Reactive useNavigatorLanguage\n *\n * Detects the currently selected user language and returns a reactive language\n * @see https://vueuse.org/useNavigatorLanguage\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useNavigatorLanguage(options?: UseNavigatorLanguageOptions): UseNavigatorLanguageReturn;\n//#endregion\n//#region useNetwork/index.d.ts\ninterface UseNetworkOptions extends ConfigurableWindow {}\ntype NetworkType = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown';\ntype NetworkEffectiveType = 'slow-2g' | '2g' | '3g' | '4g' | undefined;\ninterface NetworkState extends Supportable {\n  /**\n   * If the user is currently connected.\n   */\n  isOnline: Readonly<ShallowRef<boolean>>;\n  /**\n   * The time since the user was last connected.\n   */\n  offlineAt: Readonly<ShallowRef<number | undefined>>;\n  /**\n   * At this time, if the user is offline and reconnects\n   */\n  onlineAt: Readonly<ShallowRef<number | undefined>>;\n  /**\n   * The download speed in Mbps.\n   */\n  downlink: Readonly<ShallowRef<number | undefined>>;\n  /**\n   * The max reachable download speed in Mbps.\n   */\n  downlinkMax: Readonly<ShallowRef<number | undefined>>;\n  /**\n   * The detected effective speed type.\n   */\n  effectiveType: Readonly<ShallowRef<NetworkEffectiveType | undefined>>;\n  /**\n   * The estimated effective round-trip time of the current connection.\n   */\n  rtt: Readonly<ShallowRef<number | undefined>>;\n  /**\n   * If the user activated data saver mode.\n   */\n  saveData: Readonly<ShallowRef<boolean | undefined>>;\n  /**\n   * The detected connection/network type.\n   */\n  type: Readonly<ShallowRef<NetworkType>>;\n}\ntype UseNetworkReturn = Readonly<NetworkState>;\n/**\n * Reactive Network status.\n *\n * @see https://vueuse.org/useNetwork\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useNetwork(options?: UseNetworkOptions): UseNetworkReturn;\n//#endregion\n//#region useNow/index.d.ts\ninterface UseNowOptions<Controls extends boolean> extends ConfigurableScheduler {\n  /**\n   * Expose more controls\n   *\n   * @default false\n   */\n  controls?: Controls;\n  /**\n   * Start the clock immediately\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Update interval in milliseconds, or use requestAnimationFrame\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default requestAnimationFrame\n   */\n  interval?: 'requestAnimationFrame' | number;\n}\ntype UseNowReturn<Controls extends boolean> = Controls extends true ? ({\n  now: Ref<Date>;\n} & Pausable) : Ref<Date>;\n/**\n * Reactive current Date instance.\n *\n * @see https://vueuse.org/useNow\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useNow(options?: UseNowOptions<false>): Ref<Date>;\ndeclare function useNow(options: UseNowOptions<true>): {\n  now: Ref<Date>;\n} & Pausable;\n//#endregion\n//#region useObjectUrl/index.d.ts\n/**\n * Reactive URL representing an object.\n *\n * @see https://vueuse.org/useObjectUrl\n * @param object\n */\ndeclare function useObjectUrl(object: MaybeRefOrGetter<Blob | MediaSource | null | undefined>): Readonly<vue0.Ref<string | undefined, string | undefined>>;\n//#endregion\n//#region useOffsetPagination/index.d.ts\ninterface UseOffsetPaginationOptions {\n  /**\n   * Total number of items.\n   */\n  total?: MaybeRefOrGetter<number>;\n  /**\n   * The number of items to display per page.\n   * @default 10\n   */\n  pageSize?: MaybeRefOrGetter<number>;\n  /**\n   * The current page number.\n   * @default 1\n   */\n  page?: MaybeRef<number>;\n  /**\n   * Callback when the `page` change.\n   */\n  onPageChange?: (returnValue: UnwrapNestedRefs<UseOffsetPaginationReturn>) => unknown;\n  /**\n   * Callback when the `pageSize` change.\n   */\n  onPageSizeChange?: (returnValue: UnwrapNestedRefs<UseOffsetPaginationReturn>) => unknown;\n  /**\n   * Callback when the `pageCount` change.\n   */\n  onPageCountChange?: (returnValue: UnwrapNestedRefs<UseOffsetPaginationReturn>) => unknown;\n}\ninterface UseOffsetPaginationReturn {\n  currentPage: Ref<number>;\n  currentPageSize: Ref<number>;\n  pageCount: ComputedRef<number>;\n  isFirstPage: ComputedRef<boolean>;\n  isLastPage: ComputedRef<boolean>;\n  prev: () => void;\n  next: () => void;\n}\ntype UseOffsetPaginationInfinityPageReturn = Omit<UseOffsetPaginationReturn, 'isLastPage'>;\ndeclare function useOffsetPagination(options: Omit<UseOffsetPaginationOptions, 'total'>): UseOffsetPaginationInfinityPageReturn;\ndeclare function useOffsetPagination(options: UseOffsetPaginationOptions): UseOffsetPaginationReturn;\n//#endregion\n//#region useOnline/index.d.ts\n/**\n * Reactive online state.\n *\n * @see https://vueuse.org/useOnline\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useOnline(options?: ConfigurableWindow): Readonly<vue0.ShallowRef<boolean>>;\n//#endregion\n//#region usePageLeave/index.d.ts\ninterface UsePageLeaveOptions extends ConfigurableWindow {}\ntype UsePageLeaveReturn = ShallowRef<boolean>;\n/**\n * Reactive state to show whether mouse leaves the page.\n *\n * @see https://vueuse.org/usePageLeave\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePageLeave(options?: UsePageLeaveOptions): UsePageLeaveReturn;\n//#endregion\n//#region useParallax/index.d.ts\ninterface UseParallaxOptions extends ConfigurableWindow {\n  deviceOrientationTiltAdjust?: (i: number) => number;\n  deviceOrientationRollAdjust?: (i: number) => number;\n  mouseTiltAdjust?: (i: number) => number;\n  mouseRollAdjust?: (i: number) => number;\n}\ninterface UseParallaxReturn {\n  /**\n   * Roll value. Scaled to `-0.5 ~ 0.5`\n   */\n  roll: ComputedRef<number>;\n  /**\n   * Tilt value. Scaled to `-0.5 ~ 0.5`\n   */\n  tilt: ComputedRef<number>;\n  /**\n   * Sensor source, can be `mouse` or `deviceOrientation`\n   */\n  source: ComputedRef<'deviceOrientation' | 'mouse'>;\n}\n/**\n * Create parallax effect easily. It uses `useDeviceOrientation` and fallback to `useMouse`\n * if orientation is not supported.\n *\n * @param target\n * @param options\n */\ndeclare function useParallax(target: MaybeElementRef, options?: UseParallaxOptions): UseParallaxReturn;\n//#endregion\n//#region useParentElement/index.d.ts\ndeclare function useParentElement(element?: MaybeRefOrGetter<HTMLElement | SVGElement | null | undefined>): Readonly<ShallowRef<HTMLElement | SVGElement | null | undefined>>;\n//#endregion\n//#region usePerformanceObserver/index.d.ts\ntype UsePerformanceObserverOptions = PerformanceObserverInit & ConfigurableWindow & {\n  /**\n   * Start the observer immediate.\n   *\n   * @default true\n   */\n  immediate?: boolean;\n};\n/**\n * Observe performance metrics.\n *\n * @see https://vueuse.org/usePerformanceObserver\n * @param options\n */\ndeclare function usePerformanceObserver(options: UsePerformanceObserverOptions, callback: PerformanceObserverCallback): {\n  isSupported: UseSupportedReturn;\n  start: () => void;\n  stop: () => void;\n};\n//#endregion\n//#region usePermission/index.d.ts\ntype DescriptorNamePolyfill = 'accelerometer' | 'accessibility-events' | 'ambient-light-sensor' | 'background-sync' | 'camera' | 'clipboard-read' | 'clipboard-write' | 'gyroscope' | 'magnetometer' | 'microphone' | 'notifications' | 'payment-handler' | 'persistent-storage' | 'push' | 'speaker' | 'local-fonts';\ntype GeneralPermissionDescriptor = PermissionDescriptor | {\n  name: DescriptorNamePolyfill;\n};\ninterface UsePermissionOptions<Controls extends boolean> extends ConfigurableNavigator {\n  /**\n   * Expose more controls\n   *\n   * @default false\n   */\n  controls?: Controls;\n}\ntype UsePermissionReturn = Readonly<ShallowRef<PermissionState | undefined>>;\ninterface UsePermissionReturnWithControls extends Supportable {\n  state: UsePermissionReturn;\n  query: () => Promise<PermissionStatus | undefined>;\n}\n/**\n * Reactive Permissions API.\n *\n * @see https://vueuse.org/usePermission\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePermission(permissionDesc: GeneralPermissionDescriptor | GeneralPermissionDescriptor['name'], options?: UsePermissionOptions<false>): UsePermissionReturn;\ndeclare function usePermission(permissionDesc: GeneralPermissionDescriptor | GeneralPermissionDescriptor['name'], options: UsePermissionOptions<true>): UsePermissionReturnWithControls;\n//#endregion\n//#region usePointer/index.d.ts\ninterface UsePointerState extends Position {\n  pressure: number;\n  pointerId: number;\n  tiltX: number;\n  tiltY: number;\n  width: number;\n  height: number;\n  twist: number;\n  pointerType: PointerType | null;\n}\ninterface UsePointerOptions extends ConfigurableWindow {\n  /**\n   * Pointer types that listen to.\n   *\n   * @default ['mouse', 'touch', 'pen']\n   */\n  pointerTypes?: PointerType[];\n  /**\n   * Initial values\n   */\n  initialValue?: MaybeRef<Partial<UsePointerState>>;\n  /**\n   * @default window\n   */\n  target?: MaybeRef<EventTarget | null | undefined> | Document | Window;\n}\ninterface UsePointerReturn {\n  pressure: Ref<number>;\n  pointerId: Ref<number>;\n  tiltX: Ref<number>;\n  tiltY: Ref<number>;\n  width: Ref<number>;\n  height: Ref<number>;\n  twist: Ref<number>;\n  pointerType: Ref<PointerType | null>;\n  x: Ref<number>;\n  y: Ref<number>;\n  isInside: ShallowRef<boolean>;\n}\n/**\n * Reactive pointer state.\n *\n * @see https://vueuse.org/usePointer\n * @param options\n */\ndeclare function usePointer(options?: UsePointerOptions): UsePointerReturn;\n//#endregion\n//#region usePointerLock/index.d.ts\ninterface UsePointerLockOptions extends ConfigurableDocument {}\ninterface UsePointerLockReturn extends Supportable {\n  element: ShallowRef<MaybeElement>;\n  triggerElement: ShallowRef<MaybeElement>;\n  lock: (e: MaybeElementRef | Event) => Promise<MaybeElement>;\n  unlock: () => Promise<boolean>;\n}\n/**\n * Reactive pointer lock.\n *\n * @see https://vueuse.org/usePointerLock\n * @param target\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePointerLock(target?: MaybeElementRef, options?: UsePointerLockOptions): UsePointerLockReturn;\n//#endregion\n//#region useSwipe/index.d.ts\ntype UseSwipeDirection = 'up' | 'down' | 'left' | 'right' | 'none';\ninterface UseSwipeOptions extends ConfigurableWindow {\n  /**\n   * Register events as passive\n   *\n   * @default true\n   */\n  passive?: boolean;\n  /**\n   * @default 50\n   */\n  threshold?: number;\n  /**\n   * Callback on swipe start\n   */\n  onSwipeStart?: (e: TouchEvent) => void;\n  /**\n   * Callback on swipe moves\n   */\n  onSwipe?: (e: TouchEvent) => void;\n  /**\n   * Callback on swipe ends\n   */\n  onSwipeEnd?: (e: TouchEvent, direction: UseSwipeDirection) => void;\n}\ninterface UseSwipeReturn {\n  isSwiping: ShallowRef<boolean>;\n  direction: ComputedRef<UseSwipeDirection>;\n  coordsStart: Readonly<Position>;\n  coordsEnd: Readonly<Position>;\n  lengthX: ComputedRef<number>;\n  lengthY: ComputedRef<number>;\n  stop: () => void;\n}\n/**\n * Reactive swipe detection.\n *\n * @see https://vueuse.org/useSwipe\n * @param target\n * @param options\n */\ndeclare function useSwipe(target: MaybeRefOrGetter<EventTarget | null | undefined>, options?: UseSwipeOptions): UseSwipeReturn;\n//#endregion\n//#region usePointerSwipe/index.d.ts\ninterface UsePointerSwipeOptions {\n  /**\n   * @default 50\n   */\n  threshold?: number;\n  /**\n   * Callback on swipe start.\n   */\n  onSwipeStart?: (e: PointerEvent) => void;\n  /**\n   * Callback on swipe move.\n   */\n  onSwipe?: (e: PointerEvent) => void;\n  /**\n   * Callback on swipe end.\n   */\n  onSwipeEnd?: (e: PointerEvent, direction: UseSwipeDirection) => void;\n  /**\n   * Pointer types to listen to.\n   *\n   * @default ['mouse', 'touch', 'pen']\n   */\n  pointerTypes?: PointerType[];\n  /**\n   * Disable text selection on swipe.\n   *\n   * @default false\n   */\n  disableTextSelect?: boolean;\n}\ninterface UsePointerSwipeReturn {\n  readonly isSwiping: ShallowRef<boolean>;\n  direction: Readonly<ShallowRef<UseSwipeDirection>>;\n  readonly posStart: Position;\n  readonly posEnd: Position;\n  distanceX: Readonly<ComputedRef<number>>;\n  distanceY: Readonly<ComputedRef<number>>;\n  stop: () => void;\n}\n/**\n * Reactive swipe detection based on PointerEvents.\n *\n * @see https://vueuse.org/usePointerSwipe\n * @param target\n * @param options\n */\ndeclare function usePointerSwipe(target: MaybeRefOrGetter<HTMLElement | null | undefined>, options?: UsePointerSwipeOptions): UsePointerSwipeReturn;\n//#endregion\n//#region usePreferredColorScheme/index.d.ts\ntype ColorSchemeType = 'dark' | 'light' | 'no-preference';\n/**\n * Reactive prefers-color-scheme media query.\n *\n * @see https://vueuse.org/usePreferredColorScheme\n * @param [options]\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePreferredColorScheme(options?: ConfigurableWindow): vue0.ComputedRef<ColorSchemeType>;\n//#endregion\n//#region usePreferredContrast/index.d.ts\ntype ContrastType = 'more' | 'less' | 'custom' | 'no-preference';\n/**\n * Reactive prefers-contrast media query.\n *\n * @see https://vueuse.org/usePreferredContrast\n * @param [options]\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePreferredContrast(options?: ConfigurableWindow): vue0.ComputedRef<ContrastType>;\n//#endregion\n//#region usePreferredDark/index.d.ts\n/**\n * Reactive dark theme preference.\n *\n * @see https://vueuse.org/usePreferredDark\n * @param [options]\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePreferredDark(options?: ConfigurableWindow): vue0.ComputedRef<boolean>;\n//#endregion\n//#region usePreferredLanguages/index.d.ts\n/**\n * Reactive Navigator Languages.\n *\n * @see https://vueuse.org/usePreferredLanguages\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePreferredLanguages(options?: ConfigurableWindow): ShallowRef<readonly string[]>;\n//#endregion\n//#region usePreferredReducedMotion/index.d.ts\ntype ReducedMotionType = 'reduce' | 'no-preference';\n/**\n * Reactive prefers-reduced-motion media query.\n *\n * @see https://vueuse.org/usePreferredReducedMotion\n * @param [options]\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePreferredReducedMotion(options?: ConfigurableWindow): vue0.ComputedRef<ReducedMotionType>;\n//#endregion\n//#region usePreferredReducedTransparency/index.d.ts\ntype ReducedTransparencyType = 'reduce' | 'no-preference';\n/**\n * Reactive prefers-reduced-transparency media query.\n *\n * @see https://vueuse.org/usePreferredReducedTransparency\n * @param [options]\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function usePreferredReducedTransparency(options?: ConfigurableWindow): vue0.ComputedRef<ReducedTransparencyType>;\n//#endregion\n//#region usePrevious/index.d.ts\n/**\n * Holds the previous value of a ref.\n *\n * @see   {@link https://vueuse.org/usePrevious}\n */\ndeclare function usePrevious<T>(value: MaybeRefOrGetter<T>): Readonly<ShallowRef<T | undefined>>;\ndeclare function usePrevious<T>(value: MaybeRefOrGetter<T>, initialValue: T): Readonly<ShallowRef<T>>;\n//#endregion\n//#region useRafFn/index.d.ts\ninterface UseRafFnCallbackArguments {\n  /**\n   * Time elapsed between this and the last frame.\n   */\n  delta: number;\n  /**\n   * Time elapsed since the creation of the web page. See {@link https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp#the_time_origin Time origin}.\n   */\n  timestamp: DOMHighResTimeStamp;\n}\ninterface UseRafFnOptions extends ConfigurableWindow {\n  /**\n   * Start the requestAnimationFrame loop immediately on creation\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * The maximum frame per second to execute the function.\n   * Set to `null` to disable the limit.\n   *\n   * @default null\n   */\n  fpsLimit?: MaybeRefOrGetter<number | null>;\n  /**\n   * After the requestAnimationFrame loop executed once, it will be automatically stopped.\n   *\n   * @default false\n   */\n  once?: boolean;\n}\n/**\n * Call function on every `requestAnimationFrame`. With controls of pausing and resuming.\n *\n * @see https://vueuse.org/useRafFn\n * @param fn\n * @param options\n */\ndeclare function useRafFn(fn: (args: UseRafFnCallbackArguments) => void, options?: UseRafFnOptions): Pausable;\n//#endregion\n//#region useSSRWidth/index.d.ts\ndeclare function useSSRWidth(): number | undefined;\ndeclare function provideSSRWidth(width: number | null, app?: App<unknown>): void;\n//#endregion\n//#region useScreenOrientation/index.d.ts\ntype OrientationType = 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary';\ntype OrientationLockType = 'any' | 'natural' | 'landscape' | 'portrait' | 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary';\ninterface ScreenOrientation extends EventTarget {\n  lock: (orientation: OrientationLockType) => Promise<void>;\n  unlock: () => void;\n  readonly type: OrientationType;\n  readonly angle: number;\n  addEventListener: (type: 'change', listener: (this: this, ev: Event) => any, useCapture?: boolean) => void;\n}\ninterface UseScreenOrientationOptions extends ConfigurableWindow {}\ninterface UseScreenOrientationReturn extends Supportable {\n  orientation: Ref<OrientationType | undefined>;\n  angle: ShallowRef<number>;\n  lockOrientation: (type: OrientationLockType) => Promise<void>;\n  unlockOrientation: () => void;\n}\n/**\n * Reactive screen orientation\n *\n * @see https://vueuse.org/useScreenOrientation\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useScreenOrientation(options?: UseScreenOrientationOptions): UseScreenOrientationReturn;\n//#endregion\n//#region useScreenSafeArea/index.d.ts\ninterface UseScreenSafeAreaReturn {\n  top: ShallowRef<string>;\n  right: ShallowRef<string>;\n  bottom: ShallowRef<string>;\n  left: ShallowRef<string>;\n  update: () => void;\n}\n/**\n * Reactive `env(safe-area-inset-*)`\n *\n * @see https://vueuse.org/useScreenSafeArea\n */\ndeclare function useScreenSafeArea(): UseScreenSafeAreaReturn;\n//#endregion\n//#region useScriptTag/index.d.ts\ninterface UseScriptTagOptions extends ConfigurableDocument {\n  /**\n   * Load the script immediately\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Add `async` attribute to the script tag\n   *\n   * @default true\n   */\n  async?: boolean;\n  /**\n   * Script type\n   *\n   * @default 'text/javascript'\n   */\n  type?: string;\n  /**\n   * Manual controls the timing of loading and unloading\n   *\n   * @default false\n   */\n  manual?: boolean;\n  crossOrigin?: 'anonymous' | 'use-credentials';\n  referrerPolicy?: 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';\n  noModule?: boolean;\n  defer?: boolean;\n  /**\n   * Add custom attribute to the script tag\n   *\n   */\n  attrs?: Record<string, string>;\n  /**\n   * Nonce value for CSP (Content Security Policy)\n   * @default undefined\n   */\n  nonce?: string;\n}\ninterface UseScriptTagReturn {\n  scriptTag: ShallowRef<HTMLScriptElement | null>;\n  load: (waitForScriptLoad?: boolean) => Promise<HTMLScriptElement | boolean>;\n  unload: () => void;\n}\n/**\n * Async script tag loading.\n *\n * @see https://vueuse.org/useScriptTag\n * @param src\n * @param onLoaded\n * @param options\n */\ndeclare function useScriptTag(src: MaybeRefOrGetter<string>, onLoaded?: (el: HTMLScriptElement) => void, options?: UseScriptTagOptions): UseScriptTagReturn;\n//#endregion\n//#region useScrollLock/index.d.ts\n/**\n * Lock scrolling of the element.\n *\n * @see https://vueuse.org/useScrollLock\n * @param element\n */\ndeclare function useScrollLock(element: MaybeRefOrGetter<HTMLElement | SVGElement | Window | Document | null | undefined>, initialState?: boolean): vue0.WritableComputedRef<boolean, boolean>;\n//#endregion\n//#region useSessionStorage/index.d.ts\ndeclare function useSessionStorage(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<string>, options?: UseStorageOptions<string>): RemovableRef<string>;\ndeclare function useSessionStorage(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<boolean>, options?: UseStorageOptions<boolean>): RemovableRef<boolean>;\ndeclare function useSessionStorage(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<number>, options?: UseStorageOptions<number>): RemovableRef<number>;\ndeclare function useSessionStorage<T>(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<T>, options?: UseStorageOptions<T>): RemovableRef<T>;\ndeclare function useSessionStorage<T = unknown>(key: MaybeRefOrGetter<string>, initialValue: MaybeRefOrGetter<null>, options?: UseStorageOptions<T>): RemovableRef<T>;\n//#endregion\n//#region useShare/index.d.ts\ninterface UseShareOptions {\n  title?: string;\n  files?: File[];\n  text?: string;\n  url?: string;\n}\ninterface UseShareReturn extends Supportable {\n  share: (overrideOptions?: MaybeRefOrGetter<UseShareOptions>) => Promise<void>;\n}\n/**\n * Reactive Web Share API.\n *\n * @see https://vueuse.org/useShare\n * @param shareOptions\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useShare(shareOptions?: MaybeRefOrGetter<UseShareOptions>, options?: ConfigurableNavigator): UseShareReturn;\n//#endregion\n//#region useSorted/index.d.ts\ntype UseSortedCompareFn<T = any> = (a: T, b: T) => number;\ntype UseSortedFn<T = any> = (arr: T[], compareFn: UseSortedCompareFn<T>) => T[];\ninterface UseSortedOptions<T = any> {\n  /**\n   * sort algorithm\n   */\n  sortFn?: UseSortedFn<T>;\n  /**\n   * compare function\n   */\n  compareFn?: UseSortedCompareFn<T>;\n  /**\n   * change the value of the source array\n   * @default false\n   */\n  dirty?: boolean;\n}\n/**\n * reactive sort array\n *\n * @see https://vueuse.org/useSorted\n */\ndeclare function useSorted<T = any>(source: MaybeRefOrGetter<T[]>, compareFn?: UseSortedCompareFn<T>): Ref<T[]>;\ndeclare function useSorted<T = any>(source: MaybeRefOrGetter<T[]>, options?: UseSortedOptions<T>): Ref<T[]>;\ndeclare function useSorted<T = any>(source: MaybeRefOrGetter<T[]>, compareFn?: UseSortedCompareFn<T>, options?: Omit<UseSortedOptions<T>, 'compareFn'>): Ref<T[]>;\n//#endregion\n//#region useSpeechRecognition/types.d.ts\ntype SpeechRecognitionErrorCode = 'aborted' | 'audio-capture' | 'bad-grammar' | 'language-not-supported' | 'network' | 'no-speech' | 'not-allowed' | 'service-not-allowed';\ninterface SpeechGrammar {\n  src: string;\n  weight: number;\n}\ninterface SpeechGrammarList {\n  readonly length: number;\n  addFromString: (string: string, weight?: number) => void;\n  addFromURI: (src: string, weight?: number) => void;\n  item: (index: number) => SpeechGrammar;\n  [index: number]: SpeechGrammar;\n}\ninterface SpeechRecognitionErrorEvent extends Event {\n  readonly error: SpeechRecognitionErrorCode;\n  readonly message: string;\n}\ninterface SpeechRecognitionEvent extends Event {\n  readonly resultIndex: number;\n  readonly results: SpeechRecognitionResultList;\n}\ninterface SpeechRecognitionEventMap {\n  audioend: Event;\n  audiostart: Event;\n  end: Event;\n  error: SpeechRecognitionErrorEvent;\n  nomatch: SpeechRecognitionEvent;\n  result: SpeechRecognitionEvent;\n  soundend: Event;\n  soundstart: Event;\n  speechend: Event;\n  speechstart: Event;\n  start: Event;\n}\ninterface SpeechRecognition extends EventTarget {\n  continuous: boolean;\n  grammars: SpeechGrammarList;\n  interimResults: boolean;\n  lang: string;\n  maxAlternatives: number;\n  onaudioend: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onaudiostart: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onend: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onerror: ((this: SpeechRecognition, ev: SpeechRecognitionErrorEvent) => any) | null;\n  onnomatch: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;\n  onresult: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;\n  onsoundend: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onsoundstart: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onspeechend: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onspeechstart: ((this: SpeechRecognition, ev: Event) => any) | null;\n  onstart: ((this: SpeechRecognition, ev: Event) => any) | null;\n  abort: () => void;\n  start: () => void;\n  stop: () => void;\n  addEventListener: (<K$1 extends keyof SpeechRecognitionEventMap>(type: K$1, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K$1]) => any, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);\n  removeEventListener: (<K$1 extends keyof SpeechRecognitionEventMap>(type: K$1, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K$1]) => any, options?: boolean | EventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions) => void);\n}\n//#endregion\n//#region useSpeechRecognition/index.d.ts\ninterface UseSpeechRecognitionOptions extends ConfigurableWindow {\n  /**\n   * Controls whether continuous results are returned for each recognition, or only a single result.\n   *\n   * @default true\n   */\n  continuous?: boolean;\n  /**\n   * Controls whether interim results should be returned (true) or not (false.) Interim results are results that are not yet final\n   *\n   * @default true\n   */\n  interimResults?: boolean;\n  /**\n   * Language for SpeechRecognition\n   *\n   * @default 'en-US'\n   */\n  lang?: MaybeRefOrGetter<string>;\n  /**\n   * A number representing the maximum returned alternatives for each result.\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition/maxAlternatives\n   * @default 1\n   */\n  maxAlternatives?: number;\n}\ninterface UseSpeechRecognitionReturn extends Supportable {\n  isListening: ShallowRef<boolean>;\n  isFinal: ShallowRef<boolean>;\n  recognition: SpeechRecognition | undefined;\n  result: ShallowRef<string>;\n  error: ShallowRef<SpeechRecognitionErrorEvent | Error | undefined>;\n  toggle: (value?: boolean) => void;\n  start: () => void;\n  stop: () => void;\n}\n/**\n * Reactive SpeechRecognition.\n *\n * @see https://vueuse.org/useSpeechRecognition\n * @see https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition SpeechRecognition\n * @param options\n */\ndeclare function useSpeechRecognition(options?: UseSpeechRecognitionOptions): UseSpeechRecognitionReturn;\n//#endregion\n//#region useSpeechSynthesis/index.d.ts\ntype UseSpeechSynthesisStatus = 'init' | 'play' | 'pause' | 'end';\ninterface UseSpeechSynthesisOptions extends ConfigurableWindow {\n  /**\n   * Language for SpeechSynthesis\n   *\n   * @default 'en-US'\n   */\n  lang?: MaybeRefOrGetter<string>;\n  /**\n   * Gets and sets the pitch at which the utterance will be spoken at.\n   *\n   * @default 1\n   */\n  pitch?: MaybeRefOrGetter<SpeechSynthesisUtterance['pitch']>;\n  /**\n   * Gets and sets the speed at which the utterance will be spoken at.\n   *\n   * @default 1\n   */\n  rate?: MaybeRefOrGetter<SpeechSynthesisUtterance['rate']>;\n  /**\n   * Gets and sets the voice that will be used to speak the utterance.\n   */\n  voice?: MaybeRef<SpeechSynthesisVoice>;\n  /**\n   * Gets and sets the volume that the utterance will be spoken at.\n   *\n   * @default 1\n   */\n  volume?: MaybeRefOrGetter<SpeechSynthesisUtterance['volume']>;\n  /**\n   * Callback function that is called when the boundary event is triggered.\n   */\n  onBoundary?: (event: SpeechSynthesisEvent) => void;\n}\ninterface UseSpeechSynthesisReturn extends Supportable {\n  isPlaying: ShallowRef<boolean>;\n  status: ShallowRef<UseSpeechSynthesisStatus>;\n  utterance: ComputedRef<SpeechSynthesisUtterance>;\n  error: ShallowRef<SpeechSynthesisErrorEvent | undefined>;\n  stop: () => void;\n  toggle: (value?: boolean) => void;\n  speak: () => void;\n}\n/**\n * Reactive SpeechSynthesis.\n *\n * @see https://vueuse.org/useSpeechSynthesis\n * @see https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesis SpeechSynthesis\n */\ndeclare function useSpeechSynthesis(text: MaybeRefOrGetter<string>, options?: UseSpeechSynthesisOptions): UseSpeechSynthesisReturn;\n//#endregion\n//#region useStepper/index.d.ts\ninterface UseStepperReturn<StepName, Steps, Step> {\n  /** List of steps. */\n  steps: Readonly<Ref<Steps>>;\n  /** List of step names. */\n  stepNames: Readonly<Ref<StepName[]>>;\n  /** Index of the current step. */\n  index: Ref<number>;\n  /** Current step. */\n  current: ComputedRef<Step>;\n  /** Next step, or undefined if the current step is the last one. */\n  next: ComputedRef<StepName | undefined>;\n  /** Previous step, or undefined if the current step is the first one. */\n  previous: ComputedRef<StepName | undefined>;\n  /** Whether the current step is the first one. */\n  isFirst: ComputedRef<boolean>;\n  /** Whether the current step is the last one. */\n  isLast: ComputedRef<boolean>;\n  /** Get the step at the specified index. */\n  at: (index: number) => Step | undefined;\n  /** Get a step by the specified name. */\n  get: (step: StepName) => Step | undefined;\n  /** Go to the specified step. */\n  goTo: (step: StepName) => void;\n  /** Go to the next step. Does nothing if the current step is the last one. */\n  goToNext: () => void;\n  /** Go to the previous step. Does nothing if the current step is the previous one. */\n  goToPrevious: () => void;\n  /** Go back to the given step, only if the current step is after. */\n  goBackTo: (step: StepName) => void;\n  /** Checks whether the given step is the next step. */\n  isNext: (step: StepName) => boolean;\n  /** Checks whether the given step is the previous step. */\n  isPrevious: (step: StepName) => boolean;\n  /** Checks whether the given step is the current step. */\n  isCurrent: (step: StepName) => boolean;\n  /** Checks if the current step is before the given step. */\n  isBefore: (step: StepName) => boolean;\n  /** Checks if the current step is after the given step. */\n  isAfter: (step: StepName) => boolean;\n}\ndeclare function useStepper<T extends string | number>(steps: MaybeRef<T[]>, initialStep?: T): UseStepperReturn<T, T[], T>;\ndeclare function useStepper<T extends Record<string, any>>(steps: MaybeRef<T>, initialStep?: keyof T): UseStepperReturn<Exclude<keyof T, symbol>, T, T[keyof T]>;\n//#endregion\n//#region useStorageAsync/index.d.ts\ninterface UseStorageAsyncOptions<T> extends Omit<UseStorageOptions<T>, 'serializer'> {\n  /**\n   * Custom data serialization\n   */\n  serializer?: SerializerAsync<T>;\n  /**\n   * On first value loaded hook.\n   */\n  onReady?: (value: T) => void;\n}\ndeclare function useStorageAsync(key: string, initialValue: MaybeRefOrGetter<string>, storage?: StorageLikeAsync, options?: UseStorageAsyncOptions<string>): RemovableRef<string> & Promise<RemovableRef<string>>;\ndeclare function useStorageAsync(key: string, initialValue: MaybeRefOrGetter<boolean>, storage?: StorageLikeAsync, options?: UseStorageAsyncOptions<boolean>): RemovableRef<boolean> & Promise<RemovableRef<boolean>>;\ndeclare function useStorageAsync(key: string, initialValue: MaybeRefOrGetter<number>, storage?: StorageLikeAsync, options?: UseStorageAsyncOptions<number>): RemovableRef<number> & Promise<RemovableRef<number>>;\ndeclare function useStorageAsync<T>(key: string, initialValue: MaybeRefOrGetter<T>, storage?: StorageLikeAsync, options?: UseStorageAsyncOptions<T>): RemovableRef<T> & Promise<RemovableRef<T>>;\ndeclare function useStorageAsync<T = unknown>(key: string, initialValue: MaybeRefOrGetter<null>, storage?: StorageLikeAsync, options?: UseStorageAsyncOptions<T>): RemovableRef<T> & Promise<RemovableRef<T>>;\n//#endregion\n//#region useStyleTag/index.d.ts\ninterface UseStyleTagOptions extends ConfigurableDocument {\n  /**\n   * Media query for styles to apply\n   */\n  media?: string;\n  /**\n   * Load the style immediately\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Manual controls the timing of loading and unloading\n   *\n   * @default false\n   */\n  manual?: boolean;\n  /**\n   * DOM id of the style tag\n   *\n   * @default auto-incremented\n   */\n  id?: string;\n  /**\n   * Nonce value for CSP (Content Security Policy)\n   *\n   * @default undefined\n   */\n  nonce?: string;\n}\ninterface UseStyleTagReturn {\n  id: string;\n  css: ShallowRef<string>;\n  load: () => void;\n  unload: () => void;\n  isLoaded: Readonly<ShallowRef<boolean>>;\n}\n/**\n * Inject <style> element in head.\n *\n * Overload: Omitted id\n *\n * @see https://vueuse.org/useStyleTag\n * @param css\n * @param options\n */\ndeclare function useStyleTag(css: MaybeRef<string>, options?: UseStyleTagOptions): UseStyleTagReturn;\n//#endregion\n//#region useSupported/index.d.ts\ntype UseSupportedReturn = ComputedRef<boolean>;\ndeclare function useSupported(callback: () => unknown): UseSupportedReturn;\n//#endregion\n//#region useTemplateRefsList/index.d.ts\ntype TemplateRefsList<T> = T[] & {\n  set: (el: object | null) => void;\n};\ndeclare function useTemplateRefsList<T = Element>(): Readonly<Ref<Readonly<TemplateRefsList<T>>>>;\n//#endregion\n//#region useTextDirection/index.d.ts\ntype UseTextDirectionValue = 'ltr' | 'rtl' | 'auto';\ninterface UseTextDirectionOptions extends ConfigurableDocument {\n  /**\n   * CSS Selector for the target element applying to\n   *\n   * @default 'html'\n   */\n  selector?: string;\n  /**\n   * Observe `document.querySelector(selector)` changes using MutationObserve\n   *\n   * @default false\n   */\n  observe?: boolean;\n  /**\n   * Initial value\n   *\n   * @default 'ltr'\n   */\n  initialValue?: UseTextDirectionValue;\n}\n/**\n * Reactive dir of the element's text.\n *\n * @see https://vueuse.org/useTextDirection\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useTextDirection(options?: UseTextDirectionOptions): vue0.WritableComputedRef<UseTextDirectionValue, UseTextDirectionValue>;\n//#endregion\n//#region useTextSelection/index.d.ts\ninterface UseTextSelectionOptions extends ConfigurableWindow {}\ninterface UseTextSelectionReturn {\n  text: ComputedRef<string>;\n  rects: ComputedRef<DOMRect[]>;\n  ranges: ComputedRef<Range[]>;\n  selection: ShallowRef<Selection | null>;\n}\n/**\n * Reactively track user text selection based on [`Window.getSelection`](https://developer.mozilla.org/en-US/docs/Web/API/Window/getSelection).\n *\n * @see https://vueuse.org/useTextSelection\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useTextSelection(options?: UseTextSelectionOptions): UseTextSelectionReturn;\n//#endregion\n//#region useTextareaAutosize/index.d.ts\ninterface UseTextareaAutosizeOptions extends ConfigurableWindow {\n  /** Textarea element to autosize. */\n  element?: MaybeRef<HTMLTextAreaElement | undefined | null>;\n  /** Textarea content. */\n  input?: MaybeRef<string>;\n  /** Watch sources that should trigger a textarea resize. */\n  watch?: WatchSource | MultiWatchSources;\n  /** Function called when the textarea size changes. */\n  onResize?: () => void;\n  /** Specify style target to apply the height based on textarea content. If not provided it will use textarea it self.  */\n  styleTarget?: MaybeRef<HTMLElement | undefined>;\n  /** Specify the style property that will be used to manipulate height. Can be `height | minHeight`. Default value is `height`. */\n  styleProp?: 'height' | 'minHeight';\n}\ninterface UseTextareaAutosizeReturn {\n  textarea: Ref<HTMLTextAreaElement | undefined | null>;\n  input: Ref<string>;\n  triggerResize: () => void;\n}\ndeclare function useTextareaAutosize(options?: UseTextareaAutosizeOptions): UseTextareaAutosizeReturn;\n//#endregion\n//#region useThrottledRefHistory/index.d.ts\ntype UseThrottledRefHistoryOptions<Raw, Serialized = Raw> = Omit<UseRefHistoryOptions<Raw, Serialized>, 'eventFilter'> & {\n  throttle?: MaybeRef<number>;\n  trailing?: boolean;\n};\ntype UseThrottledRefHistoryReturn<Raw, Serialized = Raw> = UseRefHistoryReturn<Raw, Serialized>;\n/**\n * Shorthand for [useRefHistory](https://vueuse.org/useRefHistory) with throttled filter.\n *\n * @see https://vueuse.org/useThrottledRefHistory\n * @param source\n * @param options\n */\ndeclare function useThrottledRefHistory<Raw, Serialized = Raw>(source: Ref<Raw>, options?: UseThrottledRefHistoryOptions<Raw, Serialized>): UseThrottledRefHistoryReturn<Raw, Serialized>;\n//#endregion\n//#region useTimeAgo/index.d.ts\ntype UseTimeAgoFormatter<T = number> = (value: T, isPast: boolean) => string;\ntype UseTimeAgoUnitNamesDefault = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';\ninterface UseTimeAgoMessagesBuiltIn {\n  justNow: string;\n  past: string | UseTimeAgoFormatter<string>;\n  future: string | UseTimeAgoFormatter<string>;\n  invalid: string;\n}\ntype UseTimeAgoMessages<UnitNames extends string = UseTimeAgoUnitNamesDefault> = UseTimeAgoMessagesBuiltIn & Record<UnitNames, string | UseTimeAgoFormatter<number>>;\ninterface FormatTimeAgoOptions<UnitNames extends string = UseTimeAgoUnitNamesDefault> {\n  /**\n   * Maximum unit (of diff in milliseconds) to display the full date instead of relative\n   *\n   * @default undefined\n   */\n  max?: UnitNames | number;\n  /**\n   * Formatter for full date\n   */\n  fullDateFormatter?: (date: Date) => string;\n  /**\n   * Messages for formatting the string\n   */\n  messages?: UseTimeAgoMessages<UnitNames>;\n  /**\n   * Minimum display time unit (default is minute)\n   *\n   * @default false\n   */\n  showSecond?: boolean;\n  /**\n   * Rounding method to apply.\n   *\n   * @default 'round'\n   */\n  rounding?: 'round' | 'ceil' | 'floor' | number;\n  /**\n   * Custom units\n   */\n  units?: UseTimeAgoUnit<UnitNames>[];\n}\ninterface UseTimeAgoOptions<Controls extends boolean, UnitNames extends string = UseTimeAgoUnitNamesDefault> extends FormatTimeAgoOptions<UnitNames>, ConfigurableScheduler {\n  /**\n   * Expose more controls\n   *\n   * @default false\n   */\n  controls?: Controls;\n  /**\n   * Intervals to update, set 0 to disable auto update\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default 30_000\n   */\n  updateInterval?: number;\n}\ninterface UseTimeAgoUnit<Unit extends string = UseTimeAgoUnitNamesDefault> {\n  max: number;\n  value: number;\n  name: Unit;\n}\ntype UseTimeAgoReturn<Controls extends boolean = false> = Controls extends true ? {\n  timeAgo: ComputedRef<string>;\n} & Pausable : ComputedRef<string>;\n/**\n * Reactive time ago formatter.\n *\n * @see https://vueuse.org/useTimeAgo\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useTimeAgo<UnitNames extends string = UseTimeAgoUnitNamesDefault>(time: MaybeRefOrGetter<Date | number | string>, options?: UseTimeAgoOptions<false, UnitNames>): UseTimeAgoReturn<false>;\ndeclare function useTimeAgo<UnitNames extends string = UseTimeAgoUnitNamesDefault>(time: MaybeRefOrGetter<Date | number | string>, options: UseTimeAgoOptions<true, UnitNames>): UseTimeAgoReturn<true>;\ndeclare function formatTimeAgo<UnitNames extends string = UseTimeAgoUnitNamesDefault>(from: Date, options?: FormatTimeAgoOptions<UnitNames>, now?: Date | number): string;\n//#endregion\n//#region useTimeAgoIntl/index.d.ts\ntype Locale = Intl.UnicodeBCP47LocaleIdentifier | Intl.Locale;\ninterface FormatTimeAgoIntlOptions {\n  /**\n   * The locale to format with\n   *\n   * @default undefined\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#locales\n   */\n  locale?: Locale;\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#options\n   */\n  relativeTimeFormatOptions?: Intl.RelativeTimeFormatOptions;\n  /**\n   * Whether to insert spaces between parts.\n   *\n   * Ignored if `joinParts` is provided.\n   *\n   * @default true\n   */\n  insertSpace?: boolean;\n  /**\n   * Custom function to join the parts returned by `Intl.RelativeTimeFormat.formatToParts`.\n   *\n   * If provided, it will be used instead of the default join logic.\n   */\n  joinParts?: (parts: Intl.RelativeTimeFormatPart[], locale?: Intl.UnicodeBCP47LocaleIdentifier | Intl.Locale) => string;\n  /**\n   * Custom units\n   */\n  units?: TimeAgoUnit[];\n}\ninterface UseTimeAgoIntlOptions<Controls extends boolean> extends FormatTimeAgoIntlOptions, ConfigurableScheduler {\n  /**\n   * Expose more controls and the raw `parts` result.\n   *\n   * @default false\n   */\n  controls?: Controls;\n  /**\n   * Update interval in milliseconds, set 0 to disable auto update\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default 30_000\n   */\n  updateInterval?: number;\n}\ntype UseTimeAgoReturn$1<Controls extends boolean = false> = Controls extends true ? {\n  timeAgoIntl: ComputedRef<string>;\n  parts: ComputedRef<Intl.RelativeTimeFormatPart[]>;\n} & Pausable : ComputedRef<string>;\ninterface TimeAgoUnit {\n  name: Intl.RelativeTimeFormatUnit;\n  ms: number;\n}\n/**\n * A reactive wrapper for `Intl.RelativeTimeFormat`.\n */\ndeclare function useTimeAgoIntl(time: MaybeRefOrGetter<Date | number | string>, options?: UseTimeAgoIntlOptions<false>): UseTimeAgoReturn$1<false>;\ndeclare function useTimeAgoIntl(time: MaybeRefOrGetter<Date | number | string>, options: UseTimeAgoIntlOptions<true>): UseTimeAgoReturn$1<true>;\n/**\n * Non-reactive version of useTimeAgoIntl\n */\ndeclare function formatTimeAgoIntl(from: Date, options?: FormatTimeAgoIntlOptions, now?: Date | number): string;\n/**\n * Format parts into a string\n */\ndeclare function formatTimeAgoIntlParts(parts: Intl.RelativeTimeFormatPart[], options?: FormatTimeAgoIntlOptions): string;\n//#endregion\n//#region useTimeoutPoll/index.d.ts\ninterface UseTimeoutPollOptions {\n  /**\n   * Start the timer immediately\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Execute the callback immediately after calling `resume`\n   *\n   * @default false\n   */\n  immediateCallback?: boolean;\n}\ndeclare function useTimeoutPoll(fn: () => Awaitable<void>, interval: MaybeRefOrGetter<number>, options?: UseTimeoutFnOptions): Pausable;\n//#endregion\n//#region useTimestamp/index.d.ts\ninterface UseTimestampOptions<Controls extends boolean> extends ConfigurableScheduler {\n  /**\n   * Expose more controls\n   *\n   * @default false\n   */\n  controls?: Controls;\n  /**\n   * Offset value adding to the value\n   *\n   * @default 0\n   */\n  offset?: number;\n  /**\n   * Update the timestamp immediately\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Update interval, or use requestAnimationFrame\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default requestAnimationFrame\n   */\n  interval?: 'requestAnimationFrame' | number;\n  /**\n   * Callback on each update\n   */\n  callback?: (timestamp: number) => void;\n}\ntype UseTimestampReturn<Controls extends boolean> = Controls extends true ? ({\n  timestamp: ShallowRef<number>;\n} & Pausable) : ShallowRef<number>;\n/**\n * Reactive current timestamp.\n *\n * @see https://vueuse.org/useTimestamp\n * @param options\n */\ndeclare function useTimestamp(options?: UseTimestampOptions<false>): ShallowRef<number>;\ndeclare function useTimestamp(options: UseTimestampOptions<true>): {\n  timestamp: ShallowRef<number>;\n} & Pausable;\n//#endregion\n//#region useTitle/index.d.ts\ntype UseTitleOptionsBase = {\n  /**\n   * Restore the original title when unmounted\n   * @param originTitle original title\n   * @returns restored title\n   */\n  restoreOnUnmount?: false | ((originalTitle: string, currentTitle: string) => string | null | undefined);\n} & ({\n  /**\n   * Observe `document.title` changes using MutationObserve\n   * Cannot be used together with `titleTemplate` option.\n   *\n   * @default false\n   */\n  observe?: boolean;\n} | {\n  /**\n   * The template string to parse the title (e.g., '%s | My Website')\n   * Cannot be used together with `observe` option.\n   *\n   * @default '%s'\n   */\n  titleTemplate?: MaybeRef<string> | ((title: string) => string);\n});\ntype UseTitleOptions = ConfigurableDocument & UseTitleOptionsBase;\ntype UseTitleReturn = ComputedRef<string | null | undefined> | Ref<string | null | undefined>;\n/**\n * Reactive document title.\n *\n * @see https://vueuse.org/useTitle\n * @param newTitle\n * @param options\n * @description It's not SSR compatible. Your value will be applied only on client-side.\n */\ndeclare function useTitle(newTitle: ReadonlyRefOrGetter<string | null | undefined>, options?: UseTitleOptions): ComputedRef<string | null | undefined>;\ndeclare function useTitle(newTitle?: MaybeRef<string | null | undefined>, options?: UseTitleOptions): Ref<string | null | undefined>;\n//#endregion\n//#region useTransition/index.d.ts\n/**\n * Cubic bezier points\n */\ntype CubicBezierPoints = [number, number, number, number];\n/**\n * Easing function\n */\ntype EasingFunction = (n: number) => number;\n/**\n * Interpolation function\n */\ntype InterpolationFunction<T> = (from: T, to: T, t: number) => T;\n/**\n * Transition options\n */\ninterface TransitionOptions<T> extends ConfigurableWindow {\n  /**\n   * Manually abort a transition\n   */\n  abort?: () => any;\n  /**\n   * Transition duration in milliseconds\n   */\n  duration?: MaybeRef<number>;\n  /**\n   * Easing function or cubic bezier points to calculate transition progress\n   */\n  easing?: MaybeRef<EasingFunction | CubicBezierPoints>;\n  /**\n   * Custom interpolation function\n   */\n  interpolation?: InterpolationFunction<T>;\n  /**\n   * Easing function or cubic bezier points to calculate transition progress\n   * @deprecated The `transition` option is deprecated, use `easing` instead.\n   */\n  transition?: MaybeRef<EasingFunction | CubicBezierPoints>;\n}\ninterface UseTransitionOptions<T> extends TransitionOptions<T> {\n  /**\n   * Milliseconds to wait before starting transition\n   */\n  delay?: MaybeRef<number>;\n  /**\n   * Disables the transition\n   */\n  disabled?: MaybeRef<boolean>;\n  /**\n   * Callback to execute after transition finishes\n   */\n  onFinished?: () => void;\n  /**\n   * Callback to execute after transition starts\n   */\n  onStarted?: () => void;\n}\ndeclare const _TransitionPresets: {\n  readonly easeInSine: readonly [0.12, 0, 0.39, 0];\n  readonly easeOutSine: readonly [0.61, 1, 0.88, 1];\n  readonly easeInOutSine: readonly [0.37, 0, 0.63, 1];\n  readonly easeInQuad: readonly [0.11, 0, 0.5, 0];\n  readonly easeOutQuad: readonly [0.5, 1, 0.89, 1];\n  readonly easeInOutQuad: readonly [0.45, 0, 0.55, 1];\n  readonly easeInCubic: readonly [0.32, 0, 0.67, 0];\n  readonly easeOutCubic: readonly [0.33, 1, 0.68, 1];\n  readonly easeInOutCubic: readonly [0.65, 0, 0.35, 1];\n  readonly easeInQuart: readonly [0.5, 0, 0.75, 0];\n  readonly easeOutQuart: readonly [0.25, 1, 0.5, 1];\n  readonly easeInOutQuart: readonly [0.76, 0, 0.24, 1];\n  readonly easeInQuint: readonly [0.64, 0, 0.78, 0];\n  readonly easeOutQuint: readonly [0.22, 1, 0.36, 1];\n  readonly easeInOutQuint: readonly [0.83, 0, 0.17, 1];\n  readonly easeInExpo: readonly [0.7, 0, 0.84, 0];\n  readonly easeOutExpo: readonly [0.16, 1, 0.3, 1];\n  readonly easeInOutExpo: readonly [0.87, 0, 0.13, 1];\n  readonly easeInCirc: readonly [0.55, 0, 1, 0.45];\n  readonly easeOutCirc: readonly [0, 0.55, 0.45, 1];\n  readonly easeInOutCirc: readonly [0.85, 0, 0.15, 1];\n  readonly easeInBack: readonly [0.36, 0, 0.66, -0.56];\n  readonly easeOutBack: readonly [0.34, 1.56, 0.64, 1];\n  readonly easeInOutBack: readonly [0.68, -0.6, 0.32, 1.6];\n};\n/**\n * Common transitions\n *\n * @see https://easings.net\n */\ndeclare const TransitionPresets: Record<keyof typeof _TransitionPresets, CubicBezierPoints> & {\n  linear: EasingFunction;\n};\n/**\n * Transition from one value to another.\n *\n * @param source\n * @param from\n * @param to\n * @param options\n */\ndeclare function transition<T>(source: Ref<T>, from: MaybeRefOrGetter<T>, to: MaybeRefOrGetter<T>, options?: TransitionOptions<T>): PromiseLike<void>;\n/**\n * Transition from one value to another.\n * @deprecated The `executeTransition` function is deprecated, use `transition` instead.\n *\n * @param source\n * @param from\n * @param to\n * @param options\n */\ndeclare function executeTransition<T>(source: Ref<T>, from: MaybeRefOrGetter<T>, to: MaybeRefOrGetter<T>, options?: TransitionOptions<T>): PromiseLike<void>;\ndeclare function useTransition<T extends MaybeRefOrGetter<number>[]>(source: [...T], options?: UseTransitionOptions<T>): ComputedRef<{ [K in keyof T]: number }>;\ndeclare function useTransition<T extends MaybeRefOrGetter<number[]>>(source: T, options?: UseTransitionOptions<T>): ComputedRef<number[]>;\ndeclare function useTransition<T>(source: MaybeRefOrGetter<T>, options?: UseTransitionOptions<T>): ComputedRef<T>;\n//#endregion\n//#region useUrlSearchParams/index.d.ts\ntype UrlParams = Record<string, string[] | string>;\ninterface UseUrlSearchParamsOptions<T> extends ConfigurableWindow {\n  /**\n   * @default true\n   */\n  removeNullishValues?: boolean;\n  /**\n   * @default false\n   */\n  removeFalsyValues?: boolean;\n  /**\n   * @default {}\n   */\n  initialValue?: T;\n  /**\n   * Write back to `window.history` automatically\n   *\n   * @default true\n   */\n  write?: boolean;\n  /**\n   * Write mode for `window.history` when `write` is enabled\n   * - `replace`: replace the current history entry\n   * - `push`: push a new history entry\n   * @default 'replace'\n   */\n  writeMode?: 'replace' | 'push';\n  /**\n   * Custom function to serialize URL parameters\n   * When provided, this function will be used instead of the default URLSearchParams.toString()\n   * @param params The URLSearchParams object to serialize\n   * @returns The serialized query string (should not include the leading '?' or '#')\n   */\n  stringify?: (params: URLSearchParams) => string;\n}\n/**\n * Reactive URLSearchParams\n *\n * @see https://vueuse.org/useUrlSearchParams\n * @param mode\n * @param options\n */\ndeclare function useUrlSearchParams<T extends Record<string, any> = UrlParams>(mode?: 'history' | 'hash' | 'hash-params', options?: UseUrlSearchParamsOptions<T>): T;\n//#endregion\n//#region useUserMedia/index.d.ts\ninterface UseUserMediaOptions extends ConfigurableNavigator {\n  /**\n   * If the stream is enabled\n   * @default false\n   */\n  enabled?: MaybeRef<boolean>;\n  /**\n   * Recreate stream when deviceIds or constraints changed\n   *\n   * @default true\n   */\n  autoSwitch?: MaybeRef<boolean>;\n  /**\n   * MediaStreamConstraints to be applied to the requested MediaStream\n   * If provided, the constraints will override videoDeviceId and audioDeviceId\n   *\n   * @default {}\n   */\n  constraints?: MaybeRef<MediaStreamConstraints>;\n}\ninterface UseUserMediaReturn extends Supportable {\n  stream: Ref<MediaStream | undefined>;\n  start: () => Promise<MediaStream | undefined>;\n  stop: () => void;\n  restart: () => Promise<MediaStream | undefined>;\n  constraints: Ref<MediaStreamConstraints | undefined>;\n  enabled: ShallowRef<boolean>;\n  autoSwitch: ShallowRef<boolean>;\n}\n/**\n * Reactive `mediaDevices.getUserMedia` streaming\n *\n * @see https://vueuse.org/useUserMedia\n * @param options\n */\ndeclare function useUserMedia(options?: UseUserMediaOptions): UseUserMediaReturn;\n//#endregion\n//#region useVModel/index.d.ts\ninterface UseVModelOptions<T, Passive extends boolean = false> {\n  /**\n   * When passive is set to `true`, it will use `watch` to sync with props and ref.\n   * Instead of relying on the `v-model` or `.sync` to work.\n   *\n   * @default false\n   */\n  passive?: Passive;\n  /**\n   * When eventName is set, it's value will be used to overwrite the emit event name.\n   *\n   * @default undefined\n   */\n  eventName?: string;\n  /**\n   * Attempting to check for changes of properties in a deeply nested object or array.\n   * Apply only when `passive` option is set to `true`\n   *\n   * @default false\n   */\n  deep?: boolean;\n  /**\n   * Defining default value for return ref when no value is passed.\n   *\n   * @default undefined\n   */\n  defaultValue?: T;\n  /**\n   * Clone the props.\n   * Accepts a custom clone function.\n   * When setting to `true`, it will use `JSON.parse(JSON.stringify(value))` to clone.\n   *\n   * @default false\n   */\n  clone?: boolean | CloneFn<T>;\n  /**\n   * The hook before triggering the emit event can be used for form validation.\n   * if false is returned, the emit event will not be triggered.\n   *\n   * @default undefined\n   */\n  shouldEmit?: (v: T) => boolean;\n}\n/**\n * Shorthand for v-model binding, props + emit -> ref\n *\n * @see https://vueuse.org/useVModel\n * @param props\n * @param key (default 'modelValue')\n * @param emit\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useVModel<P$1 extends object, K$1 extends keyof P$1, Name extends string>(props: P$1, key?: K$1, emit?: (name: Name, ...args: any[]) => void, options?: UseVModelOptions<P$1[K$1], false>): WritableComputedRef<P$1[K$1]>;\ndeclare function useVModel<P$1 extends object, K$1 extends keyof P$1, Name extends string>(props: P$1, key?: K$1, emit?: (name: Name, ...args: any[]) => void, options?: UseVModelOptions<P$1[K$1], true>): Ref<UnwrapRef<P$1[K$1]>>;\n//#endregion\n//#region useVModels/index.d.ts\n/**\n * Shorthand for props v-model binding. Think like `toRefs(props)` but changes will also emit out.\n *\n * @see https://vueuse.org/useVModels\n * @param props\n * @param emit\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useVModels<P$1 extends object, Name extends string>(props: P$1, emit?: (name: Name, ...args: any[]) => void, options?: UseVModelOptions<any, true>): ToRefs<P$1>;\ndeclare function useVModels<P$1 extends object, Name extends string>(props: P$1, emit?: (name: Name, ...args: any[]) => void, options?: UseVModelOptions<any, false>): ToRefs<P$1>;\n//#endregion\n//#region useVibrate/index.d.ts\ninterface UseVibrateOptions extends ConfigurableNavigator, ConfigurableScheduler {\n  /**\n   *\n   * Vibration Pattern\n   *\n   * An array of values describes alternating periods in which the\n   * device is vibrating and not vibrating. Each value in the array\n   * is converted to an integer, then interpreted alternately as\n   * the number of milliseconds the device should vibrate and the\n   * number of milliseconds it should not be vibrating\n   *\n   * @default []\n   *\n   */\n  pattern?: MaybeRefOrGetter<Arrayable<number>>;\n  /**\n   * Interval to run a persistent vibration, in ms\n   *\n   * Pass `0` to disable\n   *\n   * @deprecated Please use `scheduler` option instead\n   * @default 0\n   *\n   */\n  interval: number;\n}\ninterface UseVibrateReturn extends Supportable {\n  pattern: MaybeRefOrGetter<Arrayable<number>>;\n  intervalControls?: Pausable;\n  vibrate: (pattern?: Arrayable<number>) => void;\n  stop: () => void;\n}\n/**\n * Reactive vibrate\n *\n * @see https://vueuse.org/useVibrate\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Vibration_API\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useVibrate(options?: UseVibrateOptions): UseVibrateReturn;\n//#endregion\n//#region useVirtualList/index.d.ts\ntype UseVirtualListItemSize = number | ((index: number) => number);\ninterface UseHorizontalVirtualListOptions extends UseVirtualListOptionsBase {\n  /**\n   * item width, accept a pixel value or a function that returns the width\n   *\n   * @default 0\n   */\n  itemWidth: UseVirtualListItemSize;\n}\ninterface UseVerticalVirtualListOptions extends UseVirtualListOptionsBase {\n  /**\n   * item height, accept a pixel value or a function that returns the height\n   *\n   * @default 0\n   */\n  itemHeight: UseVirtualListItemSize;\n}\ninterface UseVirtualListOptionsBase {\n  /**\n   * the extra buffer items outside of the view area\n   *\n   * @default 5\n   */\n  overscan?: number;\n}\ntype UseVirtualListOptions = UseHorizontalVirtualListOptions | UseVerticalVirtualListOptions;\ninterface UseVirtualListItem<T> {\n  data: T;\n  index: number;\n}\ninterface UseVirtualListReturn<T> {\n  list: Ref<UseVirtualListItem<T>[]>;\n  scrollTo: (index: number) => void;\n  containerProps: {\n    ref: Ref<HTMLElement | null>;\n    onScroll: () => void;\n    style: StyleValue;\n  };\n  wrapperProps: ComputedRef<{\n    style: {\n      width: string;\n      height: string;\n      marginTop: string;\n    } | {\n      width: string;\n      height: string;\n      marginLeft: string;\n      display: string;\n    };\n  }>;\n}\n/**\n * Please consider using [`vue-virtual-scroller`](https://github.com/Akryum/vue-virtual-scroller) if you are looking for more features.\n */\ndeclare function useVirtualList<T = any>(list: MaybeRef<readonly T[]>, options: UseVirtualListOptions): UseVirtualListReturn<T>;\n//#endregion\n//#region useWakeLock/index.d.ts\ntype WakeLockType = 'screen';\ninterface WakeLockSentinel extends EventTarget {\n  type: WakeLockType;\n  released: boolean;\n  release: () => Promise<void>;\n}\ntype UseWakeLockOptions = ConfigurableNavigator & ConfigurableDocument;\ninterface UseWakeLockReturn extends Supportable {\n  sentinel: ShallowRef<WakeLockSentinel | null>;\n  isActive: ComputedRef<boolean>;\n  request: (type: WakeLockType) => Promise<void>;\n  forceRequest: (type: WakeLockType) => Promise<void>;\n  release: () => Promise<void>;\n}\n/**\n * Reactive Screen Wake Lock API.\n *\n * @see https://vueuse.org/useWakeLock\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useWakeLock(options?: UseWakeLockOptions): UseWakeLockReturn;\n//#endregion\n//#region useWebNotification/index.d.ts\ninterface WebNotificationOptions {\n  /**\n   * The title read-only property of the Notification interface indicates\n   * the title of the notification\n   *\n   * @default ''\n   */\n  title?: string;\n  /**\n   * The body string of the notification as specified in the constructor's\n   * options parameter.\n   *\n   * @default ''\n   */\n  body?: string;\n  /**\n   * The text direction of the notification as specified in the constructor's\n   * options parameter.\n   *\n   * @default ''\n   */\n  dir?: 'auto' | 'ltr' | 'rtl';\n  /**\n   * The language code of the notification as specified in the constructor's\n   * options parameter.\n   *\n   * @default DOMString\n   */\n  lang?: string;\n  /**\n   * The ID of the notification(if any) as specified in the constructor's options\n   * parameter.\n   *\n   * @default ''\n   */\n  tag?: string;\n  /**\n   * The URL of the image used as an icon of the notification as specified\n   * in the constructor's options parameter.\n   *\n   * @default ''\n   */\n  icon?: string;\n  /**\n   * Specifies whether the user should be notified after a new notification\n   * replaces an old one.\n   *\n   * @default false\n   */\n  renotify?: boolean;\n  /**\n   * A boolean value indicating that a notification should remain active until the\n   * user clicks or dismisses it, rather than closing automatically.\n   *\n   * @default false\n   */\n  requireInteraction?: boolean;\n  /**\n   * The silent read-only property of the Notification interface specifies\n   * whether the notification should be silent, i.e., no sounds or vibrations\n   * should be issued, regardless of the device settings.\n   *\n   * @default false\n   */\n  silent?: boolean;\n  /**\n   * Specifies a vibration pattern for devices with vibration hardware to emit.\n   * A vibration pattern, as specified in the Vibration API spec\n   *\n   * @see https://w3c.github.io/vibration/\n   */\n  vibrate?: number[];\n}\ninterface UseWebNotificationOptions extends ConfigurableWindow, WebNotificationOptions {\n  /**\n   * Request for permissions onMounted if it's not granted.\n   *\n   * Can be disabled and calling `ensurePermissions` to grant afterwords.\n   *\n   * @default true\n   */\n  requestPermissions?: boolean;\n}\ninterface UseWebNotificationReturn extends Supportable {\n  notification: Ref<Notification | null>;\n  ensurePermissions: () => Promise<boolean | undefined>;\n  permissionGranted: ShallowRef<boolean>;\n  show: (overrides?: WebNotificationOptions) => Promise<Notification | undefined>;\n  close: () => void;\n  onClick: EventHookOn<Event>;\n  onShow: EventHookOn<Event>;\n  onError: EventHookOn<Event>;\n  onClose: EventHookOn<Event>;\n}\n/**\n * Reactive useWebNotification\n *\n * @see https://vueuse.org/useWebNotification\n * @see https://developer.mozilla.org/en-US/docs/Web/API/notification\n */\ndeclare function useWebNotification(options?: UseWebNotificationOptions): UseWebNotificationReturn;\n//#endregion\n//#region useWebSocket/index.d.ts\ntype WebSocketStatus = 'OPEN' | 'CONNECTING' | 'CLOSED';\ntype WebSocketHeartbeatMessage = string | ArrayBuffer | Blob;\ninterface UseWebSocketOptions {\n  onConnected?: (ws: WebSocket) => void;\n  onDisconnected?: (ws: WebSocket, event: CloseEvent) => void;\n  onError?: (ws: WebSocket, event: Event) => void;\n  onMessage?: (ws: WebSocket, event: MessageEvent) => void;\n  /**\n   * Send heartbeat for every x milliseconds passed\n   *\n   * @default false\n   */\n  heartbeat?: boolean | ConfigurableScheduler & {\n    /**\n     * Message for the heartbeat\n     *\n     * @default 'ping'\n     */\n    message?: MaybeRefOrGetter<WebSocketHeartbeatMessage>;\n    /**\n     * Response message for the heartbeat, if undefined the message will be used\n     */\n    responseMessage?: MaybeRefOrGetter<WebSocketHeartbeatMessage>;\n    /**\n     * Interval, in milliseconds\n     *\n     * @deprecated Please use `scheduler` option instead\n     * @default 1000\n     */\n    interval?: number;\n    /**\n     * Heartbeat response timeout, in milliseconds\n     *\n     * @default 1000\n     */\n    pongTimeout?: number;\n  };\n  /**\n   * Enabled auto reconnect\n   *\n   * @default false\n   */\n  autoReconnect?: boolean | {\n    /**\n     * Maximum retry times.\n     *\n     * Or you can pass a predicate function (which returns true if you want to retry).\n     *\n     * @default -1\n     */\n    retries?: number | ((retried: number) => boolean);\n    /**\n     * Delay for reconnect, in milliseconds\n     *\n     * Or you can pass a function to calculate the delay based on the number of retries.\n     *\n     * @default 1000\n     */\n    delay?: number | ((retries: number) => number);\n    /**\n     * On maximum retry times reached.\n     */\n    onFailed?: Fn;\n  };\n  /**\n   * Immediately open the connection when calling this composable\n   *\n   * @default true\n   */\n  immediate?: boolean;\n  /**\n   * Automatically connect to the websocket when URL changes\n   *\n   * @default true\n   */\n  autoConnect?: boolean;\n  /**\n   * Automatically close a connection\n   *\n   * @default true\n   */\n  autoClose?: boolean;\n  /**\n   * List of one or more sub-protocol strings\n   *\n   * @default []\n   */\n  protocols?: string[];\n}\ninterface UseWebSocketReturn<T> {\n  /**\n   * Reference to the latest data received via the websocket,\n   * can be watched to respond to incoming messages\n   */\n  data: Ref<T | null>;\n  /**\n   * The current websocket status, can be only one of:\n   * 'OPEN', 'CONNECTING', 'CLOSED'\n   */\n  status: ShallowRef<WebSocketStatus>;\n  /**\n   * Closes the websocket connection gracefully.\n   */\n  close: WebSocket['close'];\n  /**\n   * Reopen the websocket connection.\n   * If there the current one is active, will close it before opening a new one.\n   */\n  open: Fn;\n  /**\n   * Sends data through the websocket connection.\n   *\n   * @param data\n   * @param useBuffer when the socket is not yet open, store the data into the buffer and sent them one connected. Default to true.\n   */\n  send: (data: string | ArrayBuffer | Blob, useBuffer?: boolean) => boolean;\n  /**\n   * Reference to the WebSocket instance.\n   */\n  ws: Ref<WebSocket | undefined>;\n}\n/**\n * Reactive WebSocket client.\n *\n * @see https://vueuse.org/useWebSocket\n * @param url\n */\ndeclare function useWebSocket<Data = any>(url: MaybeRefOrGetter<string | URL | undefined>, options?: UseWebSocketOptions): UseWebSocketReturn<Data>;\n//#endregion\n//#region useWebWorker/index.d.ts\ntype PostMessage = typeof Worker.prototype['postMessage'];\ninterface UseWebWorkerReturn<Data = any> {\n  data: Ref<Data>;\n  post: PostMessage;\n  terminate: () => void;\n  worker: ShallowRef<Worker | undefined>;\n}\ntype WorkerFn = (...args: unknown[]) => Worker;\n/**\n * Simple Web Workers registration and communication.\n *\n * @see https://vueuse.org/useWebWorker\n * @param url\n * @param workerOptions\n * @param options\n */\ndeclare function useWebWorker<T = any>(url: string, workerOptions?: WorkerOptions, options?: ConfigurableWindow): UseWebWorkerReturn<T>;\n/**\n * Simple Web Workers registration and communication.\n *\n * @see https://vueuse.org/useWebWorker\n */\ndeclare function useWebWorker<T = any>(worker: Worker | WorkerFn): UseWebWorkerReturn<T>;\n//#endregion\n//#region useWebWorkerFn/index.d.ts\ntype WebWorkerStatus = 'PENDING' | 'SUCCESS' | 'RUNNING' | 'ERROR' | 'TIMEOUT_EXPIRED';\ninterface UseWebWorkerOptions extends ConfigurableWindow {\n  /**\n   * Number of milliseconds before killing the worker\n   *\n   * @default undefined\n   */\n  timeout?: number;\n  /**\n   * An array that contains the external dependencies needed to run the worker\n   */\n  dependencies?: string[];\n  /**\n   * An array that contains the local dependencies needed to run the worker\n   */\n  localDependencies?: Function[];\n}\ninterface UseWebWorkerFnReturn<T extends (...fnArgs: any[]) => any> {\n  workerFn: (...fnArgs: Parameters<T>) => Promise<ReturnType<T>>;\n  workerStatus: ShallowRef<WebWorkerStatus>;\n  workerTerminate: (status?: WebWorkerStatus) => void;\n}\n/**\n * Run expensive function without blocking the UI, using a simple syntax that makes use of Promise.\n *\n * @see https://vueuse.org/useWebWorkerFn\n * @param fn\n * @param options\n */\ndeclare function useWebWorkerFn<T extends (...fnArgs: any[]) => any>(fn: T, options?: UseWebWorkerOptions): UseWebWorkerFnReturn<T>;\n//#endregion\n//#region useWindowFocus/index.d.ts\n/**\n * Reactively track window focus with `window.onfocus` and `window.onblur`.\n *\n * @see https://vueuse.org/useWindowFocus\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useWindowFocus(options?: ConfigurableWindow): ShallowRef<boolean>;\n//#endregion\n//#region useWindowScroll/index.d.ts\ninterface UseWindowScrollOptions extends ConfigurableWindow, UseScrollOptions {}\ninterface UseWindowScrollReturn extends UseScrollReturn {}\n/**\n * Reactive window scroll.\n *\n * @see https://vueuse.org/useWindowScroll\n * @param options\n */\ndeclare function useWindowScroll(options?: UseWindowScrollOptions): UseWindowScrollReturn;\n//#endregion\n//#region useWindowSize/index.d.ts\ninterface UseWindowSizeOptions extends ConfigurableWindow {\n  initialWidth?: number;\n  initialHeight?: number;\n  /**\n   * Listen to window `orientationchange` event\n   *\n   * @default true\n   */\n  listenOrientation?: boolean;\n  /**\n   * Whether the scrollbar should be included in the width and height\n   * Only effective when `type` is `'inner'`\n   *\n   * @default true\n   */\n  includeScrollbar?: boolean;\n  /**\n   * Use `window.innerWidth` or `window.outerWidth` or `window.visualViewport`\n   * visualViewport documentation from MDN(https://developer.mozilla.org/zh-CN/docs/Web/API/VisualViewport)\n   * @default 'inner'\n   */\n  type?: 'inner' | 'outer' | 'visual';\n}\ninterface UseWindowSizeReturn {\n  width: ShallowRef<number>;\n  height: ShallowRef<number>;\n}\n/**\n * Reactive window size.\n *\n * @see https://vueuse.org/useWindowSize\n * @param options\n *\n * @__NO_SIDE_EFFECTS__\n */\ndeclare function useWindowSize(options?: UseWindowSizeOptions): UseWindowSizeReturn;\n//#endregion\nexport { AfterFetchContext, AsyncComputedOnCancel, AsyncComputedOptions, BasicColorMode, BasicColorSchema, BatteryManager, BeforeFetchContext, Breakpoints, BrowserLocationState, CloneFn, ColorSchemeType, ComputedInjectGetter, ComputedInjectGetterWithDefault, ComputedInjectSetter, ConfigurableDeepRefs, ConfigurableDocument, ConfigurableDocumentOrShadowRoot, ConfigurableLocation, ConfigurableNavigator, ConfigurableScheduler, ConfigurableWindow, ContrastType, CreateFetchOptions, CreateReusableTemplateOptions, CubicBezierPoints, DefaultMagicKeysAliasMap, DefineTemplateComponent, DeviceMotionOptions, DocumentEventName, EasingFunction, ElementSize, EventBusEvents, EventBusIdentifier, EventBusKey, EventBusListener, EventSourceStatus, EyeDropper, EyeDropperOpenOptions, FileSystemAccessShowOpenFileOptions, FileSystemAccessShowSaveFileOptions, FileSystemAccessWindow, FileSystemFileHandle, FormatTimeAgoIntlOptions, FormatTimeAgoOptions, GeneralEventListener, GeneralPermissionDescriptor, InterpolationFunction, KeyFilter, KeyModifier, KeyPredicate, KeyStrokeEventName, MagicKeysInternal, MaybeComputedElementRef, MaybeElement, MaybeElementRef, MemoryInfo, MouseInElementOptions, MousePressedOptions, NavigatorLanguageState, NetworkEffectiveType, NetworkState, NetworkType, OnClickOutsideHandler, OnClickOutsideOptions, OnClickOutsideReturn, OnElementRemovalOptions, OnFetchErrorContext, OnKeyStrokeOptions, OnLongPressModifiers, OnLongPressOptions, OnLongPressReturn, OrientationLockType, OrientationType, PointerType, Position, ReducedMotionType, ReducedTransparencyType, RenderableComponent, ResizeObserverCallback, ResizeObserverEntry, ResizeObserverSize, ReusableTemplatePair, ReuseTemplateComponent, SSRHandlersMap, ScreenOrientation, Serializer, SerializerAsync, ShadowRootEventName, StorageEventLike, StorageLike, StorageLikeAsync, StorageSerializers, Supportable, TemplatePromise, TemplatePromiseOptions, TemplatePromiseProps, TemplateRefsList, TimeAgoUnit, ToDataURLOptions, TransitionOptions, TransitionPresets, UnRefElementReturn, UnrefFn, UrlParams, UseActiveElementOptions, UseActiveElementReturn, UseAnimateKeyframes, UseAnimateOptions, UseAnimateReturn, UseAsyncQueueOptions, UseAsyncQueueResult, UseAsyncQueueReturn, UseAsyncQueueTask, UseAsyncStateOptions, UseAsyncStateReturn, UseAsyncStateReturnBase, UseBase64ObjectOptions, UseBase64Options, UseBase64Return, UseBatteryOptions, UseBatteryReturn, UseBluetoothOptions, UseBluetoothRequestDeviceOptions, UseBluetoothReturn, UseBreakpointReturn, UseBreakpointsOptions, UseBroadcastChannelOptions, UseBroadcastChannelReturn, UseBrowserLocationOptions, UseBrowserLocationReturn, UseCachedOptions, UseCachedReturn, UseClipboardItemsOptions, UseClipboardItemsReturn, UseClipboardOptions, UseClipboardReturn, UseClonedOptions, UseClonedReturn, UseColorModeOptions, UseColorModeReturn, UseConfirmDialogReturn, UseConfirmDialogRevealResult, UseCountdownOptions, UseCountdownReturn, UseCssSupportsOptions, UseCssSupportsReturn, UseCssVarOptions, UseCycleListOptions, UseCycleListReturn, UseDarkOptions, UseDarkReturn, UseDeviceMotionOptions, UseDeviceMotionReturn, UseDeviceOrientationOptions, UseDeviceOrientationReturn, UseDevicePixelRatioOptions, UseDevicePixelRatioReturn, UseDevicesListOptions, UseDevicesListReturn, UseDisplayMediaOptions, UseDisplayMediaReturn, UseDocumentVisibilityOptions, UseDocumentVisibilityReturn, UseDraggableOptions, UseDraggableReturn, UseDropZoneOptions, UseDropZoneReturn, UseElementBoundingOptions, UseElementBoundingReturn, UseElementByPointOptions, UseElementByPointReturn, UseElementHoverOptions, UseElementSizeOptions, UseElementSizeReturn, UseElementVisibilityOptions, UseElementVisibilityReturn, UseEventBusReturn, UseEventSourceOptions, UseEventSourceReturn, UseEyeDropperOptions, UseEyeDropperReturn, UseFaviconOptions, UseFaviconReturn, UseFetchOptions, UseFetchReturn, UseFileDialogOptions, UseFileDialogReturn, UseFileSystemAccessCommonOptions, UseFileSystemAccessOptions, UseFileSystemAccessReturn, UseFileSystemAccessShowSaveFileOptions, UseFocusOptions, UseFocusReturn, UseFocusWithinReturn, UseFpsOptions, UseFullscreenOptions, UseFullscreenReturn, UseGamepadOptions, UseGamepadReturn, UseGeolocationOptions, UseGeolocationReturn, UseHorizontalVirtualListOptions, UseIdleOptions, UseIdleReturn, UseImageOptions, UseImageReturn, UseInfiniteScrollOptions, UseInfiniteScrollReturn, UseIntersectionObserverOptions, UseIntersectionObserverReturn, UseKeyModifierReturn, UseMagicKeysOptions, UseMagicKeysReturn, UseManualRefHistoryOptions, UseManualRefHistoryReturn, UseMediaControlsReturn, UseMediaSource, UseMediaTextTrack, UseMediaTextTrackSource, UseMemoizeCache, UseMemoizeOptions, UseMemoizeReturn, UseMemoryOptions, UseMemoryReturn, UseModifierOptions, UseMouseCoordType, UseMouseEventExtractor, UseMouseInElementReturn, UseMouseOptions, UseMousePressedOptions, UseMousePressedReturn, UseMouseReturn, UseMouseSourceType, UseMutationObserverOptions, UseMutationObserverReturn, UseNavigatorLanguageOptions, UseNavigatorLanguageReturn, UseNetworkOptions, UseNetworkReturn, UseNowOptions, UseNowReturn, UseOffsetPaginationInfinityPageReturn, UseOffsetPaginationOptions, UseOffsetPaginationReturn, UseOnLongPressReturn, UsePageLeaveOptions, UsePageLeaveReturn, UseParallaxOptions, UseParallaxReturn, UsePerformanceObserverOptions, UsePermissionOptions, UsePermissionReturn, UsePermissionReturnWithControls, UsePointerLockOptions, UsePointerLockReturn, UsePointerOptions, UsePointerReturn, UsePointerState, UsePointerSwipeOptions, UsePointerSwipeReturn, UseRafFnCallbackArguments, UseRafFnOptions, UseRefHistoryOptions, UseRefHistoryRecord, UseRefHistoryReturn, UseResizeObserverOptions, UseResizeObserverReturn, UseScreenOrientationOptions, UseScreenOrientationReturn, UseScreenSafeAreaReturn, UseScriptTagOptions, UseScriptTagReturn, UseScrollOptions, UseScrollReturn, UseShareOptions, UseShareReturn, UseSortedCompareFn, UseSortedFn, UseSortedOptions, UseSpeechRecognitionOptions, UseSpeechRecognitionReturn, UseSpeechSynthesisOptions, UseSpeechSynthesisReturn, UseSpeechSynthesisStatus, UseStepperReturn, UseStorageAsyncOptions, UseStorageOptions, UseStyleTagOptions, UseStyleTagReturn, UseSupportedReturn, UseSwipeDirection, UseSwipeOptions, UseSwipeReturn, UseTextDirectionOptions, UseTextDirectionValue, UseTextSelectionOptions, UseTextSelectionReturn, UseTextareaAutosizeOptions, UseTextareaAutosizeReturn, UseThrottledRefHistoryOptions, UseThrottledRefHistoryReturn, UseTimeAgoFormatter, UseTimeAgoIntlOptions, UseTimeAgoMessages, UseTimeAgoMessagesBuiltIn, UseTimeAgoOptions, UseTimeAgoReturn, UseTimeAgoUnit, UseTimeAgoUnitNamesDefault, UseTimeoutPollOptions, UseTimestampOptions, UseTimestampReturn, UseTitleOptions, UseTitleOptionsBase, UseTitleReturn, UseTransitionOptions, UseUrlSearchParamsOptions, UseUserMediaOptions, UseUserMediaReturn, UseVModelOptions, UseVerticalVirtualListOptions, UseVibrateOptions, UseVibrateReturn, UseVirtualListItem, UseVirtualListOptions, UseVirtualListOptionsBase, UseVirtualListReturn, UseWakeLockOptions, UseWakeLockReturn, UseWebNotificationOptions, UseWebNotificationReturn, UseWebSocketOptions, UseWebSocketReturn, UseWebWorkerFnReturn, UseWebWorkerOptions, UseWebWorkerReturn, UseWindowScrollOptions, UseWindowScrollReturn, UseWindowSizeOptions, UseWindowSizeReturn, VueInstance, WakeLockSentinel, WebNotificationOptions, WebSocketHeartbeatMessage, WebSocketStatus, WebWorkerStatus, WindowEventName, WritableComputedInjectOptions, WritableComputedInjectOptionsWithDefault, asyncComputed, breakpointsAntDesign, breakpointsBootstrapV5, breakpointsElement, breakpointsMasterCss, breakpointsPrimeFlex, breakpointsQuasar, breakpointsSematic, breakpointsTailwind, breakpointsVuetify, breakpointsVuetifyV2, breakpointsVuetifyV3, cloneFnJSON, computedAsync, computedInject, createFetch, createReusableTemplate, createTemplatePromise, createUnrefFn, customStorageEventName, defaultDocument, defaultLocation, defaultNavigator, defaultWindow, executeTransition, formatTimeAgo, formatTimeAgoIntl, formatTimeAgoIntlParts, getSSRHandler, mapGamepadToXbox360Controller, onClickOutside, onElementRemoval, onKeyDown, onKeyPressed, onKeyStroke, onKeyUp, onLongPress, onStartTyping, provideSSRWidth, setSSRHandler, templateRef, transition, unrefElement, useActiveElement, useAnimate, useAsyncQueue, useAsyncState, useBase64, useBattery, useBluetooth, useBreakpoints, useBroadcastChannel, useBrowserLocation, useCached, useClipboard, useClipboardItems, useCloned, useColorMode, useConfirmDialog, useCountdown, useCssSupports, useCssVar, useCurrentElement, useCycleList, useDark, useDebouncedRefHistory, useDeviceMotion, useDeviceOrientation, useDevicePixelRatio, useDevicesList, useDisplayMedia, useDocumentVisibility, useDraggable, useDropZone, useElementBounding, useElementByPoint, useElementHover, useElementSize, useElementVisibility, useEventBus, useEventListener, useEventSource, useEyeDropper, useFavicon, useFetch, useFileDialog, useFileSystemAccess, useFocus, useFocusWithin, useFps, useFullscreen, useGamepad, useGeolocation, useIdle, useImage, useInfiniteScroll, useIntersectionObserver, useKeyModifier, useLocalStorage, useMagicKeys, useManualRefHistory, useMediaControls, useMediaQuery, useMemoize, useMemory, useMounted, useMouse, useMouseInElement, useMousePressed, useMutationObserver, useNavigatorLanguage, useNetwork, useNow, useObjectUrl, useOffsetPagination, useOnline, usePageLeave, useParallax, useParentElement, usePerformanceObserver, usePermission, usePointer, usePointerLock, usePointerSwipe, usePreferredColorScheme, usePreferredContrast, usePreferredDark, usePreferredLanguages, usePreferredReducedMotion, usePreferredReducedTransparency, usePrevious, useRafFn, useRefHistory, useResizeObserver, useSSRWidth, useScreenOrientation, useScreenSafeArea, useScriptTag, useScroll, useScrollLock, useSessionStorage, useShare, useSorted, useSpeechRecognition, useSpeechSynthesis, useStepper, useStorage, useStorageAsync, useStyleTag, useSupported, useSwipe, useTemplateRefsList, useTextDirection, useTextSelection, useTextareaAutosize, useThrottledRefHistory, useTimeAgo, useTimeAgoIntl, useTimeoutPoll, useTimestamp, useTitle, useTransition, useUrlSearchParams, useUserMedia, useVModel, useVModels, useVibrate, useVirtualList, useWakeLock, useWebNotification, useWebSocket, useWebWorker, useWebWorkerFn, useWindowFocus, useWindowScroll, useWindowSize };","export declare function useBreakpoints(): import(\"@vueuse/core\").UseBreakpointReturn<\"sm\" | \"md\" | \"lg\" | \"xl\" | \"2xl\">;\n","import type { MaybeRef } from 'vue';\nexport interface RGB {\n    r: number;\n    g: number;\n    b: number;\n}\nexport interface RGBA extends RGB {\n    a: number;\n}\nexport interface HSL {\n    h: number;\n    s: number;\n    l: number;\n}\nexport interface OKLCH {\n    l: number;\n    c: number;\n    h: number;\n}\nexport declare function extracRGB(color: string): RGB;\nexport declare function extractRGBA(color: string): RGBA;\nexport declare function hexToRGB(hex: string): RGB;\nexport declare function hslToRgb(hsl: string): RGB;\nexport declare function rgbToHsl(r: number, g: number, b: number): HSL;\nexport declare function rgbToHex(r: number, g: number, b: number): string;\nexport declare function rgbaToString(rgba: RGBA): string;\nexport declare function extractOKLCH(color: string): OKLCH;\nexport declare function oklchToRgb(color: string): RGB;\nexport declare function rgbToOklch(r: number, g: number, b: number): OKLCH;\nexport declare function useColorType(payload?: MaybeRef<string | null | undefined>): import(\"vue\").WritableComputedRef<string | null, string | null>;\nexport declare function useRGB(payload?: MaybeRef<string | null | undefined>): import(\"vue\").WritableComputedRef<RGB | null, RGB | null>;\nexport declare function useRGBA(payload?: MaybeRef<string | null | undefined>): import(\"vue\").WritableComputedRef<RGBA | null, RGBA | null>;\nexport declare function useHSL(payload?: MaybeRef<string | null | undefined>): import(\"vue\").WritableComputedRef<HSL | null, HSL | null>;\nexport declare function useHex(payload?: MaybeRef<string | null | undefined>): import(\"vue\").WritableComputedRef<string | null, string | null>;\nexport declare function useColor(payload?: MaybeRef<string | null | undefined>): {\n    type: import(\"vue\").WritableComputedRef<string | null, string | null>;\n    color: import(\"vue\").Ref<string | null | undefined, string | null | undefined>;\n    hex: import(\"vue\").WritableComputedRef<string | null, string | null>;\n    rgb: import(\"vue\").WritableComputedRef<RGB | null, RGB | null>;\n    hsl: import(\"vue\").WritableComputedRef<HSL | null, HSL | null>;\n    oklch: import(\"vue\").WritableComputedRef<OKLCH | null, OKLCH | null>;\n    rgba: import(\"vue\").WritableComputedRef<RGBA | null, RGBA | null>;\n};\n","import LoggerService from './LoggerService.ts';\nexport interface EmmitterListenerOptions {\n    event: string;\n}\nexport interface EmmitterListener {\n    (data: any, options: EmmitterListenerOptions): void;\n}\ninterface EmmitterHandler {\n    id: string;\n    event: string;\n    listener: EmmitterListener;\n    originalListener?: EmmitterListener;\n}\ninterface OnOptions {\n    id?: string;\n    unique?: boolean;\n}\ninterface OnDebounceOptions extends OnOptions {\n    debounce?: number;\n}\nexport interface EmmitterServiceOptions {\n    debug?: boolean;\n    logger?: LoggerService;\n}\nexport default class EmmitterService<Events extends Record<string, any> = Record<string, any>> {\n    static __container_entry_key: string;\n    handlers: EmmitterHandler[];\n    debug: boolean;\n    logger: LoggerService;\n    constructor(options?: EmmitterServiceOptions);\n    static create<Events extends Record<string, any> = Record<string, any>>(options?: EmmitterServiceOptions): EmmitterService<Events>;\n    setDebug(debug: boolean): void;\n    setLogger(logger: LoggerService): void;\n    on<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler;\n    on(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler;\n    once<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler;\n    once(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler;\n    onDebounce<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnDebounceOptions): EmmitterHandler;\n    onDebounce(event: string, listener: (args: any) => void, options?: OnDebounceOptions): EmmitterHandler;\n    onAnyOf<K extends keyof Events>(events: K[], listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler[];\n    onAnyOf(events: string[], listener: (args: any) => void, options?: OnOptions): EmmitterHandler[];\n    off(event: string, listener: EmmitterHandler['listener']): void;\n    emit<K extends keyof Events>(event: K, args: Events[K]): void;\n    emit(event: string, args?: any): void;\n    emitAndWait<K extends keyof Events>(event: K, args: Events[K]): Promise<void>;\n    emitAndWait(event: string, args?: any): Promise<void>;\n    list(): EmmitterHandler[];\n    listByEvent(event: string): EmmitterHandler[];\n    remove(payload: string | string[]): void;\n    clear(): void;\n    hasHandlers(): boolean;\n}\nexport {};\n","export interface DashboardGridUnit {\n    base?: number;\n    sm?: number;\n    md?: number;\n    lg?: number;\n    xl?: number;\n}\nexport default class DashboardWidgetData {\n    id: string;\n    name: string;\n    definition_id: string;\n    columns: DashboardGridUnit;\n    rows: DashboardGridUnit;\n    x: DashboardGridUnit;\n    y: DashboardGridUnit;\n    order: number;\n    options: Record<string, any>;\n    constructor(data: Partial<DashboardWidgetData>);\n}\n","export interface DashboardWidgetAction {\n    props?: Record<string, any>;\n    component: any;\n}\nexport default class DashboardWidgetDefinition {\n    id: string;\n    name: string;\n    description?: string;\n    icon?: string;\n    constructor();\n    component(): any;\n    actions(): DashboardWidgetAction[];\n}\n","import EmmitterService from '#shared/services/EmmitterService.ts';\nimport type DashboardWidgetData from './DashboardWidgetData';\nimport DashboardWidgetDefinition from './DashboardWidgetDefinition';\nexport declare const DASHBOARD_ROW_HEIGHT = 80;\ninterface DashboardWidgetOptions {\n    data: DashboardWidgetData;\n    definition: DashboardWidgetDefinition;\n}\ninterface StylesOptions {\n    contianerWidth: number;\n    breakpoint?: 'base' | 'sm' | 'md' | 'xl';\n}\nexport default class DashboardWidget {\n    data: DashboardWidgetData;\n    definition: DashboardWidgetDefinition;\n    emmitter: EmmitterService;\n    constructor({ data, definition }: DashboardWidgetOptions);\n    static fromData(data: DashboardWidgetData): DashboardWidget;\n    setEmmitter(emmitter: EmmitterService): void;\n    get id(): string;\n    get name(): string;\n    set name(value: string);\n    get options(): DashboardWidgetData['options'];\n    get definition_id(): string;\n    component(): any;\n    actions(): import(\"./DashboardWidgetDefinition\").DashboardWidgetAction[];\n    get columns(): DashboardWidgetData['columns'];\n    set columns(payload: DashboardWidgetData['columns']);\n    get rows(): DashboardWidgetData['rows'];\n    set rows(payload: DashboardWidgetData['rows']);\n    get x(): DashboardWidgetData['x'];\n    set x(payload: DashboardWidgetData['x']);\n    get y(): DashboardWidgetData['y'];\n    set y(payload: DashboardWidgetData['y']);\n    get classes(): string;\n    computeStyles(options: StylesOptions): string;\n    update(payload: Partial<DashboardWidgetData>): void;\n    setOption(key: string, value: any): void;\n    setX(breakpoint: 'base' | 'sm' | 'md' | 'lg' | 'xl', value?: number | undefined): void;\n    setY(breakpoint: 'base' | 'sm' | 'md' | 'lg' | 'xl', value?: number | undefined): void;\n    setColumn(breakpoint: 'base' | 'sm' | 'md' | 'lg' | 'xl', value?: number | undefined): void;\n    setRow(breakpoint: 'base' | 'sm' | 'md' | 'lg' | 'xl', value?: number | undefined): void;\n}\nexport {};\n","import * as v from 'valibot';\nexport declare const number: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>;\nexport declare const boolean: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>], undefined>, v.TransformAction<string | boolean, boolean>]>;\nexport declare const date: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, Date>, v.TransformAction<Date, string>]>;\nexport declare const datetime: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, string | null>]>;\nexport declare const array: <T extends v.BaseSchema<any, any, any>>(schema?: T) => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<T, undefined>]>;\nexport declare const arrayNumber: () => v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.BaseSchema<any, any, any>, undefined>]>, v.TransformAction<any[], number[]>]>;\nexport declare const object: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>], undefined>, v.TransformAction<string | {\n    [x: string]: any;\n}, {\n    [x: string]: any;\n}>, v.TransformAction<{\n    [x: string]: any;\n}, Record<string, any>>]>;\nexport declare function url(): v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>], undefined>, v.TransformAction<string | {\n    [x: string]: any;\n}, {\n    [x: string]: any;\n}>, v.TransformAction<{\n    [x: string]: any;\n}, Record<string, any>>]>;\nexport declare namespace url {\n    var number: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>;\n    var boolean: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>], undefined>, v.TransformAction<string | boolean, boolean>]>;\n    var date: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, Date>, v.TransformAction<Date, string>]>;\n    var datetime: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, string | null>]>;\n    var array: <T extends v.BaseSchema<any, any, any>>(schema?: T) => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<T, undefined>]>;\n    var arrayNumber: () => v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.BaseSchema<any, any, any>, undefined>]>, v.TransformAction<any[], number[]>]>;\n    var object: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>], undefined>, v.TransformAction<string | {\n        [x: string]: any;\n    }, {\n        [x: string]: any;\n    }>, v.TransformAction<{\n        [x: string]: any;\n    }, Record<string, any>>]>;\n}\n","import * as v from 'valibot';\nexport declare const keyValue: () => v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TransformAction<string, Record<string, any>>]>;\n","import * as v from 'valibot';\nexport interface PaginationParams {\n    maxLimit?: number;\n    orderFields?: string[];\n}\nexport declare const base: (options?: PaginationParams) => v.ObjectSchema<{\n    readonly page: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, 1>;\n    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, number>;\n    readonly orderBy: v.NullishSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.PicklistSchema<string[], undefined>, undefined>]> | v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.StringSchema<undefined>, undefined>]>, readonly []>;\n    readonly orderDirection: v.NullishSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.UnionSchema<[v.LiteralSchema<\"asc\", undefined>, v.LiteralSchema<\"desc\", undefined>], undefined>, undefined>]>, readonly []>;\n}, undefined>;\nexport declare function pagination(options?: PaginationParams): v.ObjectSchema<{\n    readonly page: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, 1>;\n    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, number>;\n    readonly orderBy: v.NullishSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.PicklistSchema<string[], undefined>, undefined>]> | v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.StringSchema<undefined>, undefined>]>, readonly []>;\n    readonly orderDirection: v.NullishSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.UnionSchema<[v.LiteralSchema<\"asc\", undefined>, v.LiteralSchema<\"desc\", undefined>], undefined>, undefined>]>, readonly []>;\n}, undefined>;\nexport declare namespace pagination {\n    var base: (options?: PaginationParams) => v.ObjectSchema<{\n        readonly page: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, 1>;\n        readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>, number>;\n        readonly orderBy: v.NullishSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.PicklistSchema<string[], undefined>, undefined>]> | v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.StringSchema<undefined>, undefined>]>, readonly []>;\n        readonly orderDirection: v.NullishSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.UnionSchema<[v.LiteralSchema<\"asc\", undefined>, v.LiteralSchema<\"desc\", undefined>], undefined>, undefined>]>, readonly []>;\n    }, undefined>;\n}\n","export * from './urlValidator.ts';\nexport * from './keyValueValidator.ts';\nexport * from './paginationValidator.ts';\n","import * as v from 'valibot';\nimport * as extras from '#shared/validators/index.ts';\nexport type Valibot = typeof v & {\n    extras: typeof extras;\n};\nexport type ValibotSchema = v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>;\nexport type ValibotObjectSchema = v.ObjectSchema<any, any>;\nexport type ValibotSchemaAsync = v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>;\nexport interface ValidatorCallback<T extends ValibotSchema> {\n    (_v: Valibot): T;\n}\nexport type ValidatorCallbackAsync<T extends ValibotSchemaAsync> = {\n    (_v: Valibot): T;\n};\nexport type ValidatorResult<T extends v.BaseSchema<any, any, any>> = v.InferOutput<T>;\nexport type ValidatePayload<T extends ValibotSchema = ValibotSchema> = ValidatorCallback<T> | T;\nexport type ValidateResult<T extends ValidatePayload> = T extends ValibotSchema ? v.InferOutput<T> : T extends ValidatorCallback<infer U> ? v.InferOutput<U> : unknown;\nexport default class ValidatorService {\n    static __container_entry_key: string;\n    v: Valibot;\n    create<T extends ValibotSchema>(cb: ValidatorCallback<T>): T;\n    validate<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): v.InferOutput<T>;\n    validateAsync<T extends ValibotSchemaAsync>(payload: any, cb: ValidatorCallbackAsync<T> | T): Promise<v.InferOutput<T>>;\n    isValid<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): boolean;\n}\n","import type { ValidatorResult } from '#shared/services/ValidatorService.ts';\nexport type DashboardSchema = ValidatorResult<ReturnType<typeof dashboardSchema>>;\nexport declare function dashboardSchema(): import(\"valibot\").ObjectSchema<{\n    readonly id: import(\"valibot\").NumberSchema<undefined>;\n    readonly name: import(\"valibot\").StringSchema<undefined>;\n    readonly description: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n    readonly created_at: import(\"valibot\").StringSchema<undefined>;\n    readonly updated_at: import(\"valibot\").StringSchema<undefined>;\n    readonly deleted_at: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n    readonly metas: import(\"valibot\").OptionalSchema<import(\"valibot\").RecordSchema<import(\"valibot\").StringSchema<undefined>, import(\"valibot\").AnySchema, undefined>, undefined>;\n}, undefined>;\nexport declare namespace dashboardSchema {\n    var create: Omit<import(\"valibot\").ObjectSchema<{\n        readonly id: import(\"valibot\").NumberSchema<undefined>;\n        readonly name: import(\"valibot\").StringSchema<undefined>;\n        readonly description: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n        readonly created_at: import(\"valibot\").StringSchema<undefined>;\n        readonly updated_at: import(\"valibot\").StringSchema<undefined>;\n        readonly deleted_at: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n        readonly metas: import(\"valibot\").OptionalSchema<import(\"valibot\").RecordSchema<import(\"valibot\").StringSchema<undefined>, import(\"valibot\").AnySchema, undefined>, undefined>;\n    }, undefined>, \"entries\" | \"~types\" | \"~run\" | \"~standard\"> & {\n        readonly entries: Pick<{\n            readonly id: import(\"valibot\").NumberSchema<undefined>;\n            readonly name: import(\"valibot\").StringSchema<undefined>;\n            readonly description: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n            readonly created_at: import(\"valibot\").StringSchema<undefined>;\n            readonly updated_at: import(\"valibot\").StringSchema<undefined>;\n            readonly deleted_at: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n            readonly metas: import(\"valibot\").OptionalSchema<import(\"valibot\").RecordSchema<import(\"valibot\").StringSchema<undefined>, import(\"valibot\").AnySchema, undefined>, undefined>;\n        }, \"description\" | \"name\">;\n        readonly \"~standard\": import(\"valibot\").StandardProps<{\n            description: string | null;\n            name: string;\n        }, {\n            description: string | null;\n            name: string;\n        }>;\n        readonly \"~run\": (dataset: import(\"valibot\").UnknownDataset, config: import(\"valibot\").Config<import(\"valibot\").BaseIssue<unknown>>) => import(\"valibot\").OutputDataset<{\n            description: string | null;\n            name: string;\n        }, import(\"valibot\").ObjectIssue | import(\"valibot\").StringIssue>;\n        readonly \"~types\"?: {\n            readonly input: {\n                description: string | null;\n                name: string;\n            };\n            readonly output: {\n                description: string | null;\n                name: string;\n            };\n            readonly issue: import(\"valibot\").ObjectIssue | import(\"valibot\").StringIssue;\n        } | undefined;\n    };\n    var update: Omit<Omit<import(\"valibot\").ObjectSchema<{\n        readonly id: import(\"valibot\").NumberSchema<undefined>;\n        readonly name: import(\"valibot\").StringSchema<undefined>;\n        readonly description: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n        readonly created_at: import(\"valibot\").StringSchema<undefined>;\n        readonly updated_at: import(\"valibot\").StringSchema<undefined>;\n        readonly deleted_at: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n        readonly metas: import(\"valibot\").OptionalSchema<import(\"valibot\").RecordSchema<import(\"valibot\").StringSchema<undefined>, import(\"valibot\").AnySchema, undefined>, undefined>;\n    }, undefined>, \"entries\" | \"~types\" | \"~run\" | \"~standard\"> & {\n        readonly entries: Pick<{\n            readonly id: import(\"valibot\").NumberSchema<undefined>;\n            readonly name: import(\"valibot\").StringSchema<undefined>;\n            readonly description: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n            readonly created_at: import(\"valibot\").StringSchema<undefined>;\n            readonly updated_at: import(\"valibot\").StringSchema<undefined>;\n            readonly deleted_at: import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n            readonly metas: import(\"valibot\").OptionalSchema<import(\"valibot\").RecordSchema<import(\"valibot\").StringSchema<undefined>, import(\"valibot\").AnySchema, undefined>, undefined>;\n        }, \"description\" | \"name\">;\n        readonly \"~standard\": import(\"valibot\").StandardProps<{\n            description: string | null;\n            name: string;\n        }, {\n            description: string | null;\n            name: string;\n        }>;\n        readonly \"~run\": (dataset: import(\"valibot\").UnknownDataset, config: import(\"valibot\").Config<import(\"valibot\").BaseIssue<unknown>>) => import(\"valibot\").OutputDataset<{\n            description: string | null;\n            name: string;\n        }, import(\"valibot\").ObjectIssue | import(\"valibot\").StringIssue>;\n        readonly \"~types\"?: {\n            readonly input: {\n                description: string | null;\n                name: string;\n            };\n            readonly output: {\n                description: string | null;\n                name: string;\n            };\n            readonly issue: import(\"valibot\").ObjectIssue | import(\"valibot\").StringIssue;\n        } | undefined;\n    }, \"entries\" | \"~types\" | \"~run\" | \"~standard\"> & {\n        readonly entries: {\n            readonly description: import(\"valibot\").OptionalSchema<import(\"valibot\").NullableSchema<import(\"valibot\").StringSchema<undefined>, undefined>, undefined>;\n            readonly name: import(\"valibot\").OptionalSchema<import(\"valibot\").StringSchema<undefined>, undefined>;\n        };\n        readonly \"~standard\": import(\"valibot\").StandardProps<{\n            description?: string | null | undefined;\n            name?: string | undefined;\n        }, {\n            description?: string | null | undefined;\n            name?: string | undefined;\n        }>;\n        readonly \"~run\": (dataset: import(\"valibot\").UnknownDataset, config: import(\"valibot\").Config<import(\"valibot\").BaseIssue<unknown>>) => import(\"valibot\").OutputDataset<{\n            description?: string | null | undefined;\n            name?: string | undefined;\n        }, import(\"valibot\").ObjectIssue | import(\"valibot\").StringIssue>;\n        readonly \"~types\"?: {\n            readonly input: {\n                description?: string | null | undefined;\n                name?: string | undefined;\n            };\n            readonly output: {\n                description?: string | null | undefined;\n                name?: string | undefined;\n            };\n            readonly issue: import(\"valibot\").ObjectIssue | import(\"valibot\").StringIssue;\n        } | undefined;\n    };\n}\n","import EmmitterService from '#shared/services/EmmitterService.ts';\nimport DashboardWidgetData from './DashboardWidgetData';\nimport DashboardWidget from './DashboardWidget';\nimport type { DashboardSchema } from '#shared/schemas/dashboardSchema.ts';\nexport interface DashboardOptions {\n    dashboard: DashboardSchema;\n    widgets?: DashboardWidgetData[];\n}\nexport default class Dashboard {\n    name: DashboardSchema['name'];\n    description: DashboardSchema['description'];\n    widgets: DashboardWidget[];\n    emmitter: EmmitterService;\n    containerWidth: number;\n    constructor();\n    setName(name: string): this;\n    setDescription(description: string): this;\n    setContainerWidth(width: number): this;\n    setWidgets(widgets: DashboardWidgetData[]): this;\n    findLastRow(): number;\n    addWidget(payload?: Partial<DashboardWidgetData>): void;\n    removeWidget(index: number): void;\n    removeWidgetById(id: string): void;\n    updateWidget(index: number, widget: DashboardWidget): void;\n    duplicateWidget(index: number): void;\n}\n","import type { Ref } from 'vue';\nimport type DashboardEntity from '#client/entities/Dashboard.ts';\nexport declare function provideDashboard(entity: Ref<DashboardEntity>): void;\nexport declare function useDashboard(): Ref<DashboardEntity>;\n","import type { Ref } from 'vue';\nimport type DashboardWidget from '#client/entities/DashboardWidget.ts';\nexport declare function provideDashboardWidget(entity: Ref<DashboardWidget>): void;\nexport declare function useDashboardWidget(): Ref<DashboardWidget>;\n","import type { MaybeRef, Ref } from 'vue';\nexport interface UseFetchPaginationOptions {\n    key?: string;\n    query?: MaybeRef<Record<string, any>>;\n    page?: MaybeRef<number>;\n    serialize?: (item: any) => any;\n    refine?: (items: any[]) => any[];\n    limit?: number;\n    orderBy?: string | string[] | null;\n    orderDirection?: 'asc' | 'desc' | ('asc' | 'desc')[] | null;\n    debounce?: number;\n    immediate?: boolean;\n}\nexport declare function useFetchPagination<T = any>(url: string, options?: UseFetchPaginationOptions): {\n    page: Ref<number, number>;\n    limit: Ref<number, number>;\n    orderBy: Ref<string | string[] | null, string | string[] | null>;\n    orderDirection: Ref<\"asc\" | \"desc\" | (\"asc\" | \"desc\")[] | null, \"asc\" | \"desc\" | (\"asc\" | \"desc\")[] | null>;\n    total: import(\"vue\").ComputedRef<number>;\n    totalPages: import(\"vue\").ComputedRef<number>;\n    items: import(\"vue\").ComputedRef<T[]>;\n    loading: Ref<boolean, boolean>;\n    load: () => Promise<void>;\n    reset: () => Promise<void>;\n    query: Ref<Record<string, any>, Record<string, any>>;\n    hydrate: () => Promise<void>;\n};\n","interface Entry {\n    key: string;\n    value: any;\n    source: string;\n}\nexport default class ConfigService {\n    static __container_entry_key: string;\n    entries: Map<string, Entry>;\n    constructor();\n    list(): Entry[];\n    parseValue(value: any): any;\n    loadFromRecord(record: Record<string, any>, source?: string): void;\n    loadFromEntries(entries: [string, any][], source?: string): void;\n    toRecord(): Record<string, any>;\n    has(key: string): boolean;\n    get<T = any | undefined>(key: string, defaultValue?: any): T;\n    getOne<T = any | undefined>(keys: string[], defaultValue?: any): T;\n    set(key: string, value: any, source?: string): void;\n    unset(key: string): void;\n    clear(): void;\n    dump(): Record<string, any>;\n}\nexport {};\n","type Constructor<T = object> = new (...args: any[]) => T;\ntype EntryKey = string | symbol | Constructor;\nexport default class ContainerService {\n    private entries;\n    loadFromRecord(record: Record<string, any>): void;\n    toRecord(): Record<string, any>;\n    private getKey;\n    set(payload: EntryKey, value: any): this;\n    has(payload: EntryKey): boolean;\n    get<T>(payload: EntryKey): T;\n    unset(payload: EntryKey): void;\n    singleton<T>(classConstructor: Constructor<T>): T;\n    load(entries: Record<any, any>): void;\n    proxy<T = unknown>(key: EntryKey): T;\n    keys(): EntryKey[];\n}\nexport {};\n","export declare function createId(prefix?: string): string;\n","import { defineAbility } from '@casl/ability';\nimport Permission from './PermissionEntity.ts';\nimport LoggerService from '#shared/services/LoggerService.ts';\nexport default class AclEntity {\n    static __container_entry_key: string;\n    ability: ReturnType<typeof defineAbility>;\n    permissions: Permission[];\n    debug: boolean;\n    logger: LoggerService;\n    constructor(data?: Partial<AclEntity>);\n    can(action: string, subject: any, object?: Record<string, any>): boolean;\n    cannot(action: string, subject: any, object?: Record<string, any>): boolean;\n    subject(subject: string, object: Record<string, any>): Record<string, any> & import(\"@casl/ability\").ForcedSubject<string>;\n}\n","export interface ModuleManifestBuildImport {\n    from: string;\n    to?: string;\n    type: 'global_import';\n}\nexport interface ModuleManifestBuild {\n    imports?: ModuleManifestBuildImport[];\n}\ndeclare const ModuleManifest_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor;\nexport default class ModuleManifest extends ModuleManifest_base {\n    id: string;\n    name: string;\n    version: string;\n    description?: string;\n    enabled: boolean;\n    author?: string;\n    dependencies?: Record<string, string>;\n    build?: ModuleManifestBuild;\n    [key: string]: any;\n}\nexport {};\n","import type ModuleManifest from './ModuleManifestEntity.ts';\nimport LifecycleHook from '#shared/entities/LifecycleHook.ts';\ninterface ModuleUpgradeInfo {\n    source: 'git' | 'zip';\n    [key: string]: any;\n}\ndeclare const Module_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor & import(\"#shared/utils/compose.ts\").Constructor<{}> & typeof LifecycleHook;\nexport default class Module extends Module_base {\n    id: string;\n    name: string;\n    enabled: boolean;\n    dependencies: Record<string, any>;\n    build: ModuleManifest['build'];\n    directory: string;\n    upgrade_info?: ModuleUpgradeInfo;\n    setData(data: Partial<Module | ModuleManifest>): void;\n}\nexport {};\n","declare const PluginEntity_base: {\n    new (...args: any[]): {\n        merge(data: Partial</*elided*/ any>): /*elided*/ any;\n    };\n    from<T>(this: new () => T, data: Partial<T>): T;\n} & import(\"#shared/utils/compose.ts\").Constructor;\nexport default class PluginEntity extends PluginEntity_base {\n    id: string;\n    name: string;\n    version: string;\n    enabled: boolean;\n    aliases: string[];\n    version_channel: string;\n    version_available_channels: string[];\n}\nexport {};\n","import { type ValibotObjectSchema, type ValibotSchema, type ValidatePayload, type ValidatorResult } from '#shared/index.ts';\nimport { toTypedSchema as veeValidateToTypedSchema } from '@vee-validate/valibot';\nimport { type FormContext, type FormOptions, type GenericObject } from 'vee-validate';\nexport interface ValibotFormOptions<T extends ValibotSchema = ValibotSchema> extends Omit<FormOptions<ValidatePayload<T>, ValidatorResult<T>>, 'validationSchema'> {\n}\nexport interface ValibotFormResultObject<T extends ValibotObjectSchema> extends GenericObject, FormContext<ValidatorResult<T>> {\n}\nexport declare const useForm: typeof useValibotForm;\nexport declare const toTypedSchema: typeof veeValidateToTypedSchema;\nexport declare function useValibotForm<T extends ValibotObjectSchema = ValibotObjectSchema>(schema: T, options?: ValibotFormOptions<T>): FormContext<ValidatorResult<T>>;\n","import * as UnheadVue from '@unhead/vue';\nexport declare const UNHEAD_VUE_CONTAINER_KEY = \"unhead-vue\";\ndeclare const unheadVue: typeof UnheadVue;\nexport default unheadVue;\n","import unheadVue from '#client/facades/unheadVue.ts';\nexport declare const useHead: typeof unheadVue.useHead;\n","export declare function useLayoutOptions(): import(\"vue\").Ref<any, any>;\n","import type { Ref } from 'vue';\ninterface Options {\n    timeout?: number;\n}\ninterface LoadingRef extends Ref<boolean> {\n    set: (value: boolean) => void;\n}\nexport declare function useLoading(defaultValue?: boolean, options?: Options): LoadingRef;\nexport {};\n","export interface MenuBase {\n    id: string;\n    label: string;\n    order?: number;\n}\nexport interface MenuSingle extends MenuBase {\n    icon: string;\n    to: string;\n    target?: '_blank' | '_self' | '_parent' | '_top';\n}\nexport interface MenuWithChildren extends MenuBase {\n    icon: string;\n    children: Omit<MenuSingle, 'icon'>[];\n}\nexport interface MenuGroup extends MenuBase {\n    group: boolean;\n    items: MenuItem[];\n}\nexport interface MenuItem {\n    id: string;\n    label: string;\n    to?: string;\n    target?: '_blank' | '_self' | '_parent' | '_top';\n    group?: string;\n    order?: number;\n    icon?: string;\n    parent?: string;\n    layout?: string;\n}\nexport type UseMenu = ReturnType<typeof useMenu>;\nexport declare function useMenu(): {\n    items: import(\"vue\").ComputedRef<{\n        id: string;\n        label: string;\n        to?: string | undefined;\n        target?: \"_blank\" | \"_self\" | \"_parent\" | \"_top\" | undefined;\n        group?: string | undefined;\n        order?: number | undefined;\n        icon?: string | undefined;\n        parent?: string | undefined;\n        layout?: string | undefined;\n    }[]>;\n    add: (...item: MenuItem[]) => void;\n    remove: (item: MenuItem | MenuItem[\"id\"]) => void;\n    removeGroup: (groupId: string) => void;\n    removeMany: (itemIds: string[]) => void;\n    removeManyGroup: (groupIds: string[]) => void;\n    clear: () => void;\n};\n","import { useRouteQuery as vueUserRouteQuery } from '@vueuse/router';\nexport declare const useRouteQuery: typeof vueUserRouteQuery;\n","import type { Ref } from 'vue';\nexport interface UseStateOptions {\n    default?: () => any;\n    transform?: (value: any) => any;\n}\nexport declare function useState<T>(key: string, options?: UseStateOptions): Ref<T>;\n","import AclEntity from '#shared/entities/AclEntity.ts';\ndeclare const acl: AclEntity;\nexport default acl;\n","import AuthService from '#client/services/AuthService.ts';\ndeclare const auth: AuthService;\nexport default auth;\n","import ConfigService from '#shared/services/ConfigService.ts';\ndeclare const config: ConfigService;\nexport default config;\n","import ContainerService from \"#shared/services/ContainerService.ts\";\ndeclare const _default: ContainerService;\nexport default _default;\n","import type DashboardWidgetDefinition from '#client/entities/DashboardWidgetDefinition.ts';\nexport default class DashboardWidgetRegistry {\n    static __container_entry_key: string;\n    private definitions;\n    register(...definition: DashboardWidgetDefinition[]): void;\n    get(id: string): DashboardWidgetDefinition | null;\n    list(): DashboardWidgetDefinition[];\n}\n","import DashboardWidgetRegistry from '#client/registry/DashboardWidgetRegistry.ts';\ndeclare const dashboardRegistry: DashboardWidgetRegistry;\nexport default dashboardRegistry;\n","import { EmmitterService } from '#shared/index.ts';\ndeclare const emmitter: EmmitterService<Record<string, any>>;\nexport default emmitter;\n","import FetchService from '#client/services/FetchService.ts';\ndeclare const fetcher: FetchService;\nexport default fetcher;\n","declare const layout: any;\nexport default layout;\n","import LifecycleService from '#client/services/LifecycleService.ts';\ndeclare const lifecycle: LifecycleService;\nexport default lifecycle;\n","import LoggerService from '#shared/services/LoggerService.ts';\ndeclare const logger: LoggerService;\nexport default logger;\n","import MenuService from '#client/services/MenuService.ts';\ndeclare const menu: MenuService;\nexport default menu;\n","import type { RouteLocationNormalizedGeneric } from 'vue-router';\ndeclare const route: RouteLocationNormalizedGeneric;\nexport default route;\n","import type { Router } from '#client/services/RouterService.ts';\ndeclare const router: Router;\nexport default router;\n","import ToastService from '#client/services/ToastService.ts';\ndeclare const toast: ToastService;\nexport default toast;\n","import * as VeeValidate from 'vee-validate';\nexport declare const VEE_VALIDATE_CONTAINER_KEY = \"vee-validate\";\ndeclare const veeValidate: typeof VeeValidate;\nexport default veeValidate;\n","import * as Vue from 'vue';\nexport declare const VUE_CONTAINER_KEY = \"Vue\";\ndeclare const vue: typeof Vue;\nexport default vue;\n","import * as VueRouter from 'vue-router';\nexport declare const VUE_ROUTER_CONTAINER_KEY = \"VueRouter\";\ndeclare const vueRouter: typeof VueRouter;\nexport default vueRouter;\n","import DashboardWidgetDefinition from './DashboardWidgetDefinition';\nimport type DashboardWidgetData from './DashboardWidgetData';\n/**\n    * Component to be used for chart widgets in the dashboard.\n    * Plugins can extend this class to create their own chart widgets.\n    * @example\n    * class MyChartWidget extends DashboardWidgetDefinitionChart {\n    *     constructor() {\n    *         super()\n    *         this.name = 'My Chart Widget'\n    *         this.id = 'my-chart-widget'\n    *     }\n    * }\n    */\nexport default class DashboardWidgetDefinitionChart extends DashboardWidgetDefinition {\n    private static renderer;\n    constructor();\n    static setRenderer(renderer: any): void;\n    component(): any;\n    chartOptions(payload: DashboardWidgetData['options']): Promise<any>;\n}\n","import Base from '#shared/entities/ModuleEntity.ts';\ndeclare const Module_base: typeof Base;\nexport default class Module extends Module_base {\n}\nexport {};\n","import Base from '#shared/entities/PluginEntity.ts';\nimport type { AutoOptions } from '#client/services/RouterService.ts';\ndeclare const PluginEntity_base: typeof Base;\nexport default class PluginEntity extends PluginEntity_base {\n    addPagesFolder(imports: any, options?: AutoOptions): void;\n    load(): Promise<void>;\n}\nexport {};\n","import type { AutoOptions } from '#client/services/RouterService.ts';\nimport type { DefineComponent } from 'vue';\nimport type { RouteRecordRaw } from 'vue-router';\n/** @deprecated Use auto from RouterService instead */\nexport declare function autoRoutes(imports: Record<string, DefineComponent | (() => Promise<DefineComponent>)>, options?: AutoOptions): RouteRecordRaw[];\n","export interface DataTableColumn<T extends Record<string, any> = Record<string, any>> {\n    id?: string;\n    label?: string;\n    field?: keyof T | ((row: T) => any) | (string & {});\n    sortable?: boolean;\n    width?: string | number;\n}\nexport declare function defineColumns<T extends Record<string, any>>(columns: DataTableColumn<T>[]): DataTableColumn<T>[];\n","export interface DefineFormField {\n    component: 'text-field' | 'textarea' | 'select' | 'autocomplete' | 'switch' | 'file-upload' | 'image-upload' | 'color-picker' | 'string-list-input' | 'json-input' | 'date-picker' | 'hidden';\n    [key: string]: any;\n}\nexport declare function defineFormFields(field: Record<string, DefineFormField>): Record<string, DefineFormField>;\n","/** @deprecated Use fetcher facade */\nexport declare const $fetch: import(\"..\").FetchService;\n","interface PickOptions {\n    accept?: string;\n    multiple?: boolean;\n}\ntype PickResult<T extends PickOptions> = T['multiple'] extends true ? File[] : File | null;\ndeclare function pick<T extends PickOptions>(options: T): Promise<PickResult<T>>;\ndeclare function toUint8Array(file: File): Promise<Uint8Array>;\ninterface UploadOptions {\n    driveId: string;\n    file: File;\n    directory?: string;\n}\ndeclare function upload(options: UploadOptions): Promise<any>;\nexport declare const $file: {\n    pick: typeof pick;\n    upload: typeof upload;\n    toUint8Array: typeof toUint8Array;\n};\nexport {};\n","export declare function parseTo(to: string): string;\n","export declare const $toast: ((message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number) & {\n    success: (message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n    info: (message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n    warning: (message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n    error: (message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n    custom: (component: import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n    message: (message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n    promise: <ToastData>(promise: Promise<ToastData> | (() => Promise<ToastData>), data?: ({\n        id?: number | string | undefined;\n        icon?: import(\"vue\").Component | undefined;\n        toasterId?: string | undefined;\n        component?: import(\"vue\").Component | undefined;\n        componentProps?: any;\n        richColors?: boolean | undefined;\n        invert?: boolean | undefined;\n        closeButton?: boolean | undefined;\n        dismissible?: boolean | undefined;\n        duration?: number | undefined;\n        important?: boolean | undefined;\n        action?: (import(\"vue-sonner\").Action | import(\"vue\").Component) | undefined;\n        cancel?: (import(\"vue-sonner\").Action | import(\"vue\").Component) | undefined;\n        onDismiss?: ((toast: import(\"vue-sonner\").ToastT) => void) | undefined;\n        onAutoClose?: ((toast: import(\"vue-sonner\").ToastT) => void) | undefined;\n        cancelButtonStyle?: import(\"vue\").CSSProperties | undefined;\n        actionButtonStyle?: import(\"vue\").CSSProperties | undefined;\n        style?: import(\"vue\").CSSProperties | undefined;\n        unstyled?: boolean | undefined;\n        class?: string | undefined;\n        classes?: import(\"vue-sonner\").ToastClasses | undefined;\n        descriptionClass?: string | undefined;\n        position?: (\"top-left\" | \"top-right\" | \"bottom-left\" | \"bottom-right\" | \"top-center\" | \"bottom-center\") | undefined;\n        closeButtonPosition?: (\"top-left\" | \"top-right\" | \"bottom-left\" | \"bottom-right\") | undefined;\n        testId?: string | undefined;\n    } & {\n        loading?: string | import(\"vue\").Component;\n        success?: (string | import(\"vue\").Component | ((data: ToastData) => import(\"vue\").Component | string | Promise<import(\"vue\").Component | string>)) | (import(\"vue-sonner\").PromiseIExtendedResult | ((data: ToastData) => import(\"vue-sonner\").PromiseIExtendedResult | Promise<import(\"vue-sonner\").PromiseIExtendedResult>)) | undefined;\n        error?: (string | import(\"vue\").Component | ((data: any) => import(\"vue\").Component | string | Promise<import(\"vue\").Component | string>)) | (import(\"vue-sonner\").PromiseIExtendedResult | ((data: any) => import(\"vue-sonner\").PromiseIExtendedResult | Promise<import(\"vue-sonner\").PromiseIExtendedResult>));\n        description?: string | import(\"vue\").Component | ((data: any) => import(\"vue\").Component | string | Promise<import(\"vue\").Component | string>);\n        finally?: () => void | Promise<void>;\n    }) | undefined) => (string & {\n        unwrap: () => Promise<ToastData>;\n    }) | (number & {\n        unwrap: () => Promise<ToastData>;\n    }) | {\n        unwrap: () => Promise<ToastData>;\n    } | undefined;\n    dismiss: (id?: number | string) => string | number | undefined;\n    loading: (message: string | (() => string | import(\"vue\").Component) | import(\"vue\").Component, data?: import(\"vue-sonner\").ExternalToast) => string | number;\n} & {\n    getHistory: () => (import(\"vue-sonner\").ToastT<import(\"vue\").Component> | import(\"vue-sonner\").ToastToDismiss)[];\n    getToasts: () => (import(\"vue-sonner\").ToastT<import(\"vue\").Component> | import(\"vue-sonner\").ToastToDismiss)[];\n};\n","import type { ClassValue } from 'clsx';\nimport { type ClassNameValue } from 'tailwind-merge';\nexport declare function twMerge(...inputs: ClassNameValue[]): string;\nexport declare function clsx(...inputs: ClassValue[]): string;\nexport declare function cn(...inputs: ClassValue[]): string;\n","import type { NavigationGuard, RouteLocationNormalized } from 'vue-router';\nexport interface AuthGuardOptions {\n    redirect: string | ((to: RouteLocationNormalized) => string);\n    exclude?: string[];\n}\nexport declare function createAuthGuard(options: AuthGuardOptions): NavigationGuard;\ndeclare const authGuard: NavigationGuard;\nexport default authGuard;\n","export interface GuestGuardOptions {\n    redirect: string;\n}\nexport declare function createGuestGuard(options: GuestGuardOptions): () => string | undefined;\ndeclare const guestGuard: () => string | undefined;\nexport default guestGuard;\n","import type { NavigationGuard } from 'vue-router';\ndeclare const setupGuard: NavigationGuard;\nexport default setupGuard;\n"],"x_google_ignoreList":[17],"mappings":"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AA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC1B,IAAA,aAAA;CAAA;OAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;;;;;;;;;;;;;;;;;;AEFA,IAAW,UAAU;CAAC;OAAW,CAAA,GAAA,gBAAA;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACjC,IAAW,gBAAc;CAAA;OAAA,CAAA,EAAA,WAAA,EAAA,WAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AACzB,IAAC,sBAAA;CAAA;OAAA,CAAA,EAAA,aAAA;CAAA,CAAA,IAAA,GAAA;CAAA;AAED,IAAW,oBAAoB;CAAC;EAAI,MAAA;EAAA;EAAsB;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAE1D,IAAO,kBAAU;CAAA;EAAkB,MAAE;EAAA,EAAA;EAAQ;EAAa,EAAE;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC5D,IAAS,kBAAW;CAAA;EAAA,MAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;;;;ACPpB,IAAO,kBAAiB;CAAA;OAAiB;EAAC;EAAiB;EAAE;EAAa;CAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC1E,IAAI,kBAAqB;CAAA;OAAU;EAAA,EAAa;EAAU,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;CAAA;AAC1D,IAAI,kBAAuB;CAAA;OAAU;EAAA,EAAa;EAAU,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA,EAAA;EAAA;CAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA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"}