@flux-ui/components 3.0.0-next.4 → 3.0.0-next.41

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, FluxFormInputBaseProps, FluxAutoCompleteType, FluxIconName, FluxInputMask, FluxInputType, FluxTo, FluxPressableType, FluxButtonProps } from '@flux-ui/types';
+import { ComponentPublicInstance, nextTick, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions, ComponentInternalInstance, VNodeProps, AllowedComponentProps, ComponentCustomProps, Attrs, Slot, ComponentOptionsBase, GlobalComponents, GlobalDirectives, DebuggerEvent, WatchOptions, WatchStopHandle, ComponentCustomProperties, VNode, CreateComponentPublicInstanceWithMixins } from 'vue';
+import { OnCleanup } from '@vue/reactivity';
 type __VLS_Props = {
     readonly disabled?: boolean;
     readonly isLoading?: boolean;
@@ -12,46 +13,44 @@ 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;
     search: (args_0: string) => any;
-    deselect: (args_0: string | number | null) => any;
-    select: (args_0: string | number | null) => any;
+    select: (args_0: string | number) => any;
     open: () => any;
     "update:searchQuery": (value: string) => any;
     keyDown: (args_0: KeyboardEvent) => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    onClose?: (() => any) | undefined;
-    onSearch?: ((args_0: string) => any) | undefined;
-    onDeselect?: ((args_0: string | number | null) => any) | undefined;
-    onSelect?: ((args_0: string | number | null) => any) | undefined;
-    onOpen?: (() => any) | undefined;
-    "onUpdate:searchQuery"?: ((value: string) => any) | undefined;
-    onKeyDown?: ((args_0: KeyboardEvent) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
-    anchor: ({
-        $: import('vue').ComponentInternalInstance;
+    deselect: (args_0: string | number) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClose?: () => any;
+    onSearch?: (args_0: string) => any;
+    onSelect?: (args_0: string | number) => any;
+    onOpen?: () => any;
+    "onUpdate:searchQuery"?: (value: string) => any;
+    onKeyDown?: (args_0: KeyboardEvent) => any;
+    onDeselect?: (args_0: string | number) => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    anchor: {
+        $: ComponentInternalInstance;
         $data: {};
         $props: {
             readonly tagName: keyof HTMLElementTagNameMap;
-        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
-        $attrs: {
-            [x: string]: unknown;
-        };
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+        $attrs: Attrs;
         $refs: {
             [x: string]: unknown;
         };
         $slots: Readonly<{
-            [name: string]: import('vue').Slot<any> | undefined;
+            [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,55 +63,53 @@ 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> & {} & ComponentCustomProperties & {} & {
         $slots: Readonly<{
-            default(): any;
+            default(): VNode[];
         }> & {
-            default(): any;
+            default(): VNode[];
         };
-    }) | null;
-    anchorPopup: ({
-        $: import('vue').ComponentInternalInstance;
+    };
+    anchorPopup: {
+        $: ComponentInternalInstance;
         $data: {};
-        $props: {
-            readonly anchor?: (ComponentPublicInstance | HTMLElement | null) | undefined;
-            readonly direction?: import('@flux-ui/types').FluxDirection | undefined;
-            readonly margin?: number | undefined;
-            readonly position?: "top" | "top-left" | "top-right" | "left" | "left-top" | "left-bottom" | "right" | "right-top" | "right-bottom" | "bottom" | "bottom-left" | "bottom-right" | undefined;
-            readonly useAnchorWidth?: boolean | undefined;
-        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
-        $attrs: {
-            [x: string]: unknown;
-        };
+        $props: Partial<{}> & Omit<{
+            readonly anchor?: ComponentPublicInstance | HTMLElement | null;
+            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;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>;
+        $attrs: Attrs;
         $refs: {
             [x: string]: unknown;
         } & {
             popup: HTMLDivElement;
         };
         $slots: Readonly<{
-            [name: string]: import('vue').Slot<any> | undefined;
+            [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,59 +122,54 @@ 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> & {} & ComponentCustomProperties & {} & {
         $slots: Readonly<{
-            default(): any;
+            default(): VNode[];
         }> & {
-            default(): any;
+            default(): VNode[];
         };
-    }) | null;
-    searchInputElement: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+    };
+    searchInputElement: CreateComponentPublicInstanceWithMixins<Readonly<{
         modelValue?: object | string | number | null;
-    } & {
-        readonly autoComplete?: import('@flux-ui/types').FluxAutoCompleteType;
-        readonly autoFocus?: boolean;
-        readonly iconLeading?: import('@flux-ui/types').FluxIconName;
-        readonly iconTrailing?: import('@flux-ui/types').FluxIconName;
-        readonly disabled?: boolean;
-        readonly isReadonly?: boolean;
-        readonly isSecondary?: boolean;
+    } & FluxFormInputBaseProps & {
+        readonly autoComplete?: FluxAutoCompleteType;
+        readonly iconLeading?: FluxIconName;
+        readonly iconTrailing?: FluxIconName;
         readonly max?: string | number;
         readonly maxLength?: number;
         readonly min?: string | number;
-        readonly pattern?: import('@flux-ui/types').FluxInputMask;
-        readonly placeholder?: string;
+        readonly pattern?: FluxInputMask;
         readonly step?: number;
-        readonly type?: import('@flux-ui/types').FluxInputType;
+        readonly type?: FluxInputType;
     }> & Readonly<{
-        onBlur?: (() => any) | undefined;
-        onFocus?: (() => any) | undefined;
-        onShowPicker?: (() => any) | undefined;
-        "onUpdate:modelValue"?: ((value: string | number | object | null) => any) | undefined;
+        onBlur?: () => any;
+        onFocus?: () => any;
+        onShowPicker?: () => any;
+        "onUpdate:modelValue"?: (value: string | number | object) => any;
     }>, {
         blur: () => void;
         focus: () => void;
-    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
         blur: () => any;
         focus: () => any;
         showPicker: () => any;
-        "update:modelValue": (value: string | number | object | null) => any;
-    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        "update:modelValue": (value: string | number | object) => any;
+    }, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
         input: HTMLInputElement;
-    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+    }, HTMLDivElement, ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
@@ -186,60 +178,112 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
         Defaults: {};
     }, Readonly<{
         modelValue?: object | string | number | null;
-    } & {
-        readonly autoComplete?: import('@flux-ui/types').FluxAutoCompleteType;
-        readonly autoFocus?: boolean;
-        readonly iconLeading?: import('@flux-ui/types').FluxIconName;
-        readonly iconTrailing?: import('@flux-ui/types').FluxIconName;
-        readonly disabled?: boolean;
-        readonly isReadonly?: boolean;
-        readonly isSecondary?: boolean;
+    } & FluxFormInputBaseProps & {
+        readonly autoComplete?: FluxAutoCompleteType;
+        readonly iconLeading?: FluxIconName;
+        readonly iconTrailing?: FluxIconName;
         readonly max?: string | number;
         readonly maxLength?: number;
         readonly min?: string | number;
-        readonly pattern?: import('@flux-ui/types').FluxInputMask;
-        readonly placeholder?: string;
+        readonly pattern?: FluxInputMask;
         readonly step?: number;
-        readonly type?: import('@flux-ui/types').FluxInputType;
+        readonly type?: FluxInputType;
     }> & Readonly<{
-        onBlur?: (() => any) | undefined;
-        onFocus?: (() => any) | undefined;
-        onShowPicker?: (() => any) | undefined;
-        "onUpdate:modelValue"?: ((value: string | number | object | null) => any) | undefined;
+        onBlur?: () => any;
+        onFocus?: () => any;
+        onShowPicker?: () => any;
+        "onUpdate:modelValue"?: (value: string | number | object) => any;
     }>, {
         blur: () => void;
         focus: () => void;
-    }, {}, {}, {}, {}> | null;
-    optionElements: (import('vue').CreateComponentPublicInstanceWithMixins<Readonly<Omit<import('@flux-ui/types').FluxButtonProps, "size" | "isFilled" | "isSubmit"> & {
-        readonly command?: string;
-        readonly commandIcon?: import('@flux-ui/types').FluxIconName;
-        readonly commandLoading?: boolean;
-        readonly imageSrc?: string;
-        readonly isActive?: boolean;
-        readonly isDestructive?: boolean;
-        readonly isHighlighted?: boolean;
-        readonly isIndented?: boolean;
-        readonly isSelectable?: boolean;
-        readonly isSelected?: boolean;
-    }> & Readonly<{
-        onClick?: ((args_0: MouseEvent) => any) | undefined;
-        onMouseenter?: ((args_0: MouseEvent) => any) | undefined;
-        onMouseleave?: ((args_0: MouseEvent) => any) | undefined;
-    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-        click: (args_0: MouseEvent) => any;
-        mouseenter: (args_0: MouseEvent) => any;
-        mouseleave: (args_0: MouseEvent) => any;
-    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<Omit<import('@flux-ui/types').FluxButtonProps, "size" | "isFilled" | "isSubmit"> & {
+    }, {}, {}, {}, {}>;
+    optionElements: ({
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{
+            readonly label?: string;
+            readonly isLoading?: boolean;
+            readonly disabled?: boolean;
+            readonly to?: FluxTo;
+            readonly tabindex?: string | number;
+            readonly type?: FluxPressableType;
+            readonly href?: string;
+            readonly rel?: string;
+            readonly target?: string;
+            readonly iconLeading?: FluxIconName | null;
+            readonly iconTrailing?: FluxIconName | null;
+            readonly command?: string;
+            readonly commandIcon?: FluxIconName;
+            readonly commandLoading?: boolean;
+            readonly imageAlt?: string;
+            readonly imageSrc?: string;
+            readonly isActive?: boolean;
+            readonly isDestructive?: boolean;
+            readonly isHighlighted?: boolean;
+            readonly isIndented?: boolean;
+            readonly isSelectable?: boolean;
+            readonly isSelected?: boolean;
+            readonly onClick?: (args_0: MouseEvent) => any;
+            readonly onMouseenter?: (args_0: MouseEvent) => any;
+            readonly onMouseleave?: (args_0: MouseEvent) => any;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>;
+        $attrs: Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [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: ComponentOptionsBase<Readonly<Omit< FluxButtonProps, "size" | "isFilled" | "isSubmit"> & {
+            readonly command?: string;
+            readonly commandIcon?: FluxIconName;
+            readonly commandLoading?: boolean;
+            readonly imageAlt?: string;
+            readonly imageSrc?: string;
+            readonly isActive?: boolean;
+            readonly isDestructive?: boolean;
+            readonly isHighlighted?: boolean;
+            readonly isIndented?: boolean;
+            readonly isSelectable?: boolean;
+            readonly isSelected?: boolean;
+        }> & Readonly<{
+            onClick?: (args_0: MouseEvent) => any;
+            onMouseenter?: (args_0: MouseEvent) => any;
+            onMouseleave?: (args_0: MouseEvent) => any;
+        }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            click: (args_0: MouseEvent) => any;
+            mouseenter: (args_0: MouseEvent) => any;
+            mouseleave: (args_0: MouseEvent) => any;
+        }, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, 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: 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, 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;
         readonly isActive?: boolean;
         readonly isDestructive?: boolean;
@@ -248,10 +292,17 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
         readonly isSelectable?: boolean;
         readonly isSelected?: boolean;
     }> & Readonly<{
-        onClick?: ((args_0: MouseEvent) => any) | undefined;
-        onMouseenter?: ((args_0: MouseEvent) => any) | undefined;
-        onMouseleave?: ((args_0: MouseEvent) => any) | undefined;
-    }>, {}, {}, {}, {}, {}> | null)[];
+        onClick?: (args_0: MouseEvent) => any;
+        onMouseenter?: (args_0: MouseEvent) => any;
+        onMouseleave?: (args_0: MouseEvent) => any;
+    }>, never> & {} & ComponentCustomProperties & {} & {
+        $slots: Readonly<{
+            after(): VNode[];
+            before(): VNode[];
+        }> & {
+            after(): VNode[];
+            before(): VNode[];
+        };
+    })[];
 }, any>;
 export default _default;
-//# sourceMappingURL=SelectBase.vue.d.ts.map

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, {
-    update: (args_0: number) => any;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     dragging: (args_0: boolean) => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onUpdate?: ((args_0: number) => any) | undefined;
-    onDragging?: ((args_0: boolean) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    update: (args_0: number) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDragging?: (args_0: boolean) => any;
+    onUpdate?: (args_0: number) => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
     root: HTMLDivElement;
 }, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
@@ -33,4 +34,3 @@ type __VLS_WithTemplateSlots<T, S> = T & {
         $slots: S;
     };
 };
-//# sourceMappingURL=SliderBase.vue.d.ts.map

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

@@ -1,16 +1,20 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
+    readonly ariaLabel?: string;
+    readonly ariaValuemax?: number;
+    readonly ariaValuemin?: number;
+    readonly ariaValuenow?: number;
     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<{
-    onDecrement?: (() => any) | undefined;
-    onGrab?: ((args_0: PointerEvent) => any) | undefined;
-    onIncrement?: (() => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDecrement?: () => any;
+    onGrab?: (args_0: PointerEvent) => any;
+    onIncrement?: () => any;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;
 export default _default;
-//# sourceMappingURL=SliderThumb.vue.d.ts.map

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 & {
@@ -19,4 +20,3 @@ type __VLS_WithTemplateSlots<T, S> = T & {
         $slots: S;
     };
 };
-//# sourceMappingURL=SliderTrack.vue.d.ts.map

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

@@ -0,0 +1,30 @@
+import { FluxColor } from '@flux-ui/types';
+import { TreeBaseOption, TreeFlatNode } from '../../composable/private';
+import { VNodeProps, AllowedComponentProps, ComponentCustomProps, PublicProps, ShallowUnwrapRef, VNode } from 'vue';
+declare const _default: <TOption extends TreeBaseOption>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onExpandClick?: (args_0: MouseEvent) => any;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onExpandClick"> & {
+        readonly node: TreeFlatNode<TOption>;
+        readonly expanded: boolean;
+        readonly levelColors?: (FluxColor | string)[];
+    } & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        trailing?(props: {
+            node: TreeFlatNode<TOption>;
+        }): any;
+    }> & {
+        trailing?(props: {
+            node: TreeFlatNode<TOption>;
+        }): any;
+    };
+    emit: (evt: "expandClick", args_0: MouseEvent) => void;
+}>) => VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -1,9 +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;
-}> | undefined, {}, {}, {}, 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>;
-//# sourceMappingURL=VNodeRenderer.d.ts.map
+}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

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

@@ -1,10 +1,13 @@
 export { default as Anchor } from './Anchor.vue';
 export { default as AnchorPopup } from './AnchorPopup.vue';
+export { default as DialogLayout } from './DialogLayout.vue';
+export { default as FilterBadge } from './FilterBadge.vue';
+export { default as FilterItem } from './FilterItem.vue';
 export { default as FilterOptionBase } from './FilterOptionBase.vue';
 export { default as SelectBase } from './SelectBase.vue';
 export { default as SliderBase } from './SliderBase.vue';
 export { default as SliderThumb } from './SliderThumb.vue';
 export { default as SliderTrack } from './SliderTrack.vue';
+export { default as TreeNodeRenderer } from './TreeNodeRenderer.vue';
 export { FilterMenuRenderer } from './FilterMenuRenderer';
 export { VNodeRenderer } from './VNodeRenderer';
-//# sourceMappingURL=index.d.ts.map

package/dist/composable/index.d.ts

@@ -1,9 +1,10 @@
 export { default as useBreakpoints } from './useBreakpoints';
 export { default as useDisabled } from './useDisabled';
+export { default as useAdaptiveGroupInjection } from './useAdaptiveGroupInjection';
 export { default as useDisabledInjection } from './useDisabledInjection';
 export { default as useExpandableGroupInjection } from './useExpandableGroupInjection';
 export { default as useFilterInjection } from './useFilterInjection';
 export { default as useFlyoutInjection } from './useFlyoutInjection';
 export { default as useFormFieldInjection } from './useFormFieldInjection';
 export { default as useTableInjection } from './useTableInjection';
-//# sourceMappingURL=index.d.ts.map
+export { default as useTooltipInjection } from './useTooltipInjection';

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

@@ -1,4 +1,12 @@
+export { default as useAsyncFilterOptions } from './useAsyncFilterOptions';
+export { default as useDateFlyout } from './useDateFlyout';
+export { default as useDropdownPopup } from './useDropdownPopup';
+export type { UseDropdownPopupOptions, UseDropdownPopupReturn } from './useDropdownPopup';
 export { default as useFormSelect } from './useFormSelect';
-export { default as useLoaded } from './useLoaded';
 export { default as useTranslate } from './useTranslate';
-//# sourceMappingURL=index.d.ts.map
+export { useCommandPalette } from './useCommandPalette';
+export type { CommandPaletteGroup, CommandPaletteResultItem } from './useCommandPalette';
+export { useFilterOptionMulti, useFilterOptionSingle } from './useFilterOption';
+export type { FilterOptionMulti, FilterOptionSingle } from './useFilterOption';
+export { flattenAll, flattenVisible, getLevelColor, INITIAL_HIGHLIGHTED_INDEX, useTreeView } from './useTreeView';
+export type { TreeBaseOption, TreeFlatNode } from './useTreeView';

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

@@ -0,0 +1,14 @@
+import { FluxFilterOptionRow, FluxFilterValue } from '@flux-ui/types';
+import { ComputedRef, ModelRef } from 'vue';
+type UseAsyncFilterOptionsParams = {
+    readonly currentValueIds: ComputedRef<FluxFilterValue[]>;
+    readonly modelSearch: ModelRef<string, string, string, string>;
+    fetchOptions(ids: FluxFilterValue[]): Promise<FluxFilterOptionRow[]>;
+    fetchRelevant(): Promise<FluxFilterOptionRow[]>;
+    fetchSearch(searchQuery: string): Promise<FluxFilterOptionRow[]>;
+};
+export default function ({ currentValueIds, modelSearch, fetchOptions: fetchOptionsProp, fetchRelevant: fetchRelevantProp, fetchSearch: fetchSearchProp }: UseAsyncFilterOptionsParams): {
+    isLoading: ComputedRef<boolean>;
+    options: ComputedRef<FluxFilterOptionRow[]>;
+};
+export {};