@mantine-vue/core 3.0.0 → 3.1.0

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

@@ -0,0 +1,94 @@
+import type { EmptyStateActions } from './EmptyStateActions/EmptyStateActions';
+import type { EmptyStateDescription } from './EmptyStateDescription/EmptyStateDescription';
+import type { EmptyStateTitle } from './EmptyStateTitle/EmptyStateTitle';
+import type { EmptyStateIndicator } from './EmptyStateIndicator/EmptyStateIndicator';
+import type { VNodeChild } from 'vue';
+import type { BoxMod, BoxProps, MantineColor, MantineNode, MantineSize, StylesApiProps, Factory } from '../../core';
+export type EmptyStateStylesNames = 'root' | 'body' | 'indicator' | 'title' | 'description' | 'actions';
+export type EmptyStateVariant = 'filled' | 'light';
+export type EmptyStateCssVariables = {
+    root: '--empty-state-indicator-size' | '--empty-state-gap' | '--empty-state-title-fz' | '--empty-state-description-fz' | '--empty-state-indicator-bg' | '--empty-state-indicator-color';
+};
+export interface EmptyStateSlots {
+    /** Extra content rendered in the body, usually `EmptyState.Actions`. */
+    default?: () => VNodeChild;
+    /** Icon or illustration rendered inside `EmptyState.Indicator`. */
+    icon?: () => VNodeChild;
+    /** Title rendered inside `EmptyState.Title`. */
+    title?: () => VNodeChild;
+    /** Description rendered inside `EmptyState.Description`. */
+    description?: () => VNodeChild;
+}
+/** 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.
+     *
+     * @default 'md'
+     */
+    size?: MantineSize | (string & {});
+    /**
+     * Content alignment. `center` stacks the content in a centered column, `left` and
+     * `right` place the indicator on the side with the content next to it.
+     *
+     * @default 'center'
+     */
+    align?: 'left' | 'center' | 'right';
+    /**
+     * Controls the indicator appearance. `filled` and `light` render a colored circular
+     * background behind the icon. Without it the icon is rendered with a dimmed color.
+     */
+    variant?: EmptyStateVariant | (string & {});
+    /**
+     * Key of `theme.colors` or any valid CSS color used by the `filled` and `light`
+     * variants.
+     *
+     * @default theme.primaryColor
+     */
+    color?: MantineColor;
+    /**
+     * Title content, rendered inside `EmptyState.Title`.
+     * Can also be set with the `title` slot – the slot takes precedence.
+     */
+    title?: MantineNode;
+    /**
+     * Description content, rendered inside `EmptyState.Description`.
+     * Can also be set with the `description` slot – the slot takes precedence.
+     */
+    description?: MantineNode;
+    /**
+     * Icon or illustration, rendered inside `EmptyState.Indicator`.
+     * Can also be set with the `icon` slot – the slot takes precedence.
+     */
+    icon?: MantineNode;
+    /**
+     * If set, a neutral circular background is rendered behind the indicator. Setting
+     * `variant` always renders a colored background regardless of this prop.
+     *
+     * @default false
+     */
+    withIndicatorBackground?: boolean;
+    /** Element modifiers transformed into `data-` attributes, for example, `{ 'data-size': 'xl' }`, falsy values are removed */
+    mod?: BoxMod;
+}
+export interface EmptyStateProps extends Omit<BoxProps, keyof EmptyStateOwnProps>, EmptyStateOwnProps {
+}
+export type EmptyStateFactory = Factory<{
+    props: Omit<EmptyStateProps, 'rootRef'>;
+    ref: HTMLDivElement;
+    slots: EmptyStateSlots;
+    element: 'div';
+    stylesNames: EmptyStateStylesNames;
+    vars: EmptyStateCssVariables;
+    variant: EmptyStateVariant;
+    staticComponents: {
+        Indicator: typeof EmptyStateIndicator;
+        Title: typeof EmptyStateTitle;
+        Description: typeof EmptyStateDescription;
+        Actions: typeof EmptyStateActions;
+    };
+}>;
+import type { VueRefTarget } from '@mantine-vue/hooks';

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

@@ -0,0 +1,24 @@
+import type { EmptyStateOwnProps, EmptyStateSlots } from './EmptyState.types';
+import { type VNode, type VNodeChild } from 'vue';
+declare const defaultProps: {
+    readonly size: "md";
+    readonly align: "center";
+};
+/** 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>>;
+/**
+ * `v-for` and conditionals produce fragments and arrays, which have to be unwrapped
+ * before the indicator can be told apart from the rest of the children.
+ */
+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, {
+    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>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -1,44 +1,8 @@
-import { type PropType, type SlotsType, type VNodeChild } from 'vue';
-export type EmptyStateActionsStylesNames = 'actions';
-export interface EmptyStateActionsProps {
-    classNames?: any;
-    styles?: any;
-    mod?: any;
-    [key: string]: any;
-}
-export interface EmptyStateActionsSlots {
-    default?: () => VNodeChild;
-}
-export declare const EmptyStateActions: import("../../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    mod: {
-        type: PropType<any>;
-        default: undefined;
-    };
-}>, () => 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<{
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    mod: {
-        type: PropType<any>;
-        default: undefined;
-    };
-}>> & Readonly<{}>, {
-    classNames: Function | Record<string, any>;
-    styles: Function | Record<string, any>;
-    mod: any;
-}, SlotsType<EmptyStateActionsSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const EmptyStateActions: import("../../..").MantineComponent<{
+    props: Omit<import("./EmptyStateActions.types").EmptyStateActionsProps, "rootRef">;
+    ref: HTMLDivElement;
+    slots: import("./EmptyStateActions.types").EmptyStateActionsSlots;
+    element: "div";
+    stylesNames: import("./EmptyStateActions.types").EmptyStateActionsStylesNames;
+}>;
+export type { EmptyStateActionsOwnProps, EmptyStateActionsProps, EmptyStateActionsSlots, EmptyStateActionsStylesNames, EmptyStateActionsFactory, } from './EmptyStateActions.types';

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

@@ -0,0 +1,28 @@
+import type { VNodeChild } from 'vue';
+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. */
+    styles?: StylesApiProps<EmptyStateActionsProps>['styles'];
+    /** Element modifiers transformed into `data-` attributes. */
+    mod?: BoxProps['mod'];
+}
+export interface EmptyStateActionsProps extends Omit<BoxProps, keyof EmptyStateActionsOwnProps>, EmptyStateActionsOwnProps {
+}
+export interface EmptyStateActionsSlots {
+    /** Action buttons or controls. */
+    default?: () => VNodeChild;
+}
+export type EmptyStateActionsFactory = Factory<{
+    props: Omit<EmptyStateActionsProps, 'rootRef'>;
+    ref: HTMLDivElement;
+    slots: EmptyStateActionsSlots;
+    element: 'div';
+    stylesNames: EmptyStateActionsStylesNames;
+}>;
+import type { VueRefTarget } from '@mantine-vue/hooks';

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

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

@@ -1,44 +1,8 @@
-import { type PropType, type SlotsType, type VNodeChild } from 'vue';
-export type EmptyStateDescriptionStylesNames = 'description';
-export interface EmptyStateDescriptionProps {
-    classNames?: any;
-    styles?: any;
-    mod?: any;
-    [key: string]: any;
-}
-export interface EmptyStateDescriptionSlots {
-    default?: () => VNodeChild;
-}
-export declare const EmptyStateDescription: import("../../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    mod: {
-        type: PropType<any>;
-        default: undefined;
-    };
-}>, () => 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<{
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    mod: {
-        type: PropType<any>;
-        default: undefined;
-    };
-}>> & Readonly<{}>, {
-    classNames: Function | Record<string, any>;
-    styles: Function | Record<string, any>;
-    mod: any;
-}, SlotsType<EmptyStateDescriptionSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const EmptyStateDescription: import("../../..").MantineComponent<{
+    props: Omit<import("./EmptyStateDescription.types").EmptyStateDescriptionProps, "rootRef">;
+    ref: HTMLParagraphElement;
+    slots: import("./EmptyStateDescription.types").EmptyStateDescriptionSlots;
+    element: "p";
+    stylesNames: import("./EmptyStateDescription.types").EmptyStateDescriptionStylesNames;
+}>;
+export type { EmptyStateDescriptionOwnProps, EmptyStateDescriptionProps, EmptyStateDescriptionSlots, EmptyStateDescriptionStylesNames, EmptyStateDescriptionFactory, } from './EmptyStateDescription.types';

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

@@ -0,0 +1,28 @@
+import type { VNodeChild } from 'vue';
+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. */
+    styles?: StylesApiProps<EmptyStateDescriptionProps>['styles'];
+    /** Element modifiers transformed into `data-` attributes. */
+    mod?: BoxProps['mod'];
+}
+export interface EmptyStateDescriptionProps extends Omit<BoxProps, keyof EmptyStateDescriptionOwnProps>, EmptyStateDescriptionOwnProps {
+}
+export interface EmptyStateDescriptionSlots {
+    /** Description content. */
+    default?: () => VNodeChild;
+}
+export type EmptyStateDescriptionFactory = Factory<{
+    props: Omit<EmptyStateDescriptionProps, 'rootRef'>;
+    ref: HTMLParagraphElement;
+    slots: EmptyStateDescriptionSlots;
+    element: 'p';
+    stylesNames: EmptyStateDescriptionStylesNames;
+}>;
+import type { VueRefTarget } from '@mantine-vue/hooks';

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

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

@@ -1,44 +1,8 @@
-import { type PropType, type SlotsType, type VNodeChild } from 'vue';
-export type EmptyStateIndicatorStylesNames = 'indicator';
-export interface EmptyStateIndicatorProps {
-    classNames?: any;
-    styles?: any;
-    mod?: any;
-    [key: string]: any;
-}
-export interface EmptyStateIndicatorSlots {
-    default?: () => VNodeChild;
-}
-export declare const EmptyStateIndicator: import("../../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    mod: {
-        type: PropType<any>;
-        default: undefined;
-    };
-}>, () => 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<{
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    mod: {
-        type: PropType<any>;
-        default: undefined;
-    };
-}>> & Readonly<{}>, {
-    classNames: Function | Record<string, any>;
-    styles: Function | Record<string, any>;
-    mod: any;
-}, SlotsType<EmptyStateIndicatorSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const EmptyStateIndicator: import("../../..").MantineComponent<{
+    props: Omit<import("./EmptyStateIndicator.types").EmptyStateIndicatorProps, "rootRef">;
+    ref: HTMLDivElement;
+    slots: import("./EmptyStateIndicator.types").EmptyStateIndicatorSlots;
+    element: "div";
+    stylesNames: import("./EmptyStateIndicator.types").EmptyStateIndicatorStylesNames;
+}>;
+export type { EmptyStateIndicatorOwnProps, EmptyStateIndicatorProps, EmptyStateIndicatorSlots, EmptyStateIndicatorStylesNames, EmptyStateIndicatorFactory, } from './EmptyStateIndicator.types';

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

@@ -0,0 +1,28 @@
+import type { VNodeChild } from 'vue';
+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. */
+    styles?: StylesApiProps<EmptyStateIndicatorProps>['styles'];
+    /** Element modifiers transformed into `data-` attributes. */
+    mod?: BoxProps['mod'];
+}
+export interface EmptyStateIndicatorProps extends Omit<BoxProps, keyof EmptyStateIndicatorOwnProps>, EmptyStateIndicatorOwnProps {
+}
+export interface EmptyStateIndicatorSlots {
+    /** Icon or illustration displayed inside the indicator. */
+    default?: () => VNodeChild;
+}
+export type EmptyStateIndicatorFactory = Factory<{
+    props: Omit<EmptyStateIndicatorProps, 'rootRef'>;
+    ref: HTMLDivElement;
+    slots: EmptyStateIndicatorSlots;
+    element: 'div';
+    stylesNames: EmptyStateIndicatorStylesNames;
+}>;
+import type { VueRefTarget } from '@mantine-vue/hooks';

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

@@ -0,0 +1,13 @@
+import type { EmptyStateIndicatorOwnProps, EmptyStateIndicatorSlots } from './EmptyStateIndicator.types';
+type __VLS_Slots = EmptyStateIndicatorSlots;
+declare const __VLS_base: import("vue").DefineComponent<EmptyStateIndicatorOwnProps, {
+    rootElement: import("vue").Ref<Element | null, Element | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<EmptyStateIndicatorOwnProps> & 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;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -1,55 +1,8 @@
-import { type PropType, type SlotsType, type VNodeChild } from 'vue';
-export type EmptyStateTitleStylesNames = 'title';
-export interface EmptyStateTitleProps {
-    /** Heading order, renders the title as `h1`–`h6` element. By default, the title is rendered as a `div` without semantic heading level */
-    order?: 1 | 2 | 3 | 4 | 5 | 6;
-    classNames?: any;
-    styles?: any;
-    mod?: any;
-    [key: string]: any;
-}
-export interface EmptyStateTitleSlots {
-    default?: () => VNodeChild;
-}
-export declare const EmptyStateTitle: import("../../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    order: {
-        type: PropType<1 | 2 | 3 | 4 | 5 | 6>;
-        default: undefined;
-    };
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    mod: {
-        type: PropType<any>;
-        default: undefined;
-    };
-}>, () => 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<{
-    order: {
-        type: PropType<1 | 2 | 3 | 4 | 5 | 6>;
-        default: undefined;
-    };
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    mod: {
-        type: PropType<any>;
-        default: undefined;
-    };
-}>> & Readonly<{}>, {
-    classNames: Function | Record<string, any>;
-    styles: Function | Record<string, any>;
-    mod: any;
-    order: 1 | 3 | 2 | 4 | 5 | 6;
-}, SlotsType<EmptyStateTitleSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const EmptyStateTitle: import("../../..").MantineComponent<{
+    props: Omit<import("./EmptyStateTitle.types").EmptyStateTitleProps, "rootRef">;
+    ref: HTMLDivElement;
+    slots: import("./EmptyStateTitle.types").EmptyStateTitleSlots;
+    element: "div";
+    stylesNames: import("./EmptyStateTitle.types").EmptyStateTitleStylesNames;
+}>;
+export type { EmptyStateTitleOwnProps, EmptyStateTitleProps, EmptyStateTitleSlots, EmptyStateTitleStylesNames, EmptyStateTitleFactory, } from './EmptyStateTitle.types';

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

@@ -0,0 +1,30 @@
+import type { VNodeChild } from 'vue';
+import type { BoxProps, StylesApiProps, Factory } from '../../../core';
+export type EmptyStateTitleStylesNames = 'title';
+/** Props declared by `EmptyStateTitle` itself. See `EmptyStateTitleProps` for the full public type. */
+export interface EmptyStateTitleOwnProps {
+    /** Receives the root DOM node. */
+    rootRef?: VueRefTarget<Element>;
+    /** Heading order. When set, renders an `h1`–`h6`; otherwise renders a `div`. */
+    order?: 1 | 2 | 3 | 4 | 5 | 6;
+    /** Class names applied to EmptyState elements. */
+    classNames?: StylesApiProps<EmptyStateTitleFactory>['classNames'];
+    /** Inline styles applied to EmptyState elements. */
+    styles?: StylesApiProps<EmptyStateTitleProps>['styles'];
+    /** Element modifiers transformed into `data-` attributes. */
+    mod?: BoxProps['mod'];
+}
+export interface EmptyStateTitleProps extends Omit<BoxProps, keyof EmptyStateTitleOwnProps>, EmptyStateTitleOwnProps {
+}
+export interface EmptyStateTitleSlots {
+    /** Title content. */
+    default?: () => VNodeChild;
+}
+export type EmptyStateTitleFactory = Factory<{
+    props: Omit<EmptyStateTitleProps, 'rootRef'>;
+    ref: HTMLDivElement;
+    slots: EmptyStateTitleSlots;
+    element: 'div';
+    stylesNames: EmptyStateTitleStylesNames;
+}>;
+import type { VueRefTarget } from '@mantine-vue/hooks';

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

@@ -0,0 +1,13 @@
+import type { EmptyStateTitleOwnProps, EmptyStateTitleSlots } from './EmptyStateTitle.types';
+type __VLS_Slots = EmptyStateTitleSlots;
+declare const __VLS_base: import("vue").DefineComponent<EmptyStateTitleOwnProps, {
+    rootElement: import("vue").Ref<Element | null, Element | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<EmptyStateTitleOwnProps> & 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;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -1,12 +1,12 @@
 export { EmptyState } from './EmptyState';
-export type { EmptyStateProps, EmptyStateSlots, EmptyStateStylesNames, EmptyStateCssVariables, EmptyStateVariant, } from './EmptyState';
+export type { EmptyStateCssVariables, EmptyStateFactory, EmptyStateOwnProps, EmptyStateProps, EmptyStateSlots, EmptyStateStylesNames, EmptyStateVariant, } from './EmptyState';
 export { EmptyStateIndicator } from './EmptyStateIndicator/EmptyStateIndicator';
-export type { EmptyStateIndicatorProps, EmptyStateIndicatorSlots, EmptyStateIndicatorStylesNames, } from './EmptyStateIndicator/EmptyStateIndicator';
+export type { EmptyStateIndicatorOwnProps, EmptyStateIndicatorProps, EmptyStateIndicatorSlots, EmptyStateIndicatorStylesNames, } from './EmptyStateIndicator/EmptyStateIndicator';
 export { EmptyStateTitle } from './EmptyStateTitle/EmptyStateTitle';
-export type { EmptyStateTitleProps, EmptyStateTitleSlots, EmptyStateTitleStylesNames, } from './EmptyStateTitle/EmptyStateTitle';
+export type { EmptyStateTitleOwnProps, EmptyStateTitleProps, EmptyStateTitleSlots, EmptyStateTitleStylesNames, } from './EmptyStateTitle/EmptyStateTitle';
 export { EmptyStateDescription } from './EmptyStateDescription/EmptyStateDescription';
-export type { EmptyStateDescriptionProps, EmptyStateDescriptionSlots, EmptyStateDescriptionStylesNames, } from './EmptyStateDescription/EmptyStateDescription';
+export type { EmptyStateDescriptionOwnProps, EmptyStateDescriptionProps, EmptyStateDescriptionSlots, EmptyStateDescriptionStylesNames, } from './EmptyStateDescription/EmptyStateDescription';
 export { EmptyStateActions } from './EmptyStateActions/EmptyStateActions';
-export type { EmptyStateActionsProps, EmptyStateActionsSlots, EmptyStateActionsStylesNames, } from './EmptyStateActions/EmptyStateActions';
+export type { EmptyStateActionsOwnProps, EmptyStateActionsProps, EmptyStateActionsSlots, EmptyStateActionsStylesNames, } from './EmptyStateActions/EmptyStateActions';
 export { useEmptyStateContext } from './EmptyState.context';
 export type { EmptyStateContextValue } from './EmptyState.context';

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

@@ -1,77 +1,10 @@
-import { type PropType, type SlotsType, type VNodeChild } from 'vue';
-import { type MantineNode, type MantineRadius } from '../../core';
-export type FieldsetStylesNames = 'root' | 'legend';
-export type FieldsetVariant = 'default' | 'filled' | 'unstyled';
-export interface FieldsetSlots {
-    default?: () => VNodeChild;
-    legend?: () => VNodeChild;
-}
-export declare const Fieldset: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    legend: {
-        type: PropType<MantineNode>;
-        default: undefined;
-    };
-    radius: {
-        type: PropType<MantineRadius>;
-        default: undefined;
-    };
-    variant: {
-        type: PropType<FieldsetVariant>;
-        default: undefined;
-    };
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    vars: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    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<{
-    legend: {
-        type: PropType<MantineNode>;
-        default: undefined;
-    };
-    radius: {
-        type: PropType<MantineRadius>;
-        default: undefined;
-    };
-    variant: {
-        type: PropType<FieldsetVariant>;
-        default: undefined;
-    };
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    vars: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    unstyled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>> & Readonly<{}>, {
-    legend: MantineNode;
-    radius: MantineRadius;
-    variant: FieldsetVariant;
-    classNames: Function | Record<string, any>;
-    styles: Function | Record<string, any>;
-    vars: Function | Record<string, any>;
-    unstyled: boolean;
-}, SlotsType<FieldsetSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const Fieldset: import("../..").MantineComponent<{
+    props: Omit<import("./Fieldset.types").FieldsetProps, "rootRef">;
+    ref: HTMLFieldSetElement;
+    slots: import("./Fieldset.types").FieldsetSlots;
+    element: "fieldset";
+    stylesNames: import("./Fieldset.types").FieldsetStylesNames;
+    vars: import("./Fieldset.types").FieldsetCssVariables;
+    variant: import("./Fieldset.types").FieldsetVariant;
+}>;
+export type { FieldsetOwnProps, FieldsetProps, FieldsetSlots, FieldsetStylesNames, FieldsetVariant, FieldsetFactory, } from './Fieldset.types';