@mantine-vue/core 3.6.0 → 3.7.0

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

@@ -1,10 +1,7 @@
 import type { VNodeChild } from 'vue';
-import type { VueRefTarget } from '@mantine-vue/hooks';
 import type { BoxProps, MantineRadius, StylesApiProps, PolymorphicFactory } from '../../core';
 /** Props declared by `ColorSwatch` itself. See `ColorSwatchProps` for the full public type. */
 export interface ColorSwatchOwnProps extends StylesApiProps<ColorSwatchProps> {
-    /** Receives the root DOM node. The factory narrows this to the element the selected root renders. */
-    rootRef?: VueRefTarget<Element>;
     /** Valid CSS color to display */
     color: string;
     /**
@@ -38,7 +35,7 @@ export type ColorSwatchCssVariables = {
 };
 /** Public contract of `ColorSwatch`. `component` and `rootRef` come from the factory. */
 export type ColorSwatchFactory = PolymorphicFactory<{
-    props: Omit<ColorSwatchProps, 'component' | 'rootRef'>;
+    props: Omit<ColorSwatchProps, 'component'>;
     slots: ColorSwatchSlots;
     ref: HTMLDivElement;
     exposed: {

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

@@ -1,10 +1,11 @@
+import type { RootRefProps } from '../../core';
 import type { ColorSwatchOwnProps, ColorSwatchSlots } from './ColorSwatch.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<ColorSwatchOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ColorSwatchOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorSwatchOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ColorSwatchSlots>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorSwatchOwnProps & RootRefProps<Element>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ColorSwatchSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/lib/components/Combobox/OptionsDropdown/OptionsDropdown.types.d.ts

@@ -1,6 +1,7 @@
 import type { VNodeChild } from 'vue';
 import type { MantineNode, Primitive } from '../../../core';
 import type { ComboboxLikeRenderOptionInput, ComboboxParsedItem, OptionsFilter } from '../Combobox.types';
+import type { ScrollAreaProps } from '../../ScrollArea';
 export type OptionsData = ComboboxParsedItem<Primitive>[];
 export interface OptionsDropdownSlots {
     /** Custom markup for a dropdown option. Takes precedence over the `renderOption` prop. */
@@ -99,5 +100,5 @@ export interface OptionsDropdownProps {
      */
     renderOption?: (input: ComboboxLikeRenderOptionInput<any>) => VNodeChild;
     /** Props passed down to the `ScrollArea.Autosize` of the dropdown. */
-    scrollAreaProps?: Record<string, any>;
+    scrollAreaProps?: ScrollAreaProps;
 }

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

@@ -1,6 +1,7 @@
-import type { VNodeChild } from 'vue';
+import type { InputHTMLAttributes, VNodeChild } from 'vue';
 import type { MantineNode, Primitive, StylesApiProps } from '../../core';
 import type { ComboboxData, ComboboxItem, ComboboxLikeRenderOptionInput, ComboboxProps, ComboboxStylesNames, OptionsFilter } from '../Combobox';
+import type { ScrollAreaProps } from '../ScrollArea';
 export type ComboboxPopoverValue<Multiple extends boolean, Value extends Primitive = string> = Multiple extends true ? Value[] : Value | null;
 export type ComboboxPopoverStylesNames = ComboboxStylesNames;
 export interface ComboboxPopoverProps<Multiple extends boolean = false, Value extends Primitive = string> extends StylesApiProps<ComboboxPopoverProps<Multiple, Value>> {
@@ -47,9 +48,9 @@ export interface ComboboxPopoverProps<Multiple extends boolean = false, Value ex
     /** A function to render content of the option, replaces the default content of the option. Can also be provided via the `#option` slot */
     renderOption?: (item: ComboboxLikeRenderOptionInput<ComboboxItem>) => VNodeChild;
     /** Props passed down to the underlying ScrollArea component in the dropdown */
-    scrollAreaProps?: Record<string, any>;
+    scrollAreaProps?: ScrollAreaProps;
     /** Props passed down to the hidden input */
-    hiddenInputProps?: Record<string, any>;
+    hiddenInputProps?: Omit<InputHTMLAttributes, 'value'>;
     /** Hidden input name for form submission */
     name?: string;
     /** Hidden input form for form submission */

package/lib/components/Container/Container.d.ts

@@ -1,5 +1,5 @@
 export declare const Container: import("../..").MantineComponent<{
-    props: Omit<import("./Container.types").ContainerProps, "rootRef">;
+    props: import("./Container.types").ContainerProps;
     ref: HTMLDivElement;
     element: "div";
     stylesNames: import("./Container.types").ContainerStylesNames;

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

@@ -1,8 +1,6 @@
 import type { BoxProps, MantineSize, StylesApiProps, Factory } from '../../core';
 /** Props declared by `Container` itself. See `ContainerProps` for the full public type. */
 export interface ContainerOwnProps extends StylesApiProps<ContainerFactory> {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /**
      * `max-width` of the container, value is not responsive – it is the same for all screen sizes. Numbers are converted to rem. Ignored when `fluid` prop is set.
      *
@@ -29,10 +27,9 @@ export type ContainerCssVariables = {
     root: '--container-size';
 };
 export type ContainerFactory = Factory<{
-    props: Omit<ContainerProps, 'rootRef'>;
+    props: ContainerProps;
     ref: HTMLDivElement;
     element: 'div';
     stylesNames: ContainerStylesNames;
     vars: ContainerCssVariables;
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';

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

@@ -1,3 +1,4 @@
+import type { RootRefProps } from '../../core';
 import type { ContainerOwnProps } from './Container.types';
 /** Module scope: created once, not per component instance. */
 declare const defaultProps: {
@@ -7,9 +8,9 @@ declare const varsResolver: (theme: import("../..").MantineTheme, props: any, ct
 export { defaultProps, varsResolver };
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ContainerOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ContainerOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ContainerOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ContainerOwnProps & RootRefProps<Element>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {}) => any;
 }>;
 type __VLS_WithSlots<T, S> = T & {

package/lib/components/DataList/DataList.d.ts

@@ -2,7 +2,7 @@ import { DataListItem } from './DataListItem/DataListItem';
 import { DataListItemLabel } from './DataListItemLabel/DataListItemLabel';
 import { DataListItemValue } from './DataListItemValue/DataListItemValue';
 export declare const DataList: import("../..").MantineComponent<{
-    props: Omit<import("./DataList.types").DataListProps, "rootRef">;
+    props: import("./DataList.types").DataListProps;
     ref: HTMLElement;
     slots: import("./DataList.types").DataListSlots;
     element: "dl";

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

@@ -13,8 +13,6 @@ export interface DataListSlots {
 }
 /** Props declared by `DataList` itself. See `DataListProps` for the full public type. */
 export interface DataListOwnProps extends StylesApiProps<DataListFactory> {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /** Controls the `font-size` and `line-height` of the list. */
     size?: MantineSize | (string & {});
     /** Key of `theme.spacing` or any valid CSS value for the gap between items. */
@@ -35,7 +33,7 @@ export interface DataListOwnProps extends StylesApiProps<DataListFactory> {
 export interface DataListProps extends Omit<BoxProps, keyof DataListOwnProps>, DataListOwnProps {
 }
 export type DataListFactory = Factory<{
-    props: Omit<DataListProps, 'rootRef'>;
+    props: DataListProps;
     ref: HTMLElement;
     slots: DataListSlots;
     element: 'dl';
@@ -47,4 +45,3 @@ export type DataListFactory = Factory<{
         ItemValue: typeof DataListItemValue;
     };
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';

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

@@ -1,3 +1,4 @@
+import type { RootRefProps } from '../../core';
 import type { DataListOwnProps, DataListSlots } from './DataList.types';
 declare const defaultProps: {
     readonly orientation: "horizontal";
@@ -7,9 +8,9 @@ declare const varsResolver: (theme: import("../..").MantineTheme, props: any, ct
 export { defaultProps, varsResolver };
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<DataListOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<DataListOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DataListOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, DataListSlots>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DataListOwnProps & RootRefProps<Element>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, DataListSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/lib/components/DataList/DataListItem/DataListItem.d.ts

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

package/lib/components/DataList/DataListItem/DataListItem.types.d.ts

@@ -3,8 +3,6 @@ import type { BoxProps, StylesApiProps, Factory } from '../../../core';
 export type DataListItemStylesNames = 'item';
 /** Props declared by `DataListItem` itself. See `DataListItemProps` for the full public type. */
 export interface DataListItemOwnProps {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /** Class names applied to DataList elements. */
     classNames?: StylesApiProps<DataListItemFactory>['classNames'];
     /** Inline styles applied to DataList elements. */
@@ -19,10 +17,9 @@ export interface DataListItemSlots {
     default?: () => VNodeChild;
 }
 export type DataListItemFactory = Factory<{
-    props: Omit<DataListItemProps, 'rootRef'>;
+    props: DataListItemProps;
     ref: HTMLDivElement;
     slots: DataListItemSlots;
     element: 'div';
     stylesNames: DataListItemStylesNames;
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';

package/lib/components/DataList/DataListItem/DataListItem.vue.d.ts

@@ -1,8 +1,10 @@
+import type { RootRefProps } from '../../../core';
 import type { DataListItemOwnProps, DataListItemSlots } from './DataListItem.types';
+type __VLS_Props = DataListItemOwnProps & RootRefProps<Element>;
 type __VLS_Slots = DataListItemSlots;
-declare const __VLS_base: import("vue").DefineComponent<DataListItemOwnProps, {
+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<DataListItemOwnProps> & 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/DataList/DataListItemLabel/DataListItemLabel.d.ts

@@ -1,5 +1,5 @@
 export declare const DataListItemLabel: import("../../..").MantineComponent<{
-    props: Omit<import("./DataListItemLabel.types").DataListItemLabelProps, "rootRef">;
+    props: import("./DataListItemLabel.types").DataListItemLabelProps;
     ref: HTMLElement;
     slots: import("./DataListItemLabel.types").DataListItemLabelSlots;
     element: "dt";

package/lib/components/DataList/DataListItemLabel/DataListItemLabel.types.d.ts

@@ -3,8 +3,6 @@ import type { BoxProps, StylesApiProps, Factory } from '../../../core';
 export type DataListItemLabelStylesNames = 'itemLabel';
 /** Props declared by `DataListItemLabel` itself. See `DataListItemLabelProps` for the full public type. */
 export interface DataListItemLabelOwnProps {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /** Class names applied to DataList elements. */
     classNames?: StylesApiProps<DataListItemLabelFactory>['classNames'];
     /** Inline styles applied to DataList elements. */
@@ -19,10 +17,9 @@ export interface DataListItemLabelSlots {
     default?: () => VNodeChild;
 }
 export type DataListItemLabelFactory = Factory<{
-    props: Omit<DataListItemLabelProps, 'rootRef'>;
+    props: DataListItemLabelProps;
     ref: HTMLElement;
     slots: DataListItemLabelSlots;
     element: 'dt';
     stylesNames: DataListItemLabelStylesNames;
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';

package/lib/components/DataList/DataListItemLabel/DataListItemLabel.vue.d.ts

@@ -1,8 +1,10 @@
+import type { RootRefProps } from '../../../core';
 import type { DataListItemLabelOwnProps, DataListItemLabelSlots } from './DataListItemLabel.types';
+type __VLS_Props = DataListItemLabelOwnProps & RootRefProps<Element>;
 type __VLS_Slots = DataListItemLabelSlots;
-declare const __VLS_base: import("vue").DefineComponent<DataListItemLabelOwnProps, {
+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<DataListItemLabelOwnProps> & 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/DataList/DataListItemValue/DataListItemValue.d.ts

@@ -1,5 +1,5 @@
 export declare const DataListItemValue: import("../../..").MantineComponent<{
-    props: Omit<import("./DataListItemValue.types").DataListItemValueProps, "rootRef">;
+    props: import("./DataListItemValue.types").DataListItemValueProps;
     ref: HTMLElement;
     slots: import("./DataListItemValue.types").DataListItemValueSlots;
     element: "dd";

package/lib/components/DataList/DataListItemValue/DataListItemValue.types.d.ts

@@ -3,8 +3,6 @@ import type { BoxProps, StylesApiProps, Factory } from '../../../core';
 export type DataListItemValueStylesNames = 'itemValue';
 /** Props declared by `DataListItemValue` itself. See `DataListItemValueProps` for the full public type. */
 export interface DataListItemValueOwnProps {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /** Class names applied to DataList elements. */
     classNames?: StylesApiProps<DataListItemValueFactory>['classNames'];
     /** Inline styles applied to DataList elements. */
@@ -19,10 +17,9 @@ export interface DataListItemValueSlots {
     default?: () => VNodeChild;
 }
 export type DataListItemValueFactory = Factory<{
-    props: Omit<DataListItemValueProps, 'rootRef'>;
+    props: DataListItemValueProps;
     ref: HTMLElement;
     slots: DataListItemValueSlots;
     element: 'dd';
     stylesNames: DataListItemValueStylesNames;
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';

package/lib/components/DataList/DataListItemValue/DataListItemValue.vue.d.ts

@@ -1,8 +1,10 @@
+import type { RootRefProps } from '../../../core';
 import type { DataListItemValueOwnProps, DataListItemValueSlots } from './DataListItemValue.types';
+type __VLS_Props = DataListItemValueOwnProps & RootRefProps<Element>;
 type __VLS_Slots = DataListItemValueSlots;
-declare const __VLS_base: import("vue").DefineComponent<DataListItemValueOwnProps, {
+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<DataListItemValueOwnProps> & 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/Dialog/Dialog.types.d.ts

@@ -1,7 +1,8 @@
 import type { VNodeChild } from 'vue';
 import type { BoxProps, MantineRadius, MantineSize, MantineSpacing, StylesApiProps } from '../../core';
 import type { AffixPosition } from '../Affix';
-import type { MantineTransition } from '../Transition';
+import type { PortalProps } from '../Portal';
+import type { TransitionOverride } from '../Transition';
 /** Props declared by `Dialog` itself. See `DialogProps` for the full public type. */
 export interface DialogOwnProps extends StylesApiProps<DialogProps> {
     /** Opened state */
@@ -23,11 +24,7 @@ export interface DialogOwnProps extends StylesApiProps<DialogProps> {
      *
      * @default { transition: 'pop-top-right', duration: 200 }
      */
-    transitionProps?: {
-        transition?: MantineTransition;
-        duration?: number;
-        keepMounted?: boolean;
-    };
+    transitionProps?: TransitionOverride;
     /**
      * Controls `width` of the dialog
      *
@@ -47,7 +44,7 @@ export interface DialogOwnProps extends StylesApiProps<DialogProps> {
      */
     withinPortal?: boolean;
     /** Props passed down to the `Portal` component. Ignored when `withinPortal` is `false`. */
-    portalProps?: Record<string, any>;
+    portalProps?: PortalProps;
     /**
      * Affix position on screen
      *

package/lib/components/Divider/Divider.d.ts

@@ -1,5 +1,5 @@
 export declare const Divider: import("../..").MantineComponent<{
-    props: Omit<import("./Divider.types").DividerProps, "rootRef">;
+    props: import("./Divider.types").DividerProps;
     ref: HTMLSpanElement;
     slots: import("./Divider.types").DividerSlots;
     element: "span";

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

@@ -3,8 +3,6 @@ import type { BoxProps, MantineColor, MantineNode, MantineSize, StylesApiProps,
 export type DividerVariant = 'solid' | 'dashed' | 'dotted';
 /** Props declared by `Divider` itself. See `DividerProps` for the full public type. */
 export interface DividerOwnProps extends StylesApiProps<DividerFactory> {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /** Key of `theme.colors` or any valid CSS color value */
     color?: MantineColor;
     /**
@@ -47,7 +45,7 @@ export type DividerCssVariables = {
     root: '--divider-color' | '--divider-border-style' | '--divider-size';
 };
 export type DividerFactory = Factory<{
-    props: Omit<DividerProps, 'rootRef'>;
+    props: DividerProps;
     ref: HTMLSpanElement;
     slots: DividerSlots;
     element: 'span';
@@ -55,4 +53,3 @@ export type DividerFactory = Factory<{
     vars: DividerCssVariables;
     variant: DividerVariant;
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';

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

@@ -1,11 +1,12 @@
+import type { RootRefProps } from '../../core';
 import type { DividerOwnProps, DividerSlots } from './Divider.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<DividerOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<DividerOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DividerOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, DividerSlots>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DividerOwnProps & RootRefProps<Element>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, DividerSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

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

@@ -1,6 +1,9 @@
 import type { VNodeChild } from 'vue';
 import type { MantineNode, StylesApiProps, Factory } from '../../core';
 import type { ModalBaseOwnProps } from '../ModalBase/ModalBase.types';
+import type { ModalBaseCloseButtonProps } from '../ModalBase/ModalBaseCloseButton.types';
+import type { ModalBaseOverlayProps } from '../ModalBase/ModalBaseOverlay.types';
+import type { TransitionOverride } from '../Transition';
 import type { DrawerBody, DrawerCloseButton, DrawerContent, DrawerHeader, DrawerOverlay, DrawerTitle } from './Drawer.compound';
 import type { DrawerRoot, DrawerStack } from './Drawer';
 export type DrawerPosition = 'top' | 'bottom' | 'left' | 'right';
@@ -49,7 +52,7 @@ export interface DrawerCompoundProps {
     /** Visible state, used by the parts that fade in and out with the drawer. */
     visible?: boolean;
     /** Props passed down to the `Transition` of the part. */
-    transitionProps?: Record<string, any>;
+    transitionProps?: TransitionOverride;
     /** Internal: hides the part without unmounting it. */
     __hidden?: boolean;
 }
@@ -107,7 +110,7 @@ export interface DrawerProps extends DrawerRootProps {
      */
     withOverlay?: boolean;
     /** Props passed down to `Drawer.Overlay`. */
-    overlayProps?: Record<string, any>;
+    overlayProps?: ModalBaseOverlayProps;
     /**
      * If set, a close button is rendered in the header.
      *
@@ -115,7 +118,7 @@ export interface DrawerProps extends DrawerRootProps {
      */
     withCloseButton?: boolean;
     /** Props passed down to `Drawer.CloseButton`. */
-    closeButtonProps?: Record<string, any>;
+    closeButtonProps?: ModalBaseCloseButtonProps;
     /** Id of the drawer within its `Drawer.Stack`. Required for stacked drawers. */
     stackId?: string;
 }

package/lib/components/Drawer/DrawerRoot.vue.d.ts

@@ -1,11 +1,12 @@
 import type { DrawerRootProps, DrawerRootSlots } from './Drawer.types';
+import type { MantineTransition } from '../Transition';
 import type { DrawerPosition } from './Drawer.types';
 /** Module scope: created once, not per component instance. */
 declare const varsResolver: (theme: import("../..").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
 /** The drawer slides in from the side it is anchored to. */
-declare const transitions: Record<DrawerPosition, string>;
+declare const transitions: Record<DrawerPosition, MantineTransition>;
 /** In RTL the horizontal sides are mirrored, so the slide directions swap with them. */
-declare const rtlTransitions: Record<DrawerPosition, string>;
+declare const rtlTransitions: Record<DrawerPosition, MantineTransition>;
 export { varsResolver, transitions, rtlTransitions };
 declare const _default: typeof __VLS_export;
 export default _default;

package/lib/components/EmptyState/EmptyState.d.ts

@@ -3,7 +3,7 @@ import { EmptyStateDescription } from './EmptyStateDescription/EmptyStateDescrip
 import { EmptyStateIndicator } from './EmptyStateIndicator/EmptyStateIndicator';
 import { EmptyStateTitle } from './EmptyStateTitle/EmptyStateTitle';
 export declare const EmptyState: import("../..").MantineComponent<{
-    props: Omit<import("./EmptyState.types").EmptyStateProps, "rootRef">;
+    props: import("./EmptyState.types").EmptyStateProps;
     ref: HTMLDivElement;
     slots: import("./EmptyState.types").EmptyStateSlots;
     element: "div";

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

@@ -21,8 +21,6 @@ export interface EmptyStateSlots {
 }
 /** Props declared by `EmptyState` itself. See `EmptyStateProps` for the full public type. */
 export interface EmptyStateOwnProps extends StylesApiProps<EmptyStateFactory> {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /**
      * Controls the indicator size, the gap between elements and the font sizes of the
      * title and the description.
@@ -77,7 +75,7 @@ export interface EmptyStateOwnProps extends StylesApiProps<EmptyStateFactory> {
 export interface EmptyStateProps extends Omit<BoxProps, keyof EmptyStateOwnProps>, EmptyStateOwnProps {
 }
 export type EmptyStateFactory = Factory<{
-    props: Omit<EmptyStateProps, 'rootRef'>;
+    props: EmptyStateProps;
     ref: HTMLDivElement;
     slots: EmptyStateSlots;
     element: 'div';
@@ -91,4 +89,3 @@ export type EmptyStateFactory = Factory<{
         Actions: typeof EmptyStateActions;
     };
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';

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

@@ -1,3 +1,4 @@
+import type { RootRefProps } from '../../core';
 import type { EmptyStateOwnProps, EmptyStateSlots } from './EmptyState.types';
 import { type VNode, type VNodeChild } from 'vue';
 declare const defaultProps: {
@@ -14,9 +15,9 @@ declare function flattenChildren(nodes: VNodeChild[]): VNode[];
 export { defaultProps, varsResolver, flattenChildren };
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<EmptyStateOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<EmptyStateOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<EmptyStateOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, EmptyStateSlots>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<EmptyStateOwnProps & RootRefProps<Element>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, EmptyStateSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/lib/components/EmptyState/EmptyStateActions/EmptyStateActions.d.ts

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

package/lib/components/EmptyState/EmptyStateActions/EmptyStateActions.types.d.ts

@@ -3,8 +3,6 @@ import type { BoxProps, StylesApiProps, Factory } from '../../../core';
 export type EmptyStateActionsStylesNames = 'actions';
 /** Props declared by `EmptyStateActions` itself. See `EmptyStateActionsProps` for the full public type. */
 export interface EmptyStateActionsOwnProps {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /** Class names applied to EmptyState elements. */
     classNames?: StylesApiProps<EmptyStateActionsFactory>['classNames'];
     /** Inline styles applied to EmptyState elements. */
@@ -19,10 +17,9 @@ export interface EmptyStateActionsSlots {
     default?: () => VNodeChild;
 }
 export type EmptyStateActionsFactory = Factory<{
-    props: Omit<EmptyStateActionsProps, 'rootRef'>;
+    props: EmptyStateActionsProps;
     ref: HTMLDivElement;
     slots: EmptyStateActionsSlots;
     element: 'div';
     stylesNames: EmptyStateActionsStylesNames;
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';

package/lib/components/EmptyState/EmptyStateActions/EmptyStateActions.vue.d.ts

@@ -1,8 +1,10 @@
+import type { RootRefProps } from '../../../core';
 import type { EmptyStateActionsOwnProps, EmptyStateActionsSlots } from './EmptyStateActions.types';
+type __VLS_Props = EmptyStateActionsOwnProps & RootRefProps<Element>;
 type __VLS_Slots = EmptyStateActionsSlots;
-declare const __VLS_base: import("vue").DefineComponent<EmptyStateActionsOwnProps, {
+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<EmptyStateActionsOwnProps> & 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/EmptyState/EmptyStateDescription/EmptyStateDescription.d.ts

@@ -1,5 +1,5 @@
 export declare const EmptyStateDescription: import("../../..").MantineComponent<{
-    props: Omit<import("./EmptyStateDescription.types").EmptyStateDescriptionProps, "rootRef">;
+    props: import("./EmptyStateDescription.types").EmptyStateDescriptionProps;
     ref: HTMLParagraphElement;
     slots: import("./EmptyStateDescription.types").EmptyStateDescriptionSlots;
     element: "p";

package/lib/components/EmptyState/EmptyStateDescription/EmptyStateDescription.types.d.ts

@@ -3,8 +3,6 @@ import type { BoxProps, StylesApiProps, Factory } from '../../../core';
 export type EmptyStateDescriptionStylesNames = 'description';
 /** Props declared by `EmptyStateDescription` itself. See `EmptyStateDescriptionProps` for the full public type. */
 export interface EmptyStateDescriptionOwnProps {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /** Class names applied to EmptyState elements. */
     classNames?: StylesApiProps<EmptyStateDescriptionFactory>['classNames'];
     /** Inline styles applied to EmptyState elements. */
@@ -19,10 +17,9 @@ export interface EmptyStateDescriptionSlots {
     default?: () => VNodeChild;
 }
 export type EmptyStateDescriptionFactory = Factory<{
-    props: Omit<EmptyStateDescriptionProps, 'rootRef'>;
+    props: EmptyStateDescriptionProps;
     ref: HTMLParagraphElement;
     slots: EmptyStateDescriptionSlots;
     element: 'p';
     stylesNames: EmptyStateDescriptionStylesNames;
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';

package/lib/components/EmptyState/EmptyStateDescription/EmptyStateDescription.vue.d.ts

@@ -1,8 +1,10 @@
+import type { RootRefProps } from '../../../core';
 import type { EmptyStateDescriptionOwnProps, EmptyStateDescriptionSlots } from './EmptyStateDescription.types';
+type __VLS_Props = EmptyStateDescriptionOwnProps & RootRefProps<Element>;
 type __VLS_Slots = EmptyStateDescriptionSlots;
-declare const __VLS_base: import("vue").DefineComponent<EmptyStateDescriptionOwnProps, {
+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<EmptyStateDescriptionOwnProps> & 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/EmptyState/EmptyStateIndicator/EmptyStateIndicator.d.ts

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

package/lib/components/EmptyState/EmptyStateIndicator/EmptyStateIndicator.types.d.ts

@@ -3,8 +3,6 @@ import type { BoxProps, StylesApiProps, Factory } from '../../../core';
 export type EmptyStateIndicatorStylesNames = 'indicator';
 /** Props declared by `EmptyStateIndicator` itself. See `EmptyStateIndicatorProps` for the full public type. */
 export interface EmptyStateIndicatorOwnProps {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /** Class names applied to EmptyState elements. */
     classNames?: StylesApiProps<EmptyStateIndicatorFactory>['classNames'];
     /** Inline styles applied to EmptyState elements. */
@@ -19,10 +17,9 @@ export interface EmptyStateIndicatorSlots {
     default?: () => VNodeChild;
 }
 export type EmptyStateIndicatorFactory = Factory<{
-    props: Omit<EmptyStateIndicatorProps, 'rootRef'>;
+    props: EmptyStateIndicatorProps;
     ref: HTMLDivElement;
     slots: EmptyStateIndicatorSlots;
     element: 'div';
     stylesNames: EmptyStateIndicatorStylesNames;
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';