@mantine-vue/core 3.5.0 → 3.7.0

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

@@ -1,17 +1,20 @@
 import type { VNodeChild } from 'vue';
+import type { FlipOptions, InlineOptions, ShiftOptions, SizeOptions } from '@floating-ui/vue';
 import type { ClassNames, MantineNode, Styles, Vars } from '../../core';
 import type { ArrowPosition, FloatingAxesOffsets, FloatingPosition, FloatingStrategy } from '../../utils/Floating';
+import type { PortalProps } from '../Portal';
+import type { TransitionOverride } from '../Transition';
 export type TooltipStylesNames = 'tooltip' | 'arrow';
 export type TooltipCssVariables = '--tooltip-radius' | '--tooltip-bg' | '--tooltip-color';
 export interface TooltipMiddlewares {
     /** Shifts the tooltip along its axis so it stays inside the viewport. */
-    shift?: boolean | Record<string, any>;
+    shift?: boolean | ShiftOptions;
     /** Flips the tooltip to the opposite side when it does not fit. */
-    flip?: boolean | Record<string, any>;
+    flip?: boolean | FlipOptions;
     /** Improves the position for targets that span multiple lines. */
-    inline?: boolean | Record<string, any>;
+    inline?: boolean | InlineOptions;
     /** Constrains the tooltip to the available space. */
-    size?: boolean | Record<string, any>;
+    size?: boolean | SizeOptions;
 }
 export interface TooltipSlots {
     /**
@@ -67,7 +70,7 @@ export interface TooltipBaseProps {
      */
     disabled?: boolean;
     /** Props passed down to the `Portal` when `withinPortal` is set. */
-    portalProps?: Record<string, any>;
+    portalProps?: PortalProps;
     /**
      * Floating UI middlewares applied to the tooltip.
      *
@@ -140,7 +143,7 @@ export interface TooltipProps extends TooltipBaseProps {
      *
      * @default { duration: 100, transition: 'fade' }
      */
-    transitionProps?: Record<string, any>;
+    transitionProps?: TransitionOverride;
     /**
      * Events that open and close the tooltip.
      *
@@ -181,4 +184,6 @@ export interface TooltipProps extends TooltipBaseProps {
      * default slot when the target is not a child of the tooltip.
      */
     target?: any;
+    /** If set, the tooltip is hidden when its target is detached, hidden, or outside the visible area. @default true */
+    hideDetached?: boolean;
 }

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

@@ -26,6 +26,7 @@ declare const defaults: {
         readonly inline: false;
     };
     readonly floatingStrategy: "absolute";
+    readonly hideDetached: true;
 };
 /** Module scope: created once, not per component instance. */
 declare const varsResolver: (theme: import("../..").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;

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

@@ -1,6 +1,7 @@
 import type { VNodeChild } from 'vue';
 import type { ClassNames, MantineNode, Styles, Vars } from '../../../core';
 import type { FloatingPosition } from '../../../utils/Floating';
+import type { PortalProps } from '../../Portal';
 export interface TooltipFloatingSlots {
     /**
      * The element the tooltip follows. Must be a single element or component that accepts
@@ -72,7 +73,7 @@ export interface TooltipFloatingProps {
     /** Key of `theme.colors` or any valid CSS color used as the background. */
     color?: string;
     /** Props passed down to the `Portal` when `withinPortal` is set. */
-    portalProps?: Record<string, any>;
+    portalProps?: PortalProps;
     /** `classNames` of the Styles API. */
     classNames?: ClassNames<TooltipFloatingProps>;
     /** `styles` of the Styles API. */

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

@@ -15,6 +15,7 @@ export interface UseTooltipOptions {
     };
     strategy: () => FloatingStrategy;
     middlewares: () => TooltipMiddlewares | undefined;
+    hideDetached?: () => boolean | undefined;
     onPositionChange?: (position: FloatingPosition) => void;
 }
 export declare function useTooltip(options: UseTooltipOptions): {
@@ -27,6 +28,7 @@ export declare function useTooltip(options: UseTooltipOptions): {
     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>;
+    referenceHidden: import("vue").ComputedRef<boolean | undefined>;
     open: () => void;
     close: () => void;
     setOpened: (value: boolean, delay?: number) => void;

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

@@ -0,0 +1,27 @@
+import type { MantineColor } from '../../core';
+import type { TourLabels } from './Tour.types';
+export declare const defaultTourLabels: TourLabels;
+export interface TourContextValue {
+    getStyles: (selector: string, options?: any) => any;
+    step: number;
+    setStep: (step: number) => void;
+    stepsCount: number;
+    close: () => void;
+    withOverlay: boolean;
+    withOverlayInteraction: boolean;
+    withCloseButton: boolean;
+    closeOnOverlayClick: boolean;
+    spotlightPadding: number;
+    spotlightRadius: number;
+    color?: MantineColor;
+    labels: TourLabels;
+    titleId: string;
+    bodyId: string;
+    titleMounted: boolean;
+    bodyMounted: boolean;
+    registerTitle: (id: string | null) => void;
+    registerBody: (id: string | null) => void;
+    targetElement: HTMLElement | null;
+    setTargetElement: (element: HTMLElement | null) => void;
+}
+export declare const provideTourContext: (value: TourContextValue) => void, useTourContext: () => TourContextValue;

package/lib/components/Tour/Tour.d.ts

@@ -0,0 +1,184 @@
+import TourRoot from './TourRoot.vue';
+import TourStep from './TourStep.vue';
+import TourOverlay from './TourOverlay.vue';
+import TourTooltip from './TourTooltip.vue';
+import TourBeacon from './TourBeacon.vue';
+import TourTitle from './TourTitle.vue';
+import TourBody from './TourBody.vue';
+import TourCloseButton from './TourCloseButton.vue';
+import TourNavigation from './TourNavigation.vue';
+export { TourRoot, TourStep, TourOverlay, TourTooltip, TourBeacon, TourTitle, TourBody, TourCloseButton, TourNavigation, };
+export declare const Tour: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Tour.types").TourOwnProps & import("../../index.js").RootRefProps<Element>> & Readonly<{
+        onClose?: (() => any) | undefined;
+        "onUpdate:step"?: ((step: number) => any) | undefined;
+        onStepChange?: ((step: number) => any) | undefined;
+        onStepOpen?: ((step: number) => any) | undefined;
+        onStepClose?: ((step: number) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        close: () => any;
+        "update:step": (step: number) => any;
+        stepChange: (step: number) => any;
+        stepOpen: (step: number) => any;
+        stepClose: (step: number) => any;
+    }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./Tour.types").TourOwnProps & import("../../index.js").RootRefProps<Element>> & Readonly<{
+        onClose?: (() => any) | undefined;
+        "onUpdate:step"?: ((step: number) => any) | undefined;
+        onStepChange?: ((step: number) => any) | undefined;
+        onStepOpen?: ((step: number) => any) | undefined;
+        onStepClose?: ((step: number) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./Tour.types").TourOwnProps & import("../../index.js").RootRefProps<Element>> & Readonly<{
+    onClose?: (() => any) | undefined;
+    "onUpdate:step"?: ((step: number) => any) | undefined;
+    onStepChange?: ((step: number) => any) | undefined;
+    onStepOpen?: ((step: number) => any) | undefined;
+    onStepClose?: ((step: number) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    "update:step": (step: number) => any;
+    stepChange: (step: number) => any;
+    stepOpen: (step: number) => any;
+    stepClose: (step: number) => any;
+}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?: () => any;
+    };
+}) & {
+    classes: Record<string, string>;
+    varsResolver: (theme: import("../../index.js").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
+    Root: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Tour.types").TourRootProps & import("../../index.js").RootRefProps<Element>> & Readonly<{
+            onClose?: (() => any) | undefined;
+            "onUpdate:step"?: ((step: number) => any) | undefined;
+            onStepChange?: ((step: number) => any) | undefined;
+            onStepOpen?: ((step: number) => any) | undefined;
+            onStepClose?: ((step: number) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            close: () => any;
+            "update:step": (step: number) => any;
+            stepChange: (step: number) => any;
+            stepOpen: (step: number) => any;
+            stepClose: (step: number) => any;
+        }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("./Tour.types").TourRootProps & import("../../index.js").RootRefProps<Element>> & Readonly<{
+            onClose?: (() => any) | undefined;
+            "onUpdate:step"?: ((step: number) => any) | undefined;
+            onStepChange?: ((step: number) => any) | undefined;
+            onStepOpen?: ((step: number) => any) | undefined;
+            onStepClose?: ((step: number) => any) | undefined;
+        }>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("./Tour.types").TourRootProps & import("../../index.js").RootRefProps<Element>> & Readonly<{
+        onClose?: (() => any) | undefined;
+        "onUpdate:step"?: ((step: number) => any) | undefined;
+        onStepChange?: ((step: number) => any) | undefined;
+        onStepOpen?: ((step: number) => any) | undefined;
+        onStepClose?: ((step: number) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        close: () => any;
+        "update:step": (step: number) => any;
+        stepChange: (step: number) => any;
+        stepOpen: (step: number) => any;
+        stepClose: (step: number) => any;
+    }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    });
+    Step: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Tour.types").TourStepProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("./Tour.types").TourStepProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("./Tour.types").TourStepProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: () => any;
+        };
+    });
+    Overlay: import("vue").DefineComponent<import("./Tour.types").TourOverlayProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        click: (event: MouseEvent) => any;
+    }, string, import("vue").PublicProps, Readonly<import("./Tour.types").TourOverlayProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    Tooltip: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Tour.types").TourTooltipProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("./Tour.types").TourTooltipProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("./Tour.types").TourTooltipProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    });
+    Beacon: import("vue").DefineComponent<import("./Tour.types").TourBeaconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./Tour.types").TourBeaconProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    Title: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    });
+    Body: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    });
+    CloseButton: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    Navigation: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};
+export type * from './Tour.types';

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

@@ -0,0 +1,129 @@
+import type { Ref, VNodeChild } from 'vue';
+import type { BoxProps, Factory, MantineColor, StylesApiProps } from '../../core';
+import type { FloatingPosition } from '../../utils/Floating';
+import type { PortalProps } from '../Portal';
+import type { TransitionOverride } from '../Transition';
+export type TourTarget = string | Ref<HTMLElement | null>;
+export interface TourLabels {
+    skip: string;
+    back: string;
+    next: string;
+    close: string;
+    stepCounter: (current: number, total: number) => string;
+    beacon: string;
+}
+export interface TourStepProps {
+    target?: TourTarget;
+    title?: VNodeChild;
+    position?: FloatingPosition;
+    withOverlay?: boolean;
+    spotlightPadding?: number;
+    spotlightRadius?: number;
+    withBeacon?: boolean;
+    onStepOpen?: () => void;
+    onStepClose?: () => void;
+}
+export interface TourStepData extends TourStepProps {
+    content?: () => VNodeChild;
+}
+export interface TourRootProps extends TourOwnProps {
+    stepsCount: number;
+}
+export interface TourOverlayProps {
+    targetRect?: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    } | null;
+    color?: string;
+    withInteraction?: boolean;
+}
+export interface TourTooltipProps extends BoxProps {
+    targetElement?: HTMLElement | null;
+    position?: FloatingPosition;
+    mounted?: boolean;
+    transitionProps?: TransitionOverride;
+}
+export interface TourBeaconProps extends BoxProps {
+    target?: TourTarget;
+}
+export type TourNavigationProps = BoxProps;
+export type TourTitleProps = BoxProps;
+export type TourBodyProps = BoxProps;
+export type TourCloseButtonProps = BoxProps;
+export type TourStylesNames = 'root' | 'overlay' | 'spotlight' | 'tooltip' | 'title' | 'body' | 'navigation' | 'closeButton' | 'stepCounter' | 'beacon' | 'beaconPulse' | 'navigationButton';
+export type TourCssVariables = {
+    root: '--tour-z-index' | '--tour-overlay-color' | '--tour-tooltip-radius' | '--tour-tooltip-shadow' | '--tour-beacon-size' | '--tour-beacon-color' | '--tour-color';
+};
+export interface TourOwnProps extends StylesApiProps<TourFactory> {
+    /** Whether the tour is active @default false */
+    active?: boolean;
+    /** Controlled current step index */
+    step?: number;
+    /** Uncontrolled default step index @default 0 */
+    defaultStep?: number;
+    /** Tour mode @default "guided" */
+    mode?: 'guided' | 'beacon';
+    /** Whether to display the overlay @default true */
+    withOverlay?: boolean;
+    /** Whether pointer events pass through the spotlight cutout to the target element, the rest of the overlay keeps blocking clicks @default false */
+    withOverlayInteraction?: boolean;
+    /** Whether to display the close button @default true */
+    withCloseButton?: boolean;
+    /** Whether keyboard navigation is enabled in guided mode @default true */
+    withKeyboardNavigation?: boolean;
+    /** Whether to scroll target elements into view @default true */
+    withScrollIntoView?: boolean;
+    /** Custom scroll handler */
+    scrollToHandler?: (element: HTMLElement) => void;
+    /** Padding around the spotlight cutout in px @default 8 */
+    spotlightPadding?: number;
+    /** Border radius of the spotlight cutout in px @default 4 */
+    spotlightRadius?: number;
+    /** Whether pressing Escape closes the tour @default true */
+    closeOnEscape?: boolean;
+    /** Whether clicking the overlay closes the tour, with `withOverlayInteraction` only clicks outside the spotlight cutout close it @default false */
+    closeOnOverlayClick?: boolean;
+    /** Labels for tour UI elements */
+    labels?: Partial<TourLabels>;
+    /** Whether to render inside a portal @default true */
+    withinPortal?: boolean;
+    /** Props passed to the Portal component */
+    portalProps?: PortalProps;
+    /** z-index of the tour @default 10000 */
+    zIndex?: string | number;
+    /** Transition props for the tooltip @default { duration: 200, transition: 'pop' } */
+    transitionProps?: TransitionOverride;
+    /** Duration of the tooltip position transition between steps in ms @default 300 */
+    stepTransitionDuration?: number;
+    /** Max width of the tooltip, tooltip always takes this width if viewport allows @default 360 */
+    maxWidth?: number;
+    /** Tour step overlay color @default "rgba(0, 0, 0, 0.5)" */
+    overlayColor?: string;
+    /** Key of `theme.colors` or any valid CSS color, controls beacon color and `Tour.Navigation` next button color @default theme.primaryColor */
+    color?: MantineColor;
+    /** Key of `theme.shadows` or any valid CSS box-shadow value, controls the tooltip shadow @default 'md' */
+    tooltipShadow?: string;
+}
+export interface TourProps extends Omit<BoxProps, keyof TourOwnProps>, TourOwnProps {
+}
+export interface TourSlots {
+    default?: () => VNodeChild;
+}
+export interface TourEmits {
+    close: [];
+    'update:step': [step: number];
+    stepChange: [step: number];
+    stepOpen: [step: number];
+    stepClose: [step: number];
+}
+export type TourFactory = Factory<{
+    props: TourProps;
+    slots: TourSlots;
+    emits: TourEmits;
+    ref: HTMLDivElement;
+    element: 'div';
+    stylesNames: TourStylesNames;
+    vars: TourCssVariables;
+}>;

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

@@ -0,0 +1,26 @@
+import type { RootRefProps } from '../../core';
+import type { TourOwnProps } from './Tour.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: __VLS_WithSlots<import("vue").DefineComponent<TourOwnProps & RootRefProps<Element>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    "update:step": (step: number) => any;
+    stepChange: (step: number) => any;
+    stepOpen: (step: number) => any;
+    stepClose: (step: number) => any;
+}, string, import("vue").PublicProps, Readonly<TourOwnProps & RootRefProps<Element>> & Readonly<{
+    onClose?: (() => any) | undefined;
+    "onUpdate:step"?: ((step: number) => any) | undefined;
+    onStepChange?: ((step: number) => any) | undefined;
+    onStepOpen?: ((step: number) => any) | undefined;
+    onStepClose?: ((step: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: () => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/Tour/TourBeacon.vue.d.ts

@@ -0,0 +1,4 @@
+import type { TourBeaconProps } from './Tour.types';
+declare const __VLS_export: import("vue").DefineComponent<TourBeaconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TourBeaconProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/lib/components/Tour/TourBeaconPositioned.vue.d.ts

@@ -0,0 +1,12 @@
+import type { TourTarget } from './Tour.types';
+type __VLS_Props = {
+    target?: TourTarget;
+    label: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/lib/components/Tour/TourBody.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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/Tour/TourCloseButton.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/Tour/TourNavigation.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/Tour/TourOverlay.vue.d.ts

@@ -0,0 +1,8 @@
+import type { TourOverlayProps } from './Tour.types';
+declare const __VLS_export: import("vue").DefineComponent<TourOverlayProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<TourOverlayProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/lib/components/Tour/TourRoot.vue.d.ts

@@ -0,0 +1,28 @@
+import type { RootRefProps } from '../../core';
+import type { TourRootProps } from './Tour.types';
+type __VLS_Props = TourRootProps & RootRefProps<Element>;
+declare var __VLS_14: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_14) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    "update:step": (step: number) => any;
+    stepChange: (step: number) => any;
+    stepOpen: (step: number) => any;
+    stepClose: (step: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    "onUpdate:step"?: ((step: number) => any) | undefined;
+    onStepChange?: ((step: number) => any) | undefined;
+    onStepOpen?: ((step: number) => any) | undefined;
+    onStepClose?: ((step: number) => any) | undefined;
+}>, {}, {}, {}, {}, 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/Tour/TourStep.vue.d.ts

@@ -0,0 +1,13 @@
+import type { TourStepProps } from './Tour.types';
+type __VLS_Slots = {
+    default?: () => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<TourStepProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TourStepProps> & 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/Tour/TourTitle.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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/Tour/TourTooltip.vue.d.ts

@@ -0,0 +1,14 @@
+import type { TourTooltipProps } from './Tour.types';
+declare var __VLS_26: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_26) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<TourTooltipProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TourTooltipProps> & 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/Tour/get-overlay-hit-path.d.ts

@@ -0,0 +1,6 @@
+export declare function getOverlayHitPath(rect: {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+} | null, padding: number): string;

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

@@ -0,0 +1,3 @@
+export * from './Tour';
+export { provideTourContext, useTourContext, defaultTourLabels } from './Tour.context';
+export type { TourContextValue } from './Tour.context';

package/lib/components/Tour/is-element-in-view.d.ts

@@ -0,0 +1 @@
+export declare function isElementInView(element: HTMLElement): boolean;

package/lib/components/Tree/Tree.d.ts

@@ -1,5 +1,5 @@
 export declare const Tree: import("../..").MantineComponent<{
-    props: Omit<import("./Tree.types").TreeProps, "rootRef">;
+    props: import("./Tree.types").TreeProps;
     ref: HTMLUListElement;
     slots: import("./Tree.types").TreeSlots;
     element: "ul";