@mantine-vue/core 2.4.0 → 3.1.0

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

@@ -0,0 +1,76 @@
+import type { ListItem } from './ListItem/ListItem';
+import type { VNodeChild } from 'vue';
+import type { BoxMod, BoxProps, MantineNode, MantineSize, MantineSpacing, StylesApiProps, Factory } from '../../core';
+/** Props declared by `List` itself. See `ListProps` for the full public type. */
+export interface ListOwnProps extends StylesApiProps<ListFactory> {
+    /** Receives the root DOM node. */
+    rootRef?: VueRefTarget<Element>;
+    /**
+     * List type
+     *
+     * @default 'unordered'
+     */
+    type?: 'ordered' | 'unordered';
+    /**
+     * Adds extra horizontal padding to the list, useful for nested lists
+     *
+     * @default false
+     */
+    withPadding?: boolean;
+    /**
+     * Controls `font-size` and `line-height`
+     *
+     * @default 'md'
+     */
+    size?: MantineSize;
+    /** Icon to replace default list markers. Applied to all items unless overridden on individual List.Item components */
+    icon?: MantineNode;
+    /**
+     * Key of `theme.spacing` or any valid CSS value to set spacing between items
+     *
+     * @default 0
+     */
+    spacing?: MantineSpacing;
+    /**
+     * Vertically centers list items with their icons
+     *
+     * @default false
+     */
+    center?: boolean;
+    /** Controls CSS `list-style-type` property. Overrides the default list marker style based on list type */
+    listStyleType?: string;
+    /** Starting value for ordered list numbering (only works with type="ordered") */
+    start?: number;
+    /**
+     * Reverses the order of list items (only works with type="ordered")
+     *
+     * @default false
+     */
+    reversed?: boolean;
+    /** Element modifiers transformed into `data-` attributes, for example, `{ 'data-size': 'xl' }`, falsy values are removed */
+    mod?: BoxMod;
+}
+export interface ListSlots {
+    /** Component content. */
+    default?: () => VNodeChild;
+    /** Custom marker inherited by list items. */
+    icon?: () => VNodeChild;
+}
+export interface ListProps extends Omit<BoxProps, keyof ListOwnProps>, ListOwnProps {
+}
+export type ListStylesNames = 'root' | 'item' | 'itemWrapper' | 'itemIcon' | 'itemLabel';
+export type ListCssVariables = {
+    root: '--list-fz' | '--list-lh' | '--list-spacing';
+};
+export type ListFactory = Factory<{
+    props: Omit<ListProps, 'rootRef'>;
+    ref: HTMLUListElement;
+    slots: ListSlots;
+    element: 'ul';
+    stylesNames: ListStylesNames;
+    vars: ListCssVariables;
+    staticComponents: {
+        Item: typeof ListItem;
+    };
+}>;
+import type { VueRefTarget } from '@mantine-vue/hooks';

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

@@ -0,0 +1,12 @@
+import type { ListOwnProps, ListSlots } from './List.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<ListOwnProps, {
+    rootElement: import("vue").Ref<Element | null, Element | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ListOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ListSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/List/ListItem/ListItem.d.ts

@@ -1,57 +1,8 @@
-import { type PropType, type SlotsType, type VNodeChild } from 'vue';
-import { type MantineNode } from '../../../core';
-export interface ListItemSlots {
-    default?: () => VNodeChild;
-    icon?: () => VNodeChild;
-}
-export declare const ListItem: import("../../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    icon: {
-        type: PropType<MantineNode>;
-        default: undefined;
-    };
-    mod: {
-        type: PropType<any>;
-        default: undefined;
-    };
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    vars: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        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<{
-    icon: {
-        type: PropType<MantineNode>;
-        default: undefined;
-    };
-    mod: {
-        type: PropType<any>;
-        default: undefined;
-    };
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    vars: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-}>> & Readonly<{}>, {
-    classNames: Function | Record<string, any>;
-    styles: Function | Record<string, any>;
-    mod: any;
-    icon: MantineNode;
-    vars: Function | Record<string, any>;
-}, SlotsType<ListItemSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const ListItem: import("../../..").MantineComponent<{
+    props: Omit<import("./ListItem.types").ListItemProps, "rootRef">;
+    ref: HTMLLIElement;
+    slots: import("./ListItem.types").ListItemSlots;
+    element: "li";
+    stylesNames: import("./ListItem.types").ListItemStylesNames;
+}>;
+export type { ListItemOwnProps, ListItemProps, ListItemSlots, ListItemStylesNames, ListItemFactory, } from './ListItem.types';

package/lib/components/List/ListItem/ListItem.types.d.ts

@@ -0,0 +1,28 @@
+import type { VNodeChild } from 'vue';
+import type { BoxMod, BoxProps, MantineNode, StylesApiProps, Factory } from '../../../core';
+/** Props declared by `ListItem` itself. See `ListItemProps` for the full public type. */
+export interface ListItemOwnProps extends Pick<StylesApiProps<ListItemFactory>, 'classNames' | 'styles' | 'vars'> {
+    /** Receives the root DOM node. */
+    rootRef?: VueRefTarget<Element>;
+    /** Icon to replace item bullet */
+    icon?: MantineNode;
+    /** Element modifiers transformed into `data-` attributes, for example, `{ 'data-size': 'xl' }`, falsy values are removed */
+    mod?: BoxMod;
+}
+export interface ListItemSlots {
+    /** Component content. */
+    default?: () => VNodeChild;
+    /** Marker that overrides the parent list icon. */
+    icon?: () => VNodeChild;
+}
+export interface ListItemProps extends Omit<BoxProps, keyof ListItemOwnProps>, ListItemOwnProps {
+}
+export type ListItemStylesNames = 'item' | 'itemWrapper' | 'itemIcon' | 'itemLabel';
+export type ListItemFactory = Factory<{
+    props: Omit<ListItemProps, 'rootRef'>;
+    ref: HTMLLIElement;
+    slots: ListItemSlots;
+    element: 'li';
+    stylesNames: ListItemStylesNames;
+}>;
+import type { VueRefTarget } from '@mantine-vue/hooks';

package/lib/components/List/ListItem/ListItem.vue.d.ts

@@ -0,0 +1,13 @@
+import type { ListItemOwnProps, ListItemSlots } from './ListItem.types';
+type __VLS_Slots = ListItemSlots;
+declare const __VLS_base: import("vue").DefineComponent<ListItemOwnProps, {
+    rootElement: import("vue").Ref<Element | null, Element | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ListItemOwnProps> & 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/Loader/Loader.d.ts

@@ -1,75 +1,17 @@
-import { type PropType } from 'vue';
-import { type MantineColor, type MantineSize } from '../../core';
-import type { MantineLoader, MantineLoadersRecord } from './Loader.types';
-export declare const defaultLoaders: MantineLoadersRecord;
-export declare const Loader: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    size: PropType<MantineSize | (string & {}) | number>;
-    color: {
-        type: PropType<MantineColor>;
-        default: undefined;
-    };
-    type: {
-        type: PropType<MantineLoader>;
-        default: undefined;
-    };
-    loaders: {
-        type: PropType<MantineLoadersRecord>;
-        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<{
-    size: PropType<MantineSize | (string & {}) | number>;
-    color: {
-        type: PropType<MantineColor>;
-        default: undefined;
-    };
-    type: {
-        type: PropType<MantineLoader>;
-        default: undefined;
-    };
-    loaders: {
-        type: PropType<MantineLoadersRecord>;
-        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<{}>, {
-    color: MantineColor;
-    type: MantineLoader;
-    classNames: Function | Record<string, any>;
-    styles: Function | Record<string, any>;
-    vars: Function | Record<string, any>;
-    unstyled: boolean;
-    loaders: MantineLoadersRecord;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+import { defaultLoaders } from './Loader.vue';
+export { defaultLoaders };
+export declare const Loader: import("../..").MantineComponent<{
+    props: Omit<import("./Loader.types").LoaderProps, "rootRef">;
+    slots: import("./Loader.types").LoaderSlots;
+    ref: HTMLSpanElement;
+    exposed: {
+        rootElement: Element | null;
+    };
+    element: "span";
+    stylesNames: import("./Loader.types").LoaderStylesNames;
+    vars: import("./Loader.types").LoaderCssVariables;
+    staticComponents: {
+        defaultLoaders: import("./Loader.types").MantineLoadersRecord;
+    };
+}>;
+export type { LoaderCssVariables, LoaderFactory, LoaderOwnProps, LoaderProps, LoaderSlots, LoaderStylesNames, } from './Loader.types';

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

@@ -1,4 +1,45 @@
-import type { Component } from 'vue';
+import type { VueRefTarget } from '@mantine-vue/hooks';
+import type { Component, HTMLAttributes, SVGAttributes, VNodeChild } from 'vue';
+import type { BoxProps, 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 */
+    color?: MantineColor;
+    /** Loader type selected from `loaders`. @default 'oval' */
+    type?: MantineLoader;
+    /** Custom loader component registry. */
+    loaders?: MantineLoadersRecord;
+}
+export interface LoaderProps extends Omit<BoxProps, keyof LoaderOwnProps>, LoaderOwnProps {
+}
+export interface LoaderSlots {
+    /** Overrides the selected loader. */ default?: () => VNodeChild;
+}
+export type LoaderStylesNames = 'root';
+export type LoaderCssVariables = {
+    root: '--loader-size' | '--loader-color';
+};
+export type BarsProps = HTMLAttributes;
+export type DotsProps = HTMLAttributes;
+export type OvalProps = HTMLAttributes;
+export type LoaderSvgProps = SVGAttributes;
+export type LoaderFactory = Factory<{
+    props: Omit<LoaderProps, 'rootRef'>;
+    slots: LoaderSlots;
+    ref: HTMLSpanElement;
+    exposed: {
+        rootElement: Element | null;
+    };
+    element: 'span';
+    stylesNames: LoaderStylesNames;
+    vars: LoaderCssVariables;
+    staticComponents: {
+        defaultLoaders: MantineLoadersRecord;
+    };
+}>;

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

@@ -0,0 +1,14 @@
+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, {
+    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>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -1,3 +1 @@
-export declare const Bars: 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 declare const Bars: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -1,3 +1 @@
-export declare const Dots: 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 declare const Dots: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -1,3 +1 @@
-export declare const Oval: 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 declare const Oval: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -1,117 +1,11 @@
-import { type PropType } from 'vue';
-export declare const LoadingOverlay: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    transitionProps: {
-        type: PropType<Record<string, any>>;
-        default: undefined;
-    };
-    loaderProps: {
-        type: PropType<Record<string, any>>;
-        default: undefined;
-    };
-    overlayProps: {
-        type: PropType<Record<string, any>>;
-        default: undefined;
-    };
-    visible: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    zIndex: PropType<string | number>;
-    onEnter: {
-        type: PropType<() => void>;
-        default: undefined;
-    };
-    onEntered: {
-        type: PropType<() => void>;
-        default: undefined;
-    };
-    onExit: {
-        type: PropType<() => void>;
-        default: undefined;
-    };
-    onExited: {
-        type: PropType<() => void>;
-        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<{
-    transitionProps: {
-        type: PropType<Record<string, any>>;
-        default: undefined;
-    };
-    loaderProps: {
-        type: PropType<Record<string, any>>;
-        default: undefined;
-    };
-    overlayProps: {
-        type: PropType<Record<string, any>>;
-        default: undefined;
-    };
-    visible: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    zIndex: PropType<string | number>;
-    onEnter: {
-        type: PropType<() => void>;
-        default: undefined;
-    };
-    onEntered: {
-        type: PropType<() => void>;
-        default: undefined;
-    };
-    onExit: {
-        type: PropType<() => void>;
-        default: undefined;
-    };
-    onExited: {
-        type: PropType<() => void>;
-        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<{}>, {
-    classNames: Function | Record<string, any>;
-    styles: Function | Record<string, any>;
-    visible: boolean;
-    vars: Function | Record<string, any>;
-    unstyled: boolean;
-    onEnter: () => void;
-    onExit: () => void;
-    onEntered: () => void;
-    onExited: () => void;
-    loaderProps: Record<string, any>;
-    transitionProps: Record<string, any>;
-    overlayProps: Record<string, any>;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const LoadingOverlay: import("../..").MantineComponent<{
+    props: Omit<import("./LoadingOverlay.types").LoadingOverlayProps, "rootRef">;
+    ref: HTMLDivElement;
+    exposed: {
+        rootElement: Element | null;
+    };
+    element: "div";
+    stylesNames: import("./LoadingOverlay.types").LoadingOverlayStylesNames;
+    vars: import("./LoadingOverlay.types").LoadingOverlayCssVariables;
+}>;
+export type { LoadingOverlayCssVariables, LoadingOverlayFactory, LoadingOverlayOwnProps, LoadingOverlayProps, LoadingOverlayStylesNames, } from './LoadingOverlay.types';

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

@@ -0,0 +1,49 @@
+import type { VueRefTarget } from '@mantine-vue/hooks';
+import type { BoxProps, StylesApiProps, Factory } from '../../core';
+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>;
+    /** Props passed down to `Loader` component */
+    loaderProps?: Record<string, any>;
+    /**
+     * Props passed down to `Overlay` component. Use to customizing blur, opacity, color and other properties.
+     *
+     * @default { backgroundOpacity: 0.75 }
+     */
+    overlayProps?: Record<string, any>;
+    /**
+     * Controls overlay visibility. Typically used with state (useState, useDisclosure).
+     *
+     * @default false
+     */
+    visible?: boolean;
+    /**
+     * Controls `z-index` of both the overlay and loader. The loader receives `z-index + 1`.
+     *
+     * @default getDefaultZIndex('overlay')
+     */
+    zIndex?: string | number;
+}
+export interface LoadingOverlayProps extends Omit<BoxProps, keyof LoadingOverlayOwnProps>, LoadingOverlayOwnProps {
+}
+export type LoadingOverlayFactory = Factory<{
+    props: Omit<LoadingOverlayProps, 'rootRef'>;
+    ref: HTMLDivElement;
+    exposed: {
+        rootElement: Element | null;
+    };
+    element: 'div';
+    stylesNames: LoadingOverlayStylesNames;
+    vars: LoadingOverlayCssVariables;
+}>;

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

@@ -0,0 +1,18 @@
+import type { LoadingOverlayOwnProps } 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, {
+    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<{
+    onEnter?: (() => any) | undefined;
+    onEntered?: (() => any) | undefined;
+    onExited?: (() => any) | undefined;
+    onExit?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -1,53 +1,9 @@
-import { type PropType } from 'vue';
-import { type MantineColor } from '../../core';
-export declare const Mark: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    color: {
-        type: PropType<MantineColor>;
-        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<{
-    color: {
-        type: PropType<MantineColor>;
-        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<{}>, {
-    color: MantineColor;
-    classNames: Function | Record<string, any>;
-    styles: Function | Record<string, any>;
-    vars: Function | Record<string, any>;
-    unstyled: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const Mark: import("../..").MantineComponent<{
+    props: Omit<import("./Mark.types").MarkProps, "rootRef">;
+    ref: HTMLElement;
+    slots: import("./Mark.types").MarkSlots;
+    element: "mark";
+    stylesNames: import("./Mark.types").MarkStylesNames;
+    vars: import("./Mark.types").MarkCssVariables;
+}>;
+export type { MarkCssVariables, MarkOwnProps, MarkProps, MarkSlots, MarkStylesNames, MarkFactory, } from './Mark.types';