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>[];
}>;

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