@mantine-vue/core 2.4.0 → 3.1.0

package/lib/components/ComboboxPopover/ComboboxPopover.types.d.ts

@@ -1,2 +1,73 @@
-import type { Primitive } from '../../core';
+import type { VNodeChild } from 'vue';
+import type { MantineNode, Primitive, StylesApiProps } from '../../core';
+import type { ComboboxData, ComboboxItem, ComboboxLikeRenderOptionInput, ComboboxProps, ComboboxStylesNames, OptionsFilter } from '../Combobox';
 export type ComboboxPopoverValue<Multiple extends boolean, Value extends Primitive = string> = Multiple extends true ? Value[] : Value | null;
+export type ComboboxPopoverStylesNames = ComboboxStylesNames;
+export interface ComboboxPopoverProps<Multiple extends boolean = false, Value extends Primitive = string> extends StylesApiProps<ComboboxPopoverProps<Multiple, Value>> {
+    /** If set, multiple items can be selected at the same time */
+    multiple?: Multiple;
+    /** Controlled component value, bound with `v-model`. */
+    modelValue?: ComboboxPopoverValue<Multiple, Value>;
+    /** Uncontrolled component default value */
+    defaultValue?: ComboboxPopoverValue<Multiple, Value>;
+    /** Data used to generate options */
+    data?: ComboboxData<Value>;
+    /** Controlled dropdown opened state */
+    dropdownOpened?: boolean;
+    /** Uncontrolled dropdown initial opened state */
+    defaultDropdownOpened?: boolean;
+    /** Props passed down to Combobox component */
+    comboboxProps?: ComboboxProps;
+    /** Function based on which items are filtered and sorted */
+    filter?: OptionsFilter<Value>;
+    /** Maximum number of options displayed at a time @default Infinity */
+    limit?: number;
+    /** Determines whether the options should be wrapped with ScrollArea.AutoSize @default true */
+    withScrollArea?: boolean;
+    /** max-height of the dropdown @default 250 */
+    maxDropdownHeight?: number | string;
+    /** If set, the first option is selected when dropdown opens @default false */
+    selectFirstOptionOnDropdownOpen?: boolean;
+    /** Displays check icon near the selected option label @default true */
+    withCheckIcon?: boolean;
+    /** Aligns unchecked labels with the checked one @default false */
+    withAlignedLabels?: boolean;
+    /** Position of the check icon relative to the option label @default 'left' */
+    checkIconPosition?: 'left' | 'right';
+    /** Message displayed when no options match the search query or when there is no data. Can also be provided via the `#nothingFound` slot */
+    nothingFoundMessage?: MantineNode;
+    /** Allows searching through options @default false */
+    searchable?: boolean;
+    /** Controlled search value */
+    searchValue?: string;
+    /** Default search value */
+    defaultSearchValue?: string;
+    /** Allows deselecting the selected option by clicking it (only for single mode) @default true */
+    allowDeselect?: boolean;
+    /** A function to render content of the option, replaces the default content of the option. Can also be provided via the `#option` slot */
+    renderOption?: (item: ComboboxLikeRenderOptionInput<ComboboxItem>) => VNodeChild;
+    /** Props passed down to the underlying ScrollArea component in the dropdown */
+    scrollAreaProps?: Record<string, any>;
+    /** Props passed down to the hidden input */
+    hiddenInputProps?: Record<string, any>;
+    /** Hidden input name for form submission */
+    name?: string;
+    /** Hidden input form for form submission */
+    form?: string;
+    /** Divider used to separate values in the hidden input value attribute @default ',' */
+    hiddenInputValuesDivider?: string;
+    unstyled?: boolean;
+    [key: string]: any;
+}
+export interface ComboboxPopoverSlots {
+    /** Target element and any additional Combobox content */
+    default?: () => VNodeChild;
+    /** Custom option content, alternative to the `renderOption` prop */
+    option?: (input: ComboboxLikeRenderOptionInput<ComboboxItem>) => VNodeChild;
+    /** Exact-name alias for the `renderOption` prop */
+    renderOption?: (input: ComboboxLikeRenderOptionInput<ComboboxItem>) => VNodeChild;
+    /** Custom "nothing found" content, alternative to the `nothingFoundMessage` prop */
+    nothingFound?: () => VNodeChild;
+    /** Exact-name alias for the `nothingFoundMessage` prop */
+    nothingFoundMessage?: () => VNodeChild;
+}

package/lib/components/ComboboxPopover/ComboboxPopover.vue.d.ts

@@ -0,0 +1,25 @@
+import type { ComboboxPopoverSlots } from './ComboboxPopover.types';
+type __VLS_Slots = ComboboxPopoverSlots;
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: any) => any;
+    "update:modelValue": (value: any) => any;
+    "option-submit": (value: any) => any;
+    "dropdown-open": () => any;
+    "dropdown-close": () => any;
+    "search-change": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onChange?: ((value: any) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    "onOption-submit"?: ((value: any) => any) | undefined;
+    "onDropdown-open"?: (() => any) | undefined;
+    "onDropdown-close"?: (() => any) | undefined;
+    "onSearch-change"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/ComboboxPopover/ComboboxPopoverTarget.d.ts

@@ -7,6 +7,14 @@ export interface ComboboxPopoverTargetProps {
 export interface ComboboxPopoverTargetSlots {
     default?: () => VNodeChild;
 }
+/**
+ * Kept as a render function deliberately.
+ *
+ * The target clones the single child the consumer provides in order to inject the
+ * combobox ARIA attributes, keyboard handlers and a merged ref. A template cannot
+ * clone and re-prop an arbitrary child VNode, so this stays as-is – the same reason
+ * `HoverCard.Target`, `FocusTrap` and `Portal` keep theirs.
+ */
 export declare const ComboboxPopoverTarget: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     refProp: {
         type: StringConstructor;

package/lib/components/ComboboxPopover/render-popover-option.d.ts

@@ -0,0 +1,28 @@
+import { type VNodeChild } from 'vue';
+import type { Primitive } from '../../core';
+import type { ComboboxLikeRenderOptionInput, ComboboxParsedItem } from '../Combobox';
+/** Single mode compares by value, multiple mode by membership. */
+export declare function isValueChecked(value: Primitive | Primitive[] | undefined | null, optionValue: Primitive): boolean;
+export interface RenderOptionOptions {
+    /** Selected value, or values in multiple mode. */
+    value: Primitive | Primitive[] | null | undefined;
+    /** If set, a check icon is rendered next to the selected options. */
+    withCheckIcon: boolean | undefined;
+    /** If set, unselected options reserve the check icon's space so all labels line up. */
+    withAlignedLabels: boolean | undefined;
+    /** Side of the option the check icon is rendered on. */
+    checkIconPosition: 'left' | 'right' | undefined;
+    /** If set, all Mantine classes are removed. */
+    unstyled: boolean | undefined;
+    /** Custom markup for the option. */
+    renderOption?: (input: ComboboxLikeRenderOptionInput<any>) => VNodeChild;
+}
+/**
+ * Renders one parsed item of the searchable dropdown, recursing into groups.
+ *
+ * Kept as a plain function rather than a component: it walks an arbitrarily nested
+ * structure and has to be able to return either a group or an option. This mirrors
+ * `OptionsDropdown`'s `renderItem`, but is driven by an explicit options object rather
+ * than by props, because the searchable dropdown builds its options itself.
+ */
+export declare function renderPopoverOption(data: ComboboxParsedItem<Primitive>, opts: RenderOptionOptions, index: number): VNodeChild;

package/lib/components/Container/Container.d.ts

@@ -1,64 +1,8 @@
-import { type PropType } from 'vue';
-import { type MantineSize } from '../../core';
-export declare const Container: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    size: PropType<MantineSize | (string & {}) | number>;
-    fluid: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    strategy: {
-        type: PropType<"block" | "grid">;
-        default: undefined;
-    };
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    vars: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    unstyled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-    [key: string]: any;
-}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    size: PropType<MantineSize | (string & {}) | number>;
-    fluid: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    strategy: {
-        type: PropType<"block" | "grid">;
-        default: undefined;
-    };
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    vars: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    unstyled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>> & Readonly<{}>, {
-    classNames: Function | Record<string, any>;
-    styles: Function | Record<string, any>;
-    vars: Function | Record<string, any>;
-    unstyled: boolean;
-    fluid: boolean;
-    strategy: "block" | "grid";
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const Container: import("../..").MantineComponent<{
+    props: Omit<import("./Container.types").ContainerProps, "rootRef">;
+    ref: HTMLDivElement;
+    element: "div";
+    stylesNames: import("./Container.types").ContainerStylesNames;
+    vars: import("./Container.types").ContainerCssVariables;
+}>;
+export type { ContainerOwnProps, ContainerProps, ContainerFactory } from './Container.types';

package/lib/components/Container/Container.types.d.ts

@@ -0,0 +1,38 @@
+import type { BoxProps, MantineSize, StylesApiProps, Factory } from '../../core';
+/** Props declared by `Container` itself. See `ContainerProps` for the full public type. */
+export interface ContainerOwnProps extends StylesApiProps<ContainerFactory> {
+    /** Receives the root DOM node. */
+    rootRef?: VueRefTarget<Element>;
+    /**
+     * `max-width` of the container, value is not responsive – it is the same for all screen sizes. Numbers are converted to rem. Ignored when `fluid` prop is set.
+     *
+     * @default 'md'
+     */
+    size?: MantineSize | (string & {}) | number;
+    /**
+     * If set, the container takes 100% width of its parent and `size` prop is ignored.
+     *
+     * @default false
+     */
+    fluid?: boolean;
+    /**
+     * Centering strategy
+     *
+     * @default 'block'
+     */
+    strategy?: 'block' | 'grid';
+}
+export interface ContainerProps extends Omit<BoxProps, keyof ContainerOwnProps>, ContainerOwnProps {
+}
+export type ContainerStylesNames = 'root';
+export type ContainerCssVariables = {
+    root: '--container-size';
+};
+export type ContainerFactory = Factory<{
+    props: Omit<ContainerProps, 'rootRef'>;
+    ref: HTMLDivElement;
+    element: 'div';
+    stylesNames: ContainerStylesNames;
+    vars: ContainerCssVariables;
+}>;
+import type { VueRefTarget } from '@mantine-vue/hooks';

package/lib/components/Container/Container.vue.d.ts

@@ -0,0 +1,19 @@
+import type { ContainerOwnProps } from './Container.types';
+/** Module scope: created once, not per component instance. */
+declare const defaultProps: {
+    readonly strategy: "block";
+};
+declare const varsResolver: (theme: import("../..").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
+export { defaultProps, varsResolver };
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ContainerOwnProps, {
+    rootElement: import("vue").Ref<Element | null, Element | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ContainerOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/CopyButton/CopyButton.d.ts

@@ -1,23 +1,2 @@
-export declare const CopyButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    value: {
-        type: StringConstructor;
-        required: true;
-    };
-    timeout: {
-        type: NumberConstructor;
-        default: undefined;
-    };
-}>, () => import("vue").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<{
-    value: {
-        type: StringConstructor;
-        required: true;
-    };
-    timeout: {
-        type: NumberConstructor;
-        default: undefined;
-    };
-}>> & Readonly<{}>, {
-    timeout: number;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export { default as CopyButton } from './CopyButton.vue';
+export type { CopyButtonOwnProps, CopyButtonProps, CopyButtonSlotProps, CopyButtonSlots, } from './CopyButton.types';

package/lib/components/CopyButton/CopyButton.types.d.ts

@@ -0,0 +1,25 @@
+import type { VNodeChild } from 'vue';
+/** Props declared by `CopyButton` itself. See `CopyButtonProps` for the full public type. */
+export interface CopyButtonOwnProps {
+    /** Value that is copied to the clipboard when the button is clicked */
+    value: string;
+    /**
+     * Copied status timeout in ms
+     *
+     * @default 1000
+     */
+    timeout?: number;
+}
+export type CopyButtonProps = CopyButtonOwnProps;
+export interface CopyButtonSlotProps {
+    /** Copies the configured value to the clipboard. */
+    copy: () => void;
+    /** Whether the value was copied within the configured timeout. */
+    copied: boolean;
+    /** Fallthrough attributes passed to `CopyButton`. */
+    [key: string]: any;
+}
+export interface CopyButtonSlots {
+    /** Renderless component content. */
+    default?: (props: CopyButtonSlotProps) => VNodeChild;
+}

package/lib/components/CopyButton/CopyButton.vue.d.ts

@@ -0,0 +1,9 @@
+import type { CopyButtonOwnProps, CopyButtonSlots } from './CopyButton.types';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<CopyButtonOwnProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CopyButtonOwnProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, CopyButtonSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/DataList/DataList.d.ts

@@ -1,304 +1,17 @@
-import { type PropType, type SlotsType, type VNodeChild } from 'vue';
-import { type MantineSize, type MantineSpacing } from '../../core';
-export type DataListStylesNames = 'root' | 'item' | 'itemLabel' | 'itemValue';
-export type DataListCssVariables = {
-    root: '--data-list-fz' | '--data-list-lh' | '--data-list-gap' | '--data-list-label-width';
-};
-export interface DataListProps {
-    /** Controls `font-size` and `line-height` @default 'sm' */
-    size?: MantineSize | (string & {});
-    /** Key of `theme.spacing` or any valid CSS value to set gap between items @default 'sm' */
-    gap?: MantineSpacing;
-    /** Controls arrangement of label and value within each item. `horizontal` renders label and value side by side, `vertical` stacks label on top of value @default 'horizontal' */
-    orientation?: 'horizontal' | 'vertical';
-    /** Adds border between items @default false */
-    withDivider?: boolean;
-    /** Controls min-width of the label (dt) element, any valid CSS value @default '120px' */
-    labelWidth?: string | number;
-    classNames?: any;
-    styles?: any;
-    vars?: any;
-    unstyled?: boolean;
-    mod?: any;
-    [key: string]: any;
-}
-export interface DataListSlots {
-    default?: () => VNodeChild;
-}
-export declare const DataList: import("../..").WithBoxProps<{
-    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-        size: {
-            type: PropType<MantineSize | (string & {})>;
-            default: undefined;
-        };
-        gap: {
-            type: PropType<MantineSpacing>;
-            default: undefined;
-        };
-        orientation: {
-            type: PropType<"horizontal" | "vertical">;
-            default: undefined;
-        };
-        withDivider: {
-            type: BooleanConstructor;
-            default: undefined;
-        };
-        labelWidth: {
-            type: PropType<string | number>;
-            default: undefined;
-        };
-        mod: {
-            type: PropType<any>;
-            default: undefined;
-        };
-        classNames: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        styles: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        vars: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        unstyled: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-    }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-        [key: string]: any;
-    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
-        size: MantineSize | (string & {});
-        orientation: "vertical" | "horizontal";
-        classNames: Function | Record<string, any>;
-        styles: Function | Record<string, any>;
-        mod: any;
-        gap: MantineSpacing;
-        vars: Function | Record<string, any>;
-        unstyled: boolean;
-        withDivider: boolean;
-        labelWidth: string | number;
-    }, true, {}, SlotsType<DataListSlots>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import("vue").ExtractPropTypes<{
-        size: {
-            type: PropType<MantineSize | (string & {})>;
-            default: undefined;
-        };
-        gap: {
-            type: PropType<MantineSpacing>;
-            default: undefined;
-        };
-        orientation: {
-            type: PropType<"horizontal" | "vertical">;
-            default: undefined;
-        };
-        withDivider: {
-            type: BooleanConstructor;
-            default: undefined;
-        };
-        labelWidth: {
-            type: PropType<string | number>;
-            default: undefined;
-        };
-        mod: {
-            type: PropType<any>;
-            default: undefined;
-        };
-        classNames: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        styles: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        vars: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        unstyled: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-    }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-        [key: string]: any;
-    }>, {}, {}, {}, {
-        size: MantineSize | (string & {});
-        orientation: "vertical" | "horizontal";
-        classNames: Function | Record<string, any>;
-        styles: Function | Record<string, any>;
-        mod: any;
-        gap: MantineSpacing;
-        vars: Function | Record<string, any>;
-        unstyled: boolean;
-        withDivider: boolean;
-        labelWidth: string | number;
-    }>;
-    __isFragment?: never;
-    __isTeleport?: never;
-    __isSuspense?: never;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    size: {
-        type: PropType<MantineSize | (string & {})>;
-        default: undefined;
+import { DataListItem } from './DataListItem/DataListItem';
+import { DataListItemLabel } from './DataListItemLabel/DataListItemLabel';
+import { DataListItemValue } from './DataListItemValue/DataListItemValue';
+export declare const DataList: import("../..").MantineComponent<{
+    props: Omit<import("./DataList.types").DataListProps, "rootRef">;
+    ref: HTMLElement;
+    slots: import("./DataList.types").DataListSlots;
+    element: "dl";
+    stylesNames: import("./DataList.types").DataListStylesNames;
+    vars: import("./DataList.types").DataListCssVariables;
+    staticComponents: {
+        Item: typeof DataListItem;
+        ItemLabel: typeof DataListItemLabel;
+        ItemValue: typeof DataListItemValue;
     };
-    gap: {
-        type: PropType<MantineSpacing>;
-        default: undefined;
-    };
-    orientation: {
-        type: PropType<"horizontal" | "vertical">;
-        default: undefined;
-    };
-    withDivider: {
-        type: BooleanConstructor;
-        default: undefined;
-    };
-    labelWidth: {
-        type: PropType<string | number>;
-        default: undefined;
-    };
-    mod: {
-        type: PropType<any>;
-        default: undefined;
-    };
-    classNames: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    styles: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    vars: {
-        type: (ObjectConstructor | FunctionConstructor)[];
-        default: undefined;
-    };
-    unstyled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-    [key: string]: any;
-}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-    size: MantineSize | (string & {});
-    orientation: "vertical" | "horizontal";
-    classNames: Function | Record<string, any>;
-    styles: Function | Record<string, any>;
-    mod: any;
-    gap: MantineSpacing;
-    vars: Function | Record<string, any>;
-    unstyled: boolean;
-    withDivider: boolean;
-    labelWidth: string | number;
-}, {}, string, SlotsType<DataListSlots>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-    classes: Record<string, string>;
-    varsResolver: (theme: import("../..").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
-    Item: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-        classNames: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        styles: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        mod: {
-            type: PropType<any>;
-            default: undefined;
-        };
-    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-        [key: string]: any;
-    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-        classNames: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        styles: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        mod: {
-            type: PropType<any>;
-            default: undefined;
-        };
-    }>> & Readonly<{}>, {
-        classNames: Function | Record<string, any>;
-        styles: Function | Record<string, any>;
-        mod: any;
-    }, SlotsType<import(".").DataListItemSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
-    ItemLabel: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-        classNames: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        styles: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        mod: {
-            type: PropType<any>;
-            default: undefined;
-        };
-    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-        [key: string]: any;
-    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-        classNames: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        styles: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        mod: {
-            type: PropType<any>;
-            default: undefined;
-        };
-    }>> & Readonly<{}>, {
-        classNames: Function | Record<string, any>;
-        styles: Function | Record<string, any>;
-        mod: any;
-    }, SlotsType<import(".").DataListItemLabelSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
-    ItemValue: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-        classNames: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        styles: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        mod: {
-            type: PropType<any>;
-            default: undefined;
-        };
-    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-        [key: string]: any;
-    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-        classNames: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        styles: {
-            type: (ObjectConstructor | FunctionConstructor)[];
-            default: undefined;
-        };
-        mod: {
-            type: PropType<any>;
-            default: undefined;
-        };
-    }>> & Readonly<{}>, {
-        classNames: Function | Record<string, any>;
-        styles: Function | Record<string, any>;
-        mod: any;
-    }, SlotsType<import(".").DataListItemValueSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
 }>;
+export type { DataListCssVariables, DataListOwnProps, DataListProps, DataListSlots, DataListStylesNames, DataListFactory, } from './DataList.types';