@mantine-vue/core 2.0.1 → 2.2.0

package/lib/components/Input/Input.d.ts

@@ -768,9 +768,9 @@ export declare const Input: import("../..").WithBoxProps<{
         };
     }>> & Readonly<{}>, {
         size: string | number;
+        label: MantineNode;
         variant: string;
         error: MantineNode;
-        label: MantineNode;
         classNames: Function | Record<string, any>;
         styles: Function | Record<string, any>;
         required: boolean;

package/lib/components/Input/InputWrapper/InputWrapper.d.ts

@@ -166,9 +166,9 @@ export declare const InputWrapper: import("vue").DefineComponent<import("vue").E
     };
 }>> & Readonly<{}>, {
     size: string | number;
+    label: MantineNode;
     variant: string;
     error: MantineNode;
-    label: MantineNode;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;
     required: boolean;

package/lib/components/InputBase/InputBase.d.ts

@@ -389,11 +389,11 @@ export declare const InputBase: import("../..").WithBoxProps<import("vue").Defin
     };
 }>> & Readonly<{}>, {
     size: string | number;
+    label: MantineNode;
     radius: string | number;
     pointer: boolean;
     variant: "default" | "filled" | "unstyled";
     error: MantineNode;
-    label: MantineNode;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;
     required: boolean;
@@ -420,7 +420,7 @@ export declare const InputBase: import("../..").WithBoxProps<import("vue").Defin
     descriptionProps: Record<string, any>;
     errorProps: Record<string, any>;
     inputContainer: (children: any) => any;
-    inputWrapperOrder: ("error" | "input" | "label" | "description")[];
+    inputWrapperOrder: ("input" | "label" | "error" | "description")[];
     __stylesApiProps: Record<string, any>;
     leftSectionWidth: string | number;
     leftSectionProps: Record<string, any>;

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

@@ -63,10 +63,10 @@ export declare const List: import("../..").WithBoxProps<{
         [key: string]: any;
     }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
         size: string;
+        center: boolean;
         type: "ordered" | "unordered";
         classNames: Function | Record<string, any>;
         styles: Function | Record<string, any>;
-        center: boolean;
         start: number;
         mod: any;
         icon: MantineNode;
@@ -140,10 +140,10 @@ export declare const List: import("../..").WithBoxProps<{
         [key: string]: any;
     }>, {}, {}, {}, {
         size: string;
+        center: boolean;
         type: "ordered" | "unordered";
         classNames: Function | Record<string, any>;
         styles: Function | Record<string, any>;
-        center: boolean;
         start: number;
         mod: any;
         icon: MantineNode;
@@ -214,10 +214,10 @@ export declare const List: import("../..").WithBoxProps<{
     [key: string]: any;
 }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
     size: string;
+    center: boolean;
     type: "ordered" | "unordered";
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;
-    center: boolean;
     start: number;
     mod: any;
     icon: MantineNode;

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

@@ -118,13 +118,13 @@ export declare const Marquee: import("../..").WithBoxProps<import("vue").DefineC
     };
 }>> & Readonly<{}>, {
     repeat: number;
+    orientation: "vertical" | "horizontal";
     reverse: boolean;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;
     duration: number;
     mod: any;
     gap: string | number;
-    orientation: "horizontal" | "vertical";
     vars: Function | Record<string, any>;
     unstyled: boolean;
     fadeEdgeColor: string;

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

@@ -545,8 +545,8 @@ export declare const Menu: {
     }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
         [key: string]: any;
     }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
-        opened: boolean;
         loop: boolean;
+        opened: boolean;
         unstyled: boolean;
         defaultOpened: boolean;
         checkIcon: any;
@@ -616,8 +616,8 @@ export declare const Menu: {
     }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
         [key: string]: any;
     }>, {}, {}, {}, {
-        opened: boolean;
         loop: boolean;
+        opened: boolean;
         unstyled: boolean;
         defaultOpened: boolean;
         checkIcon: any;
@@ -684,8 +684,8 @@ export declare const Menu: {
 }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
 }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-    opened: boolean;
     loop: boolean;
+    opened: boolean;
     unstyled: boolean;
     defaultOpened: boolean;
     checkIcon: any;

package/lib/components/Menubar/Menubar.context.d.ts

@@ -0,0 +1,51 @@
+import type { Ref } from 'vue';
+export interface MenubarContextValue {
+    getStyles: (selector: string, options?: Record<string, any>) => any;
+    /** Unique id of the menubar instance, used to scope dropdown lookups across multiple menubars */
+    id: string;
+    /** Revision counter bumped whenever the set of targets changes, used by menus to recompute their DOM index */
+    revision: Ref<number>;
+    /** Index of the currently opened menu, `null` when all menus are closed */
+    readonly openIndex: number | null;
+    /** Opens the menu at the given index, `null` closes all menus */
+    setOpenIndex: (index: number | null) => void;
+    /** Opens the menu at the given index and records whether it was opened by click or hover */
+    openMenu: (index: number, source: 'click' | 'hover') => void;
+    /** Closes all menus */
+    closeMenu: () => void;
+    /** Schedules a delayed close, used by hover trigger when the pointer leaves the bar */
+    scheduleClose: () => void;
+    /** Cancels a pending delayed close */
+    cancelClose: () => void;
+    /** Returns how the currently opened menu was opened */
+    getOpenSource: () => 'click' | 'hover' | null;
+    /** Returns the previously opened menu index, used to skip transitions when switching menus */
+    getPreviousOpenIndex: () => number | null;
+    /** Index of the menu that currently holds the single menubar tab stop */
+    readonly activeIndex: number;
+    /** Sets the roving tabindex to the given menu index */
+    setActiveIndex: (index: number) => void;
+    readonly trigger: 'click' | 'hover';
+    readonly loop: boolean;
+    readonly position: string;
+    readonly unstyled: boolean | undefined;
+    /** Returns the DOM-order index of a `Menubar.Menu` by its id */
+    getMenuIndex: (id: string) => number;
+    /** Returns all top-level target buttons in DOM order */
+    getTargets: () => HTMLButtonElement[];
+    /** Returns the indexes of the enabled top-level targets in DOM order */
+    getEnabledIndexes: () => number[];
+    /** Returns the index of the next/previous enabled target relative to `current` */
+    getAdjacentIndex: (current: number, direction: 1 | -1) => number;
+    /** Focuses the top-level target at the given index */
+    focusTarget: (index: number) => void;
+    /** Focuses the first or last item of the (opened) menu at the given index */
+    focusMenuItem: (index: number, position: 'first' | 'last') => void;
+}
+export declare const provideMenubarContext: (value: MenubarContextValue) => void, useMenubarContext: () => MenubarContextValue;
+export interface MenubarMenuContextValue {
+    readonly id: string;
+    readonly index: number;
+    readonly opened: boolean;
+}
+export declare const provideMenubarMenuContext: (value: MenubarMenuContextValue) => void, useMenubarMenuContext: () => MenubarMenuContextValue;

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

@@ -0,0 +1,282 @@
+import { type PropType, type SlotsType, type VNode, type VNodeChild } from 'vue';
+export type MenubarStylesNames = 'root' | 'target';
+export interface MenubarProps {
+    /** Index of the controlled opened menu, `null` closes all menus */
+    openIndex?: number | null;
+    /** Index of the opened menu for uncontrolled component @default `null` */
+    defaultOpenIndex?: number | null;
+    /** Called when the opened menu changes with its index or `null` when all menus are closed */
+    onOpenChange?: (index: number | null) => void;
+    /** Event that opens a menu when none of the menus is opened. `'click'` opens a menu on target
+     * click and then switches menus on hover (desktop application pattern), `'hover'` opens a menu
+     * when the target is hovered @default `'click'` */
+    trigger?: 'click' | 'hover';
+    /** If set, arrow key navigation wraps from last to first menu and vice versa @default `true` */
+    loop?: boolean;
+    /** Dropdown position relative to the target element @default `'bottom-start'` */
+    position?: string;
+    classNames?: any;
+    styles?: any;
+    vars?: any;
+    unstyled?: boolean;
+    mod?: any;
+    [key: string]: any;
+}
+export interface MenubarSlots {
+    default?: () => VNodeChild;
+}
+export declare const Menubar: import("../..").WithBoxProps<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        openIndex: {
+            type: PropType<number | null>;
+            default: undefined;
+        };
+        defaultOpenIndex: {
+            type: PropType<number | null>;
+            default: undefined;
+        };
+        onOpenChange: {
+            type: PropType<(index: number | null) => void>;
+            default: undefined;
+        };
+        trigger: {
+            type: PropType<"click" | "hover">;
+            default: undefined;
+        };
+        loop: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        position: {
+            type: StringConstructor;
+            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;
+        };
+        unstyled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        loop: boolean;
+        classNames: Function | Record<string, any>;
+        styles: Function | Record<string, any>;
+        mod: any;
+        position: string;
+        vars: Function | Record<string, any>;
+        unstyled: boolean;
+        trigger: "click" | "hover";
+        openIndex: number | null;
+        defaultOpenIndex: number | null;
+        onOpenChange: (index: number | null) => void;
+    }, true, {}, SlotsType<MenubarSlots>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        openIndex: {
+            type: PropType<number | null>;
+            default: undefined;
+        };
+        defaultOpenIndex: {
+            type: PropType<number | null>;
+            default: undefined;
+        };
+        onOpenChange: {
+            type: PropType<(index: number | null) => void>;
+            default: undefined;
+        };
+        trigger: {
+            type: PropType<"click" | "hover">;
+            default: undefined;
+        };
+        loop: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        position: {
+            type: StringConstructor;
+            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;
+        };
+        unstyled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, {
+        loop: boolean;
+        classNames: Function | Record<string, any>;
+        styles: Function | Record<string, any>;
+        mod: any;
+        position: string;
+        vars: Function | Record<string, any>;
+        unstyled: boolean;
+        trigger: "click" | "hover";
+        openIndex: number | null;
+        defaultOpenIndex: number | null;
+        onOpenChange: (index: number | null) => void;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    openIndex: {
+        type: PropType<number | null>;
+        default: undefined;
+    };
+    defaultOpenIndex: {
+        type: PropType<number | null>;
+        default: undefined;
+    };
+    onOpenChange: {
+        type: PropType<(index: number | null) => void>;
+        default: undefined;
+    };
+    trigger: {
+        type: PropType<"click" | "hover">;
+        default: undefined;
+    };
+    loop: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    position: {
+        type: StringConstructor;
+        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;
+    };
+    unstyled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    loop: boolean;
+    classNames: Function | Record<string, any>;
+    styles: Function | Record<string, any>;
+    mod: any;
+    position: string;
+    vars: Function | Record<string, any>;
+    unstyled: boolean;
+    trigger: "click" | "hover";
+    openIndex: number | null;
+    defaultOpenIndex: number | null;
+    onOpenChange: (index: number | null) => void;
+}, {}, string, SlotsType<MenubarSlots>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    classes: Record<string, string>;
+    Menu: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        transitionProps: {
+            type: PropType<{
+                duration?: number;
+                exitDuration?: number;
+                [key: string]: any;
+            }>;
+            default: undefined;
+        };
+        __index: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>, () => 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<{
+                duration?: number;
+                exitDuration?: number;
+                [key: string]: any;
+            }>;
+            default: undefined;
+        };
+        __index: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>> & Readonly<{}>, {
+        transitionProps: {
+            [key: string]: any;
+            duration?: number;
+            exitDuration?: number;
+        };
+        __index: number;
+    }, SlotsType<import(".").MenubarMenuSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    Target: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        refProp: {
+            type: StringConstructor;
+            default: string;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        refProp: {
+            type: StringConstructor;
+            default: string;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        disabled: boolean;
+        refProp: string;
+    }, SlotsType<import(".").MenubarTargetSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    Dropdown: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<import(".").MenubarDropdownSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}>;

package/lib/components/Menubar/MenubarDropdown/MenubarDropdown.d.ts

@@ -0,0 +1,10 @@
+import { type SlotsType, type VNodeChild } from 'vue';
+export interface MenubarDropdownProps {
+    [key: string]: any;
+}
+export interface MenubarDropdownSlots {
+    default?: () => VNodeChild;
+}
+export declare const MenubarDropdown: 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<{}>, {}, SlotsType<MenubarDropdownSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,49 @@
+import { type PropType, type SlotsType, type VNodeChild } from 'vue';
+export interface MenubarMenuProps {
+    /** Props passed down to the underlying transition */
+    transitionProps?: {
+        duration?: number;
+        exitDuration?: number;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface MenubarMenuSlots {
+    default?: () => VNodeChild;
+}
+export declare const MenubarMenu: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    transitionProps: {
+        type: PropType<{
+            duration?: number;
+            exitDuration?: number;
+            [key: string]: any;
+        }>;
+        default: undefined;
+    };
+    __index: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => 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<{
+            duration?: number;
+            exitDuration?: number;
+            [key: string]: any;
+        }>;
+        default: undefined;
+    };
+    __index: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    transitionProps: {
+        [key: string]: any;
+        duration?: number;
+        exitDuration?: number;
+    };
+    __index: number;
+}, SlotsType<MenubarMenuSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/components/Menubar/MenubarTarget/MenubarTarget.d.ts

@@ -0,0 +1,35 @@
+import { type SlotsType, type VNodeChild } from 'vue';
+export interface MenubarTargetProps {
+    /** Key of the prop used to get element ref, useful for forwarding refs to custom components @default 'ref' */
+    refProp?: string;
+    /** Disables the target button */
+    disabled?: boolean;
+    [key: string]: any;
+}
+export interface MenubarTargetSlots {
+    default?: () => VNodeChild;
+}
+export declare const MenubarTarget: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    refProp: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        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<{
+    refProp: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    disabled: boolean;
+    refProp: string;
+}, SlotsType<MenubarTargetSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,10 @@
+export { Menubar } from './Menubar';
+export type { MenubarProps, MenubarSlots, MenubarStylesNames } from './Menubar';
+export { MenubarMenu } from './MenubarMenu/MenubarMenu';
+export type { MenubarMenuProps, MenubarMenuSlots } from './MenubarMenu/MenubarMenu';
+export { MenubarTarget } from './MenubarTarget/MenubarTarget';
+export type { MenubarTargetProps, MenubarTargetSlots } from './MenubarTarget/MenubarTarget';
+export { MenubarDropdown } from './MenubarDropdown/MenubarDropdown';
+export type { MenubarDropdownProps, MenubarDropdownSlots } from './MenubarDropdown/MenubarDropdown';
+export { useMenubarContext, useMenubarMenuContext } from './Menubar.context';
+export type { MenubarContextValue, MenubarMenuContextValue } from './Menubar.context';

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

@@ -189,13 +189,13 @@ export declare const MultiSelect: import("vue").DefineComponent<import("vue").Ex
     withScrollArea: boolean;
     checkIconPosition: "left" | "right";
     nothingFoundMessage: any;
-    searchable: boolean;
     dropdownOpened: boolean;
     defaultDropdownOpened: boolean;
     selectFirstOptionOnDropdownOpen: boolean;
+    searchable: boolean;
+    hiddenInputValuesDivider: string;
     openOnFocus: boolean;
     maxValues: number;
     hidePickedOptions: boolean;
     clearSearchOnChange: boolean;
-    hiddenInputValuesDivider: string;
 }, SlotsType<MultiSelectSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -206,14 +206,14 @@ export declare const NativeSelect: import("vue").DefineComponent<import("vue").E
     };
 }>> & Readonly<{}>, {
     size: string | number;
+    data: NativeSelectData<any>;
+    form: string;
+    label: MantineNode;
     radius: string | number;
     name: string;
     variant: "default" | "filled" | "unstyled";
     error: MantineNode;
     onChange: (event: Event) => void;
-    data: NativeSelectData<any>;
-    form: string;
-    label: MantineNode;
     value: string;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;

package/lib/components/NavLink/NavLink.d.ts

@@ -188,11 +188,11 @@ export declare const NavLink: import("../..").WithBoxProps<import("vue").DefineC
         default: boolean;
     };
 }>> & Readonly<{}>, {
+    label: any;
     color: string;
     autoContrast: boolean;
     variant: NavLinkVariant;
     onChange: (opened: boolean) => void;
-    label: any;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;
     description: MantineNode;

package/lib/components/Notification/Notification.d.ts

@@ -131,10 +131,10 @@ export declare const Notification: import("../..").WithBoxProps<import("vue").De
         default: boolean;
     };
 }>> & Readonly<{}>, {
+    title: MantineNode;
     radius: string | number;
     color: string;
     onClose: () => void;
-    title: MantineNode;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;
     mod: any;

package/lib/components/NumberInput/NumberInput.d.ts

@@ -393,9 +393,9 @@ export declare const NumberInput: import("vue").DefineComponent<import("vue").Ex
 }>> & Readonly<{}>, {
     size: string | number;
     max: number | bigint | undefined;
+    label: MantineNode;
     error: MantineNode;
     onChange: (value: NumberInputValue) => void;
-    label: MantineNode;
     value: NumberInputValue | undefined;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;

package/lib/components/Overlay/Overlay.d.ts

@@ -91,11 +91,11 @@ export declare const Overlay: import("../..").WithBoxProps<import("vue").DefineC
     };
 }>> & Readonly<{}>, {
     fixed: boolean;
+    center: boolean;
     color: string;
     gradient: string;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;
-    center: boolean;
     component: string;
     vars: Function | Record<string, any>;
     unstyled: boolean;