@flux-ui/components 3.0.0-next.0 → 3.0.0-next.2

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

@@ -0,0 +1,257 @@
+import { FluxFormSelectOption, FluxFormSelectOptions } from '@flux-ui/types';
+import { ComponentPublicInstance, nextTick } from 'vue';
+type __VLS_Props = {
+    readonly disabled?: boolean;
+    readonly isLoading?: boolean;
+    readonly isMultiple?: boolean;
+    readonly isSearchable?: boolean;
+    readonly options: FluxFormSelectOptions[];
+    readonly placeholder?: string;
+    readonly selected: FluxFormSelectOption[];
+};
+type __VLS_PublicProps = {
+    'searchQuery'?: string;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+    search: (args_0: string) => any;
+    deselect: (args_0: string | number | null) => any;
+    select: (args_0: string | number | null) => 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;
+        $data: {};
+        $props: {
+            readonly tagName: keyof HTMLElementTagNameMap;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import('vue').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> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{
+        readonly tagName: keyof HTMLElementTagNameMap;
+    }> & Readonly<{}>, never> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: Readonly<{
+            default(): any;
+        }> & {
+            default(): any;
+        };
+    }) | null;
+    anchorPopup: ({
+        $: import('vue').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;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            popup: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            readonly anchor?: ComponentPublicInstance | HTMLElement | null;
+            readonly direction?: import('@flux-ui/types').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> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{
+        readonly anchor?: ComponentPublicInstance | HTMLElement | null;
+        readonly direction?: import('@flux-ui/types').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 & {} & {
+        $slots: Readonly<{
+            default(): any;
+        }> & {
+            default(): any;
+        };
+    }) | null;
+    searchInputElement: import('vue').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;
+        readonly max?: string | number;
+        readonly maxLength?: number;
+        readonly min?: string | number;
+        readonly pattern?: import('@flux-ui/types').FluxInputMask;
+        readonly placeholder?: string;
+        readonly step?: number;
+        readonly type?: import('@flux-ui/types').FluxInputType;
+    }> & Readonly<{
+        onBlur?: (() => any) | undefined;
+        onFocus?: (() => any) | undefined;
+        onShowPicker?: (() => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number | object | null) => any) | undefined;
+    }>, {
+        blur: () => void;
+        focus: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').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, {
+        input: HTMLInputElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        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;
+        readonly max?: string | number;
+        readonly maxLength?: number;
+        readonly min?: string | number;
+        readonly pattern?: import('@flux-ui/types').FluxInputMask;
+        readonly placeholder?: string;
+        readonly step?: number;
+        readonly type?: import('@flux-ui/types').FluxInputType;
+    }> & Readonly<{
+        onBlur?: (() => any) | undefined;
+        onFocus?: (() => any) | undefined;
+        onShowPicker?: (() => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number | object | null) => any) | undefined;
+    }>, {
+        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"> & {
+        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;
+    }>, {}, {}, {}, {}, {}> | null)[];
+}, any>;
+export default _default;
+//# sourceMappingURL=SelectBase.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SelectBase.vue.d.ts","sourceRoot":"","sources":["../../../src/component/primitive/SelectBase.vue"],"names":[],"mappings":"AAuVI,OAAO,KAAK,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAElF,OAAO,EAAE,uBAAuB,EAAY,QAAQ,EAA4C,MAAM,KAAK,CAAC;AAqC5G,KAAK,WAAW,GAAG;IACf,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,qBAAqB,EAAE,CAAC;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,EAAE,CAAC;CAC7C,CAAC;AA0KN,KAAK,iBAAiB,GAAG;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAsLA,GAAJ,8CAEV,GAAG,yBACA,GAAG,6DACW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAJN,GAAJ,8CAEV,GAAG,yBACA,GAAG,6DACW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuPtB,wBAQG"}

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

@@ -0,0 +1,36 @@
+type __VLS_Props = {
+    readonly disabled?: boolean;
+    readonly isDragging?: boolean;
+    readonly isTicksVisible?: boolean;
+    readonly max: number;
+    readonly min: number;
+    readonly step: number;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        root: HTMLDivElement;
+    };
+    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;
+    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, {
+    root: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=SliderBase.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SliderBase.vue.d.ts","sourceRoot":"","sources":["../../../src/component/primitive/SliderBase.vue"],"names":[],"mappings":"AAwGI,KAAK,WAAW,GAAG;IACf,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACzB,CAAC;AAoDN,iBAAS,cAAc;WA+CT,OAAO,IAA6B;;yBAXrB,GAAG;;;;;;EAgB/B;AAcD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;kBASnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAQpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

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

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    readonly disabled?: boolean;
+    readonly isDragging?: boolean;
+    readonly position: number;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    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>;
+export default _default;
+//# sourceMappingURL=SliderThumb.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SliderThumb.vue.d.ts","sourceRoot":"","sources":["../../../src/component/primitive/SliderThumb.vue"],"names":[],"mappings":"AA8EI,KAAK,WAAW,GAAG;IACf,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC;;;;;;;;;;AAsFN,wBAQG"}

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

@@ -0,0 +1,22 @@
+type __VLS_Props = {
+    readonly percentageLower: number;
+    readonly percentageUpper: number;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    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 _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=SliderTrack.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SliderTrack.vue.d.ts","sourceRoot":"","sources":["../../../src/component/primitive/SliderTrack.vue"],"names":[],"mappings":"AA0BI,KAAK,WAAW,GAAG;IACf,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CACpC,CAAC;AAKN,iBAAS,cAAc;WA8BT,OAAO,IAA6B;;yBAVrB,GAAG;;;;EAe/B;AASD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe,6SAOnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAQpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

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

@@ -0,0 +1,9 @@
+import { PropType, VNode } from 'vue';
+export declare const VNodeRenderer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    vnode: PropType<VNode>;
+}>, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    vnode: PropType<VNode>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=VNodeRenderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VNodeRenderer.d.ts","sourceRoot":"","sources":["../../../src/component/primitive/VNodeRenderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC;AAG3C,eAAO,MAAM,aAAa;WAED,QAAQ,CAAC,KAAK,CAAC;;;;WAAf,QAAQ,CAAC,KAAK,CAAC;iGAKtC,CAAC"}

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

@@ -0,0 +1,10 @@
+export { default as Anchor } from './Anchor.vue';
+export { default as AnchorPopup } from './AnchorPopup.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 { FilterMenuRenderer } from './FilterMenuRenderer';
+export { VNodeRenderer } from './VNodeRenderer';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/component/primitive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/composable/index.d.ts

@@ -0,0 +1,9 @@
+export { default as useBreakpoints } from './useBreakpoints';
+export { default as useDisabled } from './useDisabled';
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/composable/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AAEvD,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AACvF,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

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

@@ -0,0 +1,4 @@
+export { default as useFormSelect } from './useFormSelect';
+export { default as useLoaded } from './useLoaded';
+export { default as useTranslate } from './useTranslate';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/composable/private/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"useFormSelect.d.ts","sourceRoot":"","sources":["../../../src/composable/private/useFormSelect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC5H,OAAO,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAIzC,MAAM,CAAC,OAAO,WAAW,UAAU,EAAE,GAAG,CAAC,mBAAmB,CAAC,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,mBAAmB,EAAE,CAAC,EAAE,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC;;;;EA4DtJ"}

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

@@ -0,0 +1,5 @@
+export default function (): {
+    isLoading: import('vue').ComputedRef<boolean>;
+    loaded: <T extends Function>(fn: T) => T;
+};
+//# sourceMappingURL=useLoaded.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLoaded.d.ts","sourceRoot":"","sources":["../../../src/composable/private/useLoaded.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO;;aAKM,CAAC,SAAS,QAAQ,MAAM,CAAC,KAAG,CAAC;EAahD"}

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

@@ -0,0 +1,4 @@
+import { FluxTranslate } from '../../data';
+declare const _default: () => FluxTranslate;
+export default _default;
+//# sourceMappingURL=useTranslate.d.ts.map

package/dist/composable/private/useTranslate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslate.d.ts","sourceRoot":"","sources":["../../../src/composable/private/useTranslate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAmB,MAAM,YAAY,CAAC;;AAiBjE,wBAQE"}

package/dist/composable/useBreakpoints.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+export default function (): {
+    xl: Ref<boolean, boolean>;
+    xs: Ref<boolean, boolean>;
+    sm: Ref<boolean, boolean>;
+    md: Ref<boolean, boolean>;
+    lg: Ref<boolean, boolean>;
+    currentBreakpoint: Ref<"xl" | "xs" | "sm" | "md" | "lg" | null, "xl" | "xs" | "sm" | "md" | "lg" | null>;
+};
+//# sourceMappingURL=useBreakpoints.d.ts.map

package/dist/composable/useBreakpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBreakpoints.d.ts","sourceRoot":"","sources":["../../src/composable/useBreakpoints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAa/B,MAAM,CAAC,OAAO;;;;;;;EAwCb"}

package/dist/composable/useDisabled.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+export default function (componentDisabled: Ref<boolean>): import('vue').ComputedRef<boolean>;
+//# sourceMappingURL=useDisabled.d.ts.map

package/dist/composable/useDisabled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDisabled.d.ts","sourceRoot":"","sources":["../../src/composable/useDisabled.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAI/B,MAAM,CAAC,OAAO,WAAW,iBAAiB,EAAE,GAAG,CAAC,OAAO,CAAC,sCAIvD"}

package/dist/composable/useDisabledInjection.d.ts

@@ -0,0 +1,2 @@
+export default function (): import('vue').Ref<boolean, boolean>;
+//# sourceMappingURL=useDisabledInjection.d.ts.map

package/dist/composable/useDisabledInjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDisabledInjection.d.ts","sourceRoot":"","sources":["../../src/composable/useDisabledInjection.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,kDAEb"}

package/dist/composable/useExpandableGroupInjection.d.ts

@@ -0,0 +1,2 @@
+export default function (): import('../data').FluxExpandableGroupInjection;
+//# sourceMappingURL=useExpandableGroupInjection.d.ts.map

package/dist/composable/useExpandableGroupInjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExpandableGroupInjection.d.ts","sourceRoot":"","sources":["../../src/composable/useExpandableGroupInjection.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,gEAMb"}

package/dist/composable/useFilterInjection.d.ts

@@ -0,0 +1,2 @@
+export default function (): import('../data').FluxFilterInjection;
+//# sourceMappingURL=useFilterInjection.d.ts.map

package/dist/composable/useFilterInjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFilterInjection.d.ts","sourceRoot":"","sources":["../../src/composable/useFilterInjection.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,uDAkBb"}

package/dist/composable/useFlyoutInjection.d.ts

@@ -0,0 +1,6 @@
+export default function (): {
+    isClosing: import('vue').Ref<boolean, boolean>;
+    isOpen: import('vue').Ref<boolean, boolean>;
+    isOpening: import('vue').Ref<boolean, boolean>;
+};
+//# sourceMappingURL=useFlyoutInjection.d.ts.map

package/dist/composable/useFlyoutInjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFlyoutInjection.d.ts","sourceRoot":"","sources":["../../src/composable/useFlyoutInjection.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO;;;;EAMb"}

package/dist/composable/useFormFieldInjection.d.ts

@@ -0,0 +1,2 @@
+export default function (): import('../data').FluxFormFieldInjection;
+//# sourceMappingURL=useFormFieldInjection.d.ts.map

package/dist/composable/useFormFieldInjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormFieldInjection.d.ts","sourceRoot":"","sources":["../../src/composable/useFormFieldInjection.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,0DAIb"}

package/dist/composable/useTableInjection.d.ts

@@ -0,0 +1,7 @@
+export default function (): {
+    isBordered: boolean;
+    isHoverable: boolean;
+    isSeparated: boolean;
+    isStriped: boolean;
+};
+//# sourceMappingURL=useTableInjection.d.ts.map

package/dist/composable/useTableInjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTableInjection.d.ts","sourceRoot":"","sources":["../../src/composable/useTableInjection.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO;;;;;EAOb"}

package/dist/data/di.d.ts

@@ -0,0 +1,36 @@
+import { FluxFilterState, FluxFilterValue } from '@flux-ui/types';
+import { ComponentInternalInstance, InjectionKey, Ref } from 'vue';
+export declare const FluxDisabledInjectionKey: InjectionKey<Ref<boolean>>;
+export declare const FluxExpandableGroupInjectionKey: InjectionKey<FluxExpandableGroupInjection>;
+export declare const FluxFlyoutInjectionKey: InjectionKey<FluxFlyoutInjection>;
+export declare const FluxFilterInjectionKey: InjectionKey<FluxFilterInjection>;
+export declare const FluxFormFieldInjectionKey: InjectionKey<FluxFormFieldInjection>;
+export declare const FluxTableInjectionKey: InjectionKey<FluxTableInjection>;
+export type FluxExpandableGroupInjection = {
+    closeAll(): void;
+    register(uid: number, expandable: ComponentInternalInstance): void;
+    unregister(uid: number): void;
+};
+export type FluxFilterInjection = {
+    readonly state: Ref<FluxFilterState>;
+    back(): void;
+    reset(name: string | number): void;
+    getValue(name: string | number): FluxFilterValue | undefined;
+    hasValue(name: string | number): boolean;
+    setValue(name: string | number, value?: FluxFilterValue): void;
+};
+export type FluxFlyoutInjection = {
+    readonly isClosing: Ref<boolean>;
+    readonly isOpen: Ref<boolean>;
+    readonly isOpening: Ref<boolean>;
+};
+export type FluxFormFieldInjection = {
+    readonly id?: string;
+};
+export type FluxTableInjection = {
+    readonly isBordered: boolean;
+    readonly isHoverable: boolean;
+    readonly isSeparated: boolean;
+    readonly isStriped: boolean;
+};
+//# sourceMappingURL=di.d.ts.map

package/dist/data/di.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"di.d.ts","sourceRoot":"","sources":["../../src/data/di.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,KAAK,EAAE,yBAAyB,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAExE,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAY,CAAC;AAC7E,eAAO,MAAM,+BAA+B,EAAE,YAAY,CAAC,4BAA4B,CAAY,CAAC;AACpG,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,mBAAmB,CAAY,CAAC;AAClF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,mBAAmB,CAAY,CAAC;AAClF,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,sBAAsB,CAAY,CAAC;AACxF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,kBAAkB,CAAY,CAAC;AAEhF,MAAM,MAAM,4BAA4B,GAAG;IACvC,QAAQ,IAAI,IAAI,CAAC;IACjB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,yBAAyB,GAAG,IAAI,CAAC;IACnE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAC9B,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,eAAe,CAAC,CAAC;IAErC,IAAI,IAAI,IAAI,CAAC;IACb,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,eAAe,GAAG,SAAS,CAAC;IAC7D,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;CAClE,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAC9B,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACjC,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC7B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC/B,CAAC"}

package/dist/data/filter.d.ts

@@ -0,0 +1,4 @@
+import { FluxFilterOptionHeader, FluxFilterOptionItem } from '@flux-ui/types';
+export declare function isFluxFilterOptionHeader(obj: object): obj is FluxFilterOptionHeader;
+export declare function isFluxFilterOptionItem(obj: object): obj is FluxFilterOptionItem;
+//# sourceMappingURL=filter.d.ts.map

package/dist/data/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/data/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEnF,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,sBAAsB,CAEnF;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,oBAAoB,CAE/E"}

package/dist/data/helper.d.ts

@@ -0,0 +1,4 @@
+import { FluxFormSelectGroup, FluxFormSelectOption } from '@flux-ui/types';
+export declare function isFluxFormSelectGroup(item: unknown): item is FluxFormSelectGroup;
+export declare function isFluxFormSelectOption(item: unknown): item is FluxFormSelectOption;
+//# sourceMappingURL=helper.d.ts.map

package/dist/data/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../../src/data/helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEhF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,mBAAmB,CAEhF;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,oBAAoB,CAElF"}