@mantine-vue/core 3.0.0 → 3.2.0

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

@@ -0,0 +1,130 @@
+import type { VNodeChild } from 'vue';
+import type { ClassNames, Factory, MantineNode, Styles, Vars } from '../../core';
+import type { ModalBaseOwnProps } from '../ModalBase/ModalBase.types';
+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';
+export type ModalCssVariables = {
+    root: '--modal-size' | '--modal-radius' | '--modal-y-offset' | '--modal-x-offset';
+};
+export interface ModalEmits {
+    /** Called when the modal is closed. */
+    close: [];
+}
+export type ModalFactory = Factory<{
+    props: ModalProps;
+    slots: ModalSlots;
+    emits: ModalEmits;
+    element: 'div';
+    stylesNames: ModalStylesNames;
+    vars: ModalCssVariables;
+    staticComponents: {
+        Root: typeof ModalRoot;
+        Overlay: typeof ModalOverlay;
+        Content: typeof ModalContent;
+        Body: typeof ModalBody;
+        Header: typeof ModalHeader;
+        Title: typeof ModalTitle;
+        CloseButton: typeof ModalCloseButton;
+    };
+}>;
+export interface ModalSlots {
+    /** Content of the modal, rendered inside `Modal.Body`. */
+    default?: () => VNodeChild;
+    /** Title of the modal, rendered inside `Modal.Title`. */
+    title?: () => VNodeChild;
+}
+export interface ModalRootSlots {
+    /** `Modal.Overlay` and `Modal.Content`. */
+    default?: () => VNodeChild;
+}
+/** Props of every compound part of `Modal` – `Modal.Body`, `Modal.Header` and so on. */
+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>;
+    /** Internal: hides the part without unmounting it. */
+    __hidden?: boolean;
+}
+/**
+ * Props of `Modal.Root`.
+ *
+ * `Modal.Root` owns the Styles API and the layout of the modal; the behaviour comes
+ * from `ModalBase`, whose props are all accepted here as well.
+ *
+ * Extends `ModalBaseOwnProps` rather than `ModalBaseProps`: the `Omit<BoxProps, …>` in
+ * the latter is not resolvable by the SFC compiler across modules, and the `Box` props
+ * reach `ModalBase` through the fallthrough attributes anyway.
+ */
+export interface ModalRootProps extends ModalBaseOwnProps {
+    /**
+     * If set, the modal is centered vertically instead of offset from the top.
+     *
+     * @default false
+     */
+    centered?: boolean;
+    /**
+     * If set, the modal takes the whole screen.
+     *
+     * @default false
+     */
+    fullScreen?: boolean;
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius`. */
+    radius?: string | number;
+    /**
+     * Horizontal offset of the modal.
+     *
+     * @default '5vw'
+     */
+    xOffset?: string | number;
+    /**
+     * Vertical offset of the modal. Ignored when `centered` is set.
+     *
+     * @default '5dvh'
+     */
+    yOffset?: string | number;
+    /**
+     * Key of `theme.spacing` or any valid CSS value to set the width of the modal.
+     *
+     * @default 'md'
+     */
+    size?: string | number;
+    /** Component used to render the scrollable area of the content, for example `ScrollArea.Autosize`. */
+    scrollAreaComponent?: any;
+    /** `classNames` of the Styles API. */
+    classNames?: ClassNames<ModalRootProps>;
+    /** `styles` of the Styles API. */
+    styles?: Styles<ModalRootProps>;
+    /** CSS variables of the Styles API. */
+    vars?: Vars<ModalRootProps>;
+}
+/**
+ * Props of `Modal`.
+ *
+ * `Modal` is the pre-composed variant. Use `Modal.Root` and the compound components when
+ * the default composition is not enough.
+ */
+export interface ModalProps extends ModalRootProps {
+    /**
+     * Title of the modal.
+     * Can also be set with the `title` slot – the slot takes precedence.
+     */
+    title?: MantineNode;
+    /**
+     * If set, an overlay is rendered behind the modal.
+     *
+     * @default true
+     */
+    withOverlay?: boolean;
+    /** Props passed down to `Modal.Overlay`. */
+    overlayProps?: Record<string, any>;
+    /**
+     * If set, a close button is rendered in the header.
+     *
+     * @default true
+     */
+    withCloseButton?: boolean;
+    /** Props passed down to `Modal.CloseButton`. */
+    closeButtonProps?: Record<string, any>;
+}

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

@@ -0,0 +1,15 @@
+import type { ModalProps, ModalSlots } from './Modal.types';
+type __VLS_Slots = ModalSlots;
+declare const __VLS_base: import("vue").DefineComponent<ModalProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<ModalProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, 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;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/Modal/ModalRoot.vue.d.ts

@@ -0,0 +1,16 @@
+import type { ModalRootProps, ModalRootSlots } from './Modal.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>>;
+export { varsResolver };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ModalRootProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<ModalRootProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ModalRootSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/Modal/create-modal-compound-component.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Builds one of the compound parts of `Modal` – `Modal.Body`, `Modal.Header` and so on.
+ *
+ * Deliberately a factory rather than six near-identical SFCs: every part does exactly
+ * the same thing, differing only in the `ModalBase` component it wraps and the Styles
+ * API selector it reads. The same reasoning applies to `create-app-shell-component`.
+ */
+export declare function createModalCompoundComponent(name: string, Base: any, selector: string, extra?: (ctx: any) => Record<string, any>): import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    transitionProps: ObjectConstructor;
+    __hidden: BooleanConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    transitionProps: ObjectConstructor;
+    __hidden: BooleanConstructor;
+}>> & Readonly<{}>, {
+    visible: boolean;
+    __hidden: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -1,2 +1,2 @@
 export { Modal, ModalRoot, ModalBody, ModalCloseButton, ModalContent, ModalHeader, ModalOverlay, ModalTitle, } from './Modal';
-export type { ModalProps, ModalStylesNames, ModalCssVariables, ModalFactory } from './Modal';
+export type { ModalCompoundProps, ModalCssVariables, ModalEmits, ModalFactory, ModalProps, ModalRootProps, ModalRootSlots, ModalSlots, ModalStylesNames, } from './Modal';

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

@@ -1,180 +1,10 @@
-import { type PropType } from 'vue';
-export interface ModalBaseProps {
-    opened: boolean;
-    onClose: () => void;
-    id?: string;
-    keepMounted?: boolean;
-    lockScroll?: boolean;
-    trapFocus?: boolean;
-    withinPortal?: boolean;
-    portalProps?: Record<string, any>;
-    closeOnClickOutside?: boolean;
-    transitionProps?: Record<string, any>;
-    onExitTransitionEnd?: () => void;
-    onEnterTransitionEnd?: () => void;
-    closeOnEscape?: boolean;
-    returnFocus?: boolean;
-    zIndex?: string | number;
-    shadow?: string;
-    padding?: string | number;
-    unstyled?: boolean;
-}
-export declare const ModalBase: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    opened: {
-        type: BooleanConstructor;
-        required: true;
-    };
-    onClose: {
-        type: PropType<() => void>;
-        required: true;
-    };
-    id: StringConstructor;
-    keepMounted: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    lockScroll: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    trapFocus: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    withinPortal: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    portalProps: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    closeOnClickOutside: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    transitionProps: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    onExitTransitionEnd: {
-        type: PropType<() => void>;
-        default: undefined;
-    };
-    onEnterTransitionEnd: {
-        type: PropType<() => void>;
-        default: undefined;
-    };
-    closeOnEscape: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    returnFocus: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    zIndex: {
-        type: (NumberConstructor | StringConstructor)[];
-        default: undefined;
-    };
-    shadow: {
-        type: StringConstructor;
-        default: string;
-    };
-    padding: {
-        type: (NumberConstructor | StringConstructor)[];
-        default: string;
-    };
-    unstyled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-    [key: string]: any;
-}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    opened: {
-        type: BooleanConstructor;
-        required: true;
-    };
-    onClose: {
-        type: PropType<() => void>;
-        required: true;
-    };
-    id: StringConstructor;
-    keepMounted: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    lockScroll: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    trapFocus: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    withinPortal: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    portalProps: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    closeOnClickOutside: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    transitionProps: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    onExitTransitionEnd: {
-        type: PropType<() => void>;
-        default: undefined;
-    };
-    onEnterTransitionEnd: {
-        type: PropType<() => void>;
-        default: undefined;
-    };
-    closeOnEscape: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    returnFocus: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    zIndex: {
-        type: (NumberConstructor | StringConstructor)[];
-        default: undefined;
-    };
-    shadow: {
-        type: StringConstructor;
-        default: string;
-    };
-    padding: {
-        type: (NumberConstructor | StringConstructor)[];
-        default: string;
-    };
-    unstyled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>> & Readonly<{}>, {
-    shadow: string;
-    keepMounted: boolean;
-    padding: string | number;
-    zIndex: string | number;
-    unstyled: boolean;
-    withinPortal: boolean;
-    transitionProps: Record<string, any>;
-    portalProps: Record<string, any>;
-    lockScroll: boolean;
-    trapFocus: boolean;
-    closeOnClickOutside: boolean;
-    onExitTransitionEnd: () => void;
-    onEnterTransitionEnd: () => void;
-    closeOnEscape: boolean;
-    returnFocus: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const ModalBase: import("../..").MantineComponent<{
+    props: Omit<import("./ModalBase.types").ModalBaseProps, "rootRef">;
+    slots: import("./ModalBase.types").ModalBaseSlots;
+    ref: HTMLDivElement;
+    exposed: {
+        rootElement: Element | null;
+    };
+    element: "div";
+}>;
+export type { ModalBaseFactory, ModalBaseOwnProps, ModalBaseProps, ModalBaseSlots, } from './ModalBase.types';

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

@@ -0,0 +1,101 @@
+import type { VueRefTarget } from '@mantine-vue/hooks';
+import type { VNodeChild } from 'vue';
+import type { BoxProps, Factory } from '../../core';
+export interface ModalBaseSlots {
+    /** Modal parts, usually `ModalBase.Overlay` and `ModalBase.Content`. */
+    default?: () => VNodeChild;
+}
+/** Props declared by `ModalBase` itself. See `ModalBaseProps` for the full public type. */
+export interface ModalBaseOwnProps {
+    /** 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. */
+    id?: string;
+    /**
+     * If set, the modal stays mounted when closed and is hidden with CSS.
+     *
+     * @default false
+     */
+    keepMounted?: boolean;
+    /**
+     * If set, scroll is locked on the body element while the modal is open.
+     *
+     * @default true
+     */
+    lockScroll?: boolean;
+    /**
+     * If set, focus is trapped inside the modal while it is open.
+     *
+     * @default true
+     */
+    trapFocus?: boolean;
+    /**
+     * If set, the modal is rendered inside a `Portal`.
+     *
+     * @default true
+     */
+    withinPortal?: boolean;
+    /** Props passed down to the `Portal` when `withinPortal` is set. */
+    portalProps?: Record<string, any>;
+    /**
+     * If set, the modal is closed when the overlay is clicked.
+     *
+     * @default true
+     */
+    closeOnClickOutside?: boolean;
+    /** Props passed down to the `Transition` used by the overlay and the content. */
+    transitionProps?: Record<string, any>;
+    /** Called after the exit transition of the content has finished. */
+    onExitTransitionEnd?: () => void;
+    /** Called after the enter transition of the content has finished. */
+    onEnterTransitionEnd?: () => void;
+    /**
+     * If set, the modal is closed when the `Escape` key is pressed.
+     *
+     * @default true
+     */
+    closeOnEscape?: boolean;
+    /**
+     * If set, focus returns to the last active element when the modal is closed.
+     *
+     * @default true
+     */
+    returnFocus?: boolean;
+    /**
+     * `z-index` of the overlay and the content.
+     *
+     * @default getDefaultZIndex('modal')
+     */
+    zIndex?: string | number;
+    /**
+     * Key of `theme.shadows` or any valid CSS value to set the content shadow.
+     *
+     * @default 'xl'
+     */
+    shadow?: string;
+    /**
+     * Key of `theme.spacing` or any valid CSS value to set the content padding.
+     *
+     * @default 'md'
+     */
+    padding?: string | number;
+    /**
+     * If set, all Mantine classes are removed.
+     *
+     * @default false
+     */
+    unstyled?: boolean;
+}
+export interface ModalBaseProps extends Omit<BoxProps, keyof ModalBaseOwnProps>, ModalBaseOwnProps {
+}
+export type ModalBaseFactory = Factory<{
+    props: Omit<ModalBaseProps, 'rootRef'>;
+    slots: ModalBaseSlots;
+    ref: HTMLDivElement;
+    exposed: {
+        rootElement: Element | null;
+    };
+    element: 'div';
+}>;

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

@@ -0,0 +1,17 @@
+import type { ModalBaseOwnProps, ModalBaseSlots } from './ModalBase.types';
+type __VLS_Slots = ModalBaseSlots;
+declare const __VLS_base: import("vue").DefineComponent<ModalBaseOwnProps, {
+    rootElement: import("vue").Ref<Element | null, Element | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<ModalBaseOwnProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, 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;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -1,6 +1,6 @@
-export declare const ModalBaseBody: import("../..").WithBoxProps<import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-    [key: string]: any;
-}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
-export interface ModalBaseBodyProps {
-    [key: string]: any;
-}
+export declare const ModalBaseBody: import("../..").MantineComponent<{
+    props: import("./ModalBaseBody.types").ModalBaseBodyProps;
+    slots: import("./ModalBaseBody.types").ModalBaseBodySlots;
+    element: "div";
+}>;
+export type { ModalBaseBodyProps, ModalBaseBodySlots, ModalBaseBodyFactory, } from './ModalBaseBody.types';

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

@@ -0,0 +1,16 @@
+import type { VNodeChild } from 'vue';
+import type { BoxProps, Factory } from '../../core';
+/** Props accepted by `ModalBaseBody`. Native div attributes are forwarded to the root element. */
+export interface ModalBaseBodyProps extends BoxProps {
+    /** Class applied to the modal body root. */
+    class?: any;
+}
+export interface ModalBaseBodySlots {
+    /** Modal body content. */
+    default?: () => VNodeChild;
+}
+export type ModalBaseBodyFactory = Factory<{
+    props: ModalBaseBodyProps;
+    slots: ModalBaseBodySlots;
+    element: 'div';
+}>;

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

@@ -0,0 +1,11 @@
+import type { ModalBaseBodySlots } from './ModalBaseBody.types';
+type __VLS_Slots = ModalBaseBodySlots;
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -1,6 +1,26 @@
-export declare const ModalBaseCloseButton: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-    [key: string]: any;
-}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-export interface ModalBaseCloseButtonProps {
-    [key: string]: any;
-}
+export declare const ModalBaseCloseButton: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./ModalBaseCloseButton.types").ModalBaseCloseButtonOwnProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        click: (event: MouseEvent) => any;
+    }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./ModalBaseCloseButton.types").ModalBaseCloseButtonOwnProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./ModalBaseCloseButton.types").ModalBaseCloseButtonOwnProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./ModalBaseCloseButton.types").ModalBaseCloseButtonSlots;
+});
+export type { ModalBaseCloseButtonOwnProps, ModalBaseCloseButtonProps, ModalBaseCloseButtonSlots, } from './ModalBaseCloseButton.types';

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

@@ -0,0 +1,13 @@
+import type { VNodeChild } from 'vue';
+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 ModalBaseCloseButtonSlots {
+    /** Custom close button content. */
+    default?: () => VNodeChild;
+    /** Custom close icon. */
+    icon?: () => VNodeChild;
+}

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

@@ -0,0 +1,15 @@
+import type { ModalBaseCloseButtonOwnProps, ModalBaseCloseButtonSlots } from './ModalBaseCloseButton.types';
+type __VLS_Slots = ModalBaseCloseButtonSlots;
+declare const __VLS_base: import("vue").DefineComponent<ModalBaseCloseButtonOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<ModalBaseCloseButtonOwnProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, 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;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -1,29 +1,11 @@
-export declare const ModalBaseContent: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    transitionProps: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    innerProps: {
-        type: ObjectConstructor;
-        default: () => {};
-    };
-}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-    [key: string]: any;
-}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    transitionProps: {
-        type: ObjectConstructor;
-        default: undefined;
-    };
-    innerProps: {
-        type: ObjectConstructor;
-        default: () => {};
-    };
-}>> & Readonly<{}>, {
-    transitionProps: Record<string, any>;
-    innerProps: Record<string, any>;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
-export interface ModalBaseContentProps {
-    transitionProps?: Record<string, any>;
-    innerProps?: Record<string, any>;
-    [key: string]: any;
-}
+/** Transitioned, focus-trapped dialog surface shared by `Modal` and `Drawer`. */
+export declare const ModalBaseContent: import("../..").MantineComponent<{
+    props: Omit<import("./ModalBaseContent.types").ModalBaseContentProps, "rootRef">;
+    slots: import("./ModalBaseContent.types").ModalBaseContentSlots;
+    ref: HTMLElement;
+    exposed: {
+        rootElement: Element | null;
+    };
+    element: "section";
+}>;
+export type { ModalBaseContentFactory, ModalBaseContentOwnProps, ModalBaseContentProps, ModalBaseContentSlots, } from './ModalBaseContent.types';