@flux-ui/components 3.0.0-next.24 → 3.0.0-next.26

package/dist/component/primitive/SelectBase.vue.d.ts

@@ -1,5 +1,6 @@
-import { FluxFormSelectOption, FluxFormSelectOptions } from '@flux-ui/types';
-import { ComponentPublicInstance, nextTick } from 'vue';
+import { FluxFormSelectOption, FluxFormSelectOptions, FluxDirection, FluxAutoCompleteType, FluxIconName, FluxInputMask, FluxInputType, FluxTo, FluxPressableType, FluxButtonProps } from '@flux-ui/types';
+import { ComponentPublicInstance, nextTick, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions, ComponentInternalInstance, VNodeProps, AllowedComponentProps, ComponentCustomProps, Slot, ComponentOptionsBase, GlobalComponents, GlobalDirectives, DebuggerEvent, WatchOptions, WatchStopHandle, ShallowUnwrapRef, ComponentCustomProperties, CreateComponentPublicInstanceWithMixins } from 'vue';
+import { OnCleanup } from '@vue/reactivity';
 type __VLS_Props = {
     readonly disabled?: boolean;
     readonly isLoading?: boolean;
@@ -12,7 +13,7 @@ type __VLS_Props = {
 type __VLS_PublicProps = {
     'searchQuery'?: string;
 } & __VLS_Props;
-declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     close: () => any;
     deselect: (args_0: string | number) => any;
     search: (args_0: string) => any;
@@ -20,7 +21,7 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
     open: () => any;
     "update:searchQuery": (value: string) => any;
     keyDown: (args_0: KeyboardEvent) => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     onClose?: () => any;
     onDeselect?: (args_0: string | number) => any;
     onSearch?: (args_0: string) => any;
@@ -28,13 +29,13 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
     onOpen?: () => any;
     "onUpdate:searchQuery"?: (value: string) => any;
     onKeyDown?: (args_0: KeyboardEvent) => any;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
     anchor: {
-        $: import('vue').ComponentInternalInstance;
+        $: ComponentInternalInstance;
         $data: {};
         $props: {
             readonly tagName: keyof HTMLElementTagNameMap;
-        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
         $attrs: {
             [x: string]: unknown;
         };
@@ -42,16 +43,16 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
             [x: string]: unknown;
         };
         $slots: Readonly<{
-            [name: string]: import('vue').Slot<any>;
+            [name: string]: Slot<any>;
         }>;
         $root: ComponentPublicInstance | null;
         $parent: ComponentPublicInstance | null;
         $host: Element | null;
         $emit: (event: string, ...args: any[]) => void;
         $el: any;
-        $options: import('vue').ComponentOptionsBase<Readonly<{
+        $options: ComponentOptionsBase<Readonly<{
             readonly tagName: keyof HTMLElementTagNameMap;
-        }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+        }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
             beforeMount?: (() => void) | (() => void)[];
@@ -64,16 +65,16 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
             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)[];
+            renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
             errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
         };
         $forceUpdate: () => void;
         $nextTick: typeof 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;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends ((...args: any) => infer R) ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
     } & Readonly<{}> & Omit<Readonly<{
         readonly tagName: keyof HTMLElementTagNameMap;
-    }> & Readonly<{}>, never> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+    }> & Readonly<{}>, never> & ShallowUnwrapRef<{}> & {} & ComponentCustomProperties & {} & {
         $slots: Readonly<{
             default(): any;
         }> & {
@@ -81,15 +82,15 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
         };
     };
     anchorPopup: {
-        $: import('vue').ComponentInternalInstance;
+        $: ComponentInternalInstance;
         $data: {};
         $props: Partial<{}> & Omit<{
             readonly anchor?: ComponentPublicInstance | HTMLElement | null;
-            readonly direction?: import('@flux-ui/types').FluxDirection;
+            readonly direction?: FluxDirection;
             readonly margin?: number;
             readonly position?: "top" | "top-left" | "top-right" | "left" | "left-top" | "left-bottom" | "right" | "right-top" | "right-bottom" | "bottom" | "bottom-left" | "bottom-right";
             readonly useAnchorWidth?: boolean;
-        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>;
         $attrs: {
             [x: string]: unknown;
         };
@@ -99,20 +100,20 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
             popup: HTMLDivElement;
         };
         $slots: Readonly<{
-            [name: string]: import('vue').Slot<any>;
+            [name: string]: Slot<any>;
         }>;
         $root: ComponentPublicInstance | null;
         $parent: ComponentPublicInstance | null;
         $host: Element | null;
         $emit: (event: string, ...args: any[]) => void;
         $el: HTMLDivElement;
-        $options: import('vue').ComponentOptionsBase<Readonly<{
+        $options: ComponentOptionsBase<Readonly<{
             readonly anchor?: ComponentPublicInstance | HTMLElement | null;
-            readonly direction?: import('@flux-ui/types').FluxDirection;
+            readonly direction?: FluxDirection;
             readonly margin?: number;
             readonly position?: "top" | "top-left" | "top-right" | "left" | "left-top" | "left-bottom" | "right" | "right-top" | "right-bottom" | "bottom" | "bottom-left" | "bottom-right";
             readonly useAnchorWidth?: boolean;
-        }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+        }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
             beforeMount?: (() => void) | (() => void)[];
@@ -125,33 +126,33 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
             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)[];
+            renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
             errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
         };
         $forceUpdate: () => void;
         $nextTick: typeof 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;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends ((...args: any) => infer R) ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
     } & Readonly<{}> & Omit<Readonly<{
         readonly anchor?: ComponentPublicInstance | HTMLElement | null;
-        readonly direction?: import('@flux-ui/types').FluxDirection;
+        readonly direction?: FluxDirection;
         readonly margin?: number;
         readonly position?: "top" | "top-left" | "top-right" | "left" | "left-top" | "left-bottom" | "right" | "right-top" | "right-bottom" | "bottom" | "bottom-left" | "bottom-right";
         readonly useAnchorWidth?: boolean;
-    }> & Readonly<{}>, never> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+    }> & Readonly<{}>, never> & ShallowUnwrapRef<{}> & {} & ComponentCustomProperties & {} & {
         $slots: Readonly<{
             default(): any;
         }> & {
             default(): any;
         };
     };
-    searchInputElement: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+    searchInputElement: CreateComponentPublicInstanceWithMixins<Readonly<{
         modelValue?: object | string | number | null;
     } & {
-        readonly autoComplete?: import('@flux-ui/types').FluxAutoCompleteType;
+        readonly autoComplete?: FluxAutoCompleteType;
         readonly autoFocus?: boolean;
-        readonly iconLeading?: import('@flux-ui/types').FluxIconName;
-        readonly iconTrailing?: import('@flux-ui/types').FluxIconName;
+        readonly iconLeading?: FluxIconName;
+        readonly iconTrailing?: FluxIconName;
         readonly disabled?: boolean;
         readonly isCondensed?: boolean;
         readonly isReadonly?: boolean;
@@ -159,10 +160,10 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
         readonly max?: string | number;
         readonly maxLength?: number;
         readonly min?: string | number;
-        readonly pattern?: import('@flux-ui/types').FluxInputMask;
+        readonly pattern?: FluxInputMask;
         readonly placeholder?: string;
         readonly step?: number;
-        readonly type?: import('@flux-ui/types').FluxInputType;
+        readonly type?: FluxInputType;
     }> & Readonly<{
         onBlur?: () => any;
         onFocus?: () => any;
@@ -171,14 +172,14 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
     }>, {
         blur: () => void;
         focus: () => void;
-    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
         blur: () => any;
         focus: () => any;
         showPicker: () => any;
         "update:modelValue": (value: string | number | object) => any;
-    }, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+    }, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
         input: HTMLInputElement;
-    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+    }, HTMLDivElement, ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
@@ -188,10 +189,10 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
     }, Readonly<{
         modelValue?: object | string | number | null;
     } & {
-        readonly autoComplete?: import('@flux-ui/types').FluxAutoCompleteType;
+        readonly autoComplete?: FluxAutoCompleteType;
         readonly autoFocus?: boolean;
-        readonly iconLeading?: import('@flux-ui/types').FluxIconName;
-        readonly iconTrailing?: import('@flux-ui/types').FluxIconName;
+        readonly iconLeading?: FluxIconName;
+        readonly iconTrailing?: FluxIconName;
         readonly disabled?: boolean;
         readonly isCondensed?: boolean;
         readonly isReadonly?: boolean;
@@ -199,10 +200,10 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
         readonly max?: string | number;
         readonly maxLength?: number;
         readonly min?: string | number;
-        readonly pattern?: import('@flux-ui/types').FluxInputMask;
+        readonly pattern?: FluxInputMask;
         readonly placeholder?: string;
         readonly step?: number;
-        readonly type?: import('@flux-ui/types').FluxInputType;
+        readonly type?: FluxInputType;
     }> & Readonly<{
         onBlur?: () => any;
         onFocus?: () => any;
@@ -213,22 +214,22 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
         focus: () => void;
     }, {}, {}, {}, {}>;
     optionElements: ({
-        $: import('vue').ComponentInternalInstance;
+        $: ComponentInternalInstance;
         $data: {};
         $props: Partial<{}> & Omit<{
             readonly label?: string;
             readonly target?: string;
             readonly disabled?: boolean;
-            readonly to?: import('@flux-ui/types').FluxTo;
+            readonly to?: FluxTo;
             readonly tabindex?: string | number;
-            readonly type?: import('@flux-ui/types').FluxPressableType;
+            readonly type?: FluxPressableType;
             readonly isLoading?: boolean;
             readonly href?: string;
             readonly rel?: string;
-            readonly iconLeading?: import('@flux-ui/types').FluxIconName | null;
-            readonly iconTrailing?: import('@flux-ui/types').FluxIconName | null;
+            readonly iconLeading?: FluxIconName | null;
+            readonly iconTrailing?: FluxIconName | null;
             readonly command?: string;
-            readonly commandIcon?: import('@flux-ui/types').FluxIconName;
+            readonly commandIcon?: FluxIconName;
             readonly commandLoading?: boolean;
             readonly imageAlt?: string;
             readonly imageSrc?: string;
@@ -241,7 +242,7 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
             readonly onClick?: (args_0: MouseEvent) => any;
             readonly onMouseenter?: (args_0: MouseEvent) => any;
             readonly onMouseleave?: (args_0: MouseEvent) => any;
-        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>;
         $attrs: {
             [x: string]: unknown;
         };
@@ -249,16 +250,16 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
             [x: string]: unknown;
         };
         $slots: Readonly<{
-            [name: string]: import('vue').Slot<any>;
+            [name: string]: Slot<any>;
         }>;
         $root: ComponentPublicInstance | null;
         $parent: ComponentPublicInstance | null;
         $host: Element | null;
         $emit: ((event: "click", args_0: MouseEvent) => void) & ((event: "mouseenter", args_0: MouseEvent) => void) & ((event: "mouseleave", args_0: MouseEvent) => void);
         $el: any;
-        $options: import('vue').ComponentOptionsBase<Readonly<Omit<import('@flux-ui/types').FluxButtonProps, "size" | "isFilled" | "isSubmit"> & {
+        $options: ComponentOptionsBase<Readonly<Omit< FluxButtonProps, "size" | "isFilled" | "isSubmit"> & {
             readonly command?: string;
-            readonly commandIcon?: import('@flux-ui/types').FluxIconName;
+            readonly commandIcon?: FluxIconName;
             readonly commandLoading?: boolean;
             readonly imageAlt?: string;
             readonly imageSrc?: string;
@@ -272,11 +273,11 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
             onClick?: (args_0: MouseEvent) => any;
             onMouseenter?: (args_0: MouseEvent) => any;
             onMouseleave?: (args_0: MouseEvent) => any;
-        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
             click: (args_0: MouseEvent) => any;
             mouseenter: (args_0: MouseEvent) => any;
             mouseleave: (args_0: MouseEvent) => any;
-        }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+        }, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
             beforeMount?: (() => void) | (() => void)[];
@@ -289,16 +290,16 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
             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)[];
+            renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
             errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
         };
         $forceUpdate: () => void;
         $nextTick: typeof 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<{}> & Omit<Readonly<Omit<import('@flux-ui/types').FluxButtonProps, "size" | "isFilled" | "isSubmit"> & {
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends ((...args: any) => infer R) ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<Omit< FluxButtonProps, "size" | "isFilled" | "isSubmit"> & {
         readonly command?: string;
-        readonly commandIcon?: import('@flux-ui/types').FluxIconName;
+        readonly commandIcon?: FluxIconName;
         readonly commandLoading?: boolean;
         readonly imageAlt?: string;
         readonly imageSrc?: string;
@@ -312,7 +313,7 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
         onClick?: (args_0: MouseEvent) => any;
         onMouseenter?: (args_0: MouseEvent) => any;
         onMouseleave?: (args_0: MouseEvent) => any;
-    }>, never> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+    }>, never> & ShallowUnwrapRef<{}> & {} & ComponentCustomProperties & {} & {
         $slots: Readonly<{
             after(): any;
         }> & {

package/dist/component/primitive/SliderBase.vue.d.ts

@@ -1,3 +1,4 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     readonly disabled?: boolean;
     readonly isDragging?: boolean;
@@ -17,13 +18,13 @@ declare function __VLS_template(): {
     rootEl: HTMLDivElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     update: (args_0: number) => any;
     dragging: (args_0: boolean) => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
     onUpdate?: (args_0: number) => any;
     onDragging?: (args_0: boolean) => any;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
     root: HTMLDivElement;
 }, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

package/dist/component/primitive/SliderThumb.vue.d.ts

@@ -1,15 +1,16 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     readonly disabled?: boolean;
     readonly isDragging?: boolean;
     readonly position: number;
 };
-declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     decrement: () => any;
     grab: (args_0: PointerEvent) => any;
     increment: () => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
     onDecrement?: () => any;
     onGrab?: (args_0: PointerEvent) => any;
     onIncrement?: () => any;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;
 export default _default;

package/dist/component/primitive/SliderTrack.vue.d.ts

@@ -1,3 +1,4 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     readonly percentageLower: number;
     readonly percentageUpper: number;
@@ -11,7 +12,7 @@ declare function __VLS_template(): {
     rootEl: HTMLDivElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/component/primitive/VNodeRenderer.d.ts

@@ -1,8 +1,8 @@
-import { PropType, VNode } from 'vue';
-export declare const VNodeRenderer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+import { PropType, VNode, DefineComponent, ExtractPropTypes, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export declare const VNodeRenderer: DefineComponent<ExtractPropTypes<{
     vnode: PropType<VNode>;
-}>, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+}>, () => VNode< RendererNode, RendererElement, {
     [key: string]: any;
-}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
     vnode: PropType<VNode>;
-}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

package/dist/composable/private/useFormSelect.d.ts

@@ -1,7 +1,7 @@
-import { FluxFormSelectEntry, FluxFormSelectOption, FluxFormSelectOptions, FluxFormSelectValue } from '@flux-ui/types';
-import { Ref } from 'vue';
+import { FluxFormSelectEntry, FluxFormSelectOption, FluxFormSelectOptions, FluxFormSelectValue, FluxFormSelectValueSingle } from '@flux-ui/types';
+import { Ref, ComputedRef } from 'vue';
 export default function (modelValue: Ref<FluxFormSelectValue>, isMultiple: boolean, options: Ref<FluxFormSelectEntry[]>, searchQuery?: Ref<string>): {
-    groups: import('vue').ComputedRef<FluxFormSelectOptions[]>;
-    selected: import('vue').ComputedRef<FluxFormSelectOption[]>;
-    values: import('vue').ComputedRef<import('@flux-ui/types').FluxFormSelectValueSingle[]>;
+    groups: ComputedRef<FluxFormSelectOptions[]>;
+    selected: ComputedRef<FluxFormSelectOption[]>;
+    values: ComputedRef< FluxFormSelectValueSingle[]>;
 };

package/dist/composable/private/useLoaded.d.ts

@@ -1,4 +1,5 @@
+import { ComputedRef } from 'vue';
 export default function (): {
-    isLoading: import('vue').ComputedRef<boolean>;
+    isLoading: ComputedRef<boolean>;
     loaded: <T extends Function>(fn: T) => T;
 };

package/dist/composable/useDisabled.d.ts

@@ -1,2 +1,2 @@
-import { Ref } from 'vue';
-export default function (componentDisabled: Ref<boolean>): import('vue').ComputedRef<boolean>;
+import { Ref, ComputedRef } from 'vue';
+export default function (componentDisabled: Ref<boolean>): ComputedRef<boolean>;

package/dist/composable/useDisabledInjection.d.ts

@@ -1 +1,2 @@
-export default function (): import('vue').Ref<boolean, boolean>;
+import { Ref } from 'vue';
+export default function (): Ref<boolean, boolean>;

package/dist/composable/useExpandableGroupInjection.d.ts

@@ -1 +1,2 @@
-export default function (): import('../data').FluxExpandableGroupInjection;
+import { FluxExpandableGroupInjection } from '../data';
+export default function (): FluxExpandableGroupInjection;

package/dist/composable/useFilterInjection.d.ts

@@ -1 +1,2 @@
-export default function (): import('../data').FluxFilterInjection;
+import { FluxFilterInjection } from '../data';
+export default function (): FluxFilterInjection;

package/dist/composable/useFlyoutInjection.d.ts

@@ -1 +1,2 @@
-export default function (): import('../data').FluxFlyoutInjection;
+import { FluxFlyoutInjection } from '../data';
+export default function (): FluxFlyoutInjection;

package/dist/composable/useFormFieldInjection.d.ts

@@ -1 +1,2 @@
-export default function (): import('../data').FluxFormFieldInjection;
+import { FluxFormFieldInjection } from '../data';
+export default function (): FluxFormFieldInjection;

package/dist/composable/useTableInjection.d.ts

@@ -1 +1,2 @@
-export default function (): import('../data').FluxTableInjection;
+import { FluxTableInjection } from '../data';
+export default function (): FluxTableInjection;