@mantine-vue/hooks 1.1.2

package/lib/use-focus-within/use-focus-within.d.ts

@@ -0,0 +1,10 @@
+import { type Ref } from 'vue';
+export interface UseFocusWithinOptions {
+    onFocus?: (event: FocusEvent) => void;
+    onBlur?: (event: FocusEvent) => void;
+}
+export interface UseFocusWithinReturnValue<T extends HTMLElement = HTMLElement> {
+    ref: Ref<T | null>;
+    focused: Ref<boolean>;
+}
+export declare function useFocusWithin<T extends HTMLElement = HTMLElement>(options?: UseFocusWithinOptions): UseFocusWithinReturnValue<T>;

package/lib/use-force-update/use-force-update.d.ts

@@ -0,0 +1,2 @@
+import { type Ref } from 'vue';
+export declare function useForceUpdate(): [Ref<number>, () => void];

package/lib/use-fullscreen/use-fullscreen.d.ts

@@ -0,0 +1,12 @@
+import { type Ref } from 'vue';
+export interface UseFullscreenElementReturnValue<T extends HTMLElement = HTMLElement> {
+    ref: Ref<T | null>;
+    toggle: () => Promise<void>;
+    fullscreen: Ref<boolean>;
+}
+export declare function useFullscreenElement<T extends HTMLElement = HTMLElement>(): UseFullscreenElementReturnValue<T>;
+export interface UseFullscreenDocumentReturnValue {
+    toggle: () => Promise<void>;
+    fullscreen: Ref<boolean>;
+}
+export declare function useFullscreenDocument(): UseFullscreenDocumentReturnValue;

package/lib/use-hash/use-hash.d.ts

@@ -0,0 +1,6 @@
+import { type Ref } from 'vue';
+export interface UseHashInput {
+    getInitialValueInEffect?: boolean;
+}
+export type UseHashReturnValue = [Ref<string>, (value: string) => void];
+export declare function useHash(options?: UseHashInput): UseHashReturnValue;

package/lib/use-headroom/use-headroom.d.ts

@@ -0,0 +1,27 @@
+import { type Ref } from 'vue';
+export { useScrollDirection } from '../use-scroll-direction/use-scroll-direction';
+export declare const isFixed: (current: number, fixedAt: number) => boolean;
+export declare const isPinned: (current: number, previous: number) => boolean;
+export declare const isReleased: (current: number, previous: number, fixedAt: number) => boolean;
+export declare const isPinnedOrReleased: (current: number, fixedAt: number, isCurrentlyPinnedRef: {
+    value: boolean;
+}, isScrollingUp: boolean, onPin?: () => void, onRelease?: () => void) => void;
+export interface UseHeadroomInput {
+    /** Number in px at which element should be fixed */
+    fixedAt?: number;
+    /** Number of px to scroll to fully reveal or hide the element, 100 by default */
+    scrollDistance?: number;
+    /** Called when element is pinned */
+    onPin?: () => void;
+    /** Called when element is at fixed position */
+    onFix?: () => void;
+    /** Called when element is unpinned */
+    onRelease?: () => void;
+}
+export interface UseHeadroomReturnValue {
+    /** True when the element is at least partially visible */
+    pinned: Ref<boolean>;
+    /** Reveal progress: 0 = fully hidden, 1 = fully visible */
+    scrollProgress: Ref<number>;
+}
+export declare function useHeadroom({ fixedAt, scrollDistance, onPin, onFix, onRelease, }?: UseHeadroomInput): UseHeadroomReturnValue;

package/lib/use-hotkeys/parse-hotkey.d.ts

@@ -0,0 +1,20 @@
+export interface KeyboardModifiers {
+    alt: boolean;
+    ctrl: boolean;
+    meta: boolean;
+    mod: boolean;
+    shift: boolean;
+}
+export interface Hotkey extends KeyboardModifiers {
+    key?: string;
+}
+type CheckHotkeyMatch = (event: KeyboardEvent) => boolean;
+export declare function parseHotkey(hotkey: string): Hotkey;
+export declare function getHotkeyMatcher(hotkey: string, usePhysicalKeys?: boolean): CheckHotkeyMatch;
+export interface HotkeyItemOptions {
+    preventDefault?: boolean;
+    usePhysicalKeys?: boolean;
+}
+type HotkeyItemTuple = [string, (event: any) => void, HotkeyItemOptions?];
+export declare function getHotkeyHandler(hotkeys: HotkeyItemTuple[]): (event: KeyboardEvent) => void;
+export {};

package/lib/use-hotkeys/use-hotkeys.d.ts

@@ -0,0 +1,15 @@
+import { type MaybeRefOrGetter } from 'vue';
+import { getHotkeyHandler, type HotkeyItemOptions } from './parse-hotkey';
+export type { HotkeyItemOptions };
+export { getHotkeyHandler };
+export type HotkeyItem = [string, (event: KeyboardEvent) => void, HotkeyItemOptions?];
+/**
+ * Listens for global keydown events and invokes matching handlers.
+ *
+ * NOTE: the listener is attached to `window` rather than
+ * `document.documentElement` (which is what React Mantine uses). Real
+ * keyboard events always bubble to `window`, so this is behaviorally
+ * equivalent for actual usage while remaining consistent with how the rest
+ * of this package (and its test suite) dispatches synthetic events.
+ */
+export declare function useHotkeys(hotkeys: MaybeRefOrGetter<HotkeyItem[]>, tagsToIgnore?: MaybeRefOrGetter<string[] | undefined>, triggerOnContentEditable?: MaybeRefOrGetter<boolean | undefined>): void;

package/lib/use-hover/use-hover.d.ts

@@ -0,0 +1,6 @@
+import { type Ref } from 'vue';
+export interface UseHoverReturnValue<T extends HTMLElement = HTMLElement> {
+    ref: Ref<T | null>;
+    hovered: Ref<boolean>;
+}
+export declare function useHover<T extends HTMLElement = HTMLElement>(): UseHoverReturnValue<T>;

package/lib/use-id/use-id.d.ts

@@ -0,0 +1,2 @@
+import { type Ref } from 'vue';
+export declare function useId(staticId?: string): Ref<string>;

package/lib/use-idle/use-idle.d.ts

@@ -0,0 +1,6 @@
+import { type MaybeRefOrGetter, type Ref } from 'vue';
+export interface UseIdleOptions {
+    events?: (keyof DocumentEventMap)[];
+    initialState?: boolean;
+}
+export declare function useIdle(timeout: MaybeRefOrGetter<number>, options?: UseIdleOptions): Ref<boolean>;

package/lib/use-in-viewport/use-in-viewport.d.ts

@@ -0,0 +1,6 @@
+import { type Ref } from 'vue';
+export interface UseInViewportReturnValue<T extends HTMLElement = HTMLElement> {
+    inViewport: Ref<boolean>;
+    ref: Ref<T | null>;
+}
+export declare function useInViewport<T extends HTMLElement = HTMLElement>(): UseInViewportReturnValue<T>;

package/lib/use-input-state/use-input-state.d.ts

@@ -0,0 +1,6 @@
+import { type Ref } from 'vue';
+export type UseInputStateReturnValue<T> = [
+    Ref<T>,
+    (eventOrValue: Event | T | ((current: T) => T)) => void
+];
+export declare function useInputState<T>(initialValue: T): UseInputStateReturnValue<T>;

package/lib/use-intersection/use-intersection.d.ts

@@ -0,0 +1,6 @@
+import { type Ref } from 'vue';
+export interface UseIntersectionReturnValue<T extends HTMLElement = HTMLElement> {
+    ref: Ref<T | null>;
+    entry: Ref<IntersectionObserverEntry | null>;
+}
+export declare function useIntersection<T extends HTMLElement = HTMLElement>(options?: IntersectionObserverInit): UseIntersectionReturnValue<T>;

package/lib/use-interval/use-interval.d.ts

@@ -0,0 +1,16 @@
+import { type MaybeRefOrGetter, type Ref } from 'vue';
+export interface UseIntervalOptions {
+    /** If set, the interval will start automatically when the component is mounted, `false` by default */
+    autoInvoke?: boolean;
+}
+export interface UseIntervalReturnValue {
+    /** Starts the interval */
+    start: () => void;
+    /** Stops the interval */
+    stop: () => void;
+    /** Toggles the interval */
+    toggle: () => void;
+    /** Indicates if the interval is active */
+    active: Ref<boolean>;
+}
+export declare function useInterval(fn: () => void, interval: MaybeRefOrGetter<number>, options?: UseIntervalOptions): UseIntervalReturnValue;

package/lib/use-is-first-render/use-is-first-render.d.ts

@@ -0,0 +1,2 @@
+import { type Ref } from 'vue';
+export declare function useIsFirstRender(): Readonly<Ref<boolean>>;

package/lib/use-isomorphic-effect/use-isomorphic-effect.d.ts

@@ -0,0 +1 @@
+export declare function useIsomorphicEffect(effect: () => void): void;

package/lib/use-list-state/use-list-state.d.ts

@@ -0,0 +1,25 @@
+import { type Ref } from 'vue';
+export interface UseListStateHandlers<T> {
+    setState: (value: T[] | ((current: T[]) => T[])) => void;
+    append: (...items: T[]) => void;
+    prepend: (...items: T[]) => void;
+    insert: (index: number, ...items: T[]) => void;
+    pop: () => void;
+    shift: () => void;
+    apply: (fn: (item: T, index?: number) => T) => void;
+    applyWhere: (condition: (item: T, index: number) => boolean, fn: (item: T, index?: number) => T) => void;
+    remove: (...indices: number[]) => void;
+    reorder: (payload: {
+        from: number;
+        to: number;
+    }) => void;
+    swap: (payload: {
+        from: number;
+        to: number;
+    }) => void;
+    setItem: (index: number, item: T) => void;
+    setItemProp: <K extends keyof T, U extends T[K]>(index: number, prop: K, value: U) => void;
+    filter: (fn: (item: T, i: number) => boolean) => void;
+}
+export type UseListStateReturnValue<T> = [Ref<T[]>, UseListStateHandlers<T>];
+export declare function useListState<T>(initialValue?: T[] | (() => T[])): UseListStateReturnValue<T>;

package/lib/use-local-storage/create-storage.d.ts

@@ -0,0 +1,23 @@
+import { type Ref } from 'vue';
+export type StorageType = 'localStorage' | 'sessionStorage';
+export interface UseStorageOptions<T> {
+    /** Storage key */
+    key: string;
+    /** Default value that will be set if value is not found in storage */
+    defaultValue?: T;
+    /** If set to true, the real storage value is read after mount rather than during initialization. Default value is true. */
+    getInitialValueInEffect?: boolean;
+    /** Determines whether the value must be synced between browser tabs, `true` by default */
+    sync?: boolean;
+    /** Function to serialize value into string to be saved in storage */
+    serialize?: (value: T) => string;
+    /** Function to deserialize string value from storage to value */
+    deserialize?: (value: string | undefined) => T;
+}
+export type UseStorageReturnValue<T> = [
+    Ref<T>,
+    (val: T | ((prevState: T) => T)) => void,
+    () => void
+];
+export declare function createStorage<T>(type: StorageType, hookName: string): ({ key, defaultValue, getInitialValueInEffect, sync, deserialize, serialize, }: UseStorageOptions<T>) => UseStorageReturnValue<T>;
+export declare function readValue(type: StorageType): <T>({ key, defaultValue, deserialize, }: UseStorageOptions<T>) => T;

package/lib/use-local-storage/use-local-storage.d.ts

@@ -0,0 +1,3 @@
+import { type UseStorageOptions, type UseStorageReturnValue } from './create-storage';
+export declare function readLocalStorageValue<T>(options: UseStorageOptions<T>): T;
+export declare function useLocalStorage<T>(options: UseStorageOptions<T>): UseStorageReturnValue<T>;

package/lib/use-logger/use-logger.d.ts

@@ -0,0 +1,2 @@
+import { type MaybeRefOrGetter } from 'vue';
+export declare function useLogger(componentName: string, props: MaybeRefOrGetter<unknown>[]): null;

package/lib/use-long-press/use-long-press.d.ts

@@ -0,0 +1,20 @@
+export type UseLongPressEvent = 'mouse' | 'touch';
+export interface UseLongPressOptions {
+    threshold?: number;
+    events?: UseLongPressEvent[];
+    cancelOnMove?: boolean | number;
+    onStart?: (event: MouseEvent | TouchEvent) => void;
+    onFinish?: (event: MouseEvent | TouchEvent) => void;
+    onCancel?: (event: MouseEvent | TouchEvent) => void;
+}
+export interface UseLongPressReturnValue {
+    onMousedown?: (event: MouseEvent) => void;
+    onMouseup?: (event: MouseEvent) => void;
+    onMouseleave?: (event: MouseEvent) => void;
+    onMousemove?: (event: MouseEvent) => void;
+    onTouchstart?: (event: TouchEvent) => void;
+    onTouchend?: (event: TouchEvent) => void;
+    onTouchcancel?: (event: TouchEvent) => void;
+    onTouchmove?: (event: TouchEvent) => void;
+}
+export declare function useLongPress(onLongPress: (event: MouseEvent | TouchEvent) => void, options?: UseLongPressOptions): UseLongPressReturnValue;

package/lib/use-map/use-map.d.ts

@@ -0,0 +1 @@
+export declare function useMap<T, V>(initialState?: [T, V][]): Map<T, V>;

package/lib/use-mask/use-mask.d.ts

@@ -0,0 +1,57 @@
+import { type Ref } from 'vue';
+export interface UseMaskOptions {
+    /** Mask pattern string or array of string literals and RegExp objects */
+    mask: string | Array<string | RegExp>;
+    /** Override or extend the default token map */
+    tokens?: Record<string, RegExp>;
+    /** Called before masking on each keystroke, can return overrides for mask options */
+    modify?: (value: string) => Partial<Pick<UseMaskOptions, 'mask' | 'tokens' | 'slotChar' | 'separate'>> | undefined;
+    /** When true, raw and display values are decoupled */
+    separate?: boolean;
+    /** Character displayed in unfilled slots, `"_"` by default */
+    slotChar?: string | null;
+    /** Show mask pattern even when field is empty and unfocused */
+    alwaysShowMask?: boolean;
+    /** Show mask placeholder on focus, `true` by default */
+    showMaskOnFocus?: boolean;
+    /** Transform each character before validation and insertion */
+    transform?: (char: string) => string;
+    /** Clear value on blur when mask is incomplete, `false` by default */
+    autoClear?: boolean;
+    /** Sets aria-invalid on the input */
+    invalid?: boolean;
+    /** Called on every change with raw and masked values */
+    onChangeRaw?: (rawValue: string, maskedValue: string) => void;
+    /** Called when all required mask slots are filled */
+    onComplete?: (maskedValue: string, rawValue: string) => void;
+    /** Escape hatch for advanced cursor/value manipulation */
+    beforeMaskedStateChange?: (states: {
+        previousState: MaskState;
+        currentState: MaskState;
+        nextState: MaskState;
+    }) => MaskState;
+}
+export interface MaskState {
+    value: string;
+    selection: {
+        start: number;
+        end: number;
+    } | null;
+}
+export interface UseMaskReturnValue {
+    /** Ref callback to attach to the input element */
+    ref: (node: HTMLInputElement | null) => void;
+    /** Current masked display value */
+    value: Ref<string>;
+    /** Current raw unmasked value */
+    rawValue: Ref<string>;
+    /** Whether all required mask slots are filled */
+    isComplete: Ref<boolean>;
+    /** Clear the input value and reset state */
+    reset: () => void;
+}
+export declare function formatMask(raw: string, options: UseMaskOptions): string;
+export declare function unformatMask(masked: string, options: UseMaskOptions): string;
+export declare function isMaskComplete(masked: string, options: UseMaskOptions): boolean;
+export declare function generatePattern(mode: 'full' | 'full-inexact', options: UseMaskOptions): string;
+export declare function useMask(options: UseMaskOptions): UseMaskReturnValue;

package/lib/use-media-query/use-media-query.d.ts

@@ -0,0 +1,5 @@
+import { type MaybeRefOrGetter, type Ref } from 'vue';
+export interface UseMediaQueryOptions {
+    getInitialValueInEffect?: boolean;
+}
+export declare function useMediaQuery(query: MaybeRefOrGetter<string>, initialValue?: boolean, options?: UseMediaQueryOptions): Readonly<Ref<boolean>>;

package/lib/use-merged-ref/use-merged-ref.d.ts

@@ -0,0 +1,6 @@
+export type VueRefTarget<T> = {
+    value: T | null;
+} | ((value: T | null) => void) | undefined;
+export declare function assignRef<T>(refTarget: VueRefTarget<T>, value: T | null): void;
+export declare function mergeRefs<T>(...refs: VueRefTarget<T>[]): (value: T | null) => void;
+export declare function useMergedRef<T>(...refs: VueRefTarget<T>[]): (value: T | null) => void;

package/lib/use-mounted/use-mounted.d.ts

@@ -0,0 +1,2 @@
+import { type Ref } from 'vue';
+export declare function useMounted(): Readonly<Ref<boolean>>;

package/lib/use-mouse/use-mouse.d.ts

@@ -0,0 +1,15 @@
+import { type Ref } from 'vue';
+export interface UseMouseOptions {
+    resetOnExit?: boolean;
+}
+export interface UseMouseReturnValue<T extends HTMLElement = HTMLElement> {
+    ref: Ref<T | null>;
+    x: Ref<number>;
+    y: Ref<number>;
+}
+export declare function useMouse<T extends HTMLElement = HTMLElement>(options?: UseMouseOptions): UseMouseReturnValue<T>;
+export interface UseMousePositionReturnValue {
+    x: Ref<number>;
+    y: Ref<number>;
+}
+export declare function useMousePosition(): UseMousePositionReturnValue;

package/lib/use-move/use-move.d.ts

@@ -0,0 +1,17 @@
+import { type ComponentPublicInstance } from 'vue';
+export interface UseMovePosition {
+    x: number;
+    y: number;
+}
+export interface UseMoveHandlers {
+    onScrubStart?: () => void;
+    onScrubEnd?: () => void;
+}
+export declare function clampUseMovePosition(position: UseMovePosition): {
+    x: number;
+    y: number;
+};
+export declare function useMove<T extends HTMLElement = HTMLElement>(onChange: (position: UseMovePosition) => void, handlers?: UseMoveHandlers, dir?: 'ltr' | 'rtl'): {
+    ref: (node: Element | ComponentPublicInstance | null) => void;
+    active: Readonly<import("vue").Ref<boolean, boolean>>;
+};

package/lib/use-mutation-observer/use-mutation-observer.d.ts

@@ -0,0 +1,3 @@
+import { type MaybeRefOrGetter, type Ref } from 'vue';
+export declare function useMutationObserver<T extends HTMLElement = HTMLElement>(callback: MutationCallback, options: MutationObserverInit): Ref<T | null>;
+export declare function useMutationObserverTarget(callback: MutationCallback, options: MutationObserverInit, target?: MaybeRefOrGetter<HTMLElement | null | undefined>): void;

package/lib/use-network/use-network.d.ts

@@ -0,0 +1,11 @@
+import { type Ref } from 'vue';
+export interface UserNetworkReturnValue {
+    online: boolean;
+    downlink?: number;
+    downlinkMax?: number;
+    effectiveType?: 'slow-2g' | '2g' | '3g' | '4g';
+    rtt?: number;
+    saveData?: boolean;
+    type?: 'bluetooth' | 'cellular' | 'ethernet' | 'wifi' | 'wimax' | 'none' | 'other' | 'unknown';
+}
+export declare function useNetwork(): Ref<UserNetworkReturnValue>;

package/lib/use-orientation/use-orientation.d.ts

@@ -0,0 +1,23 @@
+import { type Ref } from 'vue';
+export interface UseOrientationOptions {
+    /** Default angle value, used until the real can be retrieved
+     * (during server side rendering and before js executes on the page)
+     * If not provided, the default value is `0`
+     * */
+    defaultAngle?: number;
+    /** Default angle value, used until the real can be retrieved
+     * (during server side rendering and before js executes on the page)
+     * If not provided, the default value is `'landscape-primary'`
+     * */
+    defaultType?: OrientationType;
+    /** If true, the initial value will be resolved after mount (ssr safe)
+     *  If false, the initial value will be resolved synchronously (ssr unsafe)
+     *  True by default.
+     */
+    getInitialValueInEffect?: boolean;
+}
+export interface UseOrientationReturnType {
+    angle: number;
+    type: OrientationType;
+}
+export declare function useOrientation(options?: UseOrientationOptions): Ref<UseOrientationReturnType>;

package/lib/use-os/use-os.d.ts

@@ -0,0 +1,6 @@
+import { type Ref } from 'vue';
+export type UseOSReturnValue = 'undetermined' | 'macos' | 'ios' | 'windows' | 'android' | 'linux' | 'chromeos';
+export interface UseOsOptions {
+    getValueInEffect: boolean;
+}
+export declare function useOs(options?: UseOsOptions): Readonly<Ref<UseOSReturnValue>>;

package/lib/use-page-leave/use-page-leave.d.ts

@@ -0,0 +1,2 @@
+import { type MaybeRefOrGetter } from 'vue';
+export declare function usePageLeave(onPageLeave: MaybeRefOrGetter<() => void>): void;

package/lib/use-pagination/use-pagination.d.ts

@@ -0,0 +1,20 @@
+import { type MaybeRefOrGetter } from 'vue';
+export declare const DOTS: "dots";
+export interface UsePaginationOptions {
+    total: number;
+    siblings?: number;
+    boundaries?: number;
+    page?: MaybeRefOrGetter<number | undefined>;
+    initialPage?: number;
+    onChange?: (page: number) => void;
+    startValue?: number;
+}
+export declare function usePagination({ total, siblings, boundaries, page, initialPage, onChange, startValue, }: UsePaginationOptions): {
+    range: import("vue").ComputedRef<(number | "dots")[]>;
+    active: import("vue").Ref<number, number>;
+    setPage: (pageNumber: number) => void;
+    next: () => void;
+    previous: () => void;
+    first: () => void;
+    last: () => void;
+};

package/lib/use-previous/use-previous.d.ts

@@ -0,0 +1,2 @@
+import { type MaybeRefOrGetter, type ShallowRef } from 'vue';
+export declare function usePrevious<T>(value: MaybeRefOrGetter<T>): ShallowRef<T | undefined>;

package/lib/use-queue/use-queue.d.ts

@@ -0,0 +1,20 @@
+import { type Ref } from 'vue';
+export interface UseQueueOptions<T> {
+    /** Initial values to be added to the queue */
+    initialValues?: T[];
+    /** Maximum number of items in the state */
+    limit: number;
+}
+export interface UseQueueReturnValue<T> {
+    /** Array of items in the queue */
+    queue: Readonly<Ref<T[]>>;
+    /** Array of items in the state */
+    state: Readonly<Ref<T[]>>;
+    /** Function to add items to state or queue */
+    add: (...items: T[]) => void;
+    /** Function to apply updates to current items */
+    update: (fn: (state: T[]) => T[]) => void;
+    /** Function to clear the queue */
+    cleanQueue: () => void;
+}
+export declare function useQueue<T>({ initialValues, limit, }: UseQueueOptions<T>): UseQueueReturnValue<T>;

package/lib/use-radial-move/use-radial-move.d.ts

@@ -0,0 +1,13 @@
+import { type Ref } from 'vue';
+export declare function normalizeRadialValue(degree: number, step: number): number;
+export interface UseRadialMoveOptions {
+    step?: number;
+    onChangeEnd?: (value: number) => void;
+    onScrubStart?: () => void;
+    onScrubEnd?: () => void;
+}
+export interface UseRadialMoveReturnValue<T extends HTMLElement = HTMLElement> {
+    ref: (node: T | null) => void;
+    active: Ref<boolean>;
+}
+export declare function useRadialMove<T extends HTMLElement = HTMLElement>(onChange: (value: number) => void, { step, onChangeEnd, onScrubStart, onScrubEnd }?: UseRadialMoveOptions): UseRadialMoveReturnValue<T>;

package/lib/use-reduced-motion/use-reduced-motion.d.ts

@@ -0,0 +1,3 @@
+import type { Ref } from 'vue';
+import { type UseMediaQueryOptions } from '../use-media-query/use-media-query';
+export declare function useReducedMotion(initialValue?: boolean, options?: UseMediaQueryOptions): Readonly<Ref<boolean>>;

package/lib/use-resize-observer/use-resize-observer.d.ts

@@ -0,0 +1,13 @@
+import { type Ref } from 'vue';
+export type ObserverRect = Omit<DOMRectReadOnly, 'toJSON'>;
+export interface UseResizeObserverReturnValue<T extends Element = HTMLElement> {
+    ref: Ref<T | null>;
+    rect: Ref<ObserverRect>;
+}
+export declare function useResizeObserver<T extends Element = HTMLElement>(options?: ResizeObserverOptions): UseResizeObserverReturnValue<T>;
+export interface UseElementSizeReturnValue<T extends Element = HTMLElement> {
+    ref: Ref<T | null>;
+    width: Ref<number>;
+    height: Ref<number>;
+}
+export declare function useElementSize<T extends Element = HTMLElement>(options?: ResizeObserverOptions): UseElementSizeReturnValue<T>;

package/lib/use-roving-index/use-roving-index.d.ts

@@ -0,0 +1,45 @@
+import { type ComponentPublicInstance, type MaybeRefOrGetter, type Ref } from 'vue';
+export interface UseRovingIndexInput {
+    /** Total number of items in the group */
+    total: MaybeRefOrGetter<number>;
+    /** Which arrow keys navigate, `'horizontal'` by default */
+    orientation?: 'horizontal' | 'vertical' | 'both';
+    /** Whether navigation wraps at boundaries, `true` by default */
+    loop?: boolean;
+    /** Text direction, `'ltr'` by default */
+    dir?: 'rtl' | 'ltr';
+    /** Whether to click element when it receives focus via keyboard, `false` by default */
+    activateOnFocus?: boolean;
+    /** Number of columns for grid (2D) navigation. When set, enables grid mode */
+    columns?: MaybeRefOrGetter<number | undefined>;
+    /** Controlled focused index */
+    focusedIndex?: MaybeRefOrGetter<number | undefined>;
+    /** Initial focused index for uncontrolled mode, first non-disabled item by default */
+    initialIndex?: number;
+    /** Called when focused index changes */
+    onFocusChange?: (index: number) => void;
+    /** Function to check if item at given index is disabled, `() => false` by default */
+    isItemDisabled?: (index: number) => boolean;
+}
+export interface UseRovingIndexGetItemPropsInput {
+    /** Index of the item in the group */
+    index: number;
+    /** Called when item is clicked */
+    onClick?: (event: MouseEvent) => void;
+    /** Called when keydown event fires on item */
+    onKeyDown?: (event: KeyboardEvent) => void;
+}
+export interface UseRovingIndexReturnValue {
+    /** Get props to spread on each navigable item */
+    getItemProps: (options: UseRovingIndexGetItemPropsInput) => {
+        tabIndex: 0 | -1;
+        onKeyDown: (event: KeyboardEvent) => void;
+        onClick: (event: MouseEvent) => void;
+        ref: (node: Element | ComponentPublicInstance | null) => void;
+    };
+    /** Currently focused index */
+    focusedIndex: Ref<number>;
+    /** Programmatically set focused index */
+    setFocusedIndex: (index: number) => void;
+}
+export declare function useRovingIndex(input: UseRovingIndexInput): UseRovingIndexReturnValue;

package/lib/use-scroll-direction/use-scroll-direction.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from 'vue';
+export type ScrollDirection = 'up' | 'down' | 'unknown';
+export declare function useScrollDirection(): Readonly<Ref<ScrollDirection>>;

package/lib/use-scroll-into-view/use-scroll-into-view.d.ts

@@ -0,0 +1,32 @@
+import { type Ref } from 'vue';
+interface UseScrollIntoViewAnimation {
+    /** Target element alignment relatively to parent based on current axis */
+    alignment?: 'start' | 'end' | 'center';
+}
+export interface UseScrollIntoViewOptions {
+    /** Callback fired after scroll */
+    onScrollFinish?: () => void;
+    /** Callback fired when scroll animation is canceled by user interaction */
+    onScrollCancel?: () => void;
+    /** Duration of scroll in milliseconds */
+    duration?: number;
+    /** Axis of scroll */
+    axis?: 'x' | 'y';
+    /** Custom mathematical easing function */
+    easing?: (t: number) => number;
+    /** Additional distance between nearest edge and element */
+    offset?: number;
+    /** Indicator if animation may be interrupted by user scrolling */
+    cancelable?: boolean;
+    /** Prevents content jumping in scrolling lists with multiple targets */
+    isList?: boolean;
+}
+export interface UseScrollIntoViewReturnValue<Target extends HTMLElement = HTMLElement, Parent extends HTMLElement | null = null> {
+    scrollableRef: Ref<Parent | null>;
+    targetRef: Ref<Target | null>;
+    scrollIntoView: (params?: UseScrollIntoViewAnimation) => void;
+    cancel: () => void;
+    scrolling: Ref<boolean>;
+}
+export declare function useScrollIntoView<Target extends HTMLElement = HTMLElement, Parent extends HTMLElement | null = null>(options?: UseScrollIntoViewOptions): UseScrollIntoViewReturnValue<Target, Parent>;
+export {};

package/lib/use-scroll-spy/use-scroll-spy.d.ts

@@ -0,0 +1,30 @@
+import { type MaybeRefOrGetter } from 'vue';
+export interface UseScrollSpyHeadingData {
+    depth: number;
+    value: string;
+    id: string;
+    getNode: () => HTMLElement;
+}
+export interface UseScrollSpyOptions {
+    selector?: MaybeRefOrGetter<string>;
+    getDepth?: (element: HTMLElement) => number;
+    getValue?: (element: HTMLElement) => string;
+    scrollHost?: MaybeRefOrGetter<HTMLElement | undefined>;
+    offset?: MaybeRefOrGetter<number>;
+}
+export declare function useScrollSpy(options?: UseScrollSpyOptions): {
+    active: Readonly<import("vue").Ref<number, number>>;
+    initialized: Readonly<import("vue").Ref<boolean, boolean>>;
+    data: Readonly<import("vue").Ref<readonly {
+        readonly depth: number;
+        readonly value: string;
+        readonly id: string;
+        readonly getNode: () => HTMLElement;
+    }[], readonly {
+        readonly depth: number;
+        readonly value: string;
+        readonly id: string;
+        readonly getNode: () => HTMLElement;
+    }[]>>;
+    reinitialize: () => void;
+};