@vueuse/components 14.0.0-alpha.0 → 14.0.0-alpha.2

package/dist/index.d.ts

@@ -0,0 +1,589 @@
+import { BasicColorMode, ColorSchemeType, ConfigurableDocument, ConfigurableNavigator, ConfigurableWindow, ContrastType, DeviceMotionOptions, ElementSize, MouseInElementOptions, MousePressedOptions, OnClickOutsideHandler, OnClickOutsideOptions, OnKeyStrokeOptions, OnLongPressOptions, ReducedMotionType, RenderableComponent, ResizeObserverCallback, UseActiveElementOptions, UseActiveElementReturn, UseBatteryReturn, UseBrowserLocationReturn, UseClipboardOptions, UseClipboardReturn, UseColorModeOptions, UseColorModeReturn, UseDarkOptions, UseDarkReturn, UseDeviceMotionReturn, UseDeviceOrientationReturn, UseDevicePixelRatioReturn, UseDevicesListOptions, UseDevicesListReturn, UseDocumentVisibilityReturn, UseDraggableOptions, UseElementBoundingOptions, UseElementBoundingReturn, UseElementHoverOptions, UseElementSizeReturn, UseElementVisibilityOptions, UseElementVisibilityReturn, UseEyeDropperOptions, UseEyeDropperReturn, UseFullscreenOptions, UseFullscreenReturn, UseGeolocationOptions, UseGeolocationReturn, UseIdleOptions, UseIdleReturn, UseImageOptions, UseImageReturn, UseInfiniteScrollOptions, UseIntersectionObserverOptions, UseMouseInElementReturn, UseMouseOptions, UseMousePressedReturn, UseMouseReturn, UseNetworkReturn, UseNowOptions, UseNowReturn, UseOffsetPaginationOptions, UseOffsetPaginationReturn, UseOnLongPressReturn, UsePageLeaveReturn, UsePointerLockOptions, UsePointerLockReturn, UsePointerOptions, UsePointerReturn, UseResizeObserverOptions, UseScreenSafeAreaReturn, UseScrollOptions, UseScrollReturn, UseTimeAgoOptions, UseTimeAgoReturn, UseTimestampOptions, UseTimestampReturn, UseVirtualListOptions, UseWindowSizeOptions, UseWindowSizeReturn, useElementSize, useInfiniteScroll } from "@vueuse/core";
+import * as vue1 from "vue";
+import { ComputedRef, FunctionDirective, MaybeRef, ObjectDirective, Reactive, Ref, ShallowRef, SlotsType, UnwrapRef } from "vue";
+import { ToggleFn } from "@vueuse/shared";
+
+//#region ../core/onClickOutside/component.d.ts
+interface OnClickOutsideProps extends RenderableComponent {
+  options?: Omit<OnClickOutsideOptions, 'controls'>;
+}
+type OnClickOutsideEmits = {
+  trigger: (event: Event) => void;
+};
+declare const OnClickOutside: vue1.DefineSetupFnComponent<OnClickOutsideProps, OnClickOutsideEmits, {}, OnClickOutsideProps & {
+  onTrigger?: ((event: Event) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/onClickOutside/directive.d.ts
+declare const vOnClickOutside: ObjectDirective<HTMLElement, OnClickOutsideHandler | [(evt: any) => void, Omit<OnClickOutsideOptions, 'controls'>]>;
+/** @deprecated use `vOnClickOutside` instead */
+declare const VOnClickOutside: ObjectDirective<HTMLElement, OnClickOutsideHandler | [(evt: any) => void, Omit<OnClickOutsideOptions<false>, "controls">], string, string>;
+//#endregion
+//#region ../core/onKeyStroke/directive.d.ts
+type BindingValueFunction$10 = (event: KeyboardEvent) => void;
+type BindingValueArray$9 = [BindingValueFunction$10, OnKeyStrokeOptions];
+declare const vOnKeyStroke: ObjectDirective<HTMLElement, BindingValueFunction$10 | BindingValueArray$9>;
+//#endregion
+//#region ../core/onLongPress/component.d.ts
+interface OnLongPressProps extends RenderableComponent {
+  options?: OnLongPressOptions;
+}
+type OnLongPressEmits = {
+  trigger: (event: PointerEvent) => void;
+};
+interface OnLongPressSlots {
+  default: (data: UseOnLongPressReturn) => any;
+}
+declare const OnLongPress: vue1.DefineSetupFnComponent<OnLongPressProps, OnLongPressEmits, SlotsType<OnLongPressSlots>, OnLongPressProps & {
+  onTrigger?: ((event: PointerEvent) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/onLongPress/directive.d.ts
+type BindingValueFunction$9 = (evt: PointerEvent) => void;
+type BindingValueArray$8 = [BindingValueFunction$9, OnLongPressOptions];
+declare const vOnLongPress: ObjectDirective<HTMLElement, BindingValueFunction$9 | BindingValueArray$8>;
+/** @deprecated use `vOnLongPress` instead */
+declare const VOnLongPress: ObjectDirective<HTMLElement, BindingValueFunction$9 | BindingValueArray$8, string, string>;
+//#endregion
+//#region ../core/useActiveElement/component.d.ts
+interface UseActiveElementProps extends UseActiveElementOptions {}
+interface UseActiveElementSlots {
+  default: (data: Reactive<{
+    element: UseActiveElementReturn;
+  }>) => any;
+}
+declare const UseActiveElement: vue1.DefineSetupFnComponent<UseActiveElementProps, Record<string, never>, SlotsType<UseActiveElementSlots>, UseActiveElementProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useBattery/component.d.ts
+interface UseBatteryProps extends ConfigurableNavigator {}
+interface UseBatterySlots {
+  default: (data: Reactive<UseBatteryReturn>) => any;
+}
+declare const UseBattery: vue1.DefineSetupFnComponent<UseBatteryProps, Record<string, never>, SlotsType<UseBatterySlots>, UseBatteryProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useBrowserLocation/component.d.ts
+interface UseBrowserLocationProps extends ConfigurableWindow {}
+interface UseBrowserLocationSlots {
+  default: (data: Reactive<UseBrowserLocationReturn>) => any;
+}
+declare const UseBrowserLocation: vue1.DefineSetupFnComponent<UseBrowserLocationProps, Record<string, never>, SlotsType<UseBrowserLocationSlots>, UseBrowserLocationProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useClipboard/component.d.ts
+interface UseClipboardProps<Source = string> extends UseClipboardOptions<Source> {}
+interface UseClipboardSlots {
+  default: (data: Reactive<UseClipboardReturn<true>>) => any;
+}
+declare const UseClipboard: vue1.DefineSetupFnComponent<UseClipboardProps<string>, Record<string, never>, SlotsType<UseClipboardSlots>, UseClipboardProps<string> & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useColorMode/component.d.ts
+interface UseColorModeProps extends UseColorModeOptions {}
+interface UseColorModeSlots {
+  default: (data: Reactive<{
+    mode: UseColorModeReturn<BasicColorMode>;
+    system: UseColorModeReturn['system'];
+    store: UseColorModeReturn['store'];
+  }>) => any;
+}
+declare const UseColorMode: vue1.DefineSetupFnComponent<UseColorModeProps, Record<string, never>, SlotsType<UseColorModeSlots>, UseColorModeProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useDark/component.d.ts
+interface UseDarkProps extends UseDarkOptions {}
+interface UseDarkSlots {
+  default: (data: Reactive<{
+    isDark: UseDarkReturn;
+    toggleDark: ToggleFn;
+  }>) => any;
+}
+declare const UseDark: vue1.DefineSetupFnComponent<UseDarkProps, Record<string, never>, SlotsType<UseDarkSlots>, UseDarkProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useDeviceMotion/component.d.ts
+interface UseDeviceMotionProps extends DeviceMotionOptions {}
+interface UseDeviceMotionSlots {
+  default: (data: UseDeviceMotionReturn) => any;
+}
+declare const UseDeviceMotion: vue1.DefineSetupFnComponent<UseDeviceMotionProps, Record<string, never>, SlotsType<UseDeviceMotionSlots>, UseDeviceMotionProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useDeviceOrientation/component.d.ts
+interface UseDeviceOrientationProps extends ConfigurableWindow {}
+interface UseDeviceOrientationSlots {
+  default: (data: Reactive<UseDeviceOrientationReturn>) => any;
+}
+declare const UseDeviceOrientation: vue1.DefineSetupFnComponent<UseDeviceOrientationProps, Record<string, never>, SlotsType<UseDeviceOrientationSlots>, UseDeviceOrientationProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useDevicePixelRatio/component.d.ts
+interface UseDevicePixelRatioProps extends ConfigurableWindow {}
+interface UseDevicePixelRatioSlots {
+  default: (data: Reactive<UseDevicePixelRatioReturn>) => any;
+}
+declare const UseDevicePixelRatio: vue1.DefineSetupFnComponent<UseDevicePixelRatioProps, Record<string, never>, SlotsType<UseDevicePixelRatioSlots>, UseDevicePixelRatioProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useDevicesList/component.d.ts
+interface UseDevicesListProps extends UseDevicesListOptions {}
+interface UseDevicesListSlots {
+  default: (data: Reactive<UseDevicesListReturn>) => any;
+}
+declare const UseDevicesList: vue1.DefineSetupFnComponent<UseDevicesListProps, Record<string, never>, SlotsType<UseDevicesListSlots>, UseDevicesListProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useDocumentVisibility/component.d.ts
+interface UseDocumentVisibilityProps extends ConfigurableDocument {}
+interface UseDocumentVisibilitySlots {
+  default: (data: Reactive<{
+    visibility: UseDocumentVisibilityReturn;
+  }>) => any;
+}
+declare const UseDocumentVisibility: vue1.DefineSetupFnComponent<UseDocumentVisibilityProps, Record<string, never>, SlotsType<UseDocumentVisibilitySlots>, UseDocumentVisibilityProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useDraggable/component.d.ts
+interface UseDraggableProps extends UseDraggableOptions, RenderableComponent {
+  /**
+   * When provided, use `useStorage` to preserve element's position
+   */
+  storageKey?: string;
+  /**
+   * Storage type
+   *
+   * @default 'local'
+   */
+  storageType?: 'local' | 'session';
+}
+declare const UseDraggable: vue1.DefineSetupFnComponent<UseDraggableProps, Record<string, never>, SlotsType<any>, UseDraggableProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useElementBounding/component.d.ts
+interface UseElementBoundingProps extends UseElementBoundingOptions, RenderableComponent {}
+interface UseElementBoundingSlots {
+  default: (data: Reactive<UseElementBoundingReturn>) => any;
+}
+declare const UseElementBounding: vue1.DefineSetupFnComponent<UseElementBoundingProps, Record<string, never>, SlotsType<UseElementBoundingSlots>, UseElementBoundingProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useElementBounding/directive.d.ts
+type ElementBounding = Omit<UseElementBoundingReturn, 'update'>;
+type BindingValueFunction$8 = (bounding: ElementBounding) => void;
+type BindingValueArray$7 = [BindingValueFunction$8, UseElementBoundingOptions];
+declare const vElementBounding: ObjectDirective<HTMLElement, BindingValueFunction$8 | BindingValueArray$7>;
+//#endregion
+//#region ../core/useElementHover/directive.d.ts
+type BindingValueFunction$7 = (state: boolean) => void;
+declare const vElementHover: ObjectDirective<HTMLElement, BindingValueFunction$7 | [handler: BindingValueFunction$7, options: UseElementHoverOptions]>;
+//#endregion
+//#region ../core/useElementSize/component.d.ts
+interface UseElementSizeProps extends Partial<ElementSize>, UseResizeObserverOptions, RenderableComponent {}
+interface UseElementSizeSlots {
+  default: (data: Reactive<UseElementSizeReturn>) => any;
+}
+declare const UseElementSize: vue1.DefineSetupFnComponent<UseElementSizeProps, Record<string, never>, SlotsType<UseElementSizeSlots>, UseElementSizeProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useElementSize/directive.d.ts
+type RemoveFirstFromTuple<T extends any[]> = T['length'] extends 0 ? undefined : (((...b: T) => void) extends ((a: any, ...b: infer I) => void) ? I : []);
+type BindingValueFunction$6 = (size: ElementSize) => void;
+type VElementSizeOptions = RemoveFirstFromTuple<Parameters<typeof useElementSize>>;
+type BindingValueArray$6 = [BindingValueFunction$6, ...VElementSizeOptions];
+declare const vElementSize: ObjectDirective<HTMLElement, BindingValueFunction$6 | BindingValueArray$6>;
+//#endregion
+//#region ../core/useElementVisibility/component.d.ts
+interface UseElementVisibilityProps extends UseElementVisibilityOptions, RenderableComponent {}
+interface UseElementVisibilitySlots {
+  default: (data: Reactive<{
+    isVisible: UseElementVisibilityReturn;
+  }>) => any;
+}
+declare const UseElementVisibility: vue1.DefineSetupFnComponent<UseElementVisibilityProps, Record<string, never>, SlotsType<UseElementVisibilitySlots>, UseElementVisibilityProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useElementVisibility/directive.d.ts
+type BindingValueFunction$5 = (state: boolean) => void;
+type BindingValueArray$5 = [BindingValueFunction$5, UseElementVisibilityOptions];
+declare const vElementVisibility: ObjectDirective<HTMLElement, BindingValueFunction$5 | BindingValueArray$5>;
+//#endregion
+//#region ../core/useEyeDropper/component.d.ts
+interface UseEyeDropperProps extends UseEyeDropperOptions {}
+interface UseEyeDropperSlots {
+  default: (data: Reactive<UseEyeDropperReturn>) => any;
+}
+declare const UseEyeDropper: vue1.DefineSetupFnComponent<UseEyeDropperProps, Record<string, never>, SlotsType<UseEyeDropperSlots>, UseEyeDropperProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useFullscreen/component.d.ts
+interface UseFullscreenProps extends UseFullscreenOptions, RenderableComponent {}
+interface UseFullscreenSlots {
+  default: (data: Reactive<UseFullscreenReturn>) => any;
+}
+declare const UseFullscreen: vue1.DefineSetupFnComponent<UseFullscreenProps, Record<string, never>, SlotsType<UseFullscreenSlots>, UseFullscreenProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useGeolocation/component.d.ts
+interface UseGeolocationProps extends UseGeolocationOptions {}
+interface UseGeolocationSlots {
+  default: (data: Reactive<UseGeolocationReturn>) => any;
+}
+declare const UseGeolocation: vue1.DefineSetupFnComponent<UseGeolocationProps, Record<string, never>, SlotsType<UseGeolocationSlots>, UseGeolocationProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useIdle/component.d.ts
+interface UseIdleProps extends UseIdleOptions {
+  timeout: number;
+}
+interface UseIdleSlots {
+  default: (data: Reactive<UseIdleReturn>) => any;
+}
+declare const UseIdle: vue1.DefineSetupFnComponent<UseIdleProps, Record<string, never>, SlotsType<UseIdleSlots>, UseIdleProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/types.d.ts
+interface RenderableComponent$1 {
+  /**
+   * The element that the component should be rendered as
+   *
+   * @default 'div'
+   */
+  as?: object | string;
+}
+//#endregion
+//#region ../core/useImage/component.d.ts
+interface UseImageProps extends UseImageOptions, RenderableComponent$1 {}
+interface UseImageSlots {
+  default: (data: Reactive<UseImageReturn>) => any;
+  loading: (data: Reactive<UseImageReturn>) => any;
+  error: (data: UnwrapRef<UseImageReturn['error']>) => any;
+}
+declare const UseImage: vue1.DefineSetupFnComponent<UseImageProps, Record<string, never>, SlotsType<UseImageSlots>, UseImageProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useInfiniteScroll/directive.d.ts
+type BindingValueFunction$4 = Parameters<typeof useInfiniteScroll>[1];
+type BindingValueArray$4 = [BindingValueFunction$4, UseInfiniteScrollOptions];
+declare const vInfiniteScroll: ObjectDirective<HTMLElement, BindingValueFunction$4 | BindingValueArray$4>;
+//#endregion
+//#region ../core/useIntersectionObserver/directive.d.ts
+type BindingValueFunction$3 = IntersectionObserverCallback;
+type BindingValueArray$3 = [BindingValueFunction$3, UseIntersectionObserverOptions];
+declare const vIntersectionObserver: ObjectDirective<HTMLElement, BindingValueFunction$3 | BindingValueArray$3>;
+//#endregion
+//#region ../core/useMouse/component.d.ts
+interface UseMouseProps extends UseMouseOptions {}
+interface UseMouseSlots {
+  default: (data: Reactive<UseMouseReturn>) => any;
+}
+declare const UseMouse: vue1.DefineSetupFnComponent<UseMouseProps, Record<string, never>, SlotsType<UseMouseSlots>, UseMouseProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useMouseInElement/component.d.ts
+interface UseMouseInElementProps extends MouseInElementOptions, RenderableComponent {}
+interface UseMouseInElementSlots {
+  default: (data: Reactive<UseMouseInElementReturn>) => any;
+}
+declare const UseMouseInElement: vue1.DefineSetupFnComponent<UseMouseInElementProps, Record<string, never>, SlotsType<UseMouseInElementSlots>, UseMouseInElementProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useMouseInElement/directive.d.ts
+type MouseInElement = Omit<UseMouseInElementReturn, 'stop'>;
+type BindingValueFunction$2 = (mouse: Reactive<MouseInElement>) => void;
+type BindingValueArray$2 = [BindingValueFunction$2, MouseInElementOptions];
+declare const vMouseInElement: ObjectDirective<HTMLElement, BindingValueFunction$2 | BindingValueArray$2>;
+//#endregion
+//#region ../core/useMousePressed/component.d.ts
+interface UseMousePressedProps extends Omit<MousePressedOptions, 'target'>, RenderableComponent {}
+interface UseMousePressedSlots {
+  default: (data: Reactive<UseMousePressedReturn>) => any;
+}
+declare const UseMousePressed: vue1.DefineSetupFnComponent<UseMousePressedProps, Record<string, never>, SlotsType<UseMousePressedSlots>, UseMousePressedProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useNetwork/component.d.ts
+interface UseNetworkProps extends ConfigurableWindow {}
+interface UseNetworkSlots {
+  default: (data: Reactive<UseNetworkReturn>) => any;
+}
+declare const UseNetwork: vue1.DefineSetupFnComponent<UseNetworkProps, Record<string, never>, SlotsType<UseNetworkSlots>, UseNetworkProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useNow/component.d.ts
+interface UseNowProps extends Omit<UseNowOptions<true>, 'controls'> {}
+interface UseNowSlots {
+  default: (data: Reactive<UseNowReturn>) => any;
+}
+declare const UseNow: vue1.DefineSetupFnComponent<UseNowProps, Record<string, never>, SlotsType<UseNowSlots>, UseNowProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useObjectUrl/component.d.ts
+interface UseObjectUrlProps {
+  object: Blob | MediaSource | undefined;
+}
+interface UseObjectUrlSlots {
+  default: (data: Readonly<string | undefined>) => any;
+}
+declare const UseObjectUrl: vue1.DefineSetupFnComponent<UseObjectUrlProps, Record<string, never>, SlotsType<UseObjectUrlSlots>, UseObjectUrlProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useOffsetPagination/component.d.ts
+interface UseOffsetPaginationProps extends UseOffsetPaginationOptions {}
+type UseOffsetPaginationEmits = {
+  'page-change': (...args: Parameters<NonNullable<UseOffsetPaginationOptions['onPageChange']>>) => void;
+  'page-size-change': (...args: Parameters<NonNullable<UseOffsetPaginationOptions['onPageSizeChange']>>) => void;
+  'page-count-change': (...args: Parameters<NonNullable<UseOffsetPaginationOptions['onPageCountChange']>>) => void;
+};
+interface UseOffsetPaginationSlots {
+  default: (data: Reactive<UseOffsetPaginationReturn>) => any;
+}
+declare const UseOffsetPagination: vue1.DefineSetupFnComponent<UseOffsetPaginationProps, UseOffsetPaginationEmits, SlotsType<UseOffsetPaginationSlots>, UseOffsetPaginationProps & {
+  "onPage-change"?: ((returnValue: {
+    currentPage: number;
+    currentPageSize: number;
+    pageCount: number;
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    prev: () => void;
+    next: () => void;
+  }) => any) | undefined;
+  "onPage-size-change"?: ((returnValue: {
+    currentPage: number;
+    currentPageSize: number;
+    pageCount: number;
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    prev: () => void;
+    next: () => void;
+  }) => any) | undefined;
+  "onPage-count-change"?: ((returnValue: {
+    currentPage: number;
+    currentPageSize: number;
+    pageCount: number;
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    prev: () => void;
+    next: () => void;
+  }) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useOnline/component.d.ts
+interface UseOnlineProps extends ConfigurableWindow {}
+interface UseOnlineSlots {
+  default: (data: Reactive<{
+    isOnline: UseNetworkReturn['isOnline'];
+  }>) => any;
+}
+declare const UseOnline: vue1.DefineSetupFnComponent<UseOnlineProps, Record<string, never>, SlotsType<UseOnlineSlots>, UseOnlineProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/usePageLeave/component.d.ts
+interface UsePageLeaveProps extends ConfigurableWindow {}
+interface UsePageLeaveSlots {
+  default: (data: Reactive<{
+    isLeft: UsePageLeaveReturn;
+  }>) => any;
+}
+declare const UsePageLeave: vue1.DefineSetupFnComponent<UsePageLeaveProps, Record<string, never>, SlotsType<UsePageLeaveSlots>, UsePageLeaveProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/usePointer/component.d.ts
+interface UsePointerProps extends Omit<UsePointerOptions, 'target'> {
+  target?: 'window' | 'self';
+}
+interface UsePointerSlots {
+  default: (data: Reactive<UsePointerReturn>) => any;
+}
+declare const UsePointer: vue1.DefineSetupFnComponent<UsePointerProps, Record<string, never>, SlotsType<UsePointerSlots>, UsePointerProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/usePointerLock/component.d.ts
+interface UsePointerLockProps extends RenderableComponent, UsePointerLockOptions {}
+interface UsePointerLockSlots {
+  default: (data: Reactive<UsePointerLockReturn>) => any;
+}
+declare const UsePointerLock: vue1.DefineSetupFnComponent<UsePointerLockProps, Record<string, never>, SlotsType<UsePointerLockSlots>, UsePointerLockProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/usePreferredColorScheme/component.d.ts
+interface UsePreferredColorSchemeProps extends ConfigurableWindow {}
+interface UsePreferredColorSchemeSlots {
+  default: (data: Reactive<{
+    colorScheme: ComputedRef<ColorSchemeType>;
+  }>) => any;
+}
+declare const UsePreferredColorScheme: vue1.DefineSetupFnComponent<UsePreferredColorSchemeProps, Record<string, never>, SlotsType<UsePreferredColorSchemeSlots>, UsePreferredColorSchemeProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/usePreferredContrast/component.d.ts
+interface UsePreferredContrastProps extends ConfigurableWindow {}
+interface UsePreferredContrastSlots {
+  default: (data: Reactive<{
+    contrast: ComputedRef<ContrastType>;
+  }>) => any;
+}
+declare const UsePreferredContrast: vue1.DefineSetupFnComponent<UsePreferredContrastProps, Record<string, never>, SlotsType<UsePreferredContrastSlots>, UsePreferredContrastProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/usePreferredDark/component.d.ts
+interface UsePreferredDarkProps extends ConfigurableWindow {}
+interface UsePreferredDarkSlots {
+  default: (data: Reactive<{
+    prefersDark: ComputedRef<boolean>;
+  }>) => any;
+}
+declare const UsePreferredDark: vue1.DefineSetupFnComponent<UsePreferredDarkProps, Record<string, never>, SlotsType<UsePreferredDarkSlots>, UsePreferredDarkProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/usePreferredLanguages/component.d.ts
+interface UsePreferredLanguagesProps extends ConfigurableWindow {}
+interface UsePreferredLanguagesSlots {
+  default: (data: Reactive<{
+    languages: Ref<readonly string[]>;
+  }>) => any;
+}
+declare const UsePreferredLanguages: vue1.DefineSetupFnComponent<UsePreferredLanguagesProps, Record<string, never>, SlotsType<UsePreferredLanguagesSlots>, UsePreferredLanguagesProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/usePreferredReducedMotion/component.d.ts
+interface UsePreferredReducedMotionProps extends ConfigurableWindow {}
+interface UsePreferredReducedMotionSlots {
+  default: (data: Reactive<{
+    motion: ComputedRef<ReducedMotionType>;
+  }>) => any;
+}
+declare const UsePreferredReducedMotion: vue1.DefineSetupFnComponent<UsePreferredReducedMotionProps, Record<string, never>, SlotsType<UsePreferredReducedMotionSlots>, UsePreferredReducedMotionProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/usePreferredReducedTransparency/component.d.ts
+declare const UsePreferredReducedTransparency: vue1.DefineComponent<{}, () => vue1.VNode<vue1.RendererNode, vue1.RendererElement, {
+  [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue1.ComponentOptionsMixin, vue1.ComponentOptionsMixin, {}, string, vue1.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue1.ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region ../core/useResizeObserver/directive.d.ts
+type BindingValueFunction$1 = ResizeObserverCallback;
+type BindingValueArray$1 = [BindingValueFunction$1, UseResizeObserverOptions];
+declare const vResizeObserver: ObjectDirective<HTMLElement, BindingValueFunction$1 | BindingValueArray$1>;
+//#endregion
+//#region ../core/useScreenSafeArea/component.d.ts
+interface UseScreenSafeAreaProps extends RenderableComponent {
+  top?: boolean;
+  right?: boolean;
+  bottom?: boolean;
+  left?: boolean;
+}
+interface UseScreenSafeAreaSlots {
+  default: (data: Reactive<UseScreenSafeAreaReturn>) => any;
+}
+declare const UseScreenSafeArea: vue1.DefineSetupFnComponent<UseScreenSafeAreaProps, Record<string, never>, SlotsType<UseScreenSafeAreaSlots>, UseScreenSafeAreaProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useScroll/directive.d.ts
+type BindingValueFunction = (state: UseScrollReturn) => void;
+type BindingValueArray = [BindingValueFunction, UseScrollOptions];
+declare const vScroll: ObjectDirective<HTMLElement, BindingValueFunction | BindingValueArray>;
+//#endregion
+//#region ../core/useScrollLock/directive.d.ts
+declare const vScrollLock: FunctionDirective<HTMLElement, boolean>;
+//#endregion
+//#region ../core/useTimeAgo/component.d.ts
+interface UseTimeAgoProps extends Omit<UseTimeAgoOptions<true>, 'controls'> {
+  time: MaybeRef<Date | number | string>;
+}
+interface UseTimeAgoSlots {
+  default: (data: Reactive<UseTimeAgoReturn<true>>) => any;
+}
+declare const UseTimeAgo: vue1.DefineSetupFnComponent<UseTimeAgoProps, Record<string, never>, SlotsType<UseTimeAgoSlots>, UseTimeAgoProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useTimestamp/component.d.ts
+interface UseTimestampProps extends Omit<UseTimestampOptions<true>, 'controls'> {}
+interface UseTimestampSlots {
+  default: (data: Reactive<UseTimestampReturn>) => any;
+}
+declare const UseTimestamp: vue1.DefineSetupFnComponent<UseTimestampProps, Record<string, never>, SlotsType<UseTimestampSlots>, UseTimestampProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useVirtualList/component.d.ts
+interface UseVirtualListProps {
+  /**
+   * data of scrollable list
+   *
+   * @default []
+   */
+  list: Array<any>;
+  /**
+   * useVirtualList's options
+   *
+   * @default {}
+   */
+  options: UseVirtualListOptions;
+  /**
+   * virtualList's height
+   *
+   * @default 300px
+   */
+  height: string;
+}
+declare const UseVirtualList: vue1.DefineSetupFnComponent<UseVirtualListProps, {}, {}, UseVirtualListProps & {}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useWindowFocus/component.d.ts
+interface UseWindowFocusProps extends ConfigurableWindow {}
+interface UseWindowFocusSlots {
+  default: (data: Reactive<{
+    focused: ShallowRef<boolean>;
+  }>) => any;
+}
+declare const UseWindowFocus: vue1.DefineSetupFnComponent<UseWindowFocusProps, Record<string, never>, SlotsType<UseWindowFocusSlots>, UseWindowFocusProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+//#region ../core/useWindowSize/component.d.ts
+interface UseWindowSizeProps extends UseWindowSizeOptions {}
+interface UseWindowSizeSlots {
+  default: (data: Reactive<UseWindowSizeReturn>) => any;
+}
+declare const UseWindowSize: vue1.DefineSetupFnComponent<UseWindowSizeProps, Record<string, never>, SlotsType<UseWindowSizeSlots>, UseWindowSizeProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue1.PublicProps>;
+//#endregion
+export { OnClickOutside, OnClickOutsideEmits, OnClickOutsideProps, OnLongPress, OnLongPressEmits, OnLongPressProps, UseActiveElement, UseActiveElementProps, UseBattery, UseBatteryProps, UseBrowserLocation, UseClipboard, UseClipboardProps, UseColorMode, UseColorModeProps, UseDark, UseDarkProps, UseDeviceMotion, UseDeviceMotionProps, UseDeviceOrientation, UseDeviceOrientationProps, UseDevicePixelRatio, UseDevicePixelRatioProps, UseDevicesList, UseDevicesListProps, UseDocumentVisibility, UseDocumentVisibilityProps, UseDraggable, UseDraggableProps, UseElementBounding, UseElementBoundingProps, UseElementSize, UseElementSizeProps, UseElementVisibility, UseElementVisibilityProps, UseEyeDropper, UseEyeDropperProps, UseFullscreen, UseFullscreenProps, UseGeolocation, UseGeolocationProps, UseIdle, UseIdleProps, UseImage, UseImageProps, UseMouse, UseMouseInElement, UseMouseInElementProps, UseMousePressed, UseMousePressedProps, UseMouseProps, UseNetwork, UseNetworkProps, UseNow, UseNowProps, UseObjectUrl, UseObjectUrlProps, UseOffsetPagination, UseOffsetPaginationEmits, UseOffsetPaginationProps, UseOnline, UseOnlineProps, UsePageLeave, UsePageLeaveProps, UsePointer, UsePointerLock, UsePointerLockProps, UsePointerProps, UsePreferredColorScheme, UsePreferredColorSchemeProps, UsePreferredContrast, UsePreferredContrastProps, UsePreferredDark, UsePreferredDarkProps, UsePreferredLanguages, UsePreferredLanguagesProps, UsePreferredReducedMotion, UsePreferredReducedMotionProps, UsePreferredReducedTransparency, UseScreenSafeArea, UseScreenSafeAreaProps, UseTimeAgo, UseTimeAgoProps, UseTimestamp, UseTimestampProps, UseVirtualList, UseVirtualListProps, UseWindowFocus, UseWindowFocusProps, UseWindowSize, UseWindowSizeProps, VOnClickOutside, VOnLongPress, vElementBounding, vElementHover, vElementSize, vElementVisibility, vInfiniteScroll, vIntersectionObserver, vMouseInElement, vOnClickOutside, vOnKeyStroke, vOnLongPress, vResizeObserver, vScroll, vScrollLock };