@vueuse/components/dist/index.d.ts

Renderless components for VueUse

import { BasicColorMode, ColorSchemeType, ConfigurableDocument, ConfigurableNavigator, ConfigurableWindow, ContrastType, DeviceMotionOptions, ElementSize, MouseInElementOptions, MousePressedOptions, OnClickOutsideHandler, OnClickOutsideOptions, OnKeyStrokeOptions, OnLongPressOptions, ReducedMotionType, RenderableComponent, 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, any>;
//#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, any>;
//#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 };