@flux-ui/components 3.0.0-next.61 → 3.0.0-next.64

package/dist/component/FluxActionStack.vue.d.ts

@@ -1,5 +1,5 @@
 import { VNode, ComponentInternalInstance, VNodeProps, AllowedComponentProps, ComponentCustomProps, Attrs, Slot, ComponentPublicInstance, ComponentOptionsBase, ComponentOptionsMixin, GlobalComponents, GlobalDirectives, ComponentProvideOptions, DebuggerEvent, nextTick, WatchOptions, WatchStopHandle, ComponentCustomProperties, DefineComponent, PublicProps } from 'vue';
-import { FluxDirection } from '@flux-ui/types';
+import { FluxAlign, FluxDirection, FluxJustify, FluxFlexWrap } from '@flux-ui/types';
 import { OnCleanup } from '@vue/reactivity';
 declare function __VLS_template(): {
     attrs: Partial<{}>;
@@ -13,12 +13,13 @@ declare function __VLS_template(): {
             $: ComponentInternalInstance;
             $data: {};
             $props: Partial<{}> & Omit<{
+                readonly align?: FluxAlign;
                 readonly direction?: FluxDirection;
                 readonly gap?: number;
-                readonly isCentered?: boolean;
-                readonly isFill?: boolean;
-                readonly isWrapping?: boolean;
+                readonly isInline?: boolean;
+                readonly justify?: FluxJustify;
                 readonly tag?: keyof HTMLElementTagNameMap;
+                readonly wrap?: FluxFlexWrap;
             } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>;
             $attrs: Attrs;
             $refs: {
@@ -33,12 +34,13 @@ declare function __VLS_template(): {
             $emit: (event: string, ...args: any[]) => void;
             $el: any;
             $options: ComponentOptionsBase<Readonly<{
+                readonly align?: FluxAlign;
                 readonly direction?: FluxDirection;
                 readonly gap?: number;
-                readonly isCentered?: boolean;
-                readonly isFill?: boolean;
-                readonly isWrapping?: boolean;
+                readonly isInline?: boolean;
+                readonly justify?: FluxJustify;
                 readonly tag?: keyof HTMLElementTagNameMap;
+                readonly wrap?: FluxFlexWrap;
             }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
                 beforeCreate?: (() => void) | (() => void)[];
                 created?: (() => void) | (() => void)[];
@@ -60,12 +62,13 @@ declare function __VLS_template(): {
             $nextTick: 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<{
+            readonly align?: FluxAlign;
             readonly direction?: FluxDirection;
             readonly gap?: number;
-            readonly isCentered?: boolean;
-            readonly isFill?: boolean;
-            readonly isWrapping?: boolean;
+            readonly isInline?: boolean;
+            readonly justify?: FluxJustify;
             readonly tag?: keyof HTMLElementTagNameMap;
+            readonly wrap?: FluxFlexWrap;
         }> & Readonly<{}>, never> & {} & ComponentCustomProperties & {} & {
             $slots: Readonly<{
                 default(): VNode[];
@@ -82,12 +85,13 @@ declare const __VLS_component: DefineComponent<{}, {}, {}, {}, {}, ComponentOpti
         $: ComponentInternalInstance;
         $data: {};
         $props: Partial<{}> & Omit<{
+            readonly align?: FluxAlign;
             readonly direction?: FluxDirection;
             readonly gap?: number;
-            readonly isCentered?: boolean;
-            readonly isFill?: boolean;
-            readonly isWrapping?: boolean;
+            readonly isInline?: boolean;
+            readonly justify?: FluxJustify;
             readonly tag?: keyof HTMLElementTagNameMap;
+            readonly wrap?: FluxFlexWrap;
         } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>;
         $attrs: Attrs;
         $refs: {
@@ -102,12 +106,13 @@ declare const __VLS_component: DefineComponent<{}, {}, {}, {}, {}, ComponentOpti
         $emit: (event: string, ...args: any[]) => void;
         $el: any;
         $options: ComponentOptionsBase<Readonly<{
+            readonly align?: FluxAlign;
             readonly direction?: FluxDirection;
             readonly gap?: number;
-            readonly isCentered?: boolean;
-            readonly isFill?: boolean;
-            readonly isWrapping?: boolean;
+            readonly isInline?: boolean;
+            readonly justify?: FluxJustify;
             readonly tag?: keyof HTMLElementTagNameMap;
+            readonly wrap?: FluxFlexWrap;
         }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
@@ -129,12 +134,13 @@ declare const __VLS_component: DefineComponent<{}, {}, {}, {}, {}, ComponentOpti
         $nextTick: 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<{
+        readonly align?: FluxAlign;
         readonly direction?: FluxDirection;
         readonly gap?: number;
-        readonly isCentered?: boolean;
-        readonly isFill?: boolean;
-        readonly isWrapping?: boolean;
+        readonly isInline?: boolean;
+        readonly justify?: FluxJustify;
         readonly tag?: keyof HTMLElementTagNameMap;
+        readonly wrap?: FluxFlexWrap;
     }> & Readonly<{}>, never> & {} & ComponentCustomProperties & {} & {
         $slots: Readonly<{
             default(): VNode[];

package/dist/component/FluxAspectRatio.vue.d.ts

@@ -1,6 +1,7 @@
 import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
-    aspectRatio: number;
+    readonly aspectRatio: number;
+    readonly tag?: keyof HTMLElementTagNameMap;
 };
 declare function __VLS_template(): {
     attrs: Partial<{}>;
@@ -10,10 +11,10 @@ declare function __VLS_template(): {
         default(): VNode[];
     };
     refs: {};
-    rootEl: HTMLDivElement;
+    rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/component/FluxBorderShine.vue.d.ts

@@ -44,9 +44,9 @@ declare const _default: DefineComponent<ExtractPropTypes<{
         type: NumberConstructor;
     };
 }>> & Readonly<{}>, {
-    offset: number;
     duration: number;
     width: number;
+    offset: number;
     colors: string[];
     radius: string | number;
 }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

package/dist/component/FluxCalendar.vue.d.ts

@@ -16,9 +16,7 @@ declare function __VLS_template(): {
     }> & {
         default?(): VNode[];
     };
-    refs: {
-        root: HTMLDivElement;
-    };
+    refs: {};
     rootEl: HTMLDivElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
@@ -78,9 +76,7 @@ declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, Comp
     onKeyboardCancel?: (args_0: {
         id: string | number;
     }) => any;
-}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
-    root: HTMLDivElement;
-}, HTMLDivElement>;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/component/FluxContainer.vue.d.ts

@@ -1,6 +1,7 @@
 import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     readonly gutter?: number;
+    readonly tag?: keyof HTMLElementTagNameMap;
 };
 declare function __VLS_template(): {
     attrs: Partial<{}>;
@@ -10,10 +11,10 @@ declare function __VLS_template(): {
         default(): VNode[];
     };
     refs: {};
-    rootEl: HTMLDivElement;
+    rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/component/FluxFilter.vue.d.ts

@@ -1,11 +1,8 @@
-import { FluxFilterState } from '@flux-ui/types';
+import { FluxFilterState, FluxFilterValue } from '@flux-ui/types';
 import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-type __VLS_Props = {
-    readonly resettable?: string[];
-};
 type __VLS_PublicProps = {
     modelValue: FluxFilterState;
-} & __VLS_Props;
+};
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: Readonly<{
@@ -18,11 +15,13 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    clear: (args_0: string) => any;
     reset: (args_0: string) => any;
-    "update:modelValue": (value: FluxFilterState) => any;
+    "update:modelValue": (value: Record<string, FluxFilterValue>) => any;
 }, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClear?: (args_0: string) => any;
     onReset?: (args_0: string) => any;
-    "onUpdate:modelValue"?: (value: FluxFilterState) => any;
+    "onUpdate:modelValue"?: (value: Record<string, FluxFilterValue>) => any;
 }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/component/FluxFilterBar.vue.d.ts

@@ -1,8 +1,7 @@
-import { FluxFilterState } from '@flux-ui/types';
+import { FluxFilterState, FluxFilterValue } from '@flux-ui/types';
 import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     readonly isSearchable?: boolean;
-    readonly resettable?: string[];
     readonly searchPlaceholder?: string;
 };
 type __VLS_PublicProps = {
@@ -21,12 +20,14 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    clear: (args_0: string) => any;
     reset: (args_0: string) => any;
-    "update:modelValue": (value: FluxFilterState) => any;
+    "update:modelValue": (value: Record<string, FluxFilterValue>) => any;
     "update:search": (value: string) => any;
 }, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClear?: (args_0: string) => any;
     onReset?: (args_0: string) => any;
-    "onUpdate:modelValue"?: (value: FluxFilterState) => any;
+    "onUpdate:modelValue"?: (value: Record<string, FluxFilterValue>) => any;
     "onUpdate:search"?: (value: string) => any;
 }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

package/dist/component/FluxFilterBase.vue.d.ts

@@ -1,25 +1,26 @@
-import { FluxFilterItem, FluxFilterState } from '@flux-ui/types';
+import { FluxFilterDefinition, FluxFilterState, FluxFilterValue } from '@flux-ui/types';
 import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-type __VLS_Props = {
-    readonly resettable?: string[];
-};
 type __VLS_PublicProps = {
     modelValue: FluxFilterState;
-} & __VLS_Props;
+};
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: Readonly<{
         default(props: {
-            readonly buttons: Record<string, FluxFilterItem>;
+            readonly buttons: Record<string, FluxFilterDefinition>;
             readonly filters: Record<string, VNode>;
-            readonly menuItems: (FluxFilterItem | VNode)[][];
+            readonly menuItems: (FluxFilterDefinition | VNode)[][];
+            clear(name: string): void;
+            reset(name: string): void;
         }): VNode[];
         filters(): VNode[];
     }> & {
         default(props: {
-            readonly buttons: Record<string, FluxFilterItem>;
+            readonly buttons: Record<string, FluxFilterDefinition>;
             readonly filters: Record<string, VNode>;
-            readonly menuItems: (FluxFilterItem | VNode)[][];
+            readonly menuItems: (FluxFilterDefinition | VNode)[][];
+            clear(name: string): void;
+            reset(name: string): void;
         }): VNode[];
         filters(): VNode[];
     };
@@ -28,13 +29,15 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    clear: (args_0: string) => any;
     reset: (args_0: string) => any;
     back: () => any;
-    "update:modelValue": (value: FluxFilterState) => any;
+    "update:modelValue": (value: Record<string, FluxFilterValue>) => any;
 }, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClear?: (args_0: string) => any;
     onReset?: (args_0: string) => any;
     onBack?: () => any;
-    "onUpdate:modelValue"?: (value: FluxFilterState) => any;
+    "onUpdate:modelValue"?: (value: Record<string, FluxFilterValue>) => any;
 }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/component/FluxFilterDate.vue.d.ts

@@ -1,12 +1,9 @@
-import { FluxIconName } from '@flux-ui/types';
+import { FluxFilterDateSpec } from '@flux-ui/types';
 import { DateTime } from 'luxon';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-type __VLS_Props = {
-    readonly icon?: FluxIconName;
-    readonly label: string;
+type Props = FluxFilterDateSpec & {
     readonly max?: DateTime;
     readonly min?: DateTime;
-    readonly name: string;
 };
-declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: DefineComponent<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/dist/component/FluxFilterDateRange.vue.d.ts

@@ -1,13 +1,10 @@
-import { FluxIconName } from '@flux-ui/types';
+import { FluxFilterDateRangeSpec } from '@flux-ui/types';
 import { DateTime } from 'luxon';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-type __VLS_Props = {
-    readonly icon?: FluxIconName;
-    readonly label: string;
+type Props = FluxFilterDateRangeSpec & {
     readonly max?: DateTime;
     readonly min?: DateTime;
-    readonly name: string;
     readonly rangeMode?: 'range' | 'week' | 'month';
 };
-declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: DefineComponent<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/dist/component/FluxFilterOption.vue.d.ts

@@ -1,13 +1,10 @@
-import { FluxFilterOptionRow, FluxIconName } from '@flux-ui/types';
+import { FluxFilterOptionSpec } from '@flux-ui/types';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-type __VLS_Props = {
-    readonly icon?: FluxIconName;
+type Props = FluxFilterOptionSpec & {
     readonly isSearchable?: boolean;
-    readonly label: string;
-    readonly name: string;
-    readonly options: FluxFilterOptionRow[];
     readonly searchPlaceholder?: string;
 };
+type __VLS_Props = Props;
 type __VLS_PublicProps = {
     'searchQuery'?: string;
 } & __VLS_Props;

package/dist/component/FluxFilterOptionAsync.vue.d.ts

@@ -1,14 +1,11 @@
-import { FluxFilterOptionRow, FluxFilterValue, FluxIconName } from '@flux-ui/types';
+import { FluxFilterOptionAsyncSpec, FluxFilterOptionRow } from '@flux-ui/types';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-type __VLS_Props = {
-    fetchOptions(ids: FluxFilterValue[]): Promise<FluxFilterOptionRow[]>;
+type Props = FluxFilterOptionAsyncSpec & {
     fetchRelevant(): Promise<FluxFilterOptionRow[]>;
     fetchSearch(searchQuery: string): Promise<FluxFilterOptionRow[]>;
-    readonly icon?: FluxIconName;
-    readonly label: string;
-    readonly name: string;
     readonly searchPlaceholder?: string;
 };
+type __VLS_Props = Props;
 type __VLS_PublicProps = {
     'searchQuery'?: string;
 } & __VLS_Props;

package/dist/component/FluxFilterOptions.vue.d.ts

@@ -1,13 +1,10 @@
-import { FluxFilterOptionRow, FluxIconName } from '@flux-ui/types';
+import { FluxFilterOptionsSpec } from '@flux-ui/types';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-type __VLS_Props = {
-    readonly icon?: FluxIconName;
+type Props = FluxFilterOptionsSpec & {
     readonly isSearchable?: boolean;
-    readonly label: string;
-    readonly name: string;
-    readonly options: FluxFilterOptionRow[];
     readonly searchPlaceholder?: string;
 };
+type __VLS_Props = Props;
 type __VLS_PublicProps = {
     'searchQuery'?: string;
 } & __VLS_Props;

package/dist/component/FluxFilterOptionsAsync.vue.d.ts

@@ -1,14 +1,11 @@
-import { FluxFilterOptionRow, FluxFilterValue, FluxIconName } from '@flux-ui/types';
+import { FluxFilterOptionRow, FluxFilterOptionsAsyncSpec } from '@flux-ui/types';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-type __VLS_Props = {
-    fetchOptions(ids: FluxFilterValue[]): Promise<FluxFilterOptionRow[]>;
+type Props = FluxFilterOptionsAsyncSpec & {
     fetchRelevant(): Promise<FluxFilterOptionRow[]>;
     fetchSearch(searchQuery: string): Promise<FluxFilterOptionRow[]>;
-    readonly icon?: FluxIconName;
-    readonly label: string;
-    readonly name: string;
     readonly searchPlaceholder?: string;
 };
+type __VLS_Props = Props;
 type __VLS_PublicProps = {
     'searchQuery'?: string;
 } & __VLS_Props;

package/dist/component/FluxFilterRange.vue.d.ts

@@ -1,14 +1,10 @@
-import { FluxIconName } from '@flux-ui/types';
+import { FluxFilterRangeSpec } from '@flux-ui/types';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-type __VLS_Props = {
-    readonly icon?: FluxIconName;
+type Props = FluxFilterRangeSpec & {
     readonly isTicksVisible?: boolean;
-    readonly label: string;
-    readonly name: string;
     readonly max: number;
     readonly min: number;
     readonly step?: number;
-    readonly formatter?: (value: number) => string;
 };
-declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: DefineComponent<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/dist/component/FluxFilterWindow.vue.d.ts

@@ -1,10 +1,9 @@
-import { FluxFilterItem } from '@flux-ui/types';
+import { FluxFilterDefinition } from '@flux-ui/types';
 import { VNode, ComponentInternalInstance, VNodeProps, AllowedComponentProps, ComponentCustomProps, Attrs, Slot, ComponentPublicInstance, ComponentOptionsBase, ComponentOptionsMixin, GlobalComponents, GlobalDirectives, ComponentProvideOptions, DebuggerEvent, nextTick, WatchOptions, WatchStopHandle, ComponentCustomProperties, DefineComponent, PublicProps } from 'vue';
 import { OnCleanup } from '@vue/reactivity';
 type __VLS_Props = {
     readonly filters: Record<string, VNode>;
-    readonly menuItems: (FluxFilterItem | VNode)[][];
-    readonly resettable?: string[];
+    readonly menuItems: (FluxFilterDefinition | VNode)[][];
 };
 declare function __VLS_template(): {
     attrs: Partial<{}>;
@@ -81,11 +80,7 @@ declare function __VLS_template(): {
     rootEl: HTMLDivElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
-    reset: (args_0: string) => any;
-}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onReset?: (args_0: string) => any;
-}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
     window: {
         $: ComponentInternalInstance;
         $data: {};

package/dist/component/FluxFlex.vue.d.ts

@@ -0,0 +1,30 @@
+import { FluxAlign, FluxDirection, FluxFlexWrap, FluxJustify } from '@flux-ui/types';
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    readonly align?: FluxAlign;
+    readonly direction?: FluxDirection;
+    readonly gap?: number;
+    readonly isInline?: boolean;
+    readonly justify?: FluxJustify;
+    readonly tag?: keyof HTMLElementTagNameMap;
+    readonly wrap?: FluxFlexWrap;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(): VNode[];
+    }> & {
+        default(): VNode[];
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, 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/component/{FluxRow.vue.d.ts → FluxFlexItem.vue.d.ts}

@@ -1,6 +1,8 @@
 import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
-    readonly gap?: number;
+    readonly basis?: number | string;
+    readonly grow?: number;
+    readonly shrink?: number;
 };
 declare function __VLS_template(): {
     attrs: Partial<{}>;
@@ -10,10 +12,10 @@ declare function __VLS_template(): {
         default(): VNode[];
     };
     refs: {};
-    rootEl: HTMLDivElement;
+    rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/component/FluxGrid.vue.d.ts

@@ -2,6 +2,7 @@ import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentPr
 type __VLS_Props = {
     readonly columns?: number;
     readonly gap?: number;
+    readonly tag?: keyof HTMLElementTagNameMap;
 };
 declare function __VLS_template(): {
     attrs: Partial<{}>;
@@ -11,10 +12,10 @@ declare function __VLS_template(): {
         default(): VNode[];
     };
     refs: {};
-    rootEl: HTMLDivElement;
+    rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/component/FluxGridColumn.vue.d.ts

@@ -5,6 +5,7 @@ type __VLS_Props = {
     readonly md?: number;
     readonly lg?: number;
     readonly xl?: number;
+    readonly tag?: keyof HTMLElementTagNameMap;
 };
 declare function __VLS_template(): {
     attrs: Partial<{}>;
@@ -14,10 +15,10 @@ declare function __VLS_template(): {
         default(): VNode[];
     };
     refs: {};
-    rootEl: HTMLDivElement;
+    rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/component/FluxKanbanColumn.vue.d.ts

@@ -1,7 +1,10 @@
+import { FluxIconName } from '@flux-ui/types';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     readonly columnId: string | number;
+    readonly count: string | number;
     readonly disabled?: boolean;
+    readonly icon?: FluxIconName;
     readonly label: string;
 };
 declare function __VLS_template(): {

package/dist/component/FluxScroller.vue.d.ts

@@ -0,0 +1,32 @@
+import { FluxAlignment, FluxDirection } from '@flux-ui/types';
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    readonly direction?: FluxDirection | 'both';
+    readonly hasFade?: boolean;
+    readonly snap?: 'mandatory' | 'proximity';
+    readonly snapAlign?: FluxAlignment;
+    readonly tag?: keyof HTMLElementTagNameMap;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(): VNode[];
+    }> & {
+        default(): VNode[];
+    };
+    refs: {
+        element: unknown;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
+    element: unknown;
+}, 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/component/{FluxStack.vue.d.ts → FluxSplitView.vue.d.ts}

@@ -2,10 +2,7 @@ import { FluxDirection } from '@flux-ui/types';
 import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     readonly direction?: FluxDirection;
-    readonly gap?: number;
-    readonly isCentered?: boolean;
-    readonly isFill?: boolean;
-    readonly isWrapping?: boolean;
+    readonly rememberKey?: string;
     readonly tag?: keyof HTMLElementTagNameMap;
 };
 declare function __VLS_template(): {
@@ -15,11 +12,15 @@ declare function __VLS_template(): {
     }> & {
         default(): VNode[];
     };
-    refs: {};
+    refs: {
+        container: unknown;
+    };
     rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
+    container: unknown;
+}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/component/{FluxColumn.vue.d.ts → FluxSplitViewPane.vue.d.ts}

@@ -1,6 +1,9 @@
 import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
-    readonly gap?: number;
+    readonly defaultSize?: number | string;
+    readonly minSize?: number;
+    readonly maxSize?: number;
+    readonly isResizable?: boolean;
 };
 declare function __VLS_template(): {
     attrs: Partial<{}>;