prlg-ui 1.8.349 → 1.8.351

package/dist/app/reka-ui/components/ScrollArea/ScrollAreaRoot.d.ts

@@ -0,0 +1,282 @@
+import { ScrollAreaRoot, ScrollAreaRootProps } from 'reka-ui';
+export interface IScrollAreaRootProps extends ScrollAreaRootProps {
+    maxHeight?: number | string;
+}
+declare const forwared: import('vue').ComputedRef<Readonly<{
+    type: "scroll" | "auto" | "hover" | "always";
+    dir: "ltr" | "rtl";
+    scrollHideDelay: number;
+    asChild: boolean;
+    as: import('reka-ui').AsTag | import('vue').Component;
+}> & {
+    readonly maxHeight: string | number;
+} & {
+    readonly asChild: boolean;
+}>;
+declare const height: import('vue').ComputedRef<string>;
+declare function scrollToBottom(): void;
+declare function scrollToTop(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        scrollArea: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly maxHeight?: number | string | undefined;
+                readonly type?: ("scroll" | "auto" | "hover" | "always") | undefined;
+                readonly dir?: ("ltr" | "rtl") | undefined;
+                readonly scrollHideDelay?: number | undefined;
+                readonly asChild?: boolean | undefined;
+                readonly as?: (import('reka-ui').AsTag | import('vue').Component) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<IScrollAreaRootProps> & Readonly<{}>, {
+                ScrollAreaRoot: typeof ScrollAreaRoot;
+                forwared: typeof forwared;
+                height: typeof height;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                maxHeight: number | string;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            maxHeight: number | string;
+        }> & Omit<Readonly<IScrollAreaRootProps> & Readonly<{}>, "height" | "maxHeight" | "forwared" | "ScrollAreaRoot"> & import('vue').ShallowUnwrapRef<{
+            ScrollAreaRoot: typeof ScrollAreaRoot;
+            forwared: typeof forwared;
+            height: typeof height;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        } & {
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly type?: ("scroll" | "auto" | "hover" | "always") | undefined;
+                readonly dir?: ("ltr" | "rtl") | undefined;
+                readonly scrollHideDelay?: number | undefined;
+                readonly asChild?: boolean | undefined;
+                readonly as?: (import('reka-ui').AsTag | import('vue').Component) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<ScrollAreaRootProps> & Readonly<{}>, {
+                viewport: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                scrollTop: () => void;
+                scrollTopLeft: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                type: "scroll" | "auto" | "hover" | "always";
+                scrollHideDelay: number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            type: "scroll" | "auto" | "hover" | "always";
+            scrollHideDelay: number;
+        }> & Omit<Readonly<ScrollAreaRootProps> & Readonly<{}>, "type" | "viewport" | "scrollHideDelay" | "scrollTop" | "scrollTopLeft"> & import('vue').ShallowUnwrapRef<{
+            viewport: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            scrollTop: () => void;
+            scrollTopLeft: () => void;
+        }>) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<IScrollAreaRootProps, {
+    scrollToBottom: typeof scrollToBottom;
+    scrollToTop: typeof scrollToTop;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<IScrollAreaRootProps> & Readonly<{}>, {
+    maxHeight: number | string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    scrollArea: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly maxHeight?: number | string | undefined;
+            readonly type?: ("scroll" | "auto" | "hover" | "always") | undefined;
+            readonly dir?: ("ltr" | "rtl") | undefined;
+            readonly scrollHideDelay?: number | undefined;
+            readonly asChild?: boolean | undefined;
+            readonly as?: (import('reka-ui').AsTag | import('vue').Component) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<IScrollAreaRootProps> & Readonly<{}>, {
+            ScrollAreaRoot: typeof ScrollAreaRoot;
+            forwared: typeof forwared;
+            height: typeof height;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            maxHeight: number | string;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        maxHeight: number | string;
+    }> & Omit<Readonly<IScrollAreaRootProps> & Readonly<{}>, "height" | "maxHeight" | "forwared" | "ScrollAreaRoot"> & import('vue').ShallowUnwrapRef<{
+        ScrollAreaRoot: typeof ScrollAreaRoot;
+        forwared: typeof forwared;
+        height: typeof height;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+        };
+    } & {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly type?: ("scroll" | "auto" | "hover" | "always") | undefined;
+            readonly dir?: ("ltr" | "rtl") | undefined;
+            readonly scrollHideDelay?: number | undefined;
+            readonly asChild?: boolean | undefined;
+            readonly as?: (import('reka-ui').AsTag | import('vue').Component) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<ScrollAreaRootProps> & Readonly<{}>, {
+            viewport: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            scrollTop: () => void;
+            scrollTopLeft: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            type: "scroll" | "auto" | "hover" | "always";
+            scrollHideDelay: number;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        type: "scroll" | "auto" | "hover" | "always";
+        scrollHideDelay: number;
+    }> & Omit<Readonly<ScrollAreaRootProps> & Readonly<{}>, "type" | "viewport" | "scrollHideDelay" | "scrollTop" | "scrollTopLeft"> & import('vue').ShallowUnwrapRef<{
+        viewport: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        scrollTop: () => void;
+        scrollTopLeft: () => void;
+    }>) | null;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/app/reka-ui/components/ScrollArea/ScrollAreaScrollbar.d.ts

@@ -0,0 +1,3 @@
+import { ScrollAreaScrollbarProps } from 'reka-ui';
+declare const _default: import('vue').DefineComponent<ScrollAreaScrollbarProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ScrollAreaScrollbarProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/app/reka-ui/components/ScrollArea/ScrollAreaViewport.d.ts

@@ -0,0 +1,18 @@
+import { ScrollAreaViewportProps } from 'reka-ui';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ScrollAreaViewportProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ScrollAreaViewportProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/app/reka-ui/components/ScrollArea/index.d.ts

@@ -0,0 +1,4 @@
+import { default as ScrollAreaRoot } from './ScrollAreaRoot';
+import { default as ScrollAreaScrollbar } from './ScrollAreaScrollbar';
+import { default as ScrollAreaViewport } from './ScrollAreaViewport';
+export { ScrollAreaRoot, ScrollAreaScrollbar, ScrollAreaViewport };

package/dist/app/reka-ui/components/Select/Select.stories.d.ts

@@ -0,0 +1,8 @@
+import { Meta, StoryObj } from '@storybook/vue3';
+import { SelectRoot } from '.';
+declare const meta: Meta<typeof SelectRoot>;
+export default meta;
+type Story = StoryObj<typeof SelectRoot>;
+export declare const Default: Story;
+export declare const Small: Story;
+export declare const Large: Story;

package/dist/app/reka-ui/components/Select/SelectContent.d.ts

@@ -0,0 +1,26 @@
+import { SelectContentProps } from 'reka-ui';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SelectContentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: import('reka-ui').PointerDownOutsideEvent) => any;
+    closeAutoFocus: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<SelectContentProps> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import('reka-ui').PointerDownOutsideEvent) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/app/reka-ui/components/Select/SelectItem.d.ts

@@ -0,0 +1,21 @@
+import { SelectItemProps } from 'reka-ui';
+interface ISelectItemProps extends SelectItemProps {
+    label?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ISelectItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ISelectItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/app/reka-ui/components/Select/SelectRoot.d.ts

@@ -0,0 +1,25 @@
+import { SelectRootProps } from 'reka-ui';
+type __VLS_Props = SelectRootProps;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: import('reka-ui').AcceptableValue) => any;
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('reka-ui').AcceptableValue) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/app/reka-ui/components/Select/SelectSeparator.d.ts

@@ -0,0 +1,3 @@
+import { SelectSeparatorProps } from 'reka-ui';
+declare const _default: import('vue').DefineComponent<SelectSeparatorProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SelectSeparatorProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/app/reka-ui/components/Select/SelectTrigger.d.ts

@@ -0,0 +1,23 @@
+import { SelectTriggerProps } from 'reka-ui';
+export interface ISelectTriggerProps extends SelectTriggerProps {
+    size?: 'small' | 'default' | 'large';
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ISelectTriggerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ISelectTriggerProps> & Readonly<{}>, {
+    size: "small" | "default" | "large";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/app/reka-ui/components/Select/SelectValue.d.ts

@@ -0,0 +1,23 @@
+import { SelectValueProps } from 'reka-ui';
+interface ISelectValueProps extends SelectValueProps {
+    maxSelectedLabels?: number;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: any): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ISelectValueProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ISelectValueProps> & Readonly<{}>, {
+    maxSelectedLabels: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/app/reka-ui/components/Select/SelectViewport.d.ts

@@ -0,0 +1,18 @@
+import { SelectViewportProps } from 'reka-ui';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SelectViewportProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SelectViewportProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/app/reka-ui/components/Select/index.d.ts

@@ -0,0 +1,9 @@
+import { SelectGroup, SelectIcon, SelectItemIndicator, SelectLabel, SelectPortal, SelectScrollDownButton, SelectScrollUpButton, SelectItemText } from 'reka-ui';
+import { default as SelectRoot } from './SelectRoot';
+import { default as SelectTrigger } from './SelectTrigger';
+import { default as SelectValue } from './SelectValue';
+import { default as SelectContent } from './SelectContent';
+import { default as SelectItem } from './SelectItem';
+import { default as SelectSeparator } from './SelectSeparator';
+import { default as SelectViewport } from './SelectViewport';
+export { SelectContent, SelectGroup, SelectIcon, SelectItem, SelectItemIndicator, SelectLabel, SelectPortal, SelectRoot, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, SelectViewport, SelectItemText, };

package/dist/app/reka-ui/components/Spinner/Spinner.d.ts

@@ -0,0 +1,6 @@
+export interface ISpinnerProps {
+    color?: string;
+    size?: number;
+}
+declare const _default: import('vue').DefineComponent<ISpinnerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ISpinnerProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/app/reka-ui/components/Spinner/Spinner.directive.d.ts

@@ -0,0 +1,11 @@
+import { ObjectDirective } from 'vue';
+interface LoadingElement extends HTMLElement {
+    dataset: DOMStringMap & {
+        loading?: string;
+        originalPosition?: string;
+    };
+    _spinnerApp?: any;
+    _spinnerContainer?: HTMLElement;
+}
+export declare const vLoading: ObjectDirective<LoadingElement, boolean>;
+export {};

package/dist/app/reka-ui/components/Spinner/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Spinner } from './Spinner';
+import { vLoading } from './Spinner.directive';
+export { Spinner, vLoading };

package/dist/app/reka-ui/components/Stepper/Stepper.stories.d.ts

@@ -0,0 +1,7 @@
+import { Meta, StoryObj } from '@storybook/vue3';
+import { StepperRoot } from '.';
+declare const meta: Meta<typeof StepperRoot>;
+export default meta;
+type Story = StoryObj<typeof StepperRoot>;
+export declare const Default: Story;
+export declare const Vertical: Story;

package/dist/app/reka-ui/components/Stepper/StepperIndicator.d.ts

@@ -0,0 +1,3 @@
+import { StepperIndicatorProps } from 'reka-ui';
+declare const _default: import('vue').DefineComponent<StepperIndicatorProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<StepperIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/app/reka-ui/components/Stepper/StepperItem.d.ts

@@ -0,0 +1,18 @@
+import { StepperItemProps } from 'reka-ui';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<StepperItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<StepperItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};