@mantine-vue/core 2.0.1 → 2.1.0

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

@@ -0,0 +1,401 @@
+import { type PropType, type SlotsType, type VNode, type VNodeChild } from 'vue';
+import { type MantineColor, type MantineNode, type MantineSize } 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 EmptyStateProps {
+    /** Controls indicator size, gap between elements and font sizes of title and description @default 'md' */
+    size?: MantineSize | (string & {});
+    /** Content alignment. `center` stacks the content in a centered column, `left`/`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` display a colored circular background behind the icon. If not set, the icon is displayed with dimmed color */
+    variant?: EmptyStateVariant | (string & {});
+    /** Key of `theme.colors` or any valid CSS color, used by `filled` and `light` variants @default theme.primaryColor */
+    color?: MantineColor;
+    /** Title content, rendered inside `EmptyState.Title`. Can also be provided via the `#title` slot */
+    title?: MantineNode;
+    /** Description content, rendered inside `EmptyState.Description`. Can also be provided via the `#description` slot */
+    description?: MantineNode;
+    /** Icon or illustration, rendered inside `EmptyState.Indicator`. Can also be provided via the `#icon` slot */
+    icon?: MantineNode;
+    /** If set, a neutral circular background is displayed behind the indicator. Setting `variant` always displays a colored background regardless of this prop @default false */
+    withIndicatorBackground?: boolean;
+    classNames?: any;
+    styles?: any;
+    vars?: any;
+    unstyled?: boolean;
+    mod?: any;
+    [key: string]: any;
+}
+export interface EmptyStateSlots {
+    default?: () => VNodeChild;
+    icon?: () => VNodeChild;
+    title?: () => VNodeChild;
+    description?: () => VNodeChild;
+}
+export declare const EmptyState: import("../..").WithBoxProps<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        size: {
+            type: PropType<MantineSize | (string & {})>;
+            default: undefined;
+        };
+        align: {
+            type: PropType<"left" | "center" | "right">;
+            default: undefined;
+        };
+        variant: {
+            type: PropType<EmptyStateVariant | (string & {})>;
+            default: undefined;
+        };
+        color: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        title: {
+            type: PropType<MantineNode>;
+            default: undefined;
+        };
+        description: {
+            type: PropType<MantineNode>;
+            default: undefined;
+        };
+        icon: {
+            type: PropType<MantineNode>;
+            default: undefined;
+        };
+        withIndicatorBackground: {
+            type: BooleanConstructor;
+            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, {
+        size: MantineSize | (string & {});
+        title: MantineNode;
+        color: string;
+        variant: (string & {}) | EmptyStateVariant;
+        classNames: Function | Record<string, any>;
+        styles: Function | Record<string, any>;
+        description: MantineNode;
+        mod: any;
+        icon: MantineNode;
+        vars: Function | Record<string, any>;
+        unstyled: boolean;
+        align: "center" | "left" | "right";
+        withIndicatorBackground: boolean;
+    }, true, {}, SlotsType<EmptyStateSlots>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        size: {
+            type: PropType<MantineSize | (string & {})>;
+            default: undefined;
+        };
+        align: {
+            type: PropType<"left" | "center" | "right">;
+            default: undefined;
+        };
+        variant: {
+            type: PropType<EmptyStateVariant | (string & {})>;
+            default: undefined;
+        };
+        color: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        title: {
+            type: PropType<MantineNode>;
+            default: undefined;
+        };
+        description: {
+            type: PropType<MantineNode>;
+            default: undefined;
+        };
+        icon: {
+            type: PropType<MantineNode>;
+            default: undefined;
+        };
+        withIndicatorBackground: {
+            type: BooleanConstructor;
+            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;
+    }>, {}, {}, {}, {
+        size: MantineSize | (string & {});
+        title: MantineNode;
+        color: string;
+        variant: (string & {}) | EmptyStateVariant;
+        classNames: Function | Record<string, any>;
+        styles: Function | Record<string, any>;
+        description: MantineNode;
+        mod: any;
+        icon: MantineNode;
+        vars: Function | Record<string, any>;
+        unstyled: boolean;
+        align: "center" | "left" | "right";
+        withIndicatorBackground: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    size: {
+        type: PropType<MantineSize | (string & {})>;
+        default: undefined;
+    };
+    align: {
+        type: PropType<"left" | "center" | "right">;
+        default: undefined;
+    };
+    variant: {
+        type: PropType<EmptyStateVariant | (string & {})>;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    title: {
+        type: PropType<MantineNode>;
+        default: undefined;
+    };
+    description: {
+        type: PropType<MantineNode>;
+        default: undefined;
+    };
+    icon: {
+        type: PropType<MantineNode>;
+        default: undefined;
+    };
+    withIndicatorBackground: {
+        type: BooleanConstructor;
+        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, {
+    size: MantineSize | (string & {});
+    title: MantineNode;
+    color: string;
+    variant: (string & {}) | EmptyStateVariant;
+    classNames: Function | Record<string, any>;
+    styles: Function | Record<string, any>;
+    description: MantineNode;
+    mod: any;
+    icon: MantineNode;
+    vars: Function | Record<string, any>;
+    unstyled: boolean;
+    align: "center" | "left" | "right";
+    withIndicatorBackground: boolean;
+}, {}, string, SlotsType<EmptyStateSlots>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    classes: Record<string, string>;
+    varsResolver: (theme: import("../..").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
+    Indicator: 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;
+        };
+    }>, () => 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<import(".").EmptyStateIndicatorSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+    Title: 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;
+        };
+    }>, () => 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<import(".").EmptyStateTitleSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+    Description: 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;
+        };
+    }>, () => 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<import(".").EmptyStateDescriptionSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+    Actions: 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;
+        };
+    }>, () => 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<import(".").EmptyStateActionsSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+}>;

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

@@ -0,0 +1,44 @@
+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>>;

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

@@ -0,0 +1,44 @@
+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>>;

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

@@ -0,0 +1,44 @@
+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>>;

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

@@ -0,0 +1,55 @@
+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>>;

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

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

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

@@ -67,9 +67,9 @@ export declare const Fieldset: import("../..").WithBoxProps<import("vue").Define
         default: boolean;
     };
 }>> & Readonly<{}>, {
+    legend: MantineNode;
     radius: string | number;
     variant: FieldsetVariant;
-    legend: MantineNode;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;
     vars: Function | Record<string, any>;

package/lib/components/FileButton/FileButton.d.ts

@@ -86,8 +86,8 @@ export declare const FileButton: import("vue").DefineComponent<import("vue").Ext
         default: undefined;
     };
 }>> & Readonly<{}>, {
-    name: string;
     form: string;
+    name: string;
     disabled: boolean;
     multiple: boolean;
     accept: string;

package/lib/components/FileInput/FileInput.d.ts

@@ -250,11 +250,11 @@ export declare const FileInput: import("vue").DefineComponent<import("vue").Extr
     };
 }>> & Readonly<{}>, {
     size: string | number;
+    form: string;
+    label: MantineNode;
     name: string;
     error: MantineNode;
     onChange: (payload: File | File[] | null) => void;
-    form: string;
-    label: MantineNode;
     value: File | File[] | null | undefined;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;

package/lib/components/Highlight/Highlight.d.ts

@@ -104,8 +104,8 @@ export declare const Highlight: import("vue").DefineComponent<import("vue").Extr
         default: undefined;
     };
 }>> & Readonly<{}>, {
-    color: string;
     span: boolean;
+    color: string;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;
     component: string;

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

@@ -1,5 +1,6 @@
 export interface HoverCardContextValue {
     openDropdown: () => void;
     closeDropdown: () => void;
+    assignTarget: (node: HTMLElement | null) => void;
 }
 export declare const provideHoverCardContext: (value: HoverCardContextValue) => void, useHoverCardContext: () => HoverCardContextValue;

package/lib/components/HoverCard/use-hover-card.d.ts

@@ -8,4 +8,5 @@ export declare function useHoverCard(settings: {
     opened: import("vue").Ref<boolean, boolean>;
     openDropdown: () => void;
     closeDropdown: () => void;
+    assignTarget: (node: HTMLElement | null) => void;
 };

package/lib/components/Indicator/Indicator.d.ts

@@ -150,9 +150,9 @@ export declare const Indicator: import("../..").WithBoxProps<import("vue").Defin
         default: boolean;
     };
 }>> & Readonly<{}>, {
+    label: MantineNode;
     color: string;
     autoContrast: boolean;
-    label: MantineNode;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;
     disabled: boolean;