@flux-ui/components 3.0.0-next.35 → 3.0.0-next.39

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

@@ -1,13 +1,13 @@
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     readonly floatingMode?: 'free' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
 };
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: Readonly<{
-        default(): any;
+        default(): VNode[];
     }> & {
-        default(): any;
+        default(): VNode[];
     };
     refs: {};
     rootEl: any;

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

@@ -1,10 +1,10 @@
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: Readonly<{
-        default(): any;
+        default(): VNode[];
     }> & {
-        default(): any;
+        default(): VNode[];
     };
     refs: {};
     rootEl: any;

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

@@ -1,4 +1,4 @@
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 declare function back(to?: string): void;
 declare function navigate(to: string): void;
 declare function __VLS_template(): {
@@ -11,7 +11,7 @@ declare function __VLS_template(): {
         default(props: {
             back(to?: string): void;
             navigate(to: string): void;
-        }): any;
+        }): VNode[];
     }> & {
         [key: string]: (props: {
             back(to?: string): void;
@@ -20,7 +20,7 @@ declare function __VLS_template(): {
         default(props: {
             back(to?: string): void;
             navigate(to: string): void;
-        }): any;
+        }): VNode[];
     };
     refs: {};
     rootEl: any;

package/dist/component/index.d.ts

@@ -2,9 +2,10 @@ export { default as FluxAction } from './FluxAction.vue';
 export { default as FluxActionBar } from './FluxActionBar.vue';
 export { default as FluxActionPane } from './FluxActionPane.vue';
 export { default as FluxActionStack } from './FluxActionStack.vue';
+export { default as FluxAdaptiveGroup } from './FluxAdaptiveGroup.vue';
+export { default as FluxAdaptiveSlot } from './FluxAdaptiveSlot.vue';
 export { default as FluxAnimatedColors } from './FluxAnimatedColors.vue';
 export { default as FluxAspectRatio } from './FluxAspectRatio.vue';
-export { default as FluxAutoGrid } from './FluxAutoGrid.vue';
 export { default as FluxAvatar } from './FluxAvatar.vue';
 export { default as FluxBadge } from './FluxBadge.vue';
 export { default as FluxBadgeStack } from './FluxBadgeStack.vue';
@@ -24,6 +25,7 @@ export { default as FluxCommandPaletteItem } from './FluxCommandPaletteItem.vue'
 export { default as FluxComment } from './FluxComment.vue';
 export { default as FluxColorPicker } from './FluxColorPicker.vue';
 export { default as FluxColorSelect } from './FluxColorSelect.vue';
+export { default as FluxColumn } from './FluxColumn.vue';
 export { default as FluxContainer } from './FluxContainer.vue';
 export { default as FluxDataTable } from './FluxDataTable.vue';
 export { default as FluxDatePicker } from './FluxDatePicker.vue';
@@ -84,9 +86,12 @@ export { default as FluxItemActions } from './FluxItemActions.vue';
 export { default as FluxItemContent } from './FluxItemContent.vue';
 export { default as FluxItemMedia } from './FluxItemMedia.vue';
 export { default as FluxItemStack } from './FluxItemStack.vue';
+export { default as FluxLayerPane } from './FluxLayerPane.vue';
+export { default as FluxLayerPaneSecondary } from './FluxLayerPaneSecondary.vue';
 export { default as FluxLegend } from './FluxLegend.vue';
 export { default as FluxLink } from './FluxLink.vue';
 export { default as FluxMenu } from './FluxMenu.vue';
+export { default as FluxMenuCollapsible } from './FluxMenuCollapsible.vue';
 export { default as FluxMenuGroup } from './FluxMenuGroup.vue';
 export { default as FluxMenuItem } from './FluxMenuItem.vue';
 export { default as FluxMenuOptions } from './FluxMenuOptions.vue';
@@ -101,7 +106,6 @@ export { default as FluxPagination } from './FluxPagination.vue';
 export { default as FluxPaginationBar } from './FluxPaginationBar.vue';
 export { default as FluxPane } from './FluxPane.vue';
 export { default as FluxPaneBody } from './FluxPaneBody.vue';
-export { default as FluxPaneDeck } from './FluxPaneDeck.vue';
 export { default as FluxPaneFooter } from './FluxPaneFooter.vue';
 export { default as FluxPaneGroup } from './FluxPaneGroup.vue';
 export { default as FluxPaneHeader } from './FluxPaneHeader.vue';
@@ -118,6 +122,7 @@ export { default as FluxPublishButton } from './FluxPublishButton.vue';
 export { default as FluxQuantitySelector } from './FluxQuantitySelector.vue';
 export { default as FluxRemove } from './FluxRemove.vue';
 export { default as FluxRoot } from './FluxRoot.vue';
+export { default as FluxRow } from './FluxRow.vue';
 export { default as FluxSecondaryButton } from './FluxSecondaryButton.vue';
 export { default as FluxSecondaryLinkButton } from './FluxSecondaryLinkButton.vue';
 export { default as FluxSegmentedControl } from './FluxSegmentedControl.vue';

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

@@ -1,13 +1,13 @@
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     readonly tagName: keyof HTMLElementTagNameMap;
 };
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: Readonly<{
-        default(): any;
+        default(): VNode[];
     }> & {
-        default(): any;
+        default(): VNode[];
     };
     refs: {};
     rootEl: any;

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

@@ -1,5 +1,5 @@
 import { FluxDirection } from '@flux-ui/types';
-import { ComponentPublicInstance, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { ComponentPublicInstance, VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     readonly anchor?: ComponentPublicInstance | HTMLElement | null;
     readonly direction?: FluxDirection;
@@ -10,9 +10,9 @@ type __VLS_Props = {
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: Readonly<{
-        default(): any;
+        default(): VNode[];
     }> & {
-        default(): any;
+        default(): VNode[];
     };
     refs: {
         popup: HTMLDivElement;

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

@@ -1,5 +1,6 @@
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
+    readonly ariaLabel?: string;
     readonly disabled?: boolean;
     readonly max?: number | [number, number];
     readonly min?: number | [number, number];

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

@@ -0,0 +1,28 @@
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { FluxIconName } from '@flux-ui/types';
+type __VLS_Props = {
+    readonly icon?: FluxIconName;
+    readonly message?: string;
+    readonly title: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?(): VNode[];
+        footer(): VNode[];
+    }> & {
+        default?(): VNode[];
+        footer(): VNode[];
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+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 _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -11,10 +11,10 @@ type __VLS_PublicProps = {
     'searchQuery'?: string;
 } & __VLS_Props;
 declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
-    select: (args_0: FluxFilterValueSingle) => any;
+    select: (args_0: any) => any;
     "update:searchQuery": (value: string) => any;
 }, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    onSelect?: (args_0: FluxFilterValueSingle) => any;
+    onSelect?: (args_0: any) => any;
     "onUpdate:searchQuery"?: (value: string) => any;
 }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

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

@@ -1,5 +1,5 @@
-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 { 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;
@@ -36,9 +36,7 @@ declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, Compo
         $props: {
             readonly tagName: keyof HTMLElementTagNameMap;
         } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
-        $attrs: {
-            [x: string]: unknown;
-        };
+        $attrs: Attrs;
         $refs: {
             [x: string]: unknown;
         };
@@ -74,11 +72,11 @@ declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, Compo
         $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> & ShallowUnwrapRef<{}> & {} & ComponentCustomProperties & {} & {
+    }> & Readonly<{}>, never> & {} & ComponentCustomProperties & {} & {
         $slots: Readonly<{
-            default(): any;
+            default(): VNode[];
         }> & {
-            default(): any;
+            default(): VNode[];
         };
     };
     anchorPopup: {
@@ -91,9 +89,7 @@ declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, Compo
             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: {
-            [x: string]: unknown;
-        };
+        $attrs: Attrs;
         $refs: {
             [x: string]: unknown;
         } & {
@@ -139,30 +135,23 @@ declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, Compo
         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> & ShallowUnwrapRef<{}> & {} & ComponentCustomProperties & {} & {
+    }> & Readonly<{}>, never> & {} & ComponentCustomProperties & {} & {
         $slots: Readonly<{
-            default(): any;
+            default(): VNode[];
         }> & {
-            default(): any;
+            default(): VNode[];
         };
     };
     searchInputElement: CreateComponentPublicInstanceWithMixins<Readonly<{
         modelValue?: object | string | number | null;
-    } & {
+    } & FluxFormInputBaseProps & {
         readonly autoComplete?: FluxAutoCompleteType;
-        readonly autoFocus?: boolean;
         readonly iconLeading?: FluxIconName;
         readonly iconTrailing?: FluxIconName;
-        readonly disabled?: boolean;
-        readonly isCondensed?: boolean;
-        readonly isLoading?: boolean;
-        readonly isReadonly?: boolean;
-        readonly isSecondary?: boolean;
         readonly max?: string | number;
         readonly maxLength?: number;
         readonly min?: string | number;
         readonly pattern?: FluxInputMask;
-        readonly placeholder?: string;
         readonly step?: number;
         readonly type?: FluxInputType;
     }> & Readonly<{
@@ -189,21 +178,14 @@ declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, Compo
         Defaults: {};
     }, Readonly<{
         modelValue?: object | string | number | null;
-    } & {
+    } & FluxFormInputBaseProps & {
         readonly autoComplete?: FluxAutoCompleteType;
-        readonly autoFocus?: boolean;
         readonly iconLeading?: FluxIconName;
         readonly iconTrailing?: FluxIconName;
-        readonly disabled?: boolean;
-        readonly isCondensed?: boolean;
-        readonly isLoading?: boolean;
-        readonly isReadonly?: boolean;
-        readonly isSecondary?: boolean;
         readonly max?: string | number;
         readonly maxLength?: number;
         readonly min?: string | number;
         readonly pattern?: FluxInputMask;
-        readonly placeholder?: string;
         readonly step?: number;
         readonly type?: FluxInputType;
     }> & Readonly<{
@@ -220,11 +202,11 @@ declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, Compo
         $data: {};
         $props: Partial<{}> & Omit<{
             readonly label?: string;
+            readonly isLoading?: boolean;
             readonly disabled?: boolean;
             readonly to?: FluxTo;
             readonly tabindex?: string | number;
             readonly type?: FluxPressableType;
-            readonly isLoading?: boolean;
             readonly href?: string;
             readonly rel?: string;
             readonly target?: string;
@@ -245,9 +227,7 @@ declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, Compo
             readonly onMouseenter?: (args_0: MouseEvent) => any;
             readonly onMouseleave?: (args_0: MouseEvent) => any;
         } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>;
-        $attrs: {
-            [x: string]: unknown;
-        };
+        $attrs: Attrs;
         $refs: {
             [x: string]: unknown;
         };
@@ -315,11 +295,13 @@ declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, Compo
         onClick?: (args_0: MouseEvent) => any;
         onMouseenter?: (args_0: MouseEvent) => any;
         onMouseleave?: (args_0: MouseEvent) => any;
-    }>, never> & ShallowUnwrapRef<{}> & {} & ComponentCustomProperties & {} & {
+    }>, never> & {} & ComponentCustomProperties & {} & {
         $slots: Readonly<{
-            after(): any;
+            after(): VNode[];
+            before(): VNode[];
         }> & {
-            after(): any;
+            after(): VNode[];
+            before(): VNode[];
         };
     })[];
 }, any>;

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

@@ -1,5 +1,9 @@
 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;

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/index.d.ts

@@ -1,5 +1,6 @@
 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';
@@ -7,5 +8,6 @@ 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';

package/dist/composable/index.d.ts

@@ -1,5 +1,6 @@
 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';

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 useTranslate } from './useTranslate';
+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 {};

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

@@ -0,0 +1,10 @@
+import { ModelRef, Ref } from 'vue';
+type FlyoutLike = {
+    close(): void;
+};
+type UseDateFlyoutOptions<T> = {
+    compareKey?(value: T | null): string | number | null | undefined;
+    transformIn?(value: T | null): T | null;
+};
+export default function <T>(modelValue: ModelRef<T | null>, flyoutRef: Readonly<Ref<FlyoutLike | null>>, options?: UseDateFlyoutOptions<T>): Ref<T | null>;
+export {};

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

@@ -0,0 +1,27 @@
+import { ComponentPublicInstance, Ref } from 'vue';
+export type UseDropdownPopupOptions = {
+    readonly anchorRef: Readonly<Ref<ComponentPublicInstance | null | undefined>>;
+    readonly popupRef: Readonly<Ref<ComponentPublicInstance | null | undefined>>;
+    readonly focusElement: Readonly<Ref<HTMLElement | null | undefined>>;
+    readonly disabled?: Readonly<Ref<boolean>>;
+    readonly readonly?: Readonly<Ref<boolean>>;
+    readonly onOpen?: () => void;
+    readonly onClose?: () => void;
+};
+export type UseDropdownPopupReturn = {
+    readonly isOpen: Ref<boolean>;
+    readonly open: () => void;
+    readonly close: () => void;
+    readonly toggle: () => void;
+    readonly focusAnchor: () => void;
+    readonly onKeyDownBase: (evt: KeyboardEvent) => boolean;
+};
+/**
+ * Shared dropdown-popup infrastructure for select-like components. Manages:
+ * - open/close state
+ * - click-outside (close when clicking outside popup + anchor)
+ * - focus-back-to-anchor on close
+ * - focus-the-inner-focus-element on open
+ * - Escape/Tab keyboard handling
+ */
+export default function useDropdownPopup(options: UseDropdownPopupOptions): UseDropdownPopupReturn;

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

@@ -0,0 +1,12 @@
+import { FluxFilterValue, FluxFilterValueSingle } from '@flux-ui/types';
+import { ComputedRef } from 'vue';
+export type FilterOptionSingle = {
+    readonly currentValue: ComputedRef<FluxFilterValueSingle>;
+    onSelect(value: FluxFilterValue): void;
+};
+export type FilterOptionMulti = {
+    readonly currentValue: ComputedRef<FluxFilterValueSingle[]>;
+    onSelect(value: FluxFilterValueSingle): void;
+};
+export declare function useFilterOptionSingle(name: string): FilterOptionSingle;
+export declare function useFilterOptionMulti(name: string): FilterOptionMulti;

package/dist/composable/useAdaptiveGroupInjection.d.ts

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

package/dist/data/di.d.ts

@@ -1,5 +1,6 @@
 import { FluxFilterState, FluxFilterValue } from '@flux-ui/types';
 import { ComponentInternalInstance, InjectionKey, Ref } from 'vue';
+export declare const FluxAdaptiveGroupInjectionKey: InjectionKey<FluxAdaptiveGroupInjection>;
 export declare const FluxDisabledInjectionKey: InjectionKey<Ref<boolean>>;
 export declare const FluxExpandableGroupInjectionKey: InjectionKey<FluxExpandableGroupInjection>;
 export declare const FluxFlyoutInjectionKey: InjectionKey<FluxFlyoutInjection>;
@@ -7,6 +8,16 @@ export declare const FluxFilterInjectionKey: InjectionKey<FluxFilterInjection>;
 export declare const FluxFormFieldInjectionKey: InjectionKey<FluxFormFieldInjection>;
 export declare const FluxTableInjectionKey: InjectionKey<FluxTableInjection>;
 export declare const FluxTooltipInjectionKey: InjectionKey<FluxTooltipInjection>;
+export type FluxAdaptiveGroupChild = {
+    readonly priority: Ref<number>;
+    readonly desiredDefaultWidth: Ref<number>;
+    readonly desiredFallbackWidth: Ref<number>;
+    readonly isDefaultVisible: Ref<boolean>;
+};
+export type FluxAdaptiveGroupInjection = {
+    register(uid: number, child: FluxAdaptiveGroupChild): void;
+    unregister(uid: number): void;
+};
 export type FluxExpandableGroupInjection = {
     closeAll(): void;
     register(uid: number, expandable: ComponentInternalInstance): void;

package/dist/data/filter.d.ts

@@ -1,20 +1,7 @@
-import { FluxFilterBase, FluxFilterDateEntry, FluxFilterDateRangeEntry, FluxFilterOptionEntry, FluxFilterOptionHeader, FluxFilterOptionItem, FluxFilterOptionsEntry, FluxFilterRangeEntry } from '@flux-ui/types';
-declare function parseDate(base: FluxFilterBase): FluxFilterDateEntry;
-declare function parseDateRange(base: FluxFilterBase): FluxFilterDateRangeEntry;
-declare function parseOption(base: FluxFilterBase): FluxFilterOptionEntry;
-declare function parseOptionAsync(base: FluxFilterBase): FluxFilterOptionEntry;
-declare function parseOptions(base: FluxFilterBase): FluxFilterOptionsEntry;
-declare function parseOptionsAsync(base: FluxFilterBase): FluxFilterOptionsEntry;
-declare function parseRange(base: FluxFilterBase): FluxFilterRangeEntry;
-export declare const filterParsers: {
-    readonly date: typeof parseDate;
-    readonly dateRange: typeof parseDateRange;
-    readonly option: typeof parseOption;
-    readonly optionAsync: typeof parseOptionAsync;
-    readonly options: typeof parseOptions;
-    readonly optionsAsync: typeof parseOptionsAsync;
-    readonly range: typeof parseRange;
+import { FluxFilterEntryMap, FluxFilterOptionHeader, FluxFilterOptionItem, FluxFilterSpecMap } from '@flux-ui/types';
+export type FluxFilterParsers = {
+    [K in keyof FluxFilterSpecMap]: (spec: FluxFilterSpecMap[K]) => FluxFilterEntryMap[K];
 };
+export declare const filterParsers: FluxFilterParsers;
 export declare function isFluxFilterOptionHeader(obj: object): obj is FluxFilterOptionHeader;
 export declare function isFluxFilterOptionItem(obj: object): obj is FluxFilterOptionItem;
-export {};

package/dist/data/i18n.d.ts

@@ -3,9 +3,11 @@ export type FluxTranslation = keyof typeof english;
 export declare const english: {
     readonly 'flux.back': "Back";
     readonly 'flux.cancel': "Cancel";
+    readonly 'flux.close': "Close";
     readonly 'flux.comingSoon': "Coming soon";
     readonly 'flux.continue': "Continue";
     readonly 'flux.customPeriod': "Custom period";
+    readonly 'flux.delete': "Delete";
     readonly 'flux.filter': "Filter";
     readonly 'flux.filterReset': "Reset filters";
     readonly 'flux.justNow': "Just now";
@@ -31,6 +33,21 @@ export declare const english: {
     readonly 'flux.sortDescending': "Descending";
     readonly 'flux.sortRemove': "Remove sorting";
     readonly 'flux.today': "Today";
+    readonly 'flux.selectMonth': "Select month";
+    readonly 'flux.selectYear': "Select year";
+    readonly 'flux.previousMonth': "Previous month";
+    readonly 'flux.nextMonth': "Next month";
+    readonly 'flux.previousYears': "Previous years";
+    readonly 'flux.nextYears': "Next years";
+    readonly 'flux.goToPage': "Go to page {page}";
+    readonly 'flux.pinDigit': "Digit {index} of {total}";
+    readonly 'flux.dropFilesOrClick': "Drop files here or click to upload";
+    readonly 'flux.colorSaturationBrightness': "Color saturation and brightness";
+    readonly 'flux.customColor': "Custom color";
+    readonly 'flux.hue': "Hue";
+    readonly 'flux.opacity': "Opacity";
+    readonly 'flux.lowerBound': "Lower bound";
+    readonly 'flux.upperBound': "Upper bound";
     readonly 'flux.galleryPlaceholderButton': "Pick image";
     readonly 'flux.galleryPlaceholderMessage': "Drop an image here or click the button to upload...";
     readonly 'flux.galleryPlaceholderTitle': "Gallery";

package/dist/data/timeZones.d.ts

@@ -0,0 +1,3 @@
+import { FluxTranslation } from './i18n';
+export declare const TIME_ZONES: readonly string[];
+export declare const TIME_ZONE_GROUP_ORDER: readonly FluxTranslation[];