@mantine-vue/core 3.5.0 → 3.7.0

package/lib/components/Fieldset/Fieldset.vue.d.ts

@@ -1,11 +1,12 @@
+import type { RootRefProps } from '../../core';
 import type { FieldsetOwnProps, FieldsetSlots } from './Fieldset.types';
 declare const varsResolver: (theme: import("../..").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
 export { varsResolver };
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<FieldsetOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<FieldsetOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FieldsetOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, FieldsetSlots>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FieldsetOwnProps & RootRefProps<Element>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, FieldsetSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/lib/components/FileButton/FileButton.types.d.ts

@@ -1,4 +1,4 @@
-import type { VNodeChild } from 'vue';
+import type { InputHTMLAttributes, VNodeChild } from 'vue';
 /** Payload passed to the default slot so the trigger can open the file dialog. */
 export interface FileButtonSlotProps {
     /** Opens the native file picker. Ignored while `disabled` is set. */
@@ -37,7 +37,7 @@ export interface FileButtonProps {
     /** Value of the `capture` attribute, used to pick a camera on mobile. */
     capture?: boolean | 'user' | 'environment';
     /** Props passed down to the hidden file input. */
-    inputProps?: Record<string, any>;
+    inputProps?: InputHTMLAttributes;
     /** Ref assigned to the hidden file input. */
     inputRef?: any;
 }

package/lib/components/FileInput/FileInput.types.d.ts

@@ -1,5 +1,5 @@
-import type { VNodeChild } from 'vue';
-import type { MantineNode, MantineSize, StylesApiProps, MantineElementType } from '../../core';
+import type { ButtonHTMLAttributes, HTMLAttributes, InputHTMLAttributes, VNodeChild } from 'vue';
+import type { DataAttributes, MantineElementType, MantineNode, MantineSize, StylesApiProps } from '../../core';
 import type { ClearSectionMode } from '../Input';
 import type { InputBaseStylesNames } from '../InputBase';
 export type FileInputStylesNames = InputBaseStylesNames;
@@ -67,7 +67,9 @@ export interface FileInputProps extends StylesApiProps<FileInputProps> {
      */
     clearSectionMode?: ClearSectionMode;
     /** Props passed down to the clear button. */
-    clearButtonProps?: Record<string, any>;
+    clearButtonProps?: Omit<ButtonHTMLAttributes, 'disabled'> & {
+        disabled?: boolean;
+    };
     /**
      * If set, the file picker cannot be opened.
      *
@@ -77,7 +79,7 @@ export interface FileInputProps extends StylesApiProps<FileInputProps> {
     /** `capture` attribute of the underlying file input, used to request a camera on mobile. */
     capture?: boolean | 'user' | 'environment';
     /** Props passed down to the underlying file input. */
-    fileInputProps?: Record<string, any>;
+    fileInputProps?: InputHTMLAttributes;
     /**
      * Content rendered while no file is selected.
      * Can also be set with the `placeholder` slot – the slot takes precedence over the prop.
@@ -117,7 +119,7 @@ export interface FileInputProps extends StylesApiProps<FileInputProps> {
     /** If set, the asterisk is shown without setting the `required` attribute. */
     withAsterisk?: boolean;
     /** Props passed down to the root element. */
-    wrapperProps?: Record<string, any>;
+    wrapperProps?: HTMLAttributes & DataAttributes;
     /**
      * If set, all Mantine classes are removed.
      *

package/lib/components/Flex/Flex.d.ts

@@ -1,5 +1,5 @@
 export declare const Flex: import("../..").MantinePolymorphicComponent<{
-    props: Omit<import("./Flex.types").FlexProps, "component" | "rootRef">;
+    props: Omit<import("./Flex.types").FlexProps, "component">;
     slots: import("./Flex.types").FlexSlots;
     ref: HTMLDivElement;
     exposed: {

package/lib/components/Flex/Flex.types.d.ts

@@ -1,10 +1,7 @@
 import type { VNodeChild } from 'vue';
 import type { AlignItems, BoxProps, FlexDirection, FlexWrap, JustifyContent, MantineSpacing, StyleProp, StylesApiProps, PolymorphicFactory, MantineElementType } from '../../core';
-import type { VueRefTarget } from '@mantine-vue/hooks';
 /** Props declared by `Flex` itself. See `FlexProps` for the full public type. */
 export interface FlexOwnProps extends StylesApiProps<FlexProps> {
-    /** Receives the root DOM node. The factory narrows this to the element the selected root renders. */
-    rootRef?: VueRefTarget<Element>;
     /**
      * Root element or component rendered by `Flex`.
      *
@@ -35,7 +32,7 @@ export interface FlexSlots {
 }
 /** Public contract of `Flex`. `component` and `rootRef` come from the factory. */
 export type FlexFactory = PolymorphicFactory<{
-    props: Omit<FlexProps, 'component' | 'rootRef'>;
+    props: Omit<FlexProps, 'component'>;
     slots: FlexSlots;
     ref: HTMLDivElement;
     exposed: {

package/lib/components/Flex/Flex.vue.d.ts

@@ -1,11 +1,13 @@
+import type { RootRefProps } from '../../core';
 import type { FlexOwnProps } from './Flex.types';
+type __VLS_Props = FlexOwnProps & RootRefProps<Element>;
 declare var __VLS_12: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_12) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<FlexOwnProps, {
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FlexOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/lib/components/FloatingIndicator/FloatingIndicator.d.ts

@@ -1,5 +1,5 @@
 export declare const FloatingIndicator: import("../..").MantineComponent<{
-    props: Omit<import("./FloatingIndicator.types").FloatingIndicatorProps, "rootRef">;
+    props: import("./FloatingIndicator.types").FloatingIndicatorProps;
     ref: HTMLDivElement;
     slots: import("./FloatingIndicator.types").FloatingIndicatorSlots;
     element: "div";

package/lib/components/FloatingIndicator/FloatingIndicator.types.d.ts

@@ -2,8 +2,6 @@ import type { VNodeChild } from 'vue';
 import type { BoxMod, BoxProps, StylesApiProps, MantineElementType, Factory } from '../../core';
 /** Props declared by `FloatingIndicator` itself. See `FloatingIndicatorProps` for the full public type. */
 export interface FloatingIndicatorOwnProps extends StylesApiProps<FloatingIndicatorFactory> {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /**
      * Target element over which the indicator is displayed.
      * The indicator will be positioned to match the target's size and position.
@@ -48,11 +46,10 @@ export type FloatingIndicatorCssVariables = {
     root: '--transition-duration';
 };
 export type FloatingIndicatorFactory = Factory<{
-    props: Omit<FloatingIndicatorProps, 'rootRef'>;
+    props: FloatingIndicatorProps;
     ref: HTMLDivElement;
     slots: FloatingIndicatorSlots;
     element: 'div';
     stylesNames: FloatingIndicatorStylesNames;
     vars: FloatingIndicatorCssVariables;
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';

package/lib/components/FloatingIndicator/FloatingIndicator.vue.d.ts

@@ -1,13 +1,14 @@
+import type { RootRefProps } from '../../core';
 import type { FloatingIndicatorOwnProps, FloatingIndicatorSlots } from './FloatingIndicator.types';
 export declare const varsResolver: (theme: import("../..").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<FloatingIndicatorOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<FloatingIndicatorOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "transition-end": () => any;
     "transition-start": () => any;
-}, string, import("vue").PublicProps, Readonly<FloatingIndicatorOwnProps> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<FloatingIndicatorOwnProps & RootRefProps<Element>> & Readonly<{
     "onTransition-end"?: (() => any) | undefined;
     "onTransition-start"?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, FloatingIndicatorSlots>;

package/lib/components/FloatingWindow/FloatingWindow.d.ts

@@ -56,7 +56,7 @@ export declare const FloatingWindow: {
 }) & {
     classes: Record<string, string>;
     ResizeHandle: import("../../index.js").MantineComponent<{
-        props: Omit<import("./FloatingWindowResizeHandle.types.js").FloatingWindowResizeHandleProps, "rootRef">;
+        props: import("./FloatingWindowResizeHandle.types.js").FloatingWindowResizeHandleProps;
         ref: HTMLDivElement;
         slots: import("./FloatingWindowResizeHandle.types.js").FloatingWindowResizeHandleSlots;
         element: "div";

package/lib/components/FloatingWindow/FloatingWindow.types.d.ts

@@ -1,6 +1,7 @@
 import type { Ref, VNodeChild } from 'vue';
 import type { FloatingWindowPositionConfig, SetFloatingWindowPosition } from '@mantine-vue/hooks';
 import type { BoxMod, BoxProps, StylesApiProps } from '../../core';
+import type { PortalProps } from '../Portal';
 import type { FloatingWindowDimensions } from './FloatingWindow.context';
 export type FloatingWindowStylesNames = 'root';
 export interface FloatingWindowSlots {
@@ -40,7 +41,7 @@ export interface FloatingWindowOwnProps extends StylesApiProps<FloatingWindowPro
      */
     withinPortal?: boolean;
     /** Props passed down to the `Portal` when `withinPortal` is set. */
-    portalProps?: Record<string, any>;
+    portalProps?: PortalProps;
     /**
      * `z-index` of the window.
      *

package/lib/components/FloatingWindow/FloatingWindowResizeHandle.d.ts

@@ -1,5 +1,5 @@
 export declare const FloatingWindowResizeHandle: import("../..").MantineComponent<{
-    props: Omit<import("./FloatingWindowResizeHandle.types").FloatingWindowResizeHandleProps, "rootRef">;
+    props: import("./FloatingWindowResizeHandle.types").FloatingWindowResizeHandleProps;
     ref: HTMLDivElement;
     slots: import("./FloatingWindowResizeHandle.types").FloatingWindowResizeHandleSlots;
     element: "div";

package/lib/components/FloatingWindow/FloatingWindowResizeHandle.types.d.ts

@@ -9,8 +9,6 @@ export interface FloatingWindowResizeHandleSlots {
  * `FloatingWindowResizeHandleProps` for the full public type.
  */
 export interface FloatingWindowResizeHandleOwnProps {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /**
      * `aria-label` of the handle. A consumer `aria-label` attribute takes precedence.
      *
@@ -28,9 +26,8 @@ export interface FloatingWindowResizeHandleOwnProps {
 export interface FloatingWindowResizeHandleProps extends Omit<BoxProps, keyof FloatingWindowResizeHandleOwnProps>, FloatingWindowResizeHandleOwnProps {
 }
 export type FloatingWindowResizeHandleFactory = Factory<{
-    props: Omit<FloatingWindowResizeHandleProps, 'rootRef'>;
+    props: FloatingWindowResizeHandleProps;
     ref: HTMLDivElement;
     slots: FloatingWindowResizeHandleSlots;
     element: 'div';
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';

package/lib/components/FloatingWindow/FloatingWindowResizeHandle.vue.d.ts

@@ -1,3 +1,4 @@
+import type { RootRefProps } from '../../core';
 import type { FloatingWindowResizeHandleOwnProps, FloatingWindowResizeHandleSlots } from './FloatingWindowResizeHandle.types';
 /** Pixels the window grows or shrinks by with each arrow key press. */
 declare const KEYBOARD_STEP = 10;
@@ -9,11 +10,11 @@ declare function clampDimension(value: number, min: number | undefined, max: num
 export { KEYBOARD_STEP, clampDimension };
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<FloatingWindowResizeHandleOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<FloatingWindowResizeHandleOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     keydown: (event: KeyboardEvent) => any;
-}, string, import("vue").PublicProps, Readonly<FloatingWindowResizeHandleOwnProps> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<FloatingWindowResizeHandleOwnProps & RootRefProps<Element>> & Readonly<{
     onKeydown?: ((event: KeyboardEvent) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, FloatingWindowResizeHandleSlots>;
 type __VLS_WithSlots<T, S> = T & {

package/lib/components/Grid/Grid.d.ts

@@ -1,6 +1,6 @@
 import { GridCol } from './GridCol/GridCol';
 export declare const Grid: import("../..").MantineComponent<{
-    props: Omit<import("./Grid.types").GridProps, "rootRef">;
+    props: import("./Grid.types").GridProps;
     ref: HTMLDivElement;
     exposed: {
         rootElement: Element | null;

package/lib/components/Grid/Grid.types.d.ts

@@ -1,12 +1,9 @@
-import type { VueRefTarget } from '@mantine-vue/hooks';
 import type { GridCol } from './GridCol/GridCol';
 import type { VNodeChild } from 'vue';
 import type { AlignItems, BoxProps, JustifyContent, MantineSpacing, Overflow, StyleProp, StylesApiProps, Factory } from '../../core';
 import type { GridBreakpoints } from './Grid.context';
 /** Props declared by `Grid` itself. See `GridProps` for the full public type. */
 export interface GridOwnProps extends StylesApiProps<GridFactory> {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /**
      * Gap between columns and rows, key of `theme.spacing` or any valid CSS value
      *
@@ -66,7 +63,7 @@ export type GridCssVariables = {
     root: '--grid-justify' | '--grid-align' | '--grid-overflow';
 };
 export type GridFactory = Factory<{
-    props: Omit<GridProps, 'rootRef'>;
+    props: GridProps;
     ref: HTMLDivElement;
     exposed: {
         rootElement: Element | null;

package/lib/components/Grid/Grid.vue.d.ts

@@ -1,10 +1,11 @@
+import type { RootRefProps } from '../../core';
 import type { GridOwnProps, GridSlots } from './Grid.types';
 export declare const varsResolver: (theme: import("../..").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<GridOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<GridOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GridOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, GridSlots>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GridOwnProps & RootRefProps<Element>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, GridSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/lib/components/Grid/GridCol/GridCol.d.ts

@@ -1,5 +1,5 @@
 export declare const GridCol: import("../../..").MantineComponent<{
-    props: Omit<import("./GridCol.types").GridColProps, "rootRef">;
+    props: import("./GridCol.types").GridColProps;
     ref: HTMLDivElement;
     exposed: {
         rootElement: Element | null;

package/lib/components/Grid/GridCol/GridCol.types.d.ts

@@ -1,11 +1,8 @@
-import type { VueRefTarget } from '@mantine-vue/hooks';
 import type { VNodeChild } from 'vue';
 import type { AlignItems, BoxProps, StyleProp, StylesApiProps, Factory } from '../../../core';
 import type { ColSpan } from './GridColVariables';
 /** Props declared by `GridCol` itself. See `GridColProps` for the full public type. */
 export interface GridColOwnProps {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /**
      * Column span
      *
@@ -33,7 +30,7 @@ export interface GridColSlots {
 }
 export type GridColStylesNames = 'col';
 export type GridColFactory = Factory<{
-    props: Omit<GridColProps, 'rootRef'>;
+    props: GridColProps;
     ref: HTMLDivElement;
     exposed: {
         rootElement: Element | null;

package/lib/components/Grid/GridCol/GridCol.vue.d.ts

@@ -1,9 +1,10 @@
+import type { RootRefProps } from '../../../core';
 import type { GridColOwnProps, GridColSlots } from './GridCol.types';
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<GridColOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<GridColOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GridColOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, GridColSlots>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GridColOwnProps & RootRefProps<Element>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, GridColSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/lib/components/Group/Group.d.ts

@@ -1,5 +1,5 @@
 export declare const Group: import("../..").MantineComponent<{
-    props: Omit<import("./Group.types").GroupProps, "rootRef">;
+    props: import("./Group.types").GroupProps;
     slots: import("./Group.types").GroupSlots;
     ref: HTMLDivElement;
     exposed: {

package/lib/components/Group/Group.types.d.ts

@@ -1,5 +1,4 @@
 import type { VNodeChild } from 'vue';
-import type { VueRefTarget } from '@mantine-vue/hooks';
 import type { AlignItems, BoxProps, Factory, FlexWrap, JustifyContent, MantineSpacing, StylesApiProps } from '../../core';
 export type GroupStylesNames = 'root';
 export type GroupCssVariables = {
@@ -7,8 +6,6 @@ export type GroupCssVariables = {
 };
 /** Props declared by `Group` itself. See `GroupProps` for the full public type. */
 export interface GroupOwnProps extends StylesApiProps<GroupFactory> {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /**
      * Controls `justify-content` CSS property
      *
@@ -53,7 +50,7 @@ export interface GroupSlots {
     default?: () => VNodeChild;
 }
 export type GroupFactory = Factory<{
-    props: Omit<GroupProps, 'rootRef'>;
+    props: GroupProps;
     slots: GroupSlots;
     ref: HTMLDivElement;
     exposed: {

package/lib/components/Group/Group.vue.d.ts

@@ -1,11 +1,12 @@
+import type { RootRefProps } from '../../core';
 import type { GroupOwnProps, GroupSlots } from './Group.types';
 declare const varsResolver: (theme: import("../..").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
 export { varsResolver };
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<GroupOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<GroupOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GroupOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, GroupSlots>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GroupOwnProps & RootRefProps<Element>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, GroupSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/lib/components/Highlight/Highlight.d.ts

@@ -3,7 +3,7 @@
  * Text's classes are the ones its style names refer to.
  */
 export declare const Highlight: import("../..").MantinePolymorphicComponent<{
-    props: Omit<import("./Highlight.types").HighlightProps, "component" | "rootRef">;
+    props: Omit<import("./Highlight.types").HighlightProps, "component">;
     slots: import("./Highlight.types").HighlightSlots;
     ref: HTMLParagraphElement;
     exposed: {

package/lib/components/Highlight/Highlight.types.d.ts

@@ -8,8 +8,6 @@ export interface HighlightTerm {
 }
 /** Props declared by `Highlight` itself. See `HighlightProps` for the full public type. */
 export interface HighlightOwnProps extends StylesApiProps<HighlightFactory> {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /**
      * Substring(s) to highlight in `children`. Can be:
      * - string: single term
@@ -67,13 +65,12 @@ export interface HighlightSlots {
     /** Plain-text content to search and highlight. */
     default?: () => VNodeChild;
 }
-import type { VueRefTarget } from '@mantine-vue/hooks';
 import type { TextStylesNames, TextVariant } from '../Text';
 /**
  * Public contract of `Highlight`.
  */
 export type HighlightFactory = PolymorphicFactory<{
-    props: Omit<HighlightProps, 'component' | 'rootRef'>;
+    props: Omit<HighlightProps, 'component'>;
     slots: HighlightSlots;
     ref: HTMLParagraphElement;
     exposed: {

package/lib/components/Highlight/Highlight.vue.d.ts

@@ -1,9 +1,10 @@
+import type { RootRefProps } from '../../core';
 import type { HighlightOwnProps, HighlightSlots } from './Highlight.types';
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<HighlightOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<HighlightOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HighlightOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, HighlightSlots>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HighlightOwnProps & RootRefProps<Element>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, HighlightSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/lib/components/HoverCard/HoverCard.context.d.ts

@@ -2,5 +2,17 @@ export interface HoverCardContextValue {
     openDropdown: () => void;
     closeDropdown: () => void;
     assignTarget: (node: HTMLElement | null) => void;
+    opened: boolean;
+    events: {
+        hover: boolean;
+        focus: boolean;
+        touch: boolean;
+    };
+    interactive: boolean;
+    role: 'dialog' | 'tooltip';
+    withRoles: boolean;
+    dropdownId: string;
+    closeImmediately: () => void;
+    dismiss: () => void;
 }
 export declare const provideHoverCardContext: (value: HoverCardContextValue) => void, useHoverCardContext: () => HoverCardContextValue;

package/lib/components/HoverCard/HoverCard.d.ts

@@ -77,4 +77,4 @@ export declare const HoverCard: {
         $slots: import("./index.js").HoverCardGroupSlots;
     });
 };
-export type { HoverCardOwnProps, HoverCardProps, HoverCardSlots } from './HoverCard.types';
+export type { HoverCardEvents, HoverCardOwnProps, HoverCardProps, HoverCardSlots, } from './HoverCard.types';

package/lib/components/HoverCard/HoverCard.types.d.ts

@@ -4,6 +4,14 @@ export interface HoverCardSlots {
     /** `HoverCard.Target` and `HoverCard.Dropdown`. */
     default?: () => VNodeChild;
 }
+export interface HoverCardEvents {
+    /** Opens the dropdown when the target is hovered. @default true */
+    hover?: boolean;
+    /** Opens the dropdown when the target receives keyboard focus. @default true */
+    focus?: boolean;
+    /** Opens the dropdown when the target is tapped. Requires hover activation. @default false */
+    touch?: boolean;
+}
 /** Props declared by `HoverCard` itself. See `HoverCardProps` for the full public type. */
 export interface HoverCardOwnProps {
     /**
@@ -24,6 +32,12 @@ export interface HoverCardOwnProps {
      * @default 150
      */
     closeDelay?: number;
+    /** Events that activate the dropdown. Unspecified fields preserve their defaults. */
+    events?: HoverCardEvents;
+    /** Keeps the dropdown open while the pointer is over it. @default false */
+    interactive?: boolean;
+    /** Accessible relationship used between the target and dropdown. @default 'dialog' */
+    role?: 'dialog' | 'tooltip';
 }
 /** `opened` and `onChange` are owned by `HoverCard`, which drives them from hover. */
 export interface HoverCardProps extends Omit<PopoverProps, 'opened' | 'onChange' | keyof HoverCardOwnProps>, HoverCardOwnProps {

package/lib/components/HoverCard/index.d.ts

@@ -3,7 +3,7 @@ export { HoverCardTarget } from './HoverCardTarget/HoverCardTarget';
 export { HoverCardDropdown } from './HoverCardDropdown/HoverCardDropdown';
 export { HoverCardGroup } from './HoverCardGroup/HoverCardGroup';
 export { useHoverCardContext } from './HoverCard.context';
-export type { HoverCardOwnProps, HoverCardProps, HoverCardSlots } from './HoverCard';
+export type { HoverCardEvents, HoverCardOwnProps, HoverCardProps, HoverCardSlots, } from './HoverCard';
 export type { HoverCardTargetProps } from './HoverCardTarget/HoverCardTarget';
 export type { HoverCardDropdownProps, HoverCardDropdownSlots, } from './HoverCardDropdown/HoverCardDropdown';
 export type { HoverCardGroupProps, HoverCardGroupSlots, HoverCardGroupContextValue, } from './HoverCardGroup/HoverCardGroup';

package/lib/components/HoverCard/use-hover-card.d.ts

@@ -4,9 +4,12 @@ export declare function useHoverCard(settings: {
     defaultOpened?: boolean;
     onOpen?: () => void;
     onClose?: () => void;
+    onDismiss?: () => void;
 }): {
     opened: import("vue").Ref<boolean, boolean>;
     openDropdown: () => void;
     closeDropdown: () => void;
+    closeImmediately: () => void;
+    dismiss: () => void;
     assignTarget: (node: HTMLElement | null) => void;
 };

package/lib/components/Image/Image.d.ts

@@ -1,5 +1,5 @@
 export declare const Image: import("../..").MantinePolymorphicComponent<{
-    props: Omit<import("./Image.types").ImageProps, "component" | "rootRef">;
+    props: Omit<import("./Image.types").ImageProps, "component">;
     emits: import("./Image.types").ImageEmits;
     ref: HTMLImageElement;
     exposed: {

package/lib/components/Image/Image.types.d.ts

@@ -1,9 +1,6 @@
 import type { BoxProps, MantineRadius, ObjectFit, StylesApiProps, PolymorphicFactory } from '../../core';
-import type { VueRefTarget } from '@mantine-vue/hooks';
 /** Props declared by `Image` itself. See `ImageProps` for the full public type. */
 export interface ImageOwnProps extends StylesApiProps<ImageProps> {
-    /** Receives the root DOM node. The factory narrows this to the element the selected root renders. */
-    rootRef?: VueRefTarget<Element>;
     /** Image url */
     src?: any;
     /** Image url used as a fallback if the image cannot be loaded */
@@ -33,7 +30,7 @@ export interface ImageEmits {
 }
 /** Public contract of `Image`. `component` and `rootRef` come from the factory. */
 export type ImageFactory = PolymorphicFactory<{
-    props: Omit<ImageProps, 'component' | 'rootRef'>;
+    props: Omit<ImageProps, 'component'>;
     emits: ImageEmits;
     ref: HTMLImageElement;
     exposed: {

package/lib/components/Image/Image.vue.d.ts

@@ -1,11 +1,12 @@
+import type { RootRefProps } from '../../core';
 import type { ImageOwnProps } from './Image.types';
 export declare const varsResolver: (theme: import("../..").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: import("vue").DefineComponent<ImageOwnProps, {
+declare const __VLS_export: import("vue").DefineComponent<ImageOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     error: (event: Event) => any;
-}, string, import("vue").PublicProps, Readonly<ImageOwnProps> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<ImageOwnProps & RootRefProps<Element>> & Readonly<{
     onError?: ((event: Event) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/lib/components/Indicator/Indicator.d.ts

@@ -1,5 +1,5 @@
 export declare const Indicator: import("../..").MantineComponent<{
-    props: Omit<import("./Indicator.types").IndicatorProps, "rootRef">;
+    props: import("./Indicator.types").IndicatorProps;
     ref: HTMLDivElement;
     slots: import("./Indicator.types").IndicatorSlots;
     element: "div";

package/lib/components/Indicator/Indicator.types.d.ts

@@ -5,8 +5,6 @@ type Placement = 'start' | 'center' | 'end';
 export type IndicatorPosition = `${Position}-${Placement}`;
 /** Props declared by `Indicator` itself. See `IndicatorProps` for the full public type. */
 export interface IndicatorOwnProps extends StylesApiProps<IndicatorFactory> {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /**
      * Indicator position relative to the target element
      *
@@ -98,12 +96,11 @@ export type IndicatorCssVariables = {
     root: '--indicator-color' | '--indicator-text-color';
 };
 export type IndicatorFactory = Factory<{
-    props: Omit<IndicatorProps, 'rootRef'>;
+    props: IndicatorProps;
     ref: HTMLDivElement;
     slots: IndicatorSlots;
     element: 'div';
     stylesNames: IndicatorStylesNames;
     vars: IndicatorCssVariables;
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';
 export {};

package/lib/components/Indicator/Indicator.vue.d.ts

@@ -1,11 +1,12 @@
+import type { RootRefProps } from '../../core';
 import type { IndicatorOwnProps, IndicatorSlots } from './Indicator.types';
 declare const varsResolver: (theme: import("../..").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
 export { varsResolver };
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<IndicatorOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<IndicatorOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IndicatorOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, IndicatorSlots>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IndicatorOwnProps & RootRefProps<Element>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, IndicatorSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/lib/components/Input/Input.d.ts

@@ -5,7 +5,7 @@ import { InputLabel } from './InputLabel/InputLabel';
 import { InputPlaceholder } from './InputPlaceholder/InputPlaceholder';
 import { InputWrapper } from './InputWrapper/InputWrapper';
 export declare const Input: import("../..").MantinePolymorphicComponent<{
-    props: Omit<import("./Input.types").InputProps, "component" | "rootRef">;
+    props: Omit<import("./Input.types").InputProps, "component">;
     slots: import("./Input.types").InputSlots;
     ref: HTMLInputElement;
     exposed: {