@mantine-vue/core 3.5.0 → 3.6.0

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

@@ -0,0 +1,90 @@
+import type { VNodeChild } from 'vue';
+import type { VueRefTarget } from '@mantine-vue/hooks';
+import type { BoxProps, Factory, MantineColor, MantineRadius, MantineSize, StylesApiProps } from '../../core';
+import type { ToggleVariant } from '../Toggle';
+import type ToolbarDivider from './ToolbarDivider.vue';
+import type ToolbarGroup from './ToolbarGroup.vue';
+import type ToolbarToggle from './ToolbarToggle.vue';
+import type ToolbarToggleGroup from './ToolbarToggleGroup.vue';
+import type ToolbarToggleItem from './ToolbarToggleItem.vue';
+export type ToolbarStylesNames = 'root' | 'group' | 'toggle' | 'divider';
+export type ToolbarCssVariables = {
+    root: '--toolbar-toggle-size' | '--toolbar-padding' | '--toolbar-gap' | '--toolbar-radius';
+    toggle: '--toolbar-toggle-active-bg' | '--toolbar-toggle-active-hover' | '--toolbar-toggle-active-color';
+};
+export interface ToolbarOwnProps extends StylesApiProps<ToolbarFactory> {
+    /** Receives the root DOM node. */
+    rootRef?: VueRefTarget<Element>;
+    /** Toolbar orientation, `'horizontal'` by default */
+    orientation?: 'horizontal' | 'vertical';
+    /** Whether arrow key navigation wraps from last to first item, `true` by default */
+    loop?: boolean;
+    /** Controls size of toggle components, padding, and gap, `'md'` by default */
+    size?: MantineSize | (string & {});
+    /** Key of `theme.radius` or any valid CSS value to set `border-radius`, propagated to all children, `theme.defaultRadius` by default */
+    radius?: MantineRadius;
+    /** Determines whether the toolbar has a border, `true` by default */
+    withBorder?: boolean;
+    /** Key of `theme.colors` or any valid CSS color, controls color of child toggle components */
+    color?: MantineColor;
+    /** Determines whether icon color with filled variant should be changed based on the given `color` prop */
+    autoContrast?: boolean;
+    /** Controls visual representation of child toggle components. @default 'filled' */
+    variant?: ToggleVariant;
+}
+export interface ToolbarProps extends Omit<BoxProps, keyof ToolbarOwnProps>, ToolbarOwnProps {
+}
+export interface ToolbarSlots {
+    default?: () => VNodeChild;
+}
+export type ToolbarFactory = Factory<{
+    props: Omit<ToolbarProps, 'rootRef'>;
+    slots: ToolbarSlots;
+    ref: HTMLDivElement;
+    exposed: {
+        rootElement: Element | null;
+    };
+    element: 'div';
+    stylesNames: ToolbarStylesNames;
+    vars: ToolbarCssVariables;
+    variant: ToggleVariant;
+    staticComponents: {
+        Group: typeof ToolbarGroup;
+        Toggle: typeof ToolbarToggle;
+        ToggleGroup: typeof ToolbarToggleGroup;
+        ToggleItem: typeof ToolbarToggleItem;
+        Divider: typeof ToolbarDivider;
+    };
+}>;
+export interface ToolbarCompoundProps extends BoxProps {
+    classNames?: any;
+    styles?: any;
+}
+export type ToolbarGroupProps = ToolbarCompoundProps;
+export type ToolbarDividerProps = ToolbarCompoundProps;
+export interface ToolbarToggleProps extends ToolbarCompoundProps {
+    disabled?: boolean;
+    active?: boolean;
+    autoWidth?: boolean;
+    component?: any;
+}
+interface ToolbarToggleGroupBaseProps extends ToolbarCompoundProps {
+    disabled?: boolean;
+}
+export interface ToolbarToggleGroupSingleProps extends ToolbarToggleGroupBaseProps {
+    type: 'single';
+    modelValue?: string | null;
+    defaultValue?: string | null;
+}
+export interface ToolbarToggleGroupMultipleProps extends ToolbarToggleGroupBaseProps {
+    type: 'multiple';
+    modelValue?: string[];
+    defaultValue?: string[];
+}
+export type ToolbarToggleGroupProps = ToolbarToggleGroupSingleProps | ToolbarToggleGroupMultipleProps;
+export interface ToolbarToggleItemProps extends ToolbarCompoundProps {
+    value: string;
+    disabled?: boolean;
+    autoWidth?: boolean;
+}
+export {};

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

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

package/lib/components/Toolbar/ToolbarDivider.vue.d.ts

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

package/lib/components/Toolbar/ToolbarGroup.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("./Toolbar.types").ToolbarCompoundProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./Toolbar.types").ToolbarCompoundProps> & 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/Toolbar/ToolbarToggle.vue.d.ts

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

@@ -0,0 +1,19 @@
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("./Toolbar.types").ToolbarToggleGroupSingleProps | import("./Toolbar.types").ToolbarToggleGroupMultipleProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: string | string[] | null) => any;
+    "update:modelValue": (value: string | string[] | null) => any;
+}, string, import("vue").PublicProps, Readonly<import("./Toolbar.types").ToolbarToggleGroupSingleProps | import("./Toolbar.types").ToolbarToggleGroupMultipleProps> & Readonly<{
+    onChange?: ((value: string | string[] | null) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | string[] | null) => 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/Toolbar/ToolbarToggleItem.vue.d.ts

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

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

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

@@ -181,4 +181,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/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> & 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> & 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> & 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> & 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> & 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> & 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,131 @@
+import type { Ref, VNodeChild } from 'vue';
+import type { VueRefTarget } from '@mantine-vue/hooks';
+import type { BoxProps, Factory, MantineColor, StylesApiProps } from '../../core';
+import type { FloatingPosition } from '../../utils/Floating';
+import type { TransitionProps } 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?: Partial<TransitionProps>;
+}
+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> {
+    /** Receives the root DOM node. */
+    rootRef?: VueRefTarget<Element>;
+    /** 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?: Record<string, any>;
+    /** z-index of the tour @default 10000 */
+    zIndex?: string | number;
+    /** Transition props for the tooltip @default { duration: 200, transition: 'pop' } */
+    transitionProps?: Partial<TransitionProps>;
+    /** 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: Omit<TourProps, 'rootRef'>;
+    slots: TourSlots;
+    emits: TourEmits;
+    ref: HTMLDivElement;
+    element: 'div';
+    stylesNames: TourStylesNames;
+    vars: TourCssVariables;
+}>;

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

@@ -0,0 +1,25 @@
+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, {}, {}, {}, {}, 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> & 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;