import * as vue from 'vue';
import { PropType } from 'vue';

type SelectItemKey = boolean | string | (string | number)[] | ((item: Record<string, any>, fallback?: any) => any);

interface InternalItem<T = any> {
    title: string;
    value: any;
    props: {
        [key: string]: any;
        title: string;
        value: any;
    };
    children?: InternalItem<T>[];
    raw: T;
}

/**
 * - match without highlight
 * - single match (index), length already known
 * - single match (start, end)
 * - multiple matches (start, end), probably shouldn't overlap
 */
type FilterMatch = boolean | number | [number, number] | [number, number][];
type FilterFunction = (value: string, query: string, item?: any) => FilterMatch;
type FilterKeyFunctions = Record<string, FilterFunction>;
type FilterKeys = string | string[];
type FilterMode = 'some' | 'every' | 'union' | 'intersection';

type DataTableCompareFunction<T = any> = (a: T, b: T) => number;
type DataTableHeader = {
    key: string;
    value?: SelectItemKey;
    title: string;
    colspan?: number;
    rowspan?: number;
    fixed?: boolean;
    align?: 'start' | 'end';
    width?: number;
    minWidth?: string;
    maxWidth?: string;
    sortable?: boolean;
    sort?: DataTableCompareFunction;
};
type InternalDataTableHeader = DataTableHeader & {
    sortable: boolean;
    fixedOffset?: number;
    lastFixed?: boolean;
};
type DataTableItem = InternalItem & {
    type: 'item';
    columns: Record<string, unknown>;
};
type GroupHeaderItem = {
    type: 'group-header';
    id: string;
    key: string;
    value: string;
    depth: number;
    items: (GroupHeaderItem | DataTableItem)[];
};
type InternalDataTableItem = DataTableItem | GroupHeaderItem;

type SortItem = {
    key: string;
    order?: boolean | 'asc' | 'desc';
};

type GroupHeaderSlot = {
    index: number;
    item: GroupHeaderItem;
    columns: InternalDataTableHeader[];
    isExpanded: (item: DataTableItem) => boolean;
    toggleExpand: (item: DataTableItem) => void;
    isSelected: (items: DataTableItem[]) => boolean;
    toggleSelect: (item: DataTableItem) => void;
    toggleGroup: (group: GroupHeaderItem) => void;
    isGroupOpen: (group: GroupHeaderItem) => boolean;
};
type ItemSlot = {
    index: number;
    item: InternalDataTableItem;
    columns: InternalDataTableHeader[];
    isExpanded: (item: DataTableItem) => boolean;
    toggleExpand: (item: DataTableItem) => void;
    isSelected: (items: DataTableItem[]) => boolean;
    toggleSelect: (item: DataTableItem) => void;
};
declare const VDataTableRows: vue.DefineComponent<{
    noDataText: string;
    loadingText: string;
    items: InternalDataTableItem[];
    hideNoData: boolean;
} & {
    loading?: string | boolean | undefined;
    rowHeight?: number | undefined;
} & {
    $children?: {} | vue.VNodeChild | {
        [x: `item.${string}`]: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: GroupHeaderSlot) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    };
    $slots?: {
        [x: `item.${string}`]: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: GroupHeaderSlot) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    } | undefined;
    'v-slots'?: {
        [x: `item.${string}`]: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        default?: false | (() => vue.VNodeChild) | undefined;
        item?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        loading?: false | (() => vue.VNodeChild) | undefined;
        'group-header'?: false | ((args_0: GroupHeaderSlot) => vue.VNodeChild) | undefined;
        'no-data'?: false | (() => vue.VNodeChild) | undefined;
        'expanded-row'?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    } | undefined;
} & {
    [x: `v-slot:item.${string}`]: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:item"?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:group-header"?: false | ((args_0: GroupHeaderSlot) => vue.VNodeChild) | undefined;
    "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:expanded-row"?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-select"?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-expand"?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    'click:row': (event: Event, value: {
        item: DataTableItem;
    }) => true;
}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {
    noDataText: string;
    loadingText: string;
    items: InternalDataTableItem[];
    hideNoData: boolean;
} & {
    loading?: string | boolean | undefined;
    rowHeight?: number | undefined;
} & {
    $children?: {} | vue.VNodeChild | {
        [x: `item.${string}`]: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: GroupHeaderSlot) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    };
    $slots?: {
        [x: `item.${string}`]: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: GroupHeaderSlot) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    } | undefined;
    'v-slots'?: {
        [x: `item.${string}`]: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        default?: false | (() => vue.VNodeChild) | undefined;
        item?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        loading?: false | (() => vue.VNodeChild) | undefined;
        'group-header'?: false | ((args_0: GroupHeaderSlot) => vue.VNodeChild) | undefined;
        'no-data'?: false | (() => vue.VNodeChild) | undefined;
        'expanded-row'?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    } | undefined;
} & {
    [x: `v-slot:item.${string}`]: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:item"?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:group-header"?: false | ((args_0: GroupHeaderSlot) => vue.VNodeChild) | undefined;
    "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:expanded-row"?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-select"?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-expand"?: false | ((args_0: ItemSlot) => vue.VNodeChild) | undefined;
} & {
    "onClick:row"?: ((event: Event, value: {
        item: DataTableItem;
    }) => any) | undefined;
}, {
    noDataText: string;
    loadingText: string;
    items: InternalDataTableItem[];
    hideNoData: boolean;
}>;
type VDataTableRows = InstanceType<typeof VDataTableRows>;

declare const VDataTable: vue.DefineComponent<{
    expanded: string[];
    page: string | number;
    headers: DataTableHeader[] | DataTableHeader[][];
    noDataText: string;
    sortBy: SortItem[];
    items: any[];
    modelValue: any[];
    itemTitle: SelectItemKey;
    itemValue: NonNullable<SelectItemKey>;
    itemChildren: SelectItemKey;
    itemProps: SelectItemKey;
    returnObject: boolean;
    hideNoData: boolean;
    filterMode: FilterMode;
    noFilter: boolean;
    fixedHeader: boolean;
    fixedFooter: boolean;
    multiSort: boolean;
    mustSort: boolean;
    groupBy: SortItem[];
    showSelect: boolean;
    expandOnClick: boolean;
    showExpand: boolean;
    itemsPerPage: string | number;
} & {
    search?: string | undefined;
    height?: string | number | undefined;
    width?: string | number | undefined;
    customFilter?: FilterFunction | undefined;
    customKeyFilter?: FilterKeyFunctions | undefined;
    filterKeys?: FilterKeys | undefined;
} & {
    $children?: {} | vue.VNodeChild | {
        [x: `item.${string}`]: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: (() => vue.VNodeChild) | undefined;
        headers?: (() => vue.VNodeChild) | undefined;
        body?: (() => vue.VNodeChild) | undefined;
        tbody?: (() => vue.VNodeChild) | undefined;
        thead?: (() => vue.VNodeChild) | undefined;
        tfoot?: (() => vue.VNodeChild) | undefined;
        bottom?: (() => vue.VNodeChild) | undefined;
        'footer.prepend'?: (() => vue.VNodeChild) | undefined;
        colgroup?: (() => vue.VNodeChild) | undefined;
    };
    $slots?: {
        [x: `item.${string}`]: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: (() => vue.VNodeChild) | undefined;
        headers?: (() => vue.VNodeChild) | undefined;
        body?: (() => vue.VNodeChild) | undefined;
        tbody?: (() => vue.VNodeChild) | undefined;
        thead?: (() => vue.VNodeChild) | undefined;
        tfoot?: (() => vue.VNodeChild) | undefined;
        bottom?: (() => vue.VNodeChild) | undefined;
        'footer.prepend'?: (() => vue.VNodeChild) | undefined;
        colgroup?: (() => vue.VNodeChild) | undefined;
    } | undefined;
    'v-slots'?: {
        [x: `item.${string}`]: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: false | (() => vue.VNodeChild) | undefined;
        item?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: false | (() => vue.VNodeChild) | undefined;
        'group-header'?: false | ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: false | (() => vue.VNodeChild) | undefined;
        'expanded-row'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: false | (() => vue.VNodeChild) | undefined;
        headers?: false | (() => vue.VNodeChild) | undefined;
        body?: false | (() => vue.VNodeChild) | undefined;
        tbody?: false | (() => vue.VNodeChild) | undefined;
        thead?: false | (() => vue.VNodeChild) | undefined;
        tfoot?: false | (() => vue.VNodeChild) | undefined;
        bottom?: false | (() => vue.VNodeChild) | undefined;
        'footer.prepend'?: false | (() => vue.VNodeChild) | undefined;
        colgroup?: false | (() => vue.VNodeChild) | undefined;
    } | undefined;
} & {
    [x: `v-slot:item.${string}`]: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:item"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:group-header"?: false | ((args_0: {
        index: number;
        item: GroupHeaderItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
        toggleGroup: (group: GroupHeaderItem) => void;
        isGroupOpen: (group: GroupHeaderItem) => boolean;
    }) => vue.VNodeChild) | undefined;
    "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:expanded-row"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-select"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-expand"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:top"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:headers"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:body"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:tbody"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:thead"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:tfoot"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:bottom"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:footer.prepend"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:colgroup"?: false | (() => vue.VNodeChild) | undefined;
}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    'update:modelValue': (value: any[]) => true;
    'update:page': (value: number) => true;
    'update:itemsPerPage': (value: number) => true;
    'update:sortBy': (value: any) => true;
    'update:options': (value: any) => true;
    'update:groupBy': (value: any) => true;
    'update:expanded': (value: any) => true;
    'click:row': (event: Event, value: {
        item: DataTableItem;
    }) => true;
}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {
    expanded: string[];
    page: string | number;
    headers: DataTableHeader[] | DataTableHeader[][];
    noDataText: string;
    sortBy: SortItem[];
    items: any[];
    modelValue: any[];
    itemTitle: SelectItemKey;
    itemValue: NonNullable<SelectItemKey>;
    itemChildren: SelectItemKey;
    itemProps: SelectItemKey;
    returnObject: boolean;
    hideNoData: boolean;
    filterMode: FilterMode;
    noFilter: boolean;
    fixedHeader: boolean;
    fixedFooter: boolean;
    multiSort: boolean;
    mustSort: boolean;
    groupBy: SortItem[];
    showSelect: boolean;
    expandOnClick: boolean;
    showExpand: boolean;
    itemsPerPage: string | number;
} & {
    search?: string | undefined;
    height?: string | number | undefined;
    width?: string | number | undefined;
    customFilter?: FilterFunction | undefined;
    customKeyFilter?: FilterKeyFunctions | undefined;
    filterKeys?: FilterKeys | undefined;
} & {
    $children?: {} | vue.VNodeChild | {
        [x: `item.${string}`]: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: (() => vue.VNodeChild) | undefined;
        headers?: (() => vue.VNodeChild) | undefined;
        body?: (() => vue.VNodeChild) | undefined;
        tbody?: (() => vue.VNodeChild) | undefined;
        thead?: (() => vue.VNodeChild) | undefined;
        tfoot?: (() => vue.VNodeChild) | undefined;
        bottom?: (() => vue.VNodeChild) | undefined;
        'footer.prepend'?: (() => vue.VNodeChild) | undefined;
        colgroup?: (() => vue.VNodeChild) | undefined;
    };
    $slots?: {
        [x: `item.${string}`]: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: (() => vue.VNodeChild) | undefined;
        headers?: (() => vue.VNodeChild) | undefined;
        body?: (() => vue.VNodeChild) | undefined;
        tbody?: (() => vue.VNodeChild) | undefined;
        thead?: (() => vue.VNodeChild) | undefined;
        tfoot?: (() => vue.VNodeChild) | undefined;
        bottom?: (() => vue.VNodeChild) | undefined;
        'footer.prepend'?: (() => vue.VNodeChild) | undefined;
        colgroup?: (() => vue.VNodeChild) | undefined;
    } | undefined;
    'v-slots'?: {
        [x: `item.${string}`]: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: false | (() => vue.VNodeChild) | undefined;
        item?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: false | (() => vue.VNodeChild) | undefined;
        'group-header'?: false | ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: false | (() => vue.VNodeChild) | undefined;
        'expanded-row'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: false | (() => vue.VNodeChild) | undefined;
        headers?: false | (() => vue.VNodeChild) | undefined;
        body?: false | (() => vue.VNodeChild) | undefined;
        tbody?: false | (() => vue.VNodeChild) | undefined;
        thead?: false | (() => vue.VNodeChild) | undefined;
        tfoot?: false | (() => vue.VNodeChild) | undefined;
        bottom?: false | (() => vue.VNodeChild) | undefined;
        'footer.prepend'?: false | (() => vue.VNodeChild) | undefined;
        colgroup?: false | (() => vue.VNodeChild) | undefined;
    } | undefined;
} & {
    [x: `v-slot:item.${string}`]: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:item"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:group-header"?: false | ((args_0: {
        index: number;
        item: GroupHeaderItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
        toggleGroup: (group: GroupHeaderItem) => void;
        isGroupOpen: (group: GroupHeaderItem) => boolean;
    }) => vue.VNodeChild) | undefined;
    "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:expanded-row"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-select"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-expand"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:top"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:headers"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:body"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:tbody"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:thead"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:tfoot"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:bottom"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:footer.prepend"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:colgroup"?: false | (() => vue.VNodeChild) | undefined;
} & {
    "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
    "onUpdate:sortBy"?: ((value: any) => any) | undefined;
    "onUpdate:expanded"?: ((value: any) => any) | undefined;
    "onClick:row"?: ((event: Event, value: {
        item: DataTableItem;
    }) => any) | undefined;
    "onUpdate:page"?: ((value: number) => any) | undefined;
    "onUpdate:itemsPerPage"?: ((value: number) => any) | undefined;
    "onUpdate:options"?: ((value: any) => any) | undefined;
    "onUpdate:groupBy"?: ((value: any) => any) | undefined;
}, {
    expanded: string[];
    page: string | number;
    headers: DataTableHeader[] | DataTableHeader[][];
    noDataText: string;
    sortBy: SortItem[];
    items: any[];
    modelValue: any[];
    itemTitle: SelectItemKey;
    itemValue: NonNullable<SelectItemKey>;
    itemChildren: SelectItemKey;
    itemProps: SelectItemKey;
    returnObject: boolean;
    hideNoData: boolean;
    filterMode: FilterMode;
    noFilter: boolean;
    fixedHeader: boolean;
    fixedFooter: boolean;
    multiSort: boolean;
    mustSort: boolean;
    groupBy: SortItem[];
    showSelect: boolean;
    expandOnClick: boolean;
    showExpand: boolean;
    itemsPerPage: string | number;
}>;
type VDataTable = InstanceType<typeof VDataTable>;

declare const VDataTableRow: vue.DefineComponent<{
    item: PropType<DataTableItem>;
}, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
    item: PropType<DataTableItem>;
}>>, {}>;
type VDataTableRow = InstanceType<typeof VDataTableRow>;

declare const VDataTableVirtual: vue.DefineComponent<{
    expanded: string[];
    headers: DataTableHeader[] | DataTableHeader[][];
    noDataText: string;
    sortBy: SortItem[];
    items: any[];
    modelValue: any[];
    itemTitle: SelectItemKey;
    itemValue: NonNullable<SelectItemKey>;
    itemChildren: SelectItemKey;
    itemProps: SelectItemKey;
    returnObject: boolean;
    hideNoData: boolean;
    filterMode: FilterMode;
    noFilter: boolean;
    fixedHeader: boolean;
    fixedFooter: boolean;
    multiSort: boolean;
    mustSort: boolean;
    groupBy: SortItem[];
    showSelect: boolean;
    expandOnClick: boolean;
    showExpand: boolean;
    visibleItems: string | number;
    itemHeight: string | number;
} & {
    search?: string | undefined;
    height?: string | number | undefined;
    width?: string | number | undefined;
    customFilter?: FilterFunction | undefined;
    customKeyFilter?: FilterKeyFunctions | undefined;
    filterKeys?: FilterKeys | undefined;
} & {
    $children?: {} | vue.VNodeChild | {
        [x: `item.${string}`]: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: (() => vue.VNodeChild) | undefined;
        headers?: (() => vue.VNodeChild) | undefined;
        bottom?: (() => vue.VNodeChild) | undefined;
    };
    $slots?: {
        [x: `item.${string}`]: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: (() => vue.VNodeChild) | undefined;
        headers?: (() => vue.VNodeChild) | undefined;
        bottom?: (() => vue.VNodeChild) | undefined;
    } | undefined;
    'v-slots'?: {
        [x: `item.${string}`]: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: false | (() => vue.VNodeChild) | undefined;
        item?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: false | (() => vue.VNodeChild) | undefined;
        'group-header'?: false | ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: false | (() => vue.VNodeChild) | undefined;
        'expanded-row'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: false | (() => vue.VNodeChild) | undefined;
        headers?: false | (() => vue.VNodeChild) | undefined;
        bottom?: false | (() => vue.VNodeChild) | undefined;
    } | undefined;
} & {
    [x: `v-slot:item.${string}`]: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:item"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:group-header"?: false | ((args_0: {
        index: number;
        item: GroupHeaderItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
        toggleGroup: (group: GroupHeaderItem) => void;
        isGroupOpen: (group: GroupHeaderItem) => boolean;
    }) => vue.VNodeChild) | undefined;
    "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:expanded-row"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-select"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-expand"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:top"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:headers"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:bottom"?: false | (() => vue.VNodeChild) | undefined;
}, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    'update:modelValue': (value: any[]) => true;
    'update:sortBy': (value: any) => true;
    'update:options': (value: any) => true;
    'update:groupBy': (value: any) => true;
    'update:expanded': (value: any) => true;
    'click:row': (event: Event, value: {
        item: DataTableItem;
    }) => true;
}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {
    expanded: string[];
    headers: DataTableHeader[] | DataTableHeader[][];
    noDataText: string;
    sortBy: SortItem[];
    items: any[];
    modelValue: any[];
    itemTitle: SelectItemKey;
    itemValue: NonNullable<SelectItemKey>;
    itemChildren: SelectItemKey;
    itemProps: SelectItemKey;
    returnObject: boolean;
    hideNoData: boolean;
    filterMode: FilterMode;
    noFilter: boolean;
    fixedHeader: boolean;
    fixedFooter: boolean;
    multiSort: boolean;
    mustSort: boolean;
    groupBy: SortItem[];
    showSelect: boolean;
    expandOnClick: boolean;
    showExpand: boolean;
    visibleItems: string | number;
    itemHeight: string | number;
} & {
    search?: string | undefined;
    height?: string | number | undefined;
    width?: string | number | undefined;
    customFilter?: FilterFunction | undefined;
    customKeyFilter?: FilterKeyFunctions | undefined;
    filterKeys?: FilterKeys | undefined;
} & {
    $children?: {} | vue.VNodeChild | {
        [x: `item.${string}`]: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: (() => vue.VNodeChild) | undefined;
        headers?: (() => vue.VNodeChild) | undefined;
        bottom?: (() => vue.VNodeChild) | undefined;
    };
    $slots?: {
        [x: `item.${string}`]: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: (() => vue.VNodeChild) | undefined;
        headers?: (() => vue.VNodeChild) | undefined;
        bottom?: (() => vue.VNodeChild) | undefined;
    } | undefined;
    'v-slots'?: {
        [x: `item.${string}`]: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: false | (() => vue.VNodeChild) | undefined;
        item?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: false | (() => vue.VNodeChild) | undefined;
        'group-header'?: false | ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: false | (() => vue.VNodeChild) | undefined;
        'expanded-row'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: false | (() => vue.VNodeChild) | undefined;
        headers?: false | (() => vue.VNodeChild) | undefined;
        bottom?: false | (() => vue.VNodeChild) | undefined;
    } | undefined;
} & {
    [x: `v-slot:item.${string}`]: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:item"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:group-header"?: false | ((args_0: {
        index: number;
        item: GroupHeaderItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
        toggleGroup: (group: GroupHeaderItem) => void;
        isGroupOpen: (group: GroupHeaderItem) => boolean;
    }) => vue.VNodeChild) | undefined;
    "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:expanded-row"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-select"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-expand"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:top"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:headers"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:bottom"?: false | (() => vue.VNodeChild) | undefined;
} & {
    "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
    "onUpdate:sortBy"?: ((value: any) => any) | undefined;
    "onUpdate:expanded"?: ((value: any) => any) | undefined;
    "onClick:row"?: ((event: Event, value: {
        item: DataTableItem;
    }) => any) | undefined;
    "onUpdate:options"?: ((value: any) => any) | undefined;
    "onUpdate:groupBy"?: ((value: any) => any) | undefined;
}, {
    expanded: string[];
    headers: DataTableHeader[] | DataTableHeader[][];
    noDataText: string;
    sortBy: SortItem[];
    items: any[];
    modelValue: any[];
    itemTitle: SelectItemKey;
    itemValue: NonNullable<SelectItemKey>;
    itemChildren: SelectItemKey;
    itemProps: SelectItemKey;
    returnObject: boolean;
    hideNoData: boolean;
    filterMode: FilterMode;
    noFilter: boolean;
    fixedHeader: boolean;
    fixedFooter: boolean;
    multiSort: boolean;
    mustSort: boolean;
    groupBy: SortItem[];
    showSelect: boolean;
    expandOnClick: boolean;
    showExpand: boolean;
    visibleItems: string | number;
    itemHeight: string | number;
}>;
type VDataTableVirtual = InstanceType<typeof VDataTableVirtual>;

declare const VDataTableServer: vue.DefineComponent<{
    expanded: string[];
    page: string | number;
    headers: DataTableHeader[] | DataTableHeader[][];
    noDataText: string;
    loadingText: string;
    sortBy: SortItem[];
    items: any[];
    modelValue: any[];
    itemTitle: SelectItemKey;
    itemValue: NonNullable<SelectItemKey>;
    itemChildren: SelectItemKey;
    itemProps: SelectItemKey;
    returnObject: boolean;
    hideNoData: boolean;
    fixedHeader: boolean;
    fixedFooter: boolean;
    multiSort: boolean;
    mustSort: boolean;
    groupBy: SortItem[];
    showSelect: boolean;
    expandOnClick: boolean;
    showExpand: boolean;
    itemsPerPage: string | number;
} & {
    height?: string | number | undefined;
    width?: string | number | undefined;
    color?: string | undefined;
    loading?: string | boolean | undefined;
    itemsLength?: string | number | undefined;
} & {
    $children?: {} | vue.VNodeChild | {
        [x: `item.${string}`]: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: (() => vue.VNodeChild) | undefined;
        headers?: (() => vue.VNodeChild) | undefined;
        body?: (() => vue.VNodeChild) | undefined;
        tbody?: (() => vue.VNodeChild) | undefined;
        thead?: (() => vue.VNodeChild) | undefined;
        tfoot?: (() => vue.VNodeChild) | undefined;
        bottom?: (() => vue.VNodeChild) | undefined;
        'footer.prepend'?: (() => vue.VNodeChild) | undefined;
    };
    $slots?: {
        [x: `item.${string}`]: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: (() => vue.VNodeChild) | undefined;
        headers?: (() => vue.VNodeChild) | undefined;
        body?: (() => vue.VNodeChild) | undefined;
        tbody?: (() => vue.VNodeChild) | undefined;
        thead?: (() => vue.VNodeChild) | undefined;
        tfoot?: (() => vue.VNodeChild) | undefined;
        bottom?: (() => vue.VNodeChild) | undefined;
        'footer.prepend'?: (() => vue.VNodeChild) | undefined;
    } | undefined;
    'v-slots'?: {
        [x: `item.${string}`]: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: false | (() => vue.VNodeChild) | undefined;
        item?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: false | (() => vue.VNodeChild) | undefined;
        'group-header'?: false | ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: false | (() => vue.VNodeChild) | undefined;
        'expanded-row'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: false | (() => vue.VNodeChild) | undefined;
        headers?: false | (() => vue.VNodeChild) | undefined;
        body?: false | (() => vue.VNodeChild) | undefined;
        tbody?: false | (() => vue.VNodeChild) | undefined;
        thead?: false | (() => vue.VNodeChild) | undefined;
        tfoot?: false | (() => vue.VNodeChild) | undefined;
        bottom?: false | (() => vue.VNodeChild) | undefined;
        'footer.prepend'?: false | (() => vue.VNodeChild) | undefined;
    } | undefined;
} & {
    [x: `v-slot:item.${string}`]: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:item"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:group-header"?: false | ((args_0: {
        index: number;
        item: GroupHeaderItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
        toggleGroup: (group: GroupHeaderItem) => void;
        isGroupOpen: (group: GroupHeaderItem) => boolean;
    }) => vue.VNodeChild) | undefined;
    "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:expanded-row"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-select"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-expand"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:top"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:headers"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:body"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:tbody"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:thead"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:tfoot"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:bottom"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:footer.prepend"?: false | (() => vue.VNodeChild) | undefined;
}, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    'update:modelValue': (value: any[]) => true;
    'update:page': (page: number) => true;
    'update:itemsPerPage': (page: number) => true;
    'update:sortBy': (sortBy: any) => true;
    'update:options': (options: any) => true;
    'update:expanded': (options: any) => true;
    'update:groupBy': (value: any) => true;
    'click:row': (event: Event, value: {
        item: DataTableItem;
    }) => true;
}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {
    expanded: string[];
    page: string | number;
    headers: DataTableHeader[] | DataTableHeader[][];
    noDataText: string;
    loadingText: string;
    sortBy: SortItem[];
    items: any[];
    modelValue: any[];
    itemTitle: SelectItemKey;
    itemValue: NonNullable<SelectItemKey>;
    itemChildren: SelectItemKey;
    itemProps: SelectItemKey;
    returnObject: boolean;
    hideNoData: boolean;
    fixedHeader: boolean;
    fixedFooter: boolean;
    multiSort: boolean;
    mustSort: boolean;
    groupBy: SortItem[];
    showSelect: boolean;
    expandOnClick: boolean;
    showExpand: boolean;
    itemsPerPage: string | number;
} & {
    height?: string | number | undefined;
    width?: string | number | undefined;
    color?: string | undefined;
    loading?: string | boolean | undefined;
    itemsLength?: string | number | undefined;
} & {
    $children?: {} | vue.VNodeChild | {
        [x: `item.${string}`]: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: (() => vue.VNodeChild) | undefined;
        headers?: (() => vue.VNodeChild) | undefined;
        body?: (() => vue.VNodeChild) | undefined;
        tbody?: (() => vue.VNodeChild) | undefined;
        thead?: (() => vue.VNodeChild) | undefined;
        tfoot?: (() => vue.VNodeChild) | undefined;
        bottom?: (() => vue.VNodeChild) | undefined;
        'footer.prepend'?: (() => vue.VNodeChild) | undefined;
    };
    $slots?: {
        [x: `item.${string}`]: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: (() => vue.VNodeChild) | undefined;
        item?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: (() => vue.VNodeChild) | undefined;
        'group-header'?: ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: (() => vue.VNodeChild) | undefined;
        'expanded-row'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: (() => vue.VNodeChild) | undefined;
        headers?: (() => vue.VNodeChild) | undefined;
        body?: (() => vue.VNodeChild) | undefined;
        tbody?: (() => vue.VNodeChild) | undefined;
        thead?: (() => vue.VNodeChild) | undefined;
        tfoot?: (() => vue.VNodeChild) | undefined;
        bottom?: (() => vue.VNodeChild) | undefined;
        'footer.prepend'?: (() => vue.VNodeChild) | undefined;
    } | undefined;
    'v-slots'?: {
        [x: `item.${string}`]: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        default?: false | (() => vue.VNodeChild) | undefined;
        item?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        loading?: false | (() => vue.VNodeChild) | undefined;
        'group-header'?: false | ((args_0: {
            index: number;
            item: GroupHeaderItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
            toggleGroup: (group: GroupHeaderItem) => void;
            isGroupOpen: (group: GroupHeaderItem) => boolean;
        }) => vue.VNodeChild) | undefined;
        'no-data'?: false | (() => vue.VNodeChild) | undefined;
        'expanded-row'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-select'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        'item.data-table-expand'?: false | ((args_0: {
            index: number;
            item: InternalDataTableItem;
            columns: InternalDataTableHeader[];
            isExpanded: (item: DataTableItem) => boolean;
            toggleExpand: (item: DataTableItem) => void;
            isSelected: (items: DataTableItem[]) => boolean;
            toggleSelect: (item: DataTableItem) => void;
        }) => vue.VNodeChild) | undefined;
        top?: false | (() => vue.VNodeChild) | undefined;
        headers?: false | (() => vue.VNodeChild) | undefined;
        body?: false | (() => vue.VNodeChild) | undefined;
        tbody?: false | (() => vue.VNodeChild) | undefined;
        thead?: false | (() => vue.VNodeChild) | undefined;
        tfoot?: false | (() => vue.VNodeChild) | undefined;
        bottom?: false | (() => vue.VNodeChild) | undefined;
        'footer.prepend'?: false | (() => vue.VNodeChild) | undefined;
    } | undefined;
} & {
    [x: `v-slot:item.${string}`]: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:item"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:group-header"?: false | ((args_0: {
        index: number;
        item: GroupHeaderItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
        toggleGroup: (group: GroupHeaderItem) => void;
        isGroupOpen: (group: GroupHeaderItem) => boolean;
    }) => vue.VNodeChild) | undefined;
    "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:expanded-row"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-select"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:item.data-table-expand"?: false | ((args_0: {
        index: number;
        item: InternalDataTableItem;
        columns: InternalDataTableHeader[];
        isExpanded: (item: DataTableItem) => boolean;
        toggleExpand: (item: DataTableItem) => void;
        isSelected: (items: DataTableItem[]) => boolean;
        toggleSelect: (item: DataTableItem) => void;
    }) => vue.VNodeChild) | undefined;
    "v-slot:top"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:headers"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:body"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:tbody"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:thead"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:tfoot"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:bottom"?: false | (() => vue.VNodeChild) | undefined;
    "v-slot:footer.prepend"?: false | (() => vue.VNodeChild) | undefined;
} & {
    "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
    "onUpdate:sortBy"?: ((sortBy: any) => any) | undefined;
    "onUpdate:expanded"?: ((options: any) => any) | undefined;
    "onClick:row"?: ((event: Event, value: {
        item: DataTableItem;
    }) => any) | undefined;
    "onUpdate:page"?: ((page: number) => any) | undefined;
    "onUpdate:itemsPerPage"?: ((page: number) => any) | undefined;
    "onUpdate:options"?: ((options: any) => any) | undefined;
    "onUpdate:groupBy"?: ((value: any) => any) | undefined;
}, {
    expanded: string[];
    page: string | number;
    headers: DataTableHeader[] | DataTableHeader[][];
    noDataText: string;
    loadingText: string;
    sortBy: SortItem[];
    items: any[];
    modelValue: any[];
    itemTitle: SelectItemKey;
    itemValue: NonNullable<SelectItemKey>;
    itemChildren: SelectItemKey;
    itemProps: SelectItemKey;
    returnObject: boolean;
    hideNoData: boolean;
    fixedHeader: boolean;
    fixedFooter: boolean;
    multiSort: boolean;
    mustSort: boolean;
    groupBy: SortItem[];
    showSelect: boolean;
    expandOnClick: boolean;
    showExpand: boolean;
    itemsPerPage: string | number;
}>;
type VDataTableServer = InstanceType<typeof VDataTableServer>;

declare const VDataTableFooter: vue.DefineComponent<{
    itemsPerPageText: string;
    pageText: string;
    nextIcon: string;
    prevIcon: string;
    firstIcon: string;
    lastIcon: string;
    showCurrentPage: boolean;
    firstPageLabel: string;
    prevPageLabel: string;
    nextPageLabel: string;
    lastPageLabel: string;
    itemsPerPageOptions: InternalItem<any>[];
} & {} & {
    $children?: {} | vue.VNodeChild | {
        prepend?: (() => vue.VNodeChild) | undefined;
    };
    $slots?: {
        prepend?: (() => vue.VNodeChild) | undefined;
    } | undefined;
    'v-slots'?: {
        prepend?: false | (() => vue.VNodeChild) | undefined;
    } | undefined;
} & {
    "v-slot:prepend"?: false | (() => vue.VNodeChild) | undefined;
}, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {
    itemsPerPageText: string;
    pageText: string;
    nextIcon: string;
    prevIcon: string;
    firstIcon: string;
    lastIcon: string;
    showCurrentPage: boolean;
    firstPageLabel: string;
    prevPageLabel: string;
    nextPageLabel: string;
    lastPageLabel: string;
    itemsPerPageOptions: InternalItem<any>[];
} & {} & {
    $children?: {} | vue.VNodeChild | {
        prepend?: (() => vue.VNodeChild) | undefined;
    };
    $slots?: {
        prepend?: (() => vue.VNodeChild) | undefined;
    } | undefined;
    'v-slots'?: {
        prepend?: false | (() => vue.VNodeChild) | undefined;
    } | undefined;
} & {
    "v-slot:prepend"?: false | (() => vue.VNodeChild) | undefined;
}, {
    itemsPerPageText: string;
    pageText: string;
    nextIcon: string;
    prevIcon: string;
    firstIcon: string;
    lastIcon: string;
    showCurrentPage: boolean;
    firstPageLabel: string;
    prevPageLabel: string;
    nextPageLabel: string;
    lastPageLabel: string;
    itemsPerPageOptions: InternalItem<any>[];
}>;

interface VVirtualScrollSlot<T> {
    item: T;
    index: number;
}
declare const VVirtualScroll: {
    new (...args: any[]): {
        $: vue.ComponentInternalInstance;
        $data: {};
        $props: Partial<{}> & Omit<Readonly<vue.ExtractPropTypes<Omit<{
            height: (StringConstructor | NumberConstructor)[];
            maxHeight: (StringConstructor | NumberConstructor)[];
            maxWidth: (StringConstructor | NumberConstructor)[];
            minHeight: (StringConstructor | NumberConstructor)[];
            minWidth: (StringConstructor | NumberConstructor)[];
            width: (StringConstructor | NumberConstructor)[];
            items: {
                type: ArrayConstructor;
                default: () => never[];
            };
            itemHeight: (StringConstructor | NumberConstructor)[];
            visibleItems: (StringConstructor | NumberConstructor)[];
        }, "$children" | "v-slot:default" | "$slots" | "v-slots" | "items">>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: vue.Slot | undefined;
        }>;
        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
        $emit: (event: string, ...args: any[]) => void;
        $el: any;
        $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<Omit<{
            height: (StringConstructor | NumberConstructor)[];
            maxHeight: (StringConstructor | NumberConstructor)[];
            maxWidth: (StringConstructor | NumberConstructor)[];
            minHeight: (StringConstructor | NumberConstructor)[];
            minWidth: (StringConstructor | NumberConstructor)[];
            width: (StringConstructor | NumberConstructor)[];
            items: {
                type: ArrayConstructor;
                default: () => never[];
            };
            itemHeight: (StringConstructor | NumberConstructor)[];
            visibleItems: (StringConstructor | NumberConstructor)[];
        }, "$children" | "v-slot:default" | "$slots" | "v-slots" | "items">>>, {
            scrollToIndex: (index: number) => void;
        }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<Record<string, any>, "$children" | "v-slot:default" | "$slots" | "v-slots" | "items">, string, {}, {}, string> & {
            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
            created?: ((() => void) | (() => void)[]) | undefined;
            beforeMount?: ((() => void) | (() => void)[]) | undefined;
            mounted?: ((() => void) | (() => void)[]) | undefined;
            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
            updated?: ((() => void) | (() => void)[]) | undefined;
            activated?: ((() => void) | (() => void)[]) | undefined;
            deactivated?: ((() => void) | (() => void)[]) | undefined;
            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
            destroyed?: ((() => void) | (() => void)[]) | undefined;
            unmounted?: ((() => void) | (() => void)[]) | undefined;
            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
        };
        $forceUpdate: () => void;
        $nextTick: typeof vue.nextTick;
        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
    } & Readonly<vue.ExtractPropTypes<Omit<{
        height: (StringConstructor | NumberConstructor)[];
        maxHeight: (StringConstructor | NumberConstructor)[];
        maxWidth: (StringConstructor | NumberConstructor)[];
        minHeight: (StringConstructor | NumberConstructor)[];
        minWidth: (StringConstructor | NumberConstructor)[];
        width: (StringConstructor | NumberConstructor)[];
        items: {
            type: ArrayConstructor;
            default: () => never[];
        };
        itemHeight: (StringConstructor | NumberConstructor)[];
        visibleItems: (StringConstructor | NumberConstructor)[];
    }, "$children" | "v-slot:default" | "$slots" | "v-slots" | "items">>> & vue.ShallowUnwrapRef<{
        scrollToIndex: (index: number) => void;
    }> & {} & vue.ComponentCustomProperties & {};
    __isFragment?: undefined;
    __isTeleport?: undefined;
    __isSuspense?: undefined;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<Omit<{
    height: (StringConstructor | NumberConstructor)[];
    maxHeight: (StringConstructor | NumberConstructor)[];
    maxWidth: (StringConstructor | NumberConstructor)[];
    minHeight: (StringConstructor | NumberConstructor)[];
    minWidth: (StringConstructor | NumberConstructor)[];
    width: (StringConstructor | NumberConstructor)[];
    items: {
        type: ArrayConstructor;
        default: () => never[];
    };
    itemHeight: (StringConstructor | NumberConstructor)[];
    visibleItems: (StringConstructor | NumberConstructor)[];
}, "$children" | "v-slot:default" | "$slots" | "v-slots" | "items">>>, {
    scrollToIndex: (index: number) => void;
}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<Record<string, any>, "$children" | "v-slot:default" | "$slots" | "v-slots" | "items">, string, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T_1>() => {
    $props: {
        items: readonly T_1[];
    } & {
        $children?: vue.VNodeChild | ((args_0: VVirtualScrollSlot<T_1>) => vue.VNodeChild) | {
            default?: ((args_0: VVirtualScrollSlot<T_1>) => vue.VNodeChild) | undefined;
        };
        $slots?: {
            default?: ((args_0: VVirtualScrollSlot<T_1>) => vue.VNodeChild) | undefined;
        } | undefined;
        'v-slots'?: {
            default?: false | ((args_0: VVirtualScrollSlot<T_1>) => vue.VNodeChild) | undefined;
        } | undefined;
    } & {
        "v-slot:default"?: false | ((args_0: VVirtualScrollSlot<T_1>) => vue.VNodeChild) | undefined;
    };
});
type VVirtualScroll = InstanceType<typeof VVirtualScroll>;

export { VDataTable, VDataTableFooter, VDataTableRow, VDataTableRows, VDataTableServer, VDataTableVirtual, VVirtualScroll };