@vueuse/components 11.0.3 → 11.2.0

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/index.cjs +90 -74
  2. package/index.d.cts +131 -131
  3. package/index.d.mts +131 -131
  4. package/index.d.ts +131 -131
  5. package/index.iife.js +91 -75
  6. package/index.iife.min.js +1 -1
  7. package/index.mjs +91 -75
  8. package/package.json +3 -3
package/index.d.cts CHANGED
@@ -1,21 +1,12 @@
1
- import * as vue_demi from 'vue-demi';
2
- import { ComponentPublicInstance, ObjectDirective, Ref, UnwrapNestedRefs, ComputedRef, FunctionDirective } from 'vue-demi';
1
+ import * as vue from 'vue-demi';
3
2
  import { MaybeRef, MaybeRefOrGetter, ConfigurableEventFilter, ConfigurableFlush, Awaitable } from '@vueuse/shared';
3
+ import { ComponentPublicInstance, ObjectDirective, Ref, UnwrapNestedRefs, ComputedRef, FunctionDirective } from 'vue-demi';
4
4
  import { UseClipboardOptions, UseDarkOptions, UseDevicesListOptions, UseDraggableOptions, ElementSize as ElementSize$1, UseGeolocationOptions, UseIdleOptions, UseMouseOptions, MouseInElementOptions, MousePressedOptions, UseNowOptions, UsePointerOptions, UseTimeAgoOptions, UseTimestampOptions, UseVirtualListOptions, UseWindowSizeOptions } from '@vueuse/core';
5
5
 
6
6
  interface ConfigurableWindow {
7
7
  window?: Window;
8
8
  }
9
9
 
10
- interface RenderableComponent {
11
- /**
12
- * The element that the component should be rendered as
13
- *
14
- * @default 'div'
15
- */
16
- as?: object | string;
17
- }
18
-
19
10
  type VueInstance = ComponentPublicInstance;
20
11
  type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>;
21
12
  type MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeRefOrGetter<T>;
@@ -25,7 +16,7 @@ interface OnClickOutsideOptions extends ConfigurableWindow {
25
16
  /**
26
17
  * List of elements that should not trigger the event.
27
18
  */
28
- ignore?: (MaybeElementRef | string)[];
19
+ ignore?: MaybeRefOrGetter<(MaybeElementRef | string)[]>;
29
20
  /**
30
21
  * Use capturing phase for internal event listener.
31
22
  * @default true
@@ -43,10 +34,19 @@ type OnClickOutsideHandler<T extends {
43
34
  detectIframe: false;
44
35
  }> = (evt: T['detectIframe'] extends true ? PointerEvent | FocusEvent : PointerEvent) => void;
45
36
 
37
+ interface RenderableComponent {
38
+ /**
39
+ * The element that the component should be rendered as
40
+ *
41
+ * @default 'div'
42
+ */
43
+ as?: object | string;
44
+ }
45
+
46
46
  interface OnClickOutsideProps extends RenderableComponent {
47
47
  options?: OnClickOutsideOptions;
48
48
  }
49
- declare const OnClickOutside: vue_demi.DefineComponent<OnClickOutsideProps, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<OnClickOutsideProps>, {}, {}>;
49
+ declare const OnClickOutside: vue.DefineComponent<OnClickOutsideProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<OnClickOutsideProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
50
50
 
51
51
  declare const vOnClickOutside: ObjectDirective<HTMLElement, OnClickOutsideHandler | [(evt: any) => void, OnClickOutsideOptions]>;
52
52
 
@@ -100,7 +100,7 @@ interface OnLongPressModifiers {
100
100
  interface OnLongPressProps extends RenderableComponent {
101
101
  options?: OnLongPressOptions;
102
102
  }
103
- declare const OnLongPress: vue_demi.DefineComponent<OnLongPressProps, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<OnLongPressProps>, {}, {}>;
103
+ declare const OnLongPress: vue.DefineComponent<OnLongPressProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<OnLongPressProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
104
104
 
105
105
  type BindingValueFunction$7 = (evt: PointerEvent) => void;
106
106
  type BindingValueArray$6 = [
@@ -109,21 +109,21 @@ type BindingValueArray$6 = [
109
109
  ];
110
110
  declare const vOnLongPress: ObjectDirective<HTMLElement, BindingValueFunction$7 | BindingValueArray$6>;
111
111
 
112
- declare const UseActiveElement: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
112
+ declare const UseActiveElement: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
113
113
  [key: string]: any;
114
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
114
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
115
115
 
116
- declare const UseBattery: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
116
+ declare const UseBattery: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
117
117
  [key: string]: any;
118
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
118
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
119
119
 
120
- declare const UseBrowserLocation: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
120
+ declare const UseBrowserLocation: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
121
121
  [key: string]: any;
122
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
122
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
123
123
 
124
124
  interface UseClipboardProps<Source = string> extends UseClipboardOptions<Source> {
125
125
  }
126
- declare const UseClipboard: vue_demi.DefineComponent<UseClipboardProps<string>, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseClipboardProps<string>>, {}, {}>;
126
+ declare const UseClipboard: vue.DefineComponent<UseClipboardProps<string>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseClipboardProps<string>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
127
127
 
128
128
  interface StorageLike {
129
129
  getItem: (key: string) => string | null;
@@ -259,27 +259,27 @@ interface UseColorModeOptions<T extends string = BasicColorMode> extends UseStor
259
259
  disableTransition?: boolean;
260
260
  }
261
261
 
262
- declare const UseColorMode: vue_demi.DefineComponent<UseColorModeOptions<BasicColorMode>, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseColorModeOptions<BasicColorMode>>, {}, {}>;
262
+ declare const UseColorMode: vue.DefineComponent<UseColorModeOptions<BasicColorMode>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseColorModeOptions<BasicColorMode>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
263
263
 
264
- declare const UseDark: vue_demi.DefineComponent<UseDarkOptions, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseDarkOptions>, {}, {}>;
264
+ declare const UseDark: vue.DefineComponent<UseDarkOptions, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseDarkOptions> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
265
265
 
266
- declare const UseDeviceMotion: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
266
+ declare const UseDeviceMotion: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
267
267
  [key: string]: any;
268
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
268
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
269
269
 
270
- declare const UseDeviceOrientation: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
270
+ declare const UseDeviceOrientation: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
271
271
  [key: string]: any;
272
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
272
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
273
273
 
274
- declare const UseDevicePixelRatio: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
274
+ declare const UseDevicePixelRatio: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
275
275
  [key: string]: any;
276
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
276
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
277
277
 
278
- declare const UseDevicesList: vue_demi.DefineComponent<UseDevicesListOptions, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseDevicesListOptions>, {}, {}>;
278
+ declare const UseDevicesList: vue.DefineComponent<UseDevicesListOptions, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseDevicesListOptions> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
279
279
 
280
- declare const UseDocumentVisibility: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
280
+ declare const UseDocumentVisibility: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
281
281
  [key: string]: any;
282
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
282
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
283
283
 
284
284
  interface UseDraggableProps extends UseDraggableOptions, RenderableComponent {
285
285
  /**
@@ -293,7 +293,7 @@ interface UseDraggableProps extends UseDraggableOptions, RenderableComponent {
293
293
  */
294
294
  storageType?: 'local' | 'session';
295
295
  }
296
- declare const UseDraggable: vue_demi.DefineComponent<UseDraggableProps, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseDraggableProps>, {}, {}>;
296
+ declare const UseDraggable: vue.DefineComponent<UseDraggableProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseDraggableProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
297
297
 
298
298
  interface ResizeObserverSize {
299
299
  readonly inlineSize: number;
@@ -302,9 +302,9 @@ interface ResizeObserverSize {
302
302
  interface ResizeObserverEntry {
303
303
  readonly target: Element;
304
304
  readonly contentRect: DOMRectReadOnly;
305
- readonly borderBoxSize?: ReadonlyArray<ResizeObserverSize>;
306
- readonly contentBoxSize?: ReadonlyArray<ResizeObserverSize>;
307
- readonly devicePixelContentBoxSize?: ReadonlyArray<ResizeObserverSize>;
305
+ readonly borderBoxSize: ReadonlyArray<ResizeObserverSize>;
306
+ readonly contentBoxSize: ReadonlyArray<ResizeObserverSize>;
307
+ readonly devicePixelContentBoxSize: ReadonlyArray<ResizeObserverSize>;
308
308
  }
309
309
  type ResizeObserverCallback = (entries: ReadonlyArray<ResizeObserverEntry>, observer: ResizeObserver) => void;
310
310
  interface UseResizeObserverOptions extends ConfigurableWindow {
@@ -323,7 +323,7 @@ declare class ResizeObserver {
323
323
  unobserve(target: Element): void;
324
324
  }
325
325
 
326
- declare const UseElementBounding: vue_demi.DefineComponent<UseResizeObserverOptions & RenderableComponent, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseResizeObserverOptions & RenderableComponent>, {}, {}>;
326
+ declare const UseElementBounding: vue.DefineComponent<UseResizeObserverOptions & RenderableComponent, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseResizeObserverOptions & RenderableComponent> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
327
327
 
328
328
  interface UseElementHoverOptions extends ConfigurableWindow {
329
329
  delayEnter?: number;
@@ -333,7 +333,7 @@ interface UseElementHoverOptions extends ConfigurableWindow {
333
333
  type BindingValueFunction$6 = (state: boolean) => void;
334
334
  declare const vElementHover: ObjectDirective<HTMLElement, BindingValueFunction$6 | [handler: BindingValueFunction$6, options: UseElementHoverOptions]>;
335
335
 
336
- declare const UseElementSize: vue_demi.DefineComponent<ElementSize$1 & UseResizeObserverOptions & RenderableComponent, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<ElementSize$1 & UseResizeObserverOptions & RenderableComponent>, {}, {}>;
336
+ declare const UseElementSize: vue.DefineComponent<ElementSize$1 & UseResizeObserverOptions & RenderableComponent, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<ElementSize$1 & UseResizeObserverOptions & RenderableComponent> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
337
337
 
338
338
  interface ElementSize {
339
339
  width: number;
@@ -345,8 +345,8 @@ interface ElementSize {
345
345
  * @see https://vueuse.org/useElementSize
346
346
  */
347
347
  declare function useElementSize(target: MaybeComputedElementRef, initialSize?: ElementSize, options?: UseResizeObserverOptions): {
348
- width: vue_demi.Ref<number>;
349
- height: vue_demi.Ref<number>;
348
+ width: vue.Ref<number, number>;
349
+ height: vue.Ref<number, number>;
350
350
  stop: () => void;
351
351
  };
352
352
 
@@ -356,7 +356,7 @@ type VElementSizeOptions = RemoveFirstFromTuple<Parameters<typeof useElementSize
356
356
  type BindingValueArray$5 = [BindingValueFunction$5, ...VElementSizeOptions];
357
357
  declare const vElementSize: ObjectDirective<HTMLElement, BindingValueFunction$5 | BindingValueArray$5>;
358
358
 
359
- declare const UseElementVisibility: vue_demi.DefineComponent<RenderableComponent, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<RenderableComponent>, {}, {}>;
359
+ declare const UseElementVisibility: vue.DefineComponent<RenderableComponent, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<RenderableComponent> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
360
360
 
361
361
  interface UseIntersectionObserverOptions extends ConfigurableWindow {
362
362
  /**
@@ -368,7 +368,7 @@ interface UseIntersectionObserverOptions extends ConfigurableWindow {
368
368
  /**
369
369
  * The Element or Document whose bounds are used as the bounding box when testing for intersection.
370
370
  */
371
- root?: MaybeComputedElementRef;
371
+ root?: MaybeComputedElementRef | Document;
372
372
  /**
373
373
  * A string which specifies a set of offsets to add to the root's bounding_box when calculating intersections.
374
374
  */
@@ -388,44 +388,23 @@ type BindingValueFunction$4 = (state: boolean) => void;
388
388
  type BindingValueArray$4 = [BindingValueFunction$4, UseElementVisibilityOptions];
389
389
  declare const vElementVisibility: ObjectDirective<HTMLElement, BindingValueFunction$4 | BindingValueArray$4>;
390
390
 
391
- declare const UseEyeDropper: vue_demi.DefineComponent<{
391
+ declare const UseEyeDropper: vue.DefineComponent<vue.ExtractPropTypes<{
392
392
  sRGBHex: StringConstructor;
393
- }, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
393
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
394
394
  [key: string]: any;
395
- }>[] | undefined, unknown, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{
395
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
396
396
  sRGBHex: StringConstructor;
397
- }>>, {}, {}>;
397
+ }>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
398
398
 
399
- declare const UseFullscreen: vue_demi.DefineComponent<RenderableComponent, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<RenderableComponent>, {}, {}>;
399
+ declare const UseFullscreen: vue.DefineComponent<RenderableComponent, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<RenderableComponent> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
400
400
 
401
- declare const UseGeolocation: vue_demi.DefineComponent<UseGeolocationOptions, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseGeolocationOptions>, {}, {}>;
401
+ declare const UseGeolocation: vue.DefineComponent<UseGeolocationOptions, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseGeolocationOptions> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
402
402
 
403
- declare const UseIdle: vue_demi.DefineComponent<UseIdleOptions & {
403
+ declare const UseIdle: vue.DefineComponent<UseIdleOptions & {
404
404
  timeout: number;
405
- }, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseIdleOptions & {
405
+ }, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseIdleOptions & {
406
406
  timeout: number;
407
- }>, {}, {}>;
408
-
409
- interface UseImageOptions {
410
- /** Address of the resource */
411
- src: string;
412
- /** Images to use in different situations, e.g., high-resolution displays, small monitors, etc. */
413
- srcset?: string;
414
- /** Image sizes for different page layouts */
415
- sizes?: string;
416
- /** Image alternative information */
417
- alt?: string;
418
- /** Image classes */
419
- class?: string;
420
- /** Image loading */
421
- loading?: HTMLImageElement['loading'];
422
- /** Image CORS settings */
423
- crossorigin?: string;
424
- /** Referrer policy for fetch https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy */
425
- referrerPolicy?: HTMLImageElement['referrerPolicy'];
426
- }
427
-
428
- declare const UseImage: vue_demi.DefineComponent<UseImageOptions & RenderableComponent, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseImageOptions & RenderableComponent>, {}, {}>;
407
+ }> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
429
408
 
430
409
  interface UseScrollOptions extends ConfigurableWindow {
431
410
  /**
@@ -489,9 +468,9 @@ interface UseScrollOptions extends ConfigurableWindow {
489
468
  * @param options
490
469
  */
491
470
  declare function useScroll(element: MaybeRefOrGetter<HTMLElement | SVGElement | Window | Document | null | undefined>, options?: UseScrollOptions): {
492
- x: vue_demi.WritableComputedRef<number>;
493
- y: vue_demi.WritableComputedRef<number>;
494
- isScrolling: vue_demi.Ref<boolean>;
471
+ x: vue.WritableComputedRef<number, number>;
472
+ y: vue.WritableComputedRef<number, number>;
473
+ isScrolling: vue.Ref<boolean, boolean>;
495
474
  arrivedState: {
496
475
  left: boolean;
497
476
  right: boolean;
@@ -541,35 +520,10 @@ interface UseInfiniteScrollOptions<T extends InfiniteScrollElement = InfiniteScr
541
520
  * @see https://vueuse.org/useInfiniteScroll
542
521
  */
543
522
  declare function useInfiniteScroll<T extends InfiniteScrollElement>(element: MaybeRefOrGetter<T>, onLoadMore: (state: UnwrapNestedRefs<ReturnType<typeof useScroll>>) => Awaitable<void>, options?: UseInfiniteScrollOptions<T>): {
544
- isLoading: vue_demi.ComputedRef<boolean>;
523
+ isLoading: vue.ComputedRef<boolean>;
545
524
  reset(): void;
546
525
  };
547
526
 
548
- type BindingValueFunction$3 = Parameters<typeof useInfiniteScroll>[1];
549
- type BindingValueArray$3 = [BindingValueFunction$3, UseInfiniteScrollOptions];
550
- declare const vInfiniteScroll: ObjectDirective<HTMLElement, BindingValueFunction$3 | BindingValueArray$3>;
551
-
552
- type BindingValueFunction$2 = IntersectionObserverCallback;
553
- type BindingValueArray$2 = [BindingValueFunction$2, UseIntersectionObserverOptions];
554
- declare const vIntersectionObserver: ObjectDirective<HTMLElement, BindingValueFunction$2 | BindingValueArray$2>;
555
-
556
- declare const UseMouse: vue_demi.DefineComponent<UseMouseOptions, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseMouseOptions>, {}, {}>;
557
-
558
- declare const UseMouseInElement: vue_demi.DefineComponent<MouseInElementOptions & RenderableComponent, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<MouseInElementOptions & RenderableComponent>, {}, {}>;
559
-
560
- declare const UseMousePressed: vue_demi.DefineComponent<Omit<MousePressedOptions, "target"> & RenderableComponent, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<Omit<MousePressedOptions, "target"> & RenderableComponent>, {}, {}>;
561
-
562
- declare const UseNetwork: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
563
- [key: string]: any;
564
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
565
-
566
- declare const UseNow: vue_demi.DefineComponent<Omit<UseNowOptions<true>, "controls">, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<Omit<UseNowOptions<true>, "controls">>, {}, {}>;
567
-
568
- interface UseObjectUrlProps {
569
- object: Blob | MediaSource | undefined;
570
- }
571
- declare const UseObjectUrl: vue_demi.DefineComponent<UseObjectUrlProps, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseObjectUrlProps>, {}, {}>;
572
-
573
527
  interface UseOffsetPaginationOptions {
574
528
  /**
575
529
  * Total number of items.
@@ -608,66 +562,112 @@ interface UseOffsetPaginationReturn {
608
562
  next: () => void;
609
563
  }
610
564
 
611
- declare const UseOffsetPagination: vue_demi.DefineComponent<UseOffsetPaginationOptions, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseOffsetPaginationOptions>, {}, {}>;
565
+ interface UseImageOptions {
566
+ /** Address of the resource */
567
+ src: string;
568
+ /** Images to use in different situations, e.g., high-resolution displays, small monitors, etc. */
569
+ srcset?: string;
570
+ /** Image sizes for different page layouts */
571
+ sizes?: string;
572
+ /** Image alternative information */
573
+ alt?: string;
574
+ /** Image classes */
575
+ class?: string;
576
+ /** Image loading */
577
+ loading?: HTMLImageElement['loading'];
578
+ /** Image CORS settings */
579
+ crossorigin?: string;
580
+ /** Referrer policy for fetch https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy */
581
+ referrerPolicy?: HTMLImageElement['referrerPolicy'];
582
+ }
583
+
584
+ declare const UseImage: vue.DefineComponent<UseImageOptions & RenderableComponent, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseImageOptions & RenderableComponent> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
585
+
586
+ type BindingValueFunction$3 = Parameters<typeof useInfiniteScroll>[1];
587
+ type BindingValueArray$3 = [BindingValueFunction$3, UseInfiniteScrollOptions];
588
+ declare const vInfiniteScroll: ObjectDirective<HTMLElement, BindingValueFunction$3 | BindingValueArray$3>;
589
+
590
+ type BindingValueFunction$2 = IntersectionObserverCallback;
591
+ type BindingValueArray$2 = [BindingValueFunction$2, UseIntersectionObserverOptions];
592
+ declare const vIntersectionObserver: ObjectDirective<HTMLElement, BindingValueFunction$2 | BindingValueArray$2>;
593
+
594
+ declare const UseMouse: vue.DefineComponent<UseMouseOptions, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseMouseOptions> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
595
+
596
+ declare const UseMouseInElement: vue.DefineComponent<MouseInElementOptions & RenderableComponent, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<MouseInElementOptions & RenderableComponent> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
597
+
598
+ declare const UseMousePressed: vue.DefineComponent<Omit<MousePressedOptions, "target"> & RenderableComponent, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<Omit<MousePressedOptions, "target"> & RenderableComponent> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
599
+
600
+ declare const UseNetwork: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
601
+ [key: string]: any;
602
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
603
+
604
+ declare const UseNow: vue.DefineComponent<Omit<UseNowOptions<true>, "controls">, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<Omit<UseNowOptions<true>, "controls">> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
605
+
606
+ interface UseObjectUrlProps {
607
+ object: Blob | MediaSource | undefined;
608
+ }
609
+ declare const UseObjectUrl: vue.DefineComponent<UseObjectUrlProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseObjectUrlProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
610
+
611
+ declare const UseOffsetPagination: vue.DefineComponent<UseOffsetPaginationOptions, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseOffsetPaginationOptions> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
612
612
 
613
- declare const UseOnline: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
613
+ declare const UseOnline: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
614
614
  [key: string]: any;
615
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
615
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
616
616
 
617
- declare const UsePageLeave: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
617
+ declare const UsePageLeave: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
618
618
  [key: string]: any;
619
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
619
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
620
620
 
621
- declare const UsePointer: vue_demi.DefineComponent<Omit<UsePointerOptions, "target"> & {
621
+ declare const UsePointer: vue.DefineComponent<Omit<UsePointerOptions, "target"> & {
622
622
  target: "window" | "self";
623
- }, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<Omit<UsePointerOptions, "target"> & {
623
+ }, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<Omit<UsePointerOptions, "target"> & {
624
624
  target: "window" | "self";
625
- }>, {}, {}>;
625
+ }> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
626
626
 
627
- declare const UsePointerLock: vue_demi.DefineComponent<RenderableComponent, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<RenderableComponent>, {}, {}>;
627
+ declare const UsePointerLock: vue.DefineComponent<RenderableComponent, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<RenderableComponent> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
628
628
 
629
- declare const UsePreferredColorScheme: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
629
+ declare const UsePreferredColorScheme: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
630
630
  [key: string]: any;
631
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
631
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
632
632
 
633
- declare const UsePreferredContrast: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
633
+ declare const UsePreferredContrast: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
634
634
  [key: string]: any;
635
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
635
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
636
636
 
637
- declare const UsePreferredDark: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
637
+ declare const UsePreferredDark: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
638
638
  [key: string]: any;
639
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
639
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
640
640
 
641
- declare const UsePreferredLanguages: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
641
+ declare const UsePreferredLanguages: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
642
642
  [key: string]: any;
643
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
643
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
644
644
 
645
- declare const UsePreferredReducedMotion: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
645
+ declare const UsePreferredReducedMotion: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
646
646
  [key: string]: any;
647
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
647
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
648
648
 
649
649
  type BindingValueFunction$1 = ResizeObserverCallback;
650
650
  type BindingValueArray$1 = [BindingValueFunction$1, UseResizeObserverOptions];
651
651
  declare const vResizeObserver: ObjectDirective<HTMLElement, BindingValueFunction$1 | BindingValueArray$1>;
652
652
 
653
- declare const UseScreenSafeArea: vue_demi.DefineComponent<{
653
+ declare const UseScreenSafeArea: vue.DefineComponent<vue.ExtractPropTypes<{
654
654
  top: BooleanConstructor;
655
655
  right: BooleanConstructor;
656
656
  bottom: BooleanConstructor;
657
657
  left: BooleanConstructor;
658
- }, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
658
+ }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
659
659
  [key: string]: any;
660
- }> | undefined, unknown, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{
660
+ }> | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
661
661
  top: BooleanConstructor;
662
662
  right: BooleanConstructor;
663
663
  bottom: BooleanConstructor;
664
664
  left: BooleanConstructor;
665
- }>>, {
665
+ }>> & Readonly<{}>, {
666
666
  top: boolean;
667
667
  left: boolean;
668
668
  right: boolean;
669
669
  bottom: boolean;
670
- }, {}>;
670
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
671
671
 
672
672
  type BindingValueFunction = (state: UseScrollReturn) => void;
673
673
  type BindingValueArray = [BindingValueFunction, UseScrollOptions];
@@ -678,9 +678,9 @@ declare const vScrollLock: FunctionDirective<HTMLElement, boolean>;
678
678
  interface UseTimeAgoComponentOptions extends Omit<UseTimeAgoOptions<true>, 'controls'> {
679
679
  time: MaybeRef<Date | number | string>;
680
680
  }
681
- declare const UseTimeAgo: vue_demi.DefineComponent<UseTimeAgoComponentOptions, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseTimeAgoComponentOptions>, {}, {}>;
681
+ declare const UseTimeAgo: vue.DefineComponent<UseTimeAgoComponentOptions, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseTimeAgoComponentOptions> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
682
682
 
683
- declare const UseTimestamp: vue_demi.DefineComponent<Omit<UseTimestampOptions<true>, "controls">, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<Omit<UseTimestampOptions<true>, "controls">>, {}, {}>;
683
+ declare const UseTimestamp: vue.DefineComponent<Omit<UseTimestampOptions<true>, "controls">, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<Omit<UseTimestampOptions<true>, "controls">> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
684
684
 
685
685
  interface UseVirtualListProps {
686
686
  /**
@@ -702,12 +702,12 @@ interface UseVirtualListProps {
702
702
  */
703
703
  height: string;
704
704
  }
705
- declare const UseVirtualList: vue_demi.DefineComponent<UseVirtualListProps, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseVirtualListProps>, {}, {}>;
705
+ declare const UseVirtualList: vue.DefineComponent<UseVirtualListProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseVirtualListProps> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
706
706
 
707
- declare const UseWindowFocus: vue_demi.DefineComponent<{}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
707
+ declare const UseWindowFocus: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
708
708
  [key: string]: any;
709
- }>[] | undefined, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{}>>, {}, {}>;
709
+ }>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
710
710
 
711
- declare const UseWindowSize: vue_demi.DefineComponent<UseWindowSizeOptions, {}, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<UseWindowSizeOptions>, {}, {}>;
711
+ declare const UseWindowSize: vue.DefineComponent<UseWindowSizeOptions, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<UseWindowSizeOptions> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
712
712
 
713
713
  export { OnClickOutside, type OnClickOutsideProps, OnLongPress, type OnLongPressProps, UseActiveElement, UseBattery, UseBrowserLocation, UseClipboard, UseColorMode, UseDark, UseDeviceMotion, UseDeviceOrientation, UseDevicePixelRatio, UseDevicesList, UseDocumentVisibility, UseDraggable, type UseDraggableProps, UseElementBounding, UseElementSize, UseElementVisibility, UseEyeDropper, UseFullscreen, UseGeolocation, UseIdle, UseImage, UseMouse, UseMouseInElement, UseMousePressed, UseNetwork, UseNow, UseObjectUrl, type UseObjectUrlProps, UseOffsetPagination, UseOnline, UsePageLeave, UsePointer, UsePointerLock, UsePreferredColorScheme, UsePreferredContrast, UsePreferredDark, UsePreferredLanguages, UsePreferredReducedMotion, UseScreenSafeArea, UseTimeAgo, UseTimestamp, UseVirtualList, type UseVirtualListProps, UseWindowFocus, UseWindowSize, vOnClickOutside as VOnClickOutside, vOnLongPress as VOnLongPress, vElementHover, vElementSize, vElementVisibility, vInfiniteScroll, vIntersectionObserver, vOnClickOutside, vOnKeyStroke, vOnLongPress, vResizeObserver, vScroll, vScrollLock };