@mantine-vue/core 1.1.1

package/lib/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,372 @@
+import { type PropType, type VNode } from 'vue';
+import { type ArrowPosition, type FloatingAxesOffsets, type FloatingPosition, type FloatingStrategy } from '../../utils/Floating';
+import type { TooltipBaseProps, TooltipMiddlewares, TooltipStylesNames } from './Tooltip.types';
+export interface TooltipProps extends TooltipBaseProps {
+    onPositionChange?: (position: FloatingPosition) => void;
+    openDelay?: number;
+    closeDelay?: number;
+    opened?: boolean;
+    defaultOpened?: boolean;
+    offset?: number | FloatingAxesOffsets;
+    withArrow?: boolean;
+    arrowSize?: number;
+    arrowOffset?: number;
+    arrowRadius?: number;
+    arrowPosition?: ArrowPosition;
+    transitionProps?: Record<string, any>;
+    events?: {
+        hover: boolean;
+        focus: boolean;
+        touch: boolean;
+    };
+    inline?: boolean;
+    keepMounted?: boolean;
+    floatingStrategy?: FloatingStrategy;
+    autoContrast?: boolean;
+    target?: any;
+    middlewares?: TooltipMiddlewares;
+}
+export declare const Tooltip: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        label: {
+            required: true;
+        };
+        position: {
+            type: PropType<FloatingPosition>;
+            default: undefined;
+        };
+        refProp: StringConstructor;
+        withinPortal: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        radius: (NumberConstructor | StringConstructor)[];
+        color: StringConstructor;
+        multiline: BooleanConstructor;
+        zIndex: (NumberConstructor | StringConstructor)[];
+        disabled: BooleanConstructor;
+        portalProps: ObjectConstructor;
+        middlewares: ObjectConstructor;
+        onPositionChange: PropType<(position: FloatingPosition) => void>;
+        openDelay: NumberConstructor;
+        closeDelay: NumberConstructor;
+        opened: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        defaultOpened: BooleanConstructor;
+        offset: {
+            type: PropType<number | FloatingAxesOffsets>;
+            default: undefined;
+        };
+        withArrow: BooleanConstructor;
+        arrowSize: NumberConstructor;
+        arrowOffset: NumberConstructor;
+        arrowRadius: NumberConstructor;
+        arrowPosition: {
+            type: PropType<ArrowPosition>;
+            default: undefined;
+        };
+        transitionProps: ObjectConstructor;
+        events: PropType<{
+            hover: boolean;
+            focus: boolean;
+            touch: boolean;
+        }>;
+        inline: BooleanConstructor;
+        keepMounted: BooleanConstructor;
+        floatingStrategy: {
+            type: PropType<FloatingStrategy>;
+            default: undefined;
+        };
+        autoContrast: BooleanConstructor;
+        target: {
+            type: PropType<any>;
+            default: undefined;
+        };
+        classNames: (ObjectConstructor | FunctionConstructor)[];
+        styles: (ObjectConstructor | FunctionConstructor)[];
+        vars: (ObjectConstructor | FunctionConstructor)[];
+        unstyled: BooleanConstructor;
+    }>> & Readonly<{}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        autoContrast: boolean;
+        multiline: boolean;
+        opened: boolean;
+        disabled: boolean;
+        offset: number | FloatingAxesOffsets;
+        target: any;
+        position: FloatingPosition;
+        keepMounted: boolean;
+        inline: boolean;
+        unstyled: boolean;
+        withinPortal: boolean;
+        defaultOpened: boolean;
+        arrowPosition: ArrowPosition;
+        withArrow: boolean;
+        floatingStrategy: FloatingStrategy;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        label: {
+            required: true;
+        };
+        position: {
+            type: PropType<FloatingPosition>;
+            default: undefined;
+        };
+        refProp: StringConstructor;
+        withinPortal: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        radius: (NumberConstructor | StringConstructor)[];
+        color: StringConstructor;
+        multiline: BooleanConstructor;
+        zIndex: (NumberConstructor | StringConstructor)[];
+        disabled: BooleanConstructor;
+        portalProps: ObjectConstructor;
+        middlewares: ObjectConstructor;
+        onPositionChange: PropType<(position: FloatingPosition) => void>;
+        openDelay: NumberConstructor;
+        closeDelay: NumberConstructor;
+        opened: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        defaultOpened: BooleanConstructor;
+        offset: {
+            type: PropType<number | FloatingAxesOffsets>;
+            default: undefined;
+        };
+        withArrow: BooleanConstructor;
+        arrowSize: NumberConstructor;
+        arrowOffset: NumberConstructor;
+        arrowRadius: NumberConstructor;
+        arrowPosition: {
+            type: PropType<ArrowPosition>;
+            default: undefined;
+        };
+        transitionProps: ObjectConstructor;
+        events: PropType<{
+            hover: boolean;
+            focus: boolean;
+            touch: boolean;
+        }>;
+        inline: BooleanConstructor;
+        keepMounted: BooleanConstructor;
+        floatingStrategy: {
+            type: PropType<FloatingStrategy>;
+            default: undefined;
+        };
+        autoContrast: BooleanConstructor;
+        target: {
+            type: PropType<any>;
+            default: undefined;
+        };
+        classNames: (ObjectConstructor | FunctionConstructor)[];
+        styles: (ObjectConstructor | FunctionConstructor)[];
+        vars: (ObjectConstructor | FunctionConstructor)[];
+        unstyled: BooleanConstructor;
+    }>> & Readonly<{}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[], {}, {}, {}, {
+        autoContrast: boolean;
+        multiline: boolean;
+        opened: boolean;
+        disabled: boolean;
+        offset: number | FloatingAxesOffsets;
+        target: any;
+        position: FloatingPosition;
+        keepMounted: boolean;
+        inline: boolean;
+        unstyled: boolean;
+        withinPortal: boolean;
+        defaultOpened: boolean;
+        arrowPosition: ArrowPosition;
+        withArrow: boolean;
+        floatingStrategy: FloatingStrategy;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    label: {
+        required: true;
+    };
+    position: {
+        type: PropType<FloatingPosition>;
+        default: undefined;
+    };
+    refProp: StringConstructor;
+    withinPortal: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    radius: (NumberConstructor | StringConstructor)[];
+    color: StringConstructor;
+    multiline: BooleanConstructor;
+    zIndex: (NumberConstructor | StringConstructor)[];
+    disabled: BooleanConstructor;
+    portalProps: ObjectConstructor;
+    middlewares: ObjectConstructor;
+    onPositionChange: PropType<(position: FloatingPosition) => void>;
+    openDelay: NumberConstructor;
+    closeDelay: NumberConstructor;
+    opened: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultOpened: BooleanConstructor;
+    offset: {
+        type: PropType<number | FloatingAxesOffsets>;
+        default: undefined;
+    };
+    withArrow: BooleanConstructor;
+    arrowSize: NumberConstructor;
+    arrowOffset: NumberConstructor;
+    arrowRadius: NumberConstructor;
+    arrowPosition: {
+        type: PropType<ArrowPosition>;
+        default: undefined;
+    };
+    transitionProps: ObjectConstructor;
+    events: PropType<{
+        hover: boolean;
+        focus: boolean;
+        touch: boolean;
+    }>;
+    inline: BooleanConstructor;
+    keepMounted: BooleanConstructor;
+    floatingStrategy: {
+        type: PropType<FloatingStrategy>;
+        default: undefined;
+    };
+    autoContrast: BooleanConstructor;
+    target: {
+        type: PropType<any>;
+        default: undefined;
+    };
+    classNames: (ObjectConstructor | FunctionConstructor)[];
+    styles: (ObjectConstructor | FunctionConstructor)[];
+    vars: (ObjectConstructor | FunctionConstructor)[];
+    unstyled: BooleanConstructor;
+}>> & Readonly<{}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    autoContrast: boolean;
+    multiline: boolean;
+    opened: boolean;
+    disabled: boolean;
+    offset: number | FloatingAxesOffsets;
+    target: any;
+    position: FloatingPosition;
+    keepMounted: boolean;
+    inline: boolean;
+    unstyled: boolean;
+    withinPortal: boolean;
+    defaultOpened: boolean;
+    arrowPosition: ArrowPosition;
+    withArrow: boolean;
+    floatingStrategy: FloatingStrategy;
+}, {}, string, {}, 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>>;
+    Floating: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        label: {
+            required: true;
+        };
+        refProp: StringConstructor;
+        withinPortal: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        offset: NumberConstructor;
+        position: {
+            type: PropType<FloatingPosition>;
+            default: undefined;
+        };
+        zIndex: (NumberConstructor | StringConstructor)[];
+        disabled: BooleanConstructor;
+        defaultOpened: BooleanConstructor;
+        multiline: BooleanConstructor;
+        radius: (NumberConstructor | StringConstructor)[];
+        color: StringConstructor;
+        portalProps: ObjectConstructor;
+        classNames: (ObjectConstructor | FunctionConstructor)[];
+        styles: (ObjectConstructor | FunctionConstructor)[];
+        vars: (ObjectConstructor | FunctionConstructor)[];
+        unstyled: BooleanConstructor;
+    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        label: {
+            required: true;
+        };
+        refProp: StringConstructor;
+        withinPortal: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        offset: NumberConstructor;
+        position: {
+            type: PropType<FloatingPosition>;
+            default: undefined;
+        };
+        zIndex: (NumberConstructor | StringConstructor)[];
+        disabled: BooleanConstructor;
+        defaultOpened: BooleanConstructor;
+        multiline: BooleanConstructor;
+        radius: (NumberConstructor | StringConstructor)[];
+        color: StringConstructor;
+        portalProps: ObjectConstructor;
+        classNames: (ObjectConstructor | FunctionConstructor)[];
+        styles: (ObjectConstructor | FunctionConstructor)[];
+        vars: (ObjectConstructor | FunctionConstructor)[];
+        unstyled: BooleanConstructor;
+    }>> & Readonly<{}>, {
+        multiline: boolean;
+        disabled: boolean;
+        position: FloatingPosition;
+        unstyled: boolean;
+        withinPortal: boolean;
+        defaultOpened: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    Group: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        openDelay: {
+            type: NumberConstructor;
+            default: number;
+        };
+        closeDelay: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        openDelay: {
+            type: NumberConstructor;
+            default: number;
+        };
+        closeDelay: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>> & Readonly<{}>, {
+        openDelay: number;
+        closeDelay: number;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};
+export type { TooltipStylesNames };

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

@@ -0,0 +1,26 @@
+import type { FloatingPosition } from '../../utils/Floating';
+export type TooltipStylesNames = 'tooltip' | 'arrow';
+export type TooltipCssVariables = '--tooltip-radius' | '--tooltip-bg' | '--tooltip-color';
+export interface TooltipMiddlewares {
+    shift?: boolean | Record<string, any>;
+    flip?: boolean | Record<string, any>;
+    inline?: boolean | Record<string, any>;
+    size?: boolean | Record<string, any>;
+}
+export interface TooltipBaseProps {
+    label: any;
+    position?: FloatingPosition;
+    refProp?: string;
+    withinPortal?: boolean;
+    radius?: string | number;
+    color?: string;
+    multiline?: boolean;
+    zIndex?: string | number;
+    disabled?: boolean;
+    portalProps?: Record<string, any>;
+    middlewares?: TooltipMiddlewares;
+    classNames?: any;
+    styles?: any;
+    vars?: any;
+    unstyled?: boolean;
+}

package/lib/components/Tooltip/TooltipFloating/TooltipFloating.d.ts

@@ -0,0 +1,69 @@
+import { type PropType, type VNode } from 'vue';
+import type { FloatingPosition } from '../../../utils/Floating';
+export declare const TooltipFloating: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    label: {
+        required: true;
+    };
+    refProp: StringConstructor;
+    withinPortal: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    offset: NumberConstructor;
+    position: {
+        type: PropType<FloatingPosition>;
+        default: undefined;
+    };
+    zIndex: (NumberConstructor | StringConstructor)[];
+    disabled: BooleanConstructor;
+    defaultOpened: BooleanConstructor;
+    multiline: BooleanConstructor;
+    radius: (NumberConstructor | StringConstructor)[];
+    color: StringConstructor;
+    portalProps: ObjectConstructor;
+    classNames: (ObjectConstructor | FunctionConstructor)[];
+    styles: (ObjectConstructor | FunctionConstructor)[];
+    vars: (ObjectConstructor | FunctionConstructor)[];
+    unstyled: BooleanConstructor;
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    label: {
+        required: true;
+    };
+    refProp: StringConstructor;
+    withinPortal: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    offset: NumberConstructor;
+    position: {
+        type: PropType<FloatingPosition>;
+        default: undefined;
+    };
+    zIndex: (NumberConstructor | StringConstructor)[];
+    disabled: BooleanConstructor;
+    defaultOpened: BooleanConstructor;
+    multiline: BooleanConstructor;
+    radius: (NumberConstructor | StringConstructor)[];
+    color: StringConstructor;
+    portalProps: ObjectConstructor;
+    classNames: (ObjectConstructor | FunctionConstructor)[];
+    styles: (ObjectConstructor | FunctionConstructor)[];
+    vars: (ObjectConstructor | FunctionConstructor)[];
+    unstyled: BooleanConstructor;
+}>> & Readonly<{}>, {
+    multiline: boolean;
+    disabled: boolean;
+    position: FloatingPosition;
+    unstyled: boolean;
+    withinPortal: boolean;
+    defaultOpened: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export interface TooltipFloatingProps {
+    label: any;
+    offset?: number;
+    position?: FloatingPosition;
+    defaultOpened?: boolean;
+    [key: string]: any;
+}

package/lib/components/Tooltip/TooltipGroup/TooltipGroup.d.ts

@@ -0,0 +1,35 @@
+import { type InjectionKey } from 'vue';
+export interface TooltipGroupContextValue {
+    withinGroup: boolean;
+    openDelay: number;
+    closeDelay: number;
+}
+export declare const TooltipGroupKey: InjectionKey<TooltipGroupContextValue>;
+export declare const TooltipGroup: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    closeDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    closeDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    openDelay: number;
+    closeDelay: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export interface TooltipGroupProps {
+    openDelay?: number;
+    closeDelay?: number;
+}

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

@@ -0,0 +1,7 @@
+export { Tooltip } from './Tooltip';
+export { TooltipFloating } from './TooltipFloating/TooltipFloating';
+export { TooltipGroup } from './TooltipGroup/TooltipGroup';
+export type { TooltipProps } from './Tooltip';
+export type { TooltipFloatingProps } from './TooltipFloating/TooltipFloating';
+export type { TooltipGroupProps, TooltipGroupContextValue } from './TooltipGroup/TooltipGroup';
+export type { TooltipBaseProps, TooltipMiddlewares, TooltipStylesNames, TooltipCssVariables, } from './Tooltip.types';

package/lib/components/Tooltip/use-tooltip.d.ts

@@ -0,0 +1,33 @@
+import type { FloatingAxesOffsets, FloatingPosition, FloatingStrategy } from '../../utils/Floating';
+import type { TooltipMiddlewares } from './Tooltip.types';
+export interface UseTooltipOptions {
+    position: () => FloatingPosition;
+    opened: () => boolean | undefined;
+    defaultOpened: boolean;
+    openDelay?: () => number | undefined;
+    closeDelay?: () => number | undefined;
+    offset: () => number | FloatingAxesOffsets;
+    arrowOffset: () => number;
+    events: () => {
+        hover: boolean;
+        focus: boolean;
+        touch: boolean;
+    };
+    strategy: () => FloatingStrategy;
+    middlewares: () => TooltipMiddlewares | undefined;
+    onPositionChange?: (position: FloatingPosition) => void;
+}
+export declare function useTooltip(options: UseTooltipOptions): {
+    opened: import("vue").ComputedRef<boolean>;
+    reference: import("vue").Ref<any, any>;
+    floating: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+    arrowRef: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+    x: Readonly<import("vue").Ref<number, number>>;
+    y: Readonly<import("vue").Ref<number, number>>;
+    placement: Readonly<import("vue").Ref<import("@floating-ui/utils").Placement, import("@floating-ui/utils").Placement>>;
+    arrowX: import("vue").ComputedRef<number | undefined>;
+    arrowY: import("vue").ComputedRef<number | undefined>;
+    open: () => void;
+    close: () => void;
+    setOpened: (value: boolean, delay?: number) => void;
+};

package/lib/components/Transition/Transition.d.ts

@@ -0,0 +1,109 @@
+import { type CSSProperties, type PropType, type SlotsType, type VNodeChild } from 'vue';
+import type { MantineTransition } from './transitions';
+export type { MantineTransition } from './transitions';
+export interface TransitionSlots {
+    default?: (styles: CSSProperties) => VNodeChild;
+}
+export interface TransitionProps {
+    /** If set, the element is kept in the DOM when hidden */
+    keepMounted?: boolean;
+    /** Transition name or object */
+    transition?: MantineTransition;
+    /** Transition duration in ms @default 250 */
+    duration?: number;
+    /** Exit transition duration in ms @default duration */
+    exitDuration?: number;
+    /** Transition timing function @default theme.transitionTimingFunction */
+    timingFunction?: string;
+    /** Determines whether component should be mounted to the DOM */
+    mounted: boolean;
+    /** Delay in ms before enter transition starts */
+    enterDelay?: number;
+    /** Delay in ms before exit transition starts */
+    exitDelay?: number;
+}
+export declare const Transition: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    keepMounted: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    transition: {
+        type: PropType<MantineTransition>;
+        default: string;
+    };
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    exitDuration: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    timingFunction: {
+        type: StringConstructor;
+        default: string;
+    };
+    mounted: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    enterDelay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    exitDelay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+}>, () => VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    enter: () => true;
+    entered: () => true;
+    exit: () => true;
+    exited: () => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    keepMounted: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    transition: {
+        type: PropType<MantineTransition>;
+        default: string;
+    };
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    exitDuration: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    timingFunction: {
+        type: StringConstructor;
+        default: string;
+    };
+    mounted: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    enterDelay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    exitDelay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onEnter?: (() => any) | undefined;
+    onEntered?: (() => any) | undefined;
+    onExited?: (() => any) | undefined;
+    onExit?: (() => any) | undefined;
+}>, {
+    duration: number;
+    keepMounted: boolean;
+    transition: MantineTransition;
+    timingFunction: string;
+    exitDuration: number;
+    enterDelay: number;
+    exitDelay: number;
+}, SlotsType<TransitionSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/components/Transition/get-transition-styles.d.ts

@@ -0,0 +1,9 @@
+import type { CSSProperties } from 'vue';
+import { type MantineTransition } from './transitions';
+export type TransitionStatus = 'entered' | 'exited' | 'entering' | 'exiting' | 'pre-exiting' | 'pre-entering';
+export declare function getTransitionStyles({ transition, state, duration, timingFunction, }: {
+    transition: MantineTransition;
+    state: TransitionStatus;
+    duration: number;
+    timingFunction: CSSProperties['transitionTimingFunction'];
+}): CSSProperties;

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

@@ -0,0 +1 @@
+export * from './Transition';

package/lib/components/Transition/transitions.d.ts

@@ -0,0 +1,10 @@
+import type { CSSProperties } from 'vue';
+export interface MantineTransitionStyles {
+    common?: CSSProperties;
+    in: CSSProperties;
+    out: CSSProperties;
+    transitionProperty: CSSProperties['transitionProperty'];
+}
+export type MantineTransitionName = 'fade' | 'fade-down' | 'fade-up' | 'fade-left' | 'fade-right' | 'skew-up' | 'skew-down' | 'rotate-right' | 'rotate-left' | 'slide-down' | 'slide-up' | 'slide-right' | 'slide-left' | 'scale-y' | 'scale-x' | 'scale' | 'pop' | 'pop-top-left' | 'pop-top-right' | 'pop-bottom-left' | 'pop-bottom-right';
+export type MantineTransition = MantineTransitionName | MantineTransitionStyles;
+export declare const transitions: Record<MantineTransitionName, MantineTransitionStyles>;