@mantine-vue/core 3.5.0 → 3.7.0

package/lib/components/Loader/Loader.d.ts

@@ -1,7 +1,7 @@
 import { defaultLoaders } from './Loader.vue';
 export { defaultLoaders };
 export declare const Loader: import("../..").MantineComponent<{
-    props: Omit<import("./Loader.types").LoaderProps, "rootRef">;
+    props: import("./Loader.types").LoaderProps;
     slots: import("./Loader.types").LoaderSlots;
     ref: HTMLSpanElement;
     exposed: {

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

@@ -1,12 +1,9 @@
-import type { VueRefTarget } from '@mantine-vue/hooks';
 import type { Component, HTMLAttributes, SVGAttributes, VNodeChild } from 'vue';
-import type { BoxProps, MantineColor, MantineSize, StylesApiProps, Factory } from '../../core';
+import type { BoxProps, DataAttributes, MantineColor, MantineSize, StylesApiProps, Factory } from '../../core';
 export type MantineLoader = 'bars' | 'oval' | 'dots' | (string & {});
 export type MantineLoaderComponent = Component;
 export type MantineLoadersRecord = Record<string, MantineLoaderComponent>;
 export interface LoaderOwnProps extends StylesApiProps<LoaderFactory> {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /** Controls loader width and height. @default 'md' */
     size?: MantineSize | (string & {}) | number;
     /** Loader color. @default theme.primaryColor */
@@ -16,7 +13,7 @@ export interface LoaderOwnProps extends StylesApiProps<LoaderFactory> {
     /** Custom loader component registry. */
     loaders?: MantineLoadersRecord;
 }
-export interface LoaderProps extends Omit<BoxProps, keyof LoaderOwnProps>, LoaderOwnProps {
+export interface LoaderProps extends Omit<BoxProps & HTMLAttributes & DataAttributes, keyof LoaderOwnProps>, LoaderOwnProps {
 }
 export interface LoaderSlots {
     /** Overrides the selected loader. */ default?: () => VNodeChild;
@@ -30,7 +27,7 @@ export type DotsProps = HTMLAttributes;
 export type OvalProps = HTMLAttributes;
 export type LoaderSvgProps = SVGAttributes;
 export type LoaderFactory = Factory<{
-    props: Omit<LoaderProps, 'rootRef'>;
+    props: LoaderProps;
     slots: LoaderSlots;
     ref: HTMLSpanElement;
     exposed: {

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

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

package/lib/components/LoadingOverlay/LoadingOverlay.d.ts

@@ -1,5 +1,6 @@
 export declare const LoadingOverlay: import("../..").MantineComponent<{
-    props: Omit<import("./LoadingOverlay.types").LoadingOverlayProps, "rootRef">;
+    props: import("./LoadingOverlay.types").LoadingOverlayProps;
+    slots: import("./LoadingOverlay.types").LoadingOverlaySlots;
     ref: HTMLDivElement;
     exposed: {
         rootElement: Element | null;
@@ -8,4 +9,4 @@ export declare const LoadingOverlay: import("../..").MantineComponent<{
     stylesNames: import("./LoadingOverlay.types").LoadingOverlayStylesNames;
     vars: import("./LoadingOverlay.types").LoadingOverlayCssVariables;
 }>;
-export type { LoadingOverlayCssVariables, LoadingOverlayFactory, LoadingOverlayOwnProps, LoadingOverlayProps, LoadingOverlayStylesNames, } from './LoadingOverlay.types';
+export type { LoadingOverlayCssVariables, LoadingOverlayFactory, LoadingOverlayOwnProps, LoadingOverlayProps, LoadingOverlaySlots, LoadingOverlayStylesNames, } from './LoadingOverlay.types';

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

@@ -1,27 +1,28 @@
-import type { VueRefTarget } from '@mantine-vue/hooks';
+import type { VNodeChild } from 'vue';
 import type { BoxProps, StylesApiProps, Factory } from '../../core';
+import type { LoaderProps } from '../Loader';
+import type { OverlayProps } from '../Overlay';
+import type { TransitionOverride } from '../Transition';
 export type LoadingOverlayStylesNames = 'root' | 'loader' | 'overlay';
 export type LoadingOverlayCssVariables = {
     root: '--lo-z-index';
 };
 /** Props declared by `LoadingOverlay` itself. See `LoadingOverlayProps` for the full public type. */
 export interface LoadingOverlayOwnProps extends StylesApiProps<LoadingOverlayFactory> {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /**
      * Props passed down to `Transition` component. Set `duration` to create custom transition or override default transition.
      *
      * @default { transition: 'fade', duration: 0 }
      */
-    transitionProps?: Record<string, any>;
+    transitionProps?: TransitionOverride;
     /** Props passed down to `Loader` component */
-    loaderProps?: Record<string, any>;
+    loaderProps?: LoaderProps;
     /**
      * Props passed down to `Overlay` component. Use to customizing blur, opacity, color and other properties.
      *
      * @default { backgroundOpacity: 0.75 }
      */
-    overlayProps?: Record<string, any>;
+    overlayProps?: OverlayProps;
     /**
      * Controls overlay visibility. Typically used with state (useState, useDisclosure).
      *
@@ -37,8 +38,13 @@ export interface LoadingOverlayOwnProps extends StylesApiProps<LoadingOverlayFac
 }
 export interface LoadingOverlayProps extends Omit<BoxProps, keyof LoadingOverlayOwnProps>, LoadingOverlayOwnProps {
 }
+export interface LoadingOverlaySlots {
+    /** Custom content rendered in place of the default loader. */
+    loader?: () => VNodeChild;
+}
 export type LoadingOverlayFactory = Factory<{
-    props: Omit<LoadingOverlayProps, 'rootRef'>;
+    props: LoadingOverlayProps;
+    slots: LoadingOverlaySlots;
     ref: HTMLDivElement;
     exposed: {
         rootElement: Element | null;

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

@@ -1,18 +1,24 @@
-import type { LoadingOverlayOwnProps } from './LoadingOverlay.types';
+import type { RootRefProps } from '../../core';
+import type { LoadingOverlayOwnProps, LoadingOverlaySlots } from './LoadingOverlay.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: import("vue").DefineComponent<LoadingOverlayOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LoadingOverlayOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     enter: () => any;
     entered: () => any;
     exited: () => any;
     exit: () => any;
-}, string, import("vue").PublicProps, Readonly<LoadingOverlayOwnProps> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<LoadingOverlayOwnProps & RootRefProps<Element>> & Readonly<{
     onEnter?: (() => any) | undefined;
     onEntered?: (() => any) | undefined;
     onExited?: (() => any) | undefined;
     onExit?: (() => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, LoadingOverlaySlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/Mark/Mark.d.ts

@@ -1,5 +1,5 @@
 export declare const Mark: import("../..").MantineComponent<{
-    props: Omit<import("./Mark.types").MarkProps, "rootRef">;
+    props: import("./Mark.types").MarkProps;
     ref: HTMLElement;
     slots: import("./Mark.types").MarkSlots;
     element: "mark";

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

@@ -10,8 +10,6 @@ export interface MarkSlots {
 }
 /** Props declared by `Mark` itself. See `MarkProps` for the full public type. */
 export interface MarkOwnProps extends StylesApiProps<MarkFactory> {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /**
      * Key of `theme.colors` or any valid CSS color.
      * @default 'yellow'
@@ -21,11 +19,10 @@ export interface MarkOwnProps extends StylesApiProps<MarkFactory> {
 export interface MarkProps extends Omit<BoxProps, keyof MarkOwnProps>, MarkOwnProps {
 }
 export type MarkFactory = Factory<{
-    props: Omit<MarkProps, 'rootRef'>;
+    props: MarkProps;
     ref: HTMLElement;
     slots: MarkSlots;
     element: 'mark';
     stylesNames: MarkStylesNames;
     vars: MarkCssVariables;
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';

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

@@ -1,3 +1,4 @@
+import type { RootRefProps } from '../../core';
 import type { MarkOwnProps, MarkSlots } from './Mark.types';
 declare const defaultProps: {
     color: string;
@@ -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<MarkOwnProps, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<MarkOwnProps & RootRefProps<Element>, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MarkOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, MarkSlots>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MarkOwnProps & RootRefProps<Element>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, MarkSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/lib/components/Marquee/Marquee.d.ts

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

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

@@ -2,8 +2,6 @@ import type { VNodeChild } from 'vue';
 import type { BoxMod, BoxProps, MantineSpacing, StylesApiProps, Factory } from '../../core';
 /** Props declared by `Marquee` itself. See `MarqueeProps` for the full public type. */
 export interface MarqueeOwnProps extends StylesApiProps<MarqueeFactory> {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /**
      * Reverses animation direction
      *
@@ -72,11 +70,10 @@ export type MarqueeCssVariables = {
     root: '--marquee-duration' | '--marquee-gap' | '--marquee-repeat' | '--marquee-fade-color' | '--marquee-fade-size';
 };
 export type MarqueeFactory = Factory<{
-    props: Omit<MarqueeProps, 'rootRef'>;
+    props: MarqueeProps;
     ref: HTMLDivElement;
     slots: MarqueeSlots;
     element: 'div';
     stylesNames: MarqueeStylesNames;
     vars: MarqueeCssVariables;
 }>;
-import type { VueRefTarget } from '@mantine-vue/hooks';

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

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

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

@@ -1,7 +1,8 @@
 import type { VNodeChild } from 'vue';
 import type { MantineNode, SectionSlots, MantineElementType } from '../../core';
-import type { PopoverProps } from '../Popover/Popover.types';
-import type { FloatingPosition } from '../../utils/Floating';
+import type { FloatingAxesOffsets, FloatingPosition } from '../../utils/Floating';
+import type { PopoverMiddlewares, PopoverProps } from '../Popover/Popover.types';
+import type { TransitionOverride } from '../Transition';
 export type MenuStylesNames = 'item' | 'itemLabel' | 'itemSection' | 'itemIndicator' | 'label' | 'divider' | 'chevron' | 'search' | 'dropdown' | 'arrow' | 'overlay';
 export interface MenuSlots {
     /** `Menu.Target` and `Menu.Dropdown`. */
@@ -281,19 +282,19 @@ export interface MenuSubProps {
      *
      * @default 0
      */
-    offset?: number | Record<string, any>;
+    offset?: number | FloatingAxesOffsets;
     /**
      * Props passed down to the `Transition`.
      *
      * @default { duration: 0 }
      */
-    transitionProps?: Record<string, any>;
+    transitionProps?: TransitionOverride;
     /**
      * Floating UI middlewares applied to the submenu.
      *
      * @default { shift: { crossAxis: true } }
      */
-    middlewares?: Record<string, any>;
+    middlewares?: PopoverMiddlewares;
     /** Any other prop is forwarded to the underlying `Menu`. */
     [key: string]: any;
 }

package/lib/components/Menubar/MenubarMenu/MenubarMenu.types.d.ts

@@ -1,4 +1,5 @@
 import type { VNodeChild } from 'vue';
+import type { TransitionOverride } from '../../Transition';
 export interface MenubarMenuSlots {
     /** `Menubar.Target` and `Menubar.Dropdown` of this menu. */
     default?: () => VNodeChild;
@@ -6,11 +7,7 @@ export interface MenubarMenuSlots {
 /** Props declared by `MenubarMenu` itself. */
 export interface MenubarMenuProps {
     /** Props passed down to the underlying transition. */
-    transitionProps?: {
-        duration?: number;
-        exitDuration?: number;
-        [key: string]: any;
-    };
+    transitionProps?: TransitionOverride;
     /**
      * Position of this menu within the menubar, assigned by the parent `Menubar`.
      *

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

@@ -1,6 +1,9 @@
 import type { VNodeChild } from 'vue';
 import type { ClassNames, Factory, MantineNode, Styles, Vars } 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 { ModalBody, ModalCloseButton, ModalContent, ModalHeader, ModalOverlay, ModalTitle } from './Modal.compound';
 import type { ModalRoot } from './Modal';
 export type ModalStylesNames = 'root' | 'body' | 'close' | 'content' | 'header' | 'inner' | 'overlay' | 'title';
@@ -43,7 +46,7 @@ export interface ModalCompoundProps {
     /** Visible state, used by the parts that fade in and out with the modal. */
     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;
 }
@@ -118,7 +121,7 @@ export interface ModalProps extends ModalRootProps {
      */
     withOverlay?: boolean;
     /** Props passed down to `Modal.Overlay`. */
-    overlayProps?: Record<string, any>;
+    overlayProps?: ModalBaseOverlayProps;
     /**
      * If set, a close button is rendered in the header.
      *
@@ -126,5 +129,5 @@ export interface ModalProps extends ModalRootProps {
      */
     withCloseButton?: boolean;
     /** Props passed down to `Modal.CloseButton`. */
-    closeButtonProps?: Record<string, any>;
+    closeButtonProps?: ModalBaseCloseButtonProps;
 }

package/lib/components/ModalBase/ModalBase.d.ts

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

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

@@ -1,6 +1,7 @@
-import type { VueRefTarget } from '@mantine-vue/hooks';
 import type { VNodeChild } from 'vue';
 import type { BoxProps, Factory } from '../../core';
+import type { PortalProps } from '../Portal';
+import type { TransitionOverride } from '../Transition';
 export interface ModalBaseSlots {
     /** Modal parts, usually `ModalBase.Overlay` and `ModalBase.Content`. */
     default?: () => VNodeChild;
@@ -9,8 +10,6 @@ export interface ModalBaseSlots {
 export interface ModalBaseOwnProps {
     /** Internal set used by modal and drawer stacks to handle each Escape event once. */
     __handledEscapeEvents?: WeakSet<KeyboardEvent>;
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /** Open state of the modal. */
     opened: boolean;
     /** Base `id` used to connect the content with its title and body. Generated when not set. */
@@ -40,7 +39,7 @@ export interface ModalBaseOwnProps {
      */
     withinPortal?: boolean;
     /** Props passed down to the `Portal` when `withinPortal` is set. */
-    portalProps?: Record<string, any>;
+    portalProps?: PortalProps;
     /**
      * If set, the modal is closed when the overlay is clicked.
      *
@@ -48,7 +47,7 @@ export interface ModalBaseOwnProps {
      */
     closeOnClickOutside?: boolean;
     /** Props passed down to the `Transition` used by the overlay and the content. */
-    transitionProps?: Record<string, any>;
+    transitionProps?: TransitionOverride;
     /** Called after the exit transition of the content has finished. */
     onExitTransitionEnd?: () => void;
     /** Called after the enter transition of the content has finished. */
@@ -93,7 +92,7 @@ export interface ModalBaseOwnProps {
 export interface ModalBaseProps extends Omit<BoxProps, keyof ModalBaseOwnProps>, ModalBaseOwnProps {
 }
 export type ModalBaseFactory = Factory<{
-    props: Omit<ModalBaseProps, 'rootRef'>;
+    props: ModalBaseProps;
     slots: ModalBaseSlots;
     ref: HTMLDivElement;
     exposed: {

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

@@ -1,10 +1,12 @@
+import type { RootRefProps } from '../../core';
 import type { ModalBaseOwnProps, ModalBaseSlots } from './ModalBase.types';
+type __VLS_Props = ModalBaseOwnProps & RootRefProps<Element>;
 type __VLS_Slots = ModalBaseSlots;
-declare const __VLS_base: import("vue").DefineComponent<ModalBaseOwnProps, {
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     rootElement: import("vue").Ref<Element | null, Element | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     close: () => any;
-}, string, import("vue").PublicProps, Readonly<ModalBaseOwnProps> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClose?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/lib/components/ModalBase/ModalBaseCloseButton.types.d.ts

@@ -1,9 +1,10 @@
-import type { VNodeChild } from 'vue';
+import type { ButtonHTMLAttributes, VNodeChild } from 'vue';
+import type { DataAttributes } from '../../core';
 import type { CloseButtonProps } from '../CloseButton';
 export interface ModalBaseCloseButtonOwnProps {
 }
 /** Full public props accepted by the close button rendered in a modal header. */
-export interface ModalBaseCloseButtonProps extends Omit<CloseButtonProps, keyof ModalBaseCloseButtonOwnProps>, ModalBaseCloseButtonOwnProps {
+export interface ModalBaseCloseButtonProps extends Omit<CloseButtonProps, keyof ModalBaseCloseButtonOwnProps>, Omit<ButtonHTMLAttributes, keyof CloseButtonProps>, DataAttributes, ModalBaseCloseButtonOwnProps {
 }
 export interface ModalBaseCloseButtonSlots {
     /** Custom close button content. */

package/lib/components/ModalBase/ModalBaseContent.d.ts

@@ -1,6 +1,6 @@
 /** Transitioned, focus-trapped dialog surface shared by `Modal` and `Drawer`. */
 export declare const ModalBaseContent: import("../..").MantineComponent<{
-    props: Omit<import("./ModalBaseContent.types").ModalBaseContentProps, "rootRef">;
+    props: import("./ModalBaseContent.types").ModalBaseContentProps;
     slots: import("./ModalBaseContent.types").ModalBaseContentSlots;
     ref: HTMLElement;
     exposed: {

package/lib/components/ModalBase/ModalBaseContent.types.d.ts

@@ -1,6 +1,6 @@
-import type { VueRefTarget } from '@mantine-vue/hooks';
-import type { VNodeChild } from 'vue';
+import type { HTMLAttributes, VNodeChild } from 'vue';
 import type { BoxProps, Factory } from '../../core';
+import type { TransitionOverride } from '../Transition';
 export interface ModalBaseContentSlots {
     /** Modal content. */
     default?: () => VNodeChild;
@@ -10,17 +10,15 @@ export interface ModalBaseContentSlots {
  * See `ModalBaseContentProps` for the full public type.
  */
 export interface ModalBaseContentOwnProps {
-    /** Receives the root DOM node. */
-    rootRef?: VueRefTarget<Element>;
     /** Props passed down to the content transition, merged over the modal's own. */
-    transitionProps?: Record<string, any>;
+    transitionProps?: TransitionOverride;
     /** Props passed down to the element that centres the content in the viewport. */
-    innerProps?: Record<string, any>;
+    innerProps?: HTMLAttributes;
 }
 export interface ModalBaseContentProps extends Omit<BoxProps, keyof ModalBaseContentOwnProps>, ModalBaseContentOwnProps {
 }
 export type ModalBaseContentFactory = Factory<{
-    props: Omit<ModalBaseContentProps, 'rootRef'>;
+    props: ModalBaseContentProps;
     slots: ModalBaseContentSlots;
     ref: HTMLElement;
     exposed: {

package/lib/components/ModalBase/ModalBaseContent.vue.d.ts

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

@@ -1,9 +1,9 @@
 import type { OverlayProps } from '../Overlay';
-import type { TransitionProps } from '../Transition';
+import type { TransitionOverride } from '../Transition';
 /** Props declared by `ModalBaseOverlay` itself. See `ModalBaseOverlayProps` for the full public type. */
 export interface ModalBaseOverlayOwnProps {
     /** Props passed to the `Transition` component. */
-    transitionProps?: Partial<TransitionProps>;
+    transitionProps?: TransitionOverride;
     /** Determines whether the overlay is visible. Defaults to the modal `opened` state. */
     visible?: boolean;
 }

package/lib/components/MultiSelect/MultiSelect.d.ts

@@ -1,8 +1,8 @@
 export declare const MultiSelect: {
     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{
         onRemove?: ((value: any) => any) | undefined;
-        onClear?: (() => any) | undefined;
         onChange?: ((value: any[]) => any) | undefined;
+        onClear?: (() => any) | undefined;
         "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
         "onOption-submit"?: ((value: any) => any) | undefined;
         "onDropdown-open"?: (() => any) | undefined;
@@ -12,8 +12,8 @@ export declare const MultiSelect: {
         "onMax-values"?: (() => any) | undefined;
     }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
         remove: (value: any) => any;
-        clear: () => any;
         change: (value: any[]) => any;
+        clear: () => any;
         "update:modelValue": (value: any[]) => any;
         "option-submit": (value: any) => any;
         "dropdown-open": () => any;
@@ -30,8 +30,8 @@ export declare const MultiSelect: {
         Defaults: {};
     }, Readonly<{}> & Readonly<{
         onRemove?: ((value: any) => any) | undefined;
-        onClear?: (() => any) | undefined;
         onChange?: ((value: any[]) => any) | undefined;
+        onClear?: (() => any) | undefined;
         "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
         "onOption-submit"?: ((value: any) => any) | undefined;
         "onDropdown-open"?: (() => any) | undefined;
@@ -45,8 +45,8 @@ export declare const MultiSelect: {
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{
     onRemove?: ((value: any) => any) | undefined;
-    onClear?: (() => any) | undefined;
     onChange?: ((value: any[]) => any) | undefined;
+    onClear?: (() => any) | undefined;
     "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
     "onOption-submit"?: ((value: any) => any) | undefined;
     "onDropdown-open"?: (() => any) | undefined;
@@ -56,8 +56,8 @@ export declare const MultiSelect: {
     "onMax-values"?: (() => any) | undefined;
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     remove: (value: any) => any;
-    clear: () => any;
     change: (value: any[]) => any;
+    clear: () => any;
     "update:modelValue": (value: any[]) => any;
     "option-submit": (value: any) => any;
     "dropdown-open": () => any;

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

@@ -1,9 +1,10 @@
-import type { VNodeChild } from 'vue';
+import type { InputHTMLAttributes, VNodeChild } from 'vue';
 import type { Primitive } from '../../core';
-import type { ComboboxData, ComboboxStylesNames, OptionsFilter } from '../Combobox';
+import type { ComboboxData, ComboboxProps, ComboboxStylesNames, OptionsFilter } from '../Combobox';
 import type { PillGroupStylesNames } from '../Pill';
 import type { PillsInputFieldStylesNames } from '../PillsInput/PillsInputField/PillsInputField.types';
 import type { PillsInputStylesNames } from '../PillsInput';
+import type { ScrollAreaProps } from '../ScrollArea';
 export type MultiSelectStylesNames = PillsInputStylesNames | ComboboxStylesNames | PillGroupStylesNames | PillsInputFieldStylesNames;
 /** Payload passed to the `renderOption` prop and slot. */
 export interface MultiSelectOptionRenderPayload {
@@ -149,9 +150,9 @@ export interface MultiSelectProps<Value extends Primitive = string> {
     /** Uncontrolled initial open state of the dropdown. */
     defaultDropdownOpened?: boolean;
     /** Props passed down to the underlying `Combobox`. */
-    comboboxProps?: Record<string, any>;
+    comboboxProps?: ComboboxProps;
     /** Props passed down to the hidden input that carries the values in a form. */
-    hiddenInputProps?: Record<string, any>;
+    hiddenInputProps?: Omit<InputHTMLAttributes, 'value'>;
     /**
      * Custom markup for a dropdown option.
      * Can also be set with the scoped `renderOption` slot – the slot takes precedence over the prop.
@@ -163,7 +164,7 @@ export interface MultiSelectProps<Value extends Primitive = string> {
      */
     renderPill?: (input: MultiSelectPillRenderPayload) => any;
     /** Props passed down to the `ScrollArea.Autosize` of the dropdown. */
-    scrollAreaProps?: Record<string, any>;
+    scrollAreaProps?: ScrollAreaProps;
     /**
      * If set, the dropdown opens when a searchable input receives focus.
      *

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

@@ -10,8 +10,8 @@ declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     remove: (value: any) => any;
-    clear: () => any;
     change: (value: any[]) => any;
+    clear: () => any;
     "update:modelValue": (value: any[]) => any;
     "option-submit": (value: any) => any;
     "dropdown-open": () => any;
@@ -21,8 +21,8 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{}, {}
     "max-values": () => any;
 }, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
     onRemove?: ((value: any) => any) | undefined;
-    onClear?: (() => any) | undefined;
     onChange?: ((value: any[]) => any) | undefined;
+    onClear?: (() => any) | undefined;
     "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
     "onOption-submit"?: ((value: any) => any) | undefined;
     "onDropdown-open"?: (() => any) | undefined;

package/lib/components/NativeSelect/NativeSelect.d.ts

@@ -1,5 +1,5 @@
 export declare const NativeSelect: import("../..").MantineComponent<{
-    props: Omit<import("./NativeSelect.types").NativeSelectProps, "rootRef">;
+    props: import("./NativeSelect.types").NativeSelectProps;
     slots: import("./NativeSelect.types").NativeSelectSlots;
     emits: import("./NativeSelect.types").NativeSelectEmits;
     ref: HTMLSelectElement;

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

@@ -1,4 +1,3 @@
-import type { VueRefTarget } from '@mantine-vue/hooks';
 import type { VNodeChild } from 'vue';
 import type { MantineNode, MantineRadius, MantineSize, StylesApiProps, Factory } from '../../core';
 import type { InputBaseOwnProps, InputBaseStylesNames } from '../InputBase';
@@ -23,8 +22,6 @@ export interface NativeSelectSlots {
  * See `NativeSelectProps` for the full public type.
  */
 export interface NativeSelectOwnProps extends StylesApiProps<NativeSelectFactory> {
-    /** Receives the input element */
-    rootRef?: VueRefTarget<Element>;
     /** Data used to generate the `option` elements. Ignored when the default slot is used. */
     data?: NativeSelectData<any>;
     /**
@@ -100,7 +97,7 @@ export interface NativeSelectEmits {
     change: [value: string];
 }
 export type NativeSelectFactory = Factory<{
-    props: Omit<NativeSelectProps, 'rootRef'>;
+    props: NativeSelectProps;
     slots: NativeSelectSlots;
     emits: NativeSelectEmits;
     ref: HTMLSelectElement;