@mantine-vue/core 1.1.1

package/lib/components/RollingNumber/get-render-slots.d.ts

@@ -0,0 +1,35 @@
+import { type DigitParts } from './get-digit-parts';
+export interface DigitSlot {
+    type: 'digit';
+    key: string;
+    digit: string;
+    previousDigit: string | null;
+    empty: boolean;
+}
+export interface CharSlot {
+    type: 'char';
+    key: string;
+    char: string;
+    empty: boolean;
+}
+export type RenderSlot = DigitSlot | CharSlot;
+export interface GetRenderSlotsInput {
+    current: DigitParts;
+    previous: DigitParts;
+    prefix?: string;
+    suffix?: string;
+    decimalSeparator?: string;
+    thousandSeparator?: string | boolean;
+}
+export declare function getRenderSlots({ current, previous, prefix, suffix, decimalSeparator, thousandSeparator, }: GetRenderSlotsInput): RenderSlot[];
+export interface GetRenderSlotsFromValuesInput {
+    value: number;
+    previousValue: number;
+    prefix?: string;
+    suffix?: string;
+    decimalSeparator?: string;
+    thousandSeparator?: string | boolean;
+    decimalScale?: number;
+    fixedDecimalScale?: boolean;
+}
+export declare function getRenderSlotsFromValues({ value, previousValue, prefix, suffix, decimalSeparator, thousandSeparator, decimalScale, fixedDecimalScale, }: GetRenderSlotsFromValuesInput): RenderSlot[];

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

@@ -0,0 +1,8 @@
+export { RollingNumber } from './RollingNumber';
+export { buildValue } from './build-value';
+export { getDigitParts } from './get-digit-parts';
+export { getRenderSlots, getRenderSlotsFromValues } from './get-render-slots';
+export type { BuildValueInput } from './build-value';
+export type { DigitParts, GetDigitPartsInput } from './get-digit-parts';
+export type { CharSlot, DigitSlot, GetRenderSlotsFromValuesInput, GetRenderSlotsInput, RenderSlot, } from './get-render-slots';
+export type { RollingNumberCssVariables, RollingNumberProps, RollingNumberStylesNames, } from './RollingNumber';

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

@@ -0,0 +1,21 @@
+import type { Ref } from 'vue';
+export interface ScrollAreaContextValue {
+    type: 'auto' | 'always' | 'scroll' | 'hover' | 'never';
+    scrollHideDelay: number;
+    scrollbars?: 'x' | 'y' | 'xy' | false;
+    viewport: Ref<HTMLDivElement | null>;
+    onViewportChange: (node: HTMLDivElement | null) => void;
+    content: Ref<HTMLDivElement | null>;
+    onContentChange: (node: HTMLDivElement | null) => void;
+    scrollbarX: Ref<HTMLDivElement | null>;
+    onScrollbarXChange: (node: HTMLDivElement | null) => void;
+    scrollbarY: Ref<HTMLDivElement | null>;
+    onScrollbarYChange: (node: HTMLDivElement | null) => void;
+    onCornerWidthChange: (width: number) => void;
+    onCornerHeightChange: (height: number) => void;
+    getStyles: (selector: string, options?: {
+        className?: any;
+        style?: any;
+    }) => any;
+}
+export declare const provideScrollAreaContext: (value: ScrollAreaContextValue) => void, useScrollAreaContext: () => ScrollAreaContextValue;

package/lib/components/ScrollArea/ScrollArea.d.ts

@@ -0,0 +1,482 @@
+import { type PropType } from 'vue';
+export type ScrollAreaStylesNames = 'root' | 'viewport' | 'scrollbar' | 'thumb' | 'corner' | 'content';
+export type ScrollAreaType = 'auto' | 'always' | 'scroll' | 'hover' | 'never';
+export type ScrollAreaScrollbars = 'x' | 'y' | 'xy' | false;
+export interface ScrollAreaProps {
+    scrollbarSize?: number | string;
+    type?: ScrollAreaType;
+    scrollHideDelay?: number;
+    scrollbars?: ScrollAreaScrollbars;
+    offsetScrollbars?: boolean | 'x' | 'y' | 'present';
+    viewportProps?: Record<string, any>;
+    onScrollPositionChange?: (position: {
+        x: number;
+        y: number;
+    }) => void;
+    onBottomReached?: () => void;
+    onTopReached?: () => void;
+    onLeftReached?: () => void;
+    onRightReached?: () => void;
+    overscrollBehavior?: string;
+    startScrollPosition?: {
+        x?: number;
+        y?: number;
+    };
+}
+export declare const ScrollAreaBase: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    scrollbarSize: PropType<string | number>;
+    type: {
+        type: PropType<ScrollAreaType>;
+        default: undefined;
+    };
+    scrollHideDelay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    scrollbars: {
+        type: PropType<ScrollAreaScrollbars>;
+        default: undefined;
+    };
+    offsetScrollbars: {
+        type: PropType<ScrollAreaProps["offsetScrollbars"]>;
+        default: undefined;
+    };
+    viewportProps: {
+        type: PropType<Record<string, any>>;
+        default: undefined;
+    };
+    onScrollPositionChange: {
+        type: PropType<ScrollAreaProps["onScrollPositionChange"]>;
+        default: undefined;
+    };
+    onBottomReached: {
+        type: PropType<ScrollAreaProps["onBottomReached"]>;
+        default: undefined;
+    };
+    onTopReached: {
+        type: PropType<ScrollAreaProps["onTopReached"]>;
+        default: undefined;
+    };
+    onLeftReached: {
+        type: PropType<ScrollAreaProps["onLeftReached"]>;
+        default: undefined;
+    };
+    onRightReached: {
+        type: PropType<ScrollAreaProps["onRightReached"]>;
+        default: undefined;
+    };
+    overscrollBehavior: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    startScrollPosition: {
+        type: PropType<ScrollAreaProps["startScrollPosition"]>;
+        default: undefined;
+    };
+    classNames: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    styles: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    vars: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    unstyled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    scrollbarSize: PropType<string | number>;
+    type: {
+        type: PropType<ScrollAreaType>;
+        default: undefined;
+    };
+    scrollHideDelay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    scrollbars: {
+        type: PropType<ScrollAreaScrollbars>;
+        default: undefined;
+    };
+    offsetScrollbars: {
+        type: PropType<ScrollAreaProps["offsetScrollbars"]>;
+        default: undefined;
+    };
+    viewportProps: {
+        type: PropType<Record<string, any>>;
+        default: undefined;
+    };
+    onScrollPositionChange: {
+        type: PropType<ScrollAreaProps["onScrollPositionChange"]>;
+        default: undefined;
+    };
+    onBottomReached: {
+        type: PropType<ScrollAreaProps["onBottomReached"]>;
+        default: undefined;
+    };
+    onTopReached: {
+        type: PropType<ScrollAreaProps["onTopReached"]>;
+        default: undefined;
+    };
+    onLeftReached: {
+        type: PropType<ScrollAreaProps["onLeftReached"]>;
+        default: undefined;
+    };
+    onRightReached: {
+        type: PropType<ScrollAreaProps["onRightReached"]>;
+        default: undefined;
+    };
+    overscrollBehavior: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    startScrollPosition: {
+        type: PropType<ScrollAreaProps["startScrollPosition"]>;
+        default: undefined;
+    };
+    classNames: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    styles: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    vars: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    unstyled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    type: ScrollAreaType;
+    classNames: Function | Record<string, any>;
+    styles: Function | Record<string, any>;
+    overscrollBehavior: string;
+    vars: Function | Record<string, any>;
+    unstyled: boolean;
+    scrollbars: ScrollAreaScrollbars;
+    scrollHideDelay: number;
+    offsetScrollbars: boolean | "x" | "y" | "present" | undefined;
+    onScrollPositionChange: ((position: {
+        x: number;
+        y: number;
+    }) => void) | undefined;
+    onBottomReached: (() => void) | undefined;
+    onTopReached: (() => void) | undefined;
+    onLeftReached: (() => void) | undefined;
+    onRightReached: (() => void) | undefined;
+    startScrollPosition: {
+        x?: number;
+        y?: number;
+    } | undefined;
+    viewportProps: Record<string, any>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const ScrollAreaAutosize: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {} | {
+    [x: string]: any;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const ScrollArea: import("../..").WithBoxProps<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        scrollbarSize: PropType<string | number>;
+        type: {
+            type: PropType<ScrollAreaType>;
+            default: undefined;
+        };
+        scrollHideDelay: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+        scrollbars: {
+            type: PropType<ScrollAreaScrollbars>;
+            default: undefined;
+        };
+        offsetScrollbars: {
+            type: PropType<ScrollAreaProps["offsetScrollbars"]>;
+            default: undefined;
+        };
+        viewportProps: {
+            type: PropType<Record<string, any>>;
+            default: undefined;
+        };
+        onScrollPositionChange: {
+            type: PropType<ScrollAreaProps["onScrollPositionChange"]>;
+            default: undefined;
+        };
+        onBottomReached: {
+            type: PropType<ScrollAreaProps["onBottomReached"]>;
+            default: undefined;
+        };
+        onTopReached: {
+            type: PropType<ScrollAreaProps["onTopReached"]>;
+            default: undefined;
+        };
+        onLeftReached: {
+            type: PropType<ScrollAreaProps["onLeftReached"]>;
+            default: undefined;
+        };
+        onRightReached: {
+            type: PropType<ScrollAreaProps["onRightReached"]>;
+            default: undefined;
+        };
+        overscrollBehavior: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        startScrollPosition: {
+            type: PropType<ScrollAreaProps["startScrollPosition"]>;
+            default: undefined;
+        };
+        classNames: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        styles: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        vars: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        unstyled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        type: ScrollAreaType;
+        classNames: Function | Record<string, any>;
+        styles: Function | Record<string, any>;
+        overscrollBehavior: string;
+        vars: Function | Record<string, any>;
+        unstyled: boolean;
+        scrollbars: ScrollAreaScrollbars;
+        scrollHideDelay: number;
+        offsetScrollbars: boolean | "x" | "y" | "present" | undefined;
+        onScrollPositionChange: ((position: {
+            x: number;
+            y: number;
+        }) => void) | undefined;
+        onBottomReached: (() => void) | undefined;
+        onTopReached: (() => void) | undefined;
+        onLeftReached: (() => void) | undefined;
+        onRightReached: (() => void) | undefined;
+        startScrollPosition: {
+            x?: number;
+            y?: number;
+        } | undefined;
+        viewportProps: Record<string, any>;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        scrollbarSize: PropType<string | number>;
+        type: {
+            type: PropType<ScrollAreaType>;
+            default: undefined;
+        };
+        scrollHideDelay: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+        scrollbars: {
+            type: PropType<ScrollAreaScrollbars>;
+            default: undefined;
+        };
+        offsetScrollbars: {
+            type: PropType<ScrollAreaProps["offsetScrollbars"]>;
+            default: undefined;
+        };
+        viewportProps: {
+            type: PropType<Record<string, any>>;
+            default: undefined;
+        };
+        onScrollPositionChange: {
+            type: PropType<ScrollAreaProps["onScrollPositionChange"]>;
+            default: undefined;
+        };
+        onBottomReached: {
+            type: PropType<ScrollAreaProps["onBottomReached"]>;
+            default: undefined;
+        };
+        onTopReached: {
+            type: PropType<ScrollAreaProps["onTopReached"]>;
+            default: undefined;
+        };
+        onLeftReached: {
+            type: PropType<ScrollAreaProps["onLeftReached"]>;
+            default: undefined;
+        };
+        onRightReached: {
+            type: PropType<ScrollAreaProps["onRightReached"]>;
+            default: undefined;
+        };
+        overscrollBehavior: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        startScrollPosition: {
+            type: PropType<ScrollAreaProps["startScrollPosition"]>;
+            default: undefined;
+        };
+        classNames: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        styles: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        vars: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        unstyled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, {
+        type: ScrollAreaType;
+        classNames: Function | Record<string, any>;
+        styles: Function | Record<string, any>;
+        overscrollBehavior: string;
+        vars: Function | Record<string, any>;
+        unstyled: boolean;
+        scrollbars: ScrollAreaScrollbars;
+        scrollHideDelay: number;
+        offsetScrollbars: boolean | "x" | "y" | "present" | undefined;
+        onScrollPositionChange: ((position: {
+            x: number;
+            y: number;
+        }) => void) | undefined;
+        onBottomReached: (() => void) | undefined;
+        onTopReached: (() => void) | undefined;
+        onLeftReached: (() => void) | undefined;
+        onRightReached: (() => void) | undefined;
+        startScrollPosition: {
+            x?: number;
+            y?: number;
+        } | undefined;
+        viewportProps: Record<string, any>;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    scrollbarSize: PropType<string | number>;
+    type: {
+        type: PropType<ScrollAreaType>;
+        default: undefined;
+    };
+    scrollHideDelay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    scrollbars: {
+        type: PropType<ScrollAreaScrollbars>;
+        default: undefined;
+    };
+    offsetScrollbars: {
+        type: PropType<ScrollAreaProps["offsetScrollbars"]>;
+        default: undefined;
+    };
+    viewportProps: {
+        type: PropType<Record<string, any>>;
+        default: undefined;
+    };
+    onScrollPositionChange: {
+        type: PropType<ScrollAreaProps["onScrollPositionChange"]>;
+        default: undefined;
+    };
+    onBottomReached: {
+        type: PropType<ScrollAreaProps["onBottomReached"]>;
+        default: undefined;
+    };
+    onTopReached: {
+        type: PropType<ScrollAreaProps["onTopReached"]>;
+        default: undefined;
+    };
+    onLeftReached: {
+        type: PropType<ScrollAreaProps["onLeftReached"]>;
+        default: undefined;
+    };
+    onRightReached: {
+        type: PropType<ScrollAreaProps["onRightReached"]>;
+        default: undefined;
+    };
+    overscrollBehavior: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    startScrollPosition: {
+        type: PropType<ScrollAreaProps["startScrollPosition"]>;
+        default: undefined;
+    };
+    classNames: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    styles: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    vars: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    unstyled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    type: ScrollAreaType;
+    classNames: Function | Record<string, any>;
+    styles: Function | Record<string, any>;
+    overscrollBehavior: string;
+    vars: Function | Record<string, any>;
+    unstyled: boolean;
+    scrollbars: ScrollAreaScrollbars;
+    scrollHideDelay: number;
+    offsetScrollbars: boolean | "x" | "y" | "present" | undefined;
+    onScrollPositionChange: ((position: {
+        x: number;
+        y: number;
+    }) => void) | undefined;
+    onBottomReached: (() => void) | undefined;
+    onTopReached: (() => void) | undefined;
+    onLeftReached: (() => void) | undefined;
+    onRightReached: (() => void) | undefined;
+    startScrollPosition: {
+        x?: number;
+        y?: number;
+    } | undefined;
+    viewportProps: Record<string, any>;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    Autosize: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {} | {
+        [x: string]: any;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    classes: Record<string, string>;
+    varsResolver: (theme: import("../..").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
+}>;

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

@@ -0,0 +1,23 @@
+export type Sizes = {
+    content: number;
+    viewport: number;
+    scrollbar: {
+        size: number;
+        paddingStart: number;
+        paddingEnd: number;
+    };
+};
+export interface ScrollAreaScrollbarAxisPrivateProps {
+    hasThumb: boolean;
+    sizes: Sizes;
+    onSizesChange: (sizes: Sizes) => void;
+    onThumbChange: (thumb: HTMLDivElement | null) => void;
+    onThumbPointerDown: (pointerPos: number) => void;
+    onThumbPointerUp: () => void;
+    onThumbPositionChange: () => void;
+    onWheelScroll: (scrollPos: number) => void;
+    onDragScroll: (pointerPos: number) => void;
+}
+export interface ScrollAreaScrollbarAxisProps extends ScrollAreaScrollbarAxisPrivateProps {
+    [key: string]: any;
+}

package/lib/components/ScrollArea/ScrollAreaCorner/ScrollAreaCorner.d.ts

@@ -0,0 +1,3 @@
+export declare const ScrollAreaCorner: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/components/ScrollArea/ScrollAreaRoot/ScrollAreaRoot.d.ts

@@ -0,0 +1,43 @@
+import { type PropType } from 'vue';
+import { type ScrollAreaContextValue } from '../ScrollArea.context';
+export declare const ScrollAreaRoot: import("../../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    getStyles: {
+        type: PropType<ScrollAreaContextValue["getStyles"]>;
+        required: true;
+    };
+    type: {
+        type: PropType<ScrollAreaContextValue["type"]>;
+        default: undefined;
+    };
+    scrollbars: {
+        type: PropType<ScrollAreaContextValue["scrollbars"]>;
+        default: undefined;
+    };
+    scrollHideDelay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    getStyles: {
+        type: PropType<ScrollAreaContextValue["getStyles"]>;
+        required: true;
+    };
+    type: {
+        type: PropType<ScrollAreaContextValue["type"]>;
+        default: undefined;
+    };
+    scrollbars: {
+        type: PropType<ScrollAreaContextValue["scrollbars"]>;
+        default: undefined;
+    };
+    scrollHideDelay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    type: "auto" | "always" | "never" | "scroll" | "hover";
+    scrollbars: false | "x" | "y" | "xy" | undefined;
+    scrollHideDelay: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;

package/lib/components/ScrollArea/ScrollAreaScrollbar/ScrollAreaScrollbar.d.ts

@@ -0,0 +1,24 @@
+import { type PropType } from 'vue';
+export declare const ScrollAreaScrollbar: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    orientation: {
+        type: PropType<"horizontal" | "vertical">;
+        required: true;
+    };
+    forceMount: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    orientation: {
+        type: PropType<"horizontal" | "vertical">;
+        required: true;
+    };
+    forceMount: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    forceMount: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/components/ScrollArea/ScrollAreaScrollbar/ScrollAreaScrollbarVisible.d.ts

@@ -0,0 +1,16 @@
+import { type PropType } from 'vue';
+export declare const ScrollAreaScrollbarVisible: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    orientation: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    orientation: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    orientation: "horizontal" | "vertical";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/components/ScrollArea/ScrollAreaScrollbar/Scrollbar.context.d.ts

@@ -0,0 +1,12 @@
+export interface ScrollbarContextValue {
+    hasThumb: boolean;
+    scrollbar: HTMLDivElement | null;
+    onThumbChange: (thumb: HTMLDivElement | null) => void;
+    onThumbPointerUp: () => void;
+    onThumbPointerDown: (pointerPos: {
+        x: number;
+        y: number;
+    }) => void;
+    onThumbPositionChange: () => void;
+}
+export declare const provideScrollbarContext: (value: ScrollbarContextValue) => void, useScrollbarContext: () => ScrollbarContextValue;