@vuetify/nightly 3.4.0-alpha.1-dev.2023-10-21 → 3.4.0-alpha.1-dev.2023-10-26

package/lib/labs/VDataTable/index.d.mts

@@ -210,66 +210,43 @@ declare const VDataTableRow: {
     new (...args: any[]): {
         $: vue.ComponentInternalInstance;
         $data: {};
-        $props: {
+        $props: Partial<{}> & Omit<{
             [x: `v-slot:item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
             index?: number | undefined;
-            key?: string | number | symbol | undefined;
             item?: DataTableItem<any> | undefined;
-            style?: unknown;
-            class?: unknown;
             onClick?: ((e: MouseEvent) => void) | undefined;
             $children?: {} | vue.VNodeChild | {
                 [x: `item.${string}`]: ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
                 'item.data-table-select'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
                 'item.data-table-expand'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
             };
-            ref?: vue.VNodeRef | undefined;
-            ref_for?: boolean | undefined;
-            ref_key?: string | undefined;
             'v-slots'?: {
                 [x: `item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
                 'item.data-table-select'?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
                 'item.data-table-expand'?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
             } | undefined;
-            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-        };
+            "v-slot:item.data-table-select"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-expand"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {} & {
+            index?: number | undefined;
+            item?: DataTableItem<any> | undefined;
+            onClick?: ((e: MouseEvent) => void) | undefined;
+        } & {
+            $children?: {} | vue.VNodeChild | {
+                [x: `item.${string}`]: ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+                'item.data-table-select'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                'item.data-table-expand'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            };
+            'v-slots'?: {
+                [x: `item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+                'item.data-table-select'?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                'item.data-table-expand'?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            [x: `v-slot:item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-select"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-expand"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+        }, never>;
         $attrs: {
             [x: string]: unknown;
         };
@@ -407,16 +384,23 @@ declare const VDataTableRows: {
     new (...args: any[]): {
         $: vue.ComponentInternalInstance;
         $data: {};
-        $props: {
+        $props: Partial<{
+            noDataText: string;
+            loadingText: string;
+            items: readonly (DataTableItem<any> | Group<any>)[];
+            hideNoData: boolean;
+        }> & Omit<{
             [x: `v-slot:item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
-            noDataText?: string | undefined;
-            loadingText?: string | undefined;
-            items?: readonly (DataTableItem<any> | Group<any>)[] | undefined;
-            hideNoData?: boolean | undefined;
-            key?: string | number | symbol | undefined;
+            noDataText: string;
+            loadingText: string;
+            items: readonly (DataTableItem<any> | Group<any>)[];
+            hideNoData: boolean;
             loading?: string | boolean | undefined;
-            style?: unknown;
-            class?: unknown;
+            rowHeight?: number | undefined;
+            'onClick:row'?: ((e: Event, value: {
+                item: any;
+                internalItem: DataTableItem;
+            }) => void) | undefined;
             $children?: {} | vue.VNodeChild | {
                 [x: `item.${string}`]: ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
                 'data-table-group'?: ((arg: {
@@ -447,9 +431,6 @@ declare const VDataTableRows: {
                 'no-data'?: (() => vue.VNodeChild) | undefined;
                 'expanded-row'?: ((arg: ItemSlot) => vue.VNodeChild) | undefined;
             };
-            ref?: vue.VNodeRef | undefined;
-            ref_for?: boolean | undefined;
-            ref_key?: string | undefined;
             'v-slots'?: {
                 [x: `item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
                 'data-table-group'?: false | ((arg: {
@@ -480,44 +461,16 @@ declare const VDataTableRows: {
                 'no-data'?: false | (() => vue.VNodeChild) | undefined;
                 'expanded-row'?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
             } | undefined;
-            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
+            "v-slot:data-table-group"?: false | ((arg: {
+                item: Group<any>;
+                count: number;
+                props: Record<string, unknown>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:data-table-select"?: false | ((arg: {
+                props: Record<string, unknown>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-select"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-expand"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
             "v-slot:item"?: false | ((arg: {
                 index: number;
                 item: any;
@@ -531,7 +484,85 @@ declare const VDataTableRows: {
             } & {
                 props: Record<string, any>;
             }) => vue.VNodeChild) | undefined;
+            "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
+            "v-slot:group-header"?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
             "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
+            "v-slot:expanded-row"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+            noDataText: string;
+            loadingText: string;
+            items: readonly (DataTableItem<any> | Group<any>)[];
+            hideNoData: boolean;
+        } & {
+            loading?: string | boolean | undefined;
+            rowHeight?: number | undefined;
+            'onClick:row'?: ((e: Event, value: {
+                item: any;
+                internalItem: DataTableItem;
+            }) => void) | undefined;
+        } & {
+            $children?: {} | vue.VNodeChild | {
+                [x: `item.${string}`]: ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+                'data-table-group'?: ((arg: {
+                    item: Group<any>;
+                    count: number;
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-select'?: ((arg: {
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'item.data-table-select'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                'item.data-table-expand'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                item?: ((arg: {
+                    index: number;
+                    item: any;
+                    internalItem: DataTableItem<any>;
+                    isExpanded: (item: DataTableItem<any>) => boolean;
+                    toggleExpand: (item: DataTableItem<any>) => void;
+                    isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+                    toggleSelect: (item: SelectableItem) => void;
+                } & {
+                    columns: InternalDataTableHeader[];
+                } & {
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+                loading?: (() => vue.VNodeChild) | undefined;
+                'group-header'?: ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
+                'no-data'?: (() => vue.VNodeChild) | undefined;
+                'expanded-row'?: ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+            };
+            'v-slots'?: {
+                [x: `item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+                'data-table-group'?: false | ((arg: {
+                    item: Group<any>;
+                    count: number;
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-select'?: false | ((arg: {
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'item.data-table-select'?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                'item.data-table-expand'?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                item?: false | ((arg: {
+                    index: number;
+                    item: any;
+                    internalItem: DataTableItem<any>;
+                    isExpanded: (item: DataTableItem<any>) => boolean;
+                    toggleExpand: (item: DataTableItem<any>) => void;
+                    isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+                    toggleSelect: (item: SelectableItem) => void;
+                } & {
+                    columns: InternalDataTableHeader[];
+                } & {
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+                loading?: false | (() => vue.VNodeChild) | undefined;
+                'group-header'?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
+                'no-data'?: false | (() => vue.VNodeChild) | undefined;
+                'expanded-row'?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            [x: `v-slot:item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
             "v-slot:data-table-group"?: false | ((arg: {
                 item: Group<any>;
                 count: number;
@@ -540,15 +571,26 @@ declare const VDataTableRows: {
             "v-slot:data-table-select"?: false | ((arg: {
                 props: Record<string, unknown>;
             }) => vue.VNodeChild) | undefined;
-            rowHeight?: number | undefined;
-            'onClick:row'?: ((e: Event, value: {
+            "v-slot:item.data-table-select"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-expand"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item"?: false | ((arg: {
+                index: number;
                 item: any;
-                internalItem: DataTableItem;
-            }) => void) | undefined;
+                internalItem: DataTableItem<any>;
+                isExpanded: (item: DataTableItem<any>) => boolean;
+                toggleExpand: (item: DataTableItem<any>) => void;
+                isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+                toggleSelect: (item: SelectableItem) => void;
+            } & {
+                columns: InternalDataTableHeader[];
+            } & {
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
             "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
             "v-slot:group-header"?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
+            "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
             "v-slot:expanded-row"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
-        };
+        }, "noDataText" | "loadingText" | "items" | "hideNoData">;
         $attrs: {
             [x: string]: unknown;
         };
@@ -1116,7 +1158,56 @@ declare const VDataTable: {
     new (...args: any[]): {
         $: vue.ComponentInternalInstance;
         $data: {};
-        $props: {
+        $props: Partial<{
+            style: vue.StyleValue;
+            expanded: readonly string[];
+            tag: string;
+            page: string | number;
+            sticky: boolean;
+            headers: vue.DeepReadonly<DataTableHeader[] | DataTableHeader[][]>;
+            noDataText: string;
+            loadingText: string;
+            itemsPerPageText: string;
+            sortBy: readonly SortItem[];
+            pageText: string;
+            items: any[];
+            density: Density;
+            groupBy: readonly SortItem[];
+            modelValue: readonly any[];
+            valueComparator: typeof deepEqual;
+            selectStrategy: "all" | "page" | "single";
+            returnObject: boolean;
+            filterMode: FilterMode;
+            noFilter: boolean;
+            itemValue: SelectItemKey;
+            hideNoData: boolean;
+            hover: boolean;
+            nextIcon: string;
+            prevIcon: string;
+            firstIcon: string;
+            lastIcon: string;
+            fixedHeader: boolean;
+            fixedFooter: boolean;
+            expandOnClick: boolean;
+            showExpand: boolean;
+            itemSelectable: SelectItemKey;
+            showSelect: boolean;
+            multiSort: boolean;
+            mustSort: boolean;
+            itemsPerPage: string | number;
+            firstPageLabel: string;
+            prevPageLabel: string;
+            nextPageLabel: string;
+            lastPageLabel: string;
+            itemsPerPageOptions: readonly (number | {
+                title: string;
+                value: number;
+            })[];
+            showCurrentPage: boolean;
+            sortAscIcon: IconValue;
+            sortDescIcon: IconValue;
+        }> & Omit<{
+            [x: `v-slot:item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
             [x: `v-slot:column.${string}`]: false | ((arg: {
                 column: InternalDataTableHeader;
                 selectAll: (value: boolean) => void;
@@ -1127,87 +1218,95 @@ declare const VDataTable: {
                 allSelected: boolean;
                 getSortIcon: (column: InternalDataTableHeader) => IconValue;
             }) => vue.VNodeChild) | undefined;
-            [x: `v-slot:item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
-            style?: vue.StyleValue | undefined;
-            expanded?: readonly string[] | undefined;
-            tag?: string | undefined;
-            page?: string | number | undefined;
-            sticky?: boolean | undefined;
-            headers?: vue.DeepReadonly<DataTableHeader[] | DataTableHeader[][]> | undefined;
-            noDataText?: string | undefined;
-            loadingText?: string | undefined;
-            itemsPerPageText?: string | undefined;
-            sortBy?: readonly SortItem[] | undefined;
-            pageText?: string | undefined;
-            items?: any[] | undefined;
-            density?: Density | undefined;
-            modelValue?: readonly any[] | undefined;
-            valueComparator?: typeof deepEqual | undefined;
-            selectStrategy?: "all" | "page" | "single" | undefined;
-            returnObject?: boolean | undefined;
-            filterMode?: FilterMode | undefined;
-            noFilter?: boolean | undefined;
-            itemValue?: SelectItemKey;
-            hideNoData?: boolean | undefined;
-            hover?: boolean | undefined;
-            nextIcon?: string | undefined;
-            prevIcon?: string | undefined;
-            firstIcon?: string | undefined;
-            lastIcon?: string | undefined;
-            fixedHeader?: boolean | undefined;
-            fixedFooter?: boolean | undefined;
-            expandOnClick?: boolean | undefined;
-            showExpand?: boolean | undefined;
-            itemSelectable?: SelectItemKey;
-            showSelect?: boolean | undefined;
-            groupBy?: readonly SortItem[] | undefined;
-            multiSort?: boolean | undefined;
-            mustSort?: boolean | undefined;
-            itemsPerPage?: string | number | undefined;
-            firstPageLabel?: string | undefined;
-            prevPageLabel?: string | undefined;
-            nextPageLabel?: string | undefined;
-            lastPageLabel?: string | undefined;
-            itemsPerPageOptions?: readonly (number | {
-                title: string;
-                value: number;
-            })[] | undefined;
-            showCurrentPage?: boolean | undefined;
-            sortAscIcon?: IconValue | undefined;
-            sortDescIcon?: IconValue | undefined;
-            search?: string | undefined;
-            key?: string | number | symbol | undefined;
-            height?: string | number | undefined;
-            width?: string | number | undefined;
-            color?: string | undefined;
-            loading?: string | boolean | undefined;
-            class?: any;
-            $children?: vue.VNodeChild | {
-                [x: `item.${string}`]: ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
-                [x: `column.${string}`]: ((arg: {
-                    column: InternalDataTableHeader;
-                    selectAll: (value: boolean) => void;
-                    isSorted: (column: InternalDataTableHeader) => boolean;
-                    toggleSort: (column: InternalDataTableHeader) => void;
-                    sortBy: readonly SortItem[];
-                    someSelected: boolean;
-                    allSelected: boolean;
-                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
-                }) => vue.VNodeChild) | undefined;
-                'data-table-group'?: ((arg: {
-                    item: Group<any>;
-                    count: number;
-                    props: Record<string, unknown>;
-                }) => vue.VNodeChild) | undefined;
-                'data-table-select'?: ((arg: {
-                    props: Record<string, unknown>;
-                }) => vue.VNodeChild) | undefined;
-                'item.data-table-select'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
-                'item.data-table-expand'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
-                item?: ((arg: {
-                    index: number;
-                    item: any;
-                    internalItem: DataTableItem<any>;
+            style: vue.StyleValue;
+            expanded: readonly string[];
+            tag: string;
+            page: string | number;
+            sticky: boolean;
+            headers: vue.DeepReadonly<DataTableHeader[] | DataTableHeader[][]>;
+            noDataText: string;
+            loadingText: string;
+            itemsPerPageText: string;
+            sortBy: readonly SortItem[];
+            pageText: string;
+            items: any[];
+            density: Density;
+            groupBy: readonly SortItem[];
+            modelValue: readonly any[];
+            valueComparator: typeof deepEqual;
+            selectStrategy: "all" | "page" | "single";
+            returnObject: boolean;
+            filterMode: FilterMode;
+            noFilter: boolean;
+            itemValue: SelectItemKey;
+            hideNoData: boolean;
+            hover: boolean;
+            nextIcon: string;
+            prevIcon: string;
+            firstIcon: string;
+            lastIcon: string;
+            fixedHeader: boolean;
+            fixedFooter: boolean;
+            expandOnClick: boolean;
+            showExpand: boolean;
+            itemSelectable: SelectItemKey;
+            showSelect: boolean;
+            multiSort: boolean;
+            mustSort: boolean;
+            itemsPerPage: string | number;
+            firstPageLabel: string;
+            prevPageLabel: string;
+            nextPageLabel: string;
+            lastPageLabel: string;
+            itemsPerPageOptions: readonly (number | {
+                title: string;
+                value: number;
+            })[];
+            showCurrentPage: boolean;
+            sortAscIcon: IconValue;
+            sortDescIcon: IconValue;
+            search?: string | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            color?: string | undefined;
+            loading?: string | boolean | undefined;
+            class?: any;
+            theme?: string | undefined;
+            customFilter?: FilterFunction | undefined;
+            customKeyFilter?: FilterKeyFunctions | undefined;
+            filterKeys?: FilterKeys | undefined;
+            customKeySort?: Record<string, DataTableCompareFunction> | undefined;
+            rowHeight?: number | undefined;
+            'onClick:row'?: ((e: Event, value: {
+                item: any;
+                internalItem: DataTableItem<any>;
+            }) => void) | undefined;
+            $children?: vue.VNodeChild | {
+                [x: `item.${string}`]: ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+                [x: `column.${string}`]: ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-group'?: ((arg: {
+                    item: Group<any>;
+                    count: number;
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-select'?: ((arg: {
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'item.data-table-select'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                'item.data-table-expand'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                item?: ((arg: {
+                    index: number;
+                    item: any;
+                    internalItem: DataTableItem<any>;
                     isExpanded: (item: DataTableItem<any>) => boolean;
                     toggleExpand: (item: DataTableItem<any>) => void;
                     isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
@@ -1253,11 +1352,6 @@ declare const VDataTable: {
                 bottom?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
                 'footer.prepend'?: (() => vue.VNodeChild) | undefined;
             } | ((arg: VDataTableSlotProps) => vue.VNodeChild);
-            ref?: vue.VNodeRef | undefined;
-            ref_for?: boolean | undefined;
-            ref_key?: string | undefined;
-            theme?: string | undefined;
-            "v-slot:default"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
             'v-slots'?: {
                 [x: `item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
                 [x: `column.${string}`]: false | ((arg: {
@@ -1329,46 +1423,16 @@ declare const VDataTable: {
                 bottom?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
                 'footer.prepend'?: false | (() => vue.VNodeChild) | undefined;
             } | undefined;
-            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
-            "v-slot:loader"?: false | ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:data-table-group"?: false | ((arg: {
+                item: Group<any>;
+                count: number;
+                props: Record<string, unknown>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:data-table-select"?: false | ((arg: {
+                props: Record<string, unknown>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-select"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-expand"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
             "v-slot:item"?: false | ((arg: {
                 index: number;
                 item: any;
@@ -1382,20 +1446,268 @@ declare const VDataTable: {
             } & {
                 props: Record<string, any>;
             }) => vue.VNodeChild) | undefined;
-            customFilter?: FilterFunction | undefined;
-            customKeyFilter?: FilterKeyFunctions | undefined;
-            filterKeys?: FilterKeys | undefined;
+            "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
+            "v-slot:group-header"?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
             "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
+            "v-slot:expanded-row"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+            "v-slot:headers"?: false | ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:loader"?: false | ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:column.data-table-select"?: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:column.data-table-expand"?: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:default"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:colgroup"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
             "v-slot:top"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:body"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:tbody"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:thead"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:tfoot"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
             "v-slot:bottom"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:footer.prepend"?: false | (() => vue.VNodeChild) | undefined;
+            "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
             "onUpdate:expanded"?: ((value: any) => any) | undefined;
-            customKeySort?: Record<string, DataTableCompareFunction> | undefined;
             "onUpdate:sortBy"?: ((value: any) => any) | undefined;
             "onUpdate:groupBy"?: ((value: any) => any) | undefined;
             "onUpdate:page"?: ((value: number) => any) | undefined;
             "onUpdate:itemsPerPage"?: ((value: number) => any) | undefined;
             "onUpdate:options"?: ((value: any) => any) | undefined;
-            "v-slot:headers"?: false | ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+            style: vue.StyleValue;
+            expanded: readonly string[];
+            tag: string;
+            page: string | number;
+            sticky: boolean;
+            headers: vue.DeepReadonly<DataTableHeader[] | DataTableHeader[][]>;
+            noDataText: string;
+            loadingText: string;
+            itemsPerPageText: string;
+            sortBy: readonly SortItem[];
+            pageText: string;
+            items: any[];
+            density: Density;
+            groupBy: readonly SortItem[];
+            modelValue: readonly any[];
+            valueComparator: typeof deepEqual;
+            selectStrategy: "all" | "page" | "single";
+            returnObject: boolean;
+            filterMode: FilterMode;
+            noFilter: boolean;
+            itemValue: SelectItemKey;
+            hideNoData: boolean;
+            hover: boolean;
+            nextIcon: string;
+            prevIcon: string;
+            firstIcon: string;
+            lastIcon: string;
+            fixedHeader: boolean;
+            fixedFooter: boolean;
+            expandOnClick: boolean;
+            showExpand: boolean;
+            itemSelectable: SelectItemKey;
+            showSelect: boolean;
+            multiSort: boolean;
+            mustSort: boolean;
+            itemsPerPage: string | number;
+            firstPageLabel: string;
+            prevPageLabel: string;
+            nextPageLabel: string;
+            lastPageLabel: string;
+            itemsPerPageOptions: readonly (number | {
+                title: string;
+                value: number;
+            })[];
+            showCurrentPage: boolean;
+            sortAscIcon: IconValue;
+            sortDescIcon: IconValue;
+        } & {
+            search?: string | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            color?: string | undefined;
+            loading?: string | boolean | undefined;
+            class?: any;
+            theme?: string | undefined;
+            customFilter?: FilterFunction | undefined;
+            customKeyFilter?: FilterKeyFunctions | undefined;
+            filterKeys?: FilterKeys | undefined;
+            customKeySort?: Record<string, DataTableCompareFunction> | undefined;
+            rowHeight?: number | undefined;
+            'onClick:row'?: ((e: Event, value: {
+                item: any;
+                internalItem: DataTableItem<any>;
+            }) => void) | undefined;
+        } & {
+            $children?: vue.VNodeChild | {
+                [x: `item.${string}`]: ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+                [x: `column.${string}`]: ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-group'?: ((arg: {
+                    item: Group<any>;
+                    count: number;
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-select'?: ((arg: {
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'item.data-table-select'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                'item.data-table-expand'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                item?: ((arg: {
+                    index: number;
+                    item: any;
+                    internalItem: DataTableItem<any>;
+                    isExpanded: (item: DataTableItem<any>) => boolean;
+                    toggleExpand: (item: DataTableItem<any>) => void;
+                    isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+                    toggleSelect: (item: SelectableItem) => void;
+                } & {
+                    columns: InternalDataTableHeader[];
+                } & {
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+                loading?: (() => vue.VNodeChild) | undefined;
+                'group-header'?: ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
+                'no-data'?: (() => vue.VNodeChild) | undefined;
+                'expanded-row'?: ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+                headers?: ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
+                loader?: ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+                'column.data-table-select'?: ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                'column.data-table-expand'?: ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                default?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                colgroup?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                top?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                body?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                tbody?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                thead?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                tfoot?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                bottom?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                'footer.prepend'?: (() => vue.VNodeChild) | undefined;
+            } | ((arg: VDataTableSlotProps) => vue.VNodeChild);
+            'v-slots'?: {
+                [x: `item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+                [x: `column.${string}`]: false | ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-group'?: false | ((arg: {
+                    item: Group<any>;
+                    count: number;
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-select'?: false | ((arg: {
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'item.data-table-select'?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                'item.data-table-expand'?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                item?: false | ((arg: {
+                    index: number;
+                    item: any;
+                    internalItem: DataTableItem<any>;
+                    isExpanded: (item: DataTableItem<any>) => boolean;
+                    toggleExpand: (item: DataTableItem<any>) => void;
+                    isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+                    toggleSelect: (item: SelectableItem) => void;
+                } & {
+                    columns: InternalDataTableHeader[];
+                } & {
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+                loading?: false | (() => vue.VNodeChild) | undefined;
+                'group-header'?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
+                'no-data'?: false | (() => vue.VNodeChild) | undefined;
+                'expanded-row'?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+                headers?: false | ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
+                loader?: false | ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+                'column.data-table-select'?: false | ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                'column.data-table-expand'?: false | ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                default?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                colgroup?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                top?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                body?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                tbody?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                thead?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                tfoot?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                bottom?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                'footer.prepend'?: false | (() => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            [x: `v-slot:item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+            [x: `v-slot:column.${string}`]: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
             "v-slot:data-table-group"?: false | ((arg: {
                 item: Group<any>;
                 count: number;
@@ -1403,22 +1715,66 @@ declare const VDataTable: {
             }) => vue.VNodeChild) | undefined;
             "v-slot:data-table-select"?: false | ((arg: {
                 props: Record<string, unknown>;
-            }) => vue.VNodeChild) | undefined;
-            rowHeight?: number | undefined;
-            'onClick:row'?: ((e: Event, value: {
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-select"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-expand"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item"?: false | ((arg: {
+                index: number;
                 item: any;
                 internalItem: DataTableItem<any>;
-            }) => void) | undefined;
+                isExpanded: (item: DataTableItem<any>) => boolean;
+                toggleExpand: (item: DataTableItem<any>) => void;
+                isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+                toggleSelect: (item: SelectableItem) => void;
+            } & {
+                columns: InternalDataTableHeader[];
+            } & {
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
             "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
             "v-slot:group-header"?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
+            "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
             "v-slot:expanded-row"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
-            "v-slot:body"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:headers"?: false | ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:loader"?: false | ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:column.data-table-select"?: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:column.data-table-expand"?: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:default"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
             "v-slot:colgroup"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:top"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:body"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
             "v-slot:tbody"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
-            "v-slot:tfoot"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
             "v-slot:thead"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:tfoot"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:bottom"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
             "v-slot:footer.prepend"?: false | (() => vue.VNodeChild) | undefined;
-        };
+        } & {
+            "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
+            "onUpdate:expanded"?: ((value: any) => any) | undefined;
+            "onUpdate:sortBy"?: ((value: any) => any) | undefined;
+            "onUpdate:groupBy"?: ((value: any) => any) | undefined;
+            "onUpdate:page"?: ((value: number) => any) | undefined;
+            "onUpdate:itemsPerPage"?: ((value: number) => any) | undefined;
+            "onUpdate:options"?: ((value: any) => any) | undefined;
+        }, "style" | "expanded" | "tag" | "page" | "sticky" | "headers" | "noDataText" | "loadingText" | "itemsPerPageText" | "sortBy" | "pageText" | "items" | "density" | "groupBy" | "modelValue" | "valueComparator" | "selectStrategy" | "returnObject" | "filterMode" | "noFilter" | "itemValue" | "hideNoData" | "hover" | "nextIcon" | "prevIcon" | "firstIcon" | "lastIcon" | "fixedHeader" | "fixedFooter" | "expandOnClick" | "showExpand" | "itemSelectable" | "showSelect" | "multiSort" | "mustSort" | "itemsPerPage" | "firstPageLabel" | "prevPageLabel" | "nextPageLabel" | "lastPageLabel" | "itemsPerPageOptions" | "showCurrentPage" | "sortAscIcon" | "sortDescIcon">;
         $attrs: {
             [x: string]: unknown;
         };
@@ -1562,6 +1918,7 @@ declare const VDataTable: {
             pageText: string;
             items: any[];
             density: Density;
+            groupBy: readonly SortItem[];
             modelValue: readonly any[];
             valueComparator: typeof deepEqual;
             selectStrategy: "all" | "page" | "single";
@@ -1581,7 +1938,6 @@ declare const VDataTable: {
             showExpand: boolean;
             itemSelectable: SelectItemKey;
             showSelect: boolean;
-            groupBy: readonly SortItem[];
             multiSort: boolean;
             mustSort: boolean;
             itemsPerPage: string | number;
@@ -1856,6 +2212,7 @@ declare const VDataTable: {
             pageText: string;
             items: any[];
             density: Density;
+            groupBy: readonly SortItem[];
             modelValue: readonly any[];
             valueComparator: typeof deepEqual;
             selectStrategy: "all" | "page" | "single";
@@ -1875,7 +2232,6 @@ declare const VDataTable: {
             showExpand: boolean;
             itemSelectable: SelectItemKey;
             showSelect: boolean;
-            groupBy: readonly SortItem[];
             multiSort: boolean;
             mustSort: boolean;
             itemsPerPage: string | number;
@@ -2042,6 +2398,7 @@ declare const VDataTable: {
         pageText: string;
         items: any[];
         density: Density;
+        groupBy: readonly SortItem[];
         modelValue: readonly any[];
         valueComparator: typeof deepEqual;
         selectStrategy: "all" | "page" | "single";
@@ -2061,7 +2418,6 @@ declare const VDataTable: {
         showExpand: boolean;
         itemSelectable: SelectItemKey;
         showSelect: boolean;
-        groupBy: readonly SortItem[];
         multiSort: boolean;
         mustSort: boolean;
         itemsPerPage: string | number;
@@ -2332,6 +2688,7 @@ declare const VDataTable: {
     pageText: string;
     items: any[];
     density: Density;
+    groupBy: readonly SortItem[];
     modelValue: readonly any[];
     valueComparator: typeof deepEqual;
     selectStrategy: "all" | "page" | "single";
@@ -2351,7 +2708,6 @@ declare const VDataTable: {
     showExpand: boolean;
     itemSelectable: SelectItemKey;
     showSelect: boolean;
-    groupBy: readonly SortItem[];
     multiSort: boolean;
     mustSort: boolean;
     itemsPerPage: string | number;
@@ -2626,6 +2982,7 @@ declare const VDataTable: {
     pageText: string;
     items: any[];
     density: Density;
+    groupBy: readonly SortItem[];
     modelValue: readonly any[];
     valueComparator: typeof deepEqual;
     selectStrategy: "all" | "page" | "single";
@@ -2645,7 +3002,6 @@ declare const VDataTable: {
     showExpand: boolean;
     itemSelectable: SelectItemKey;
     showSelect: boolean;
-    groupBy: readonly SortItem[];
     multiSort: boolean;
     mustSort: boolean;
     itemsPerPage: string | number;
@@ -3107,74 +3463,71 @@ declare const VDataTableFooter: {
     new (...args: any[]): {
         $: vue.ComponentInternalInstance;
         $data: {};
-        $props: {
-            itemsPerPageText?: string | undefined;
-            pageText?: string | undefined;
-            nextIcon?: string | undefined;
-            prevIcon?: string | undefined;
-            firstIcon?: string | undefined;
-            lastIcon?: string | undefined;
-            firstPageLabel?: string | undefined;
-            prevPageLabel?: string | undefined;
-            nextPageLabel?: string | undefined;
-            lastPageLabel?: string | undefined;
-            itemsPerPageOptions?: readonly (number | {
+        $props: Partial<{
+            itemsPerPageText: string;
+            pageText: string;
+            nextIcon: string;
+            prevIcon: string;
+            firstIcon: string;
+            lastIcon: string;
+            firstPageLabel: string;
+            prevPageLabel: string;
+            nextPageLabel: string;
+            lastPageLabel: string;
+            itemsPerPageOptions: readonly (number | {
+                title: string;
+                value: number;
+            })[];
+            showCurrentPage: boolean;
+        }> & Omit<{
+            itemsPerPageText: string;
+            pageText: string;
+            nextIcon: string;
+            prevIcon: string;
+            firstIcon: string;
+            lastIcon: string;
+            firstPageLabel: string;
+            prevPageLabel: string;
+            nextPageLabel: string;
+            lastPageLabel: string;
+            itemsPerPageOptions: readonly (number | {
                 title: string;
                 value: number;
-            })[] | undefined;
-            showCurrentPage?: boolean | undefined;
-            key?: string | number | symbol | undefined;
-            style?: unknown;
-            class?: unknown;
+            })[];
+            showCurrentPage: boolean;
             $children?: {} | vue.VNodeChild | {
                 prepend?: (() => vue.VNodeChild) | undefined;
             };
-            ref?: vue.VNodeRef | undefined;
-            ref_for?: boolean | undefined;
-            ref_key?: string | undefined;
             'v-slots'?: {
                 prepend?: false | (() => vue.VNodeChild) | undefined;
             } | undefined;
-            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
             "v-slot:prepend"?: false | (() => vue.VNodeChild) | undefined;
-        };
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+            itemsPerPageText: string;
+            pageText: string;
+            nextIcon: string;
+            prevIcon: string;
+            firstIcon: string;
+            lastIcon: string;
+            firstPageLabel: string;
+            prevPageLabel: string;
+            nextPageLabel: string;
+            lastPageLabel: string;
+            itemsPerPageOptions: readonly (number | {
+                title: string;
+                value: number;
+            })[];
+            showCurrentPage: boolean;
+        } & {} & {
+            $children?: {} | vue.VNodeChild | {
+                prepend?: (() => vue.VNodeChild) | undefined;
+            };
+            'v-slots'?: {
+                prepend?: false | (() => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            "v-slot:prepend"?: false | (() => vue.VNodeChild) | undefined;
+        }, "itemsPerPageText" | "pageText" | "nextIcon" | "prevIcon" | "firstIcon" | "lastIcon" | "firstPageLabel" | "prevPageLabel" | "nextPageLabel" | "lastPageLabel" | "itemsPerPageOptions" | "showCurrentPage">;
         $attrs: {
             [x: string]: unknown;
         };
@@ -3440,7 +3793,40 @@ declare const VDataTableVirtual: {
     new (...args: any[]): {
         $: vue.ComponentInternalInstance;
         $data: {};
-        $props: {
+        $props: Partial<{
+            style: vue.StyleValue;
+            expanded: readonly string[];
+            tag: string;
+            sticky: boolean;
+            headers: vue.DeepReadonly<DataTableHeader[] | DataTableHeader[][]>;
+            noDataText: string;
+            loadingText: string;
+            sortBy: readonly SortItem[];
+            items: any[];
+            density: Density;
+            groupBy: readonly SortItem[];
+            modelValue: readonly any[];
+            valueComparator: typeof deepEqual;
+            selectStrategy: "all" | "page" | "single";
+            returnObject: boolean;
+            filterMode: FilterMode;
+            noFilter: boolean;
+            itemValue: SelectItemKey;
+            itemHeight: string | number;
+            hideNoData: boolean;
+            hover: boolean;
+            fixedHeader: boolean;
+            fixedFooter: boolean;
+            expandOnClick: boolean;
+            showExpand: boolean;
+            itemSelectable: SelectItemKey;
+            showSelect: boolean;
+            multiSort: boolean;
+            mustSort: boolean;
+            sortAscIcon: IconValue;
+            sortDescIcon: IconValue;
+        }> & Omit<{
+            [x: `v-slot:item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
             [x: `v-slot:column.${string}`]: false | ((arg: {
                 column: InternalDataTableHeader;
                 selectAll: (value: boolean) => void;
@@ -3451,45 +3837,293 @@ declare const VDataTableVirtual: {
                 allSelected: boolean;
                 getSortIcon: (column: InternalDataTableHeader) => IconValue;
             }) => vue.VNodeChild) | undefined;
-            [x: `v-slot:item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
-            style?: vue.StyleValue | undefined;
-            expanded?: readonly string[] | undefined;
-            tag?: string | undefined;
-            sticky?: boolean | undefined;
-            headers?: vue.DeepReadonly<DataTableHeader[] | DataTableHeader[][]> | undefined;
-            noDataText?: string | undefined;
-            loadingText?: string | undefined;
-            sortBy?: readonly SortItem[] | undefined;
-            items?: any[] | undefined;
-            density?: Density | undefined;
-            modelValue?: readonly any[] | undefined;
-            valueComparator?: typeof deepEqual | undefined;
-            selectStrategy?: "all" | "page" | "single" | undefined;
-            returnObject?: boolean | undefined;
-            filterMode?: FilterMode | undefined;
-            noFilter?: boolean | undefined;
-            itemValue?: SelectItemKey;
-            itemHeight?: string | number | undefined;
-            hideNoData?: boolean | undefined;
-            hover?: boolean | undefined;
-            fixedHeader?: boolean | undefined;
-            fixedFooter?: boolean | undefined;
-            expandOnClick?: boolean | undefined;
-            showExpand?: boolean | undefined;
-            itemSelectable?: SelectItemKey;
-            showSelect?: boolean | undefined;
-            groupBy?: readonly SortItem[] | undefined;
-            multiSort?: boolean | undefined;
-            mustSort?: boolean | undefined;
-            sortAscIcon?: IconValue | undefined;
-            sortDescIcon?: IconValue | undefined;
+            style: vue.StyleValue;
+            expanded: readonly string[];
+            tag: string;
+            sticky: boolean;
+            headers: vue.DeepReadonly<DataTableHeader[] | DataTableHeader[][]>;
+            noDataText: string;
+            loadingText: string;
+            sortBy: readonly SortItem[];
+            items: any[];
+            density: Density;
+            groupBy: readonly SortItem[];
+            modelValue: readonly any[];
+            valueComparator: typeof deepEqual;
+            selectStrategy: "all" | "page" | "single";
+            returnObject: boolean;
+            filterMode: FilterMode;
+            noFilter: boolean;
+            itemValue: SelectItemKey;
+            itemHeight: string | number;
+            hideNoData: boolean;
+            hover: boolean;
+            fixedHeader: boolean;
+            fixedFooter: boolean;
+            expandOnClick: boolean;
+            showExpand: boolean;
+            itemSelectable: SelectItemKey;
+            showSelect: boolean;
+            multiSort: boolean;
+            mustSort: boolean;
+            sortAscIcon: IconValue;
+            sortDescIcon: IconValue;
+            search?: string | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            color?: string | undefined;
+            loading?: string | boolean | undefined;
+            class?: any;
+            theme?: string | undefined;
+            customFilter?: FilterFunction | undefined;
+            customKeyFilter?: FilterKeyFunctions | undefined;
+            filterKeys?: FilterKeys | undefined;
+            customKeySort?: Record<string, DataTableCompareFunction> | undefined;
+            rowHeight?: number | undefined;
+            'onClick:row'?: ((e: Event, value: {
+                item: any;
+                internalItem: DataTableItem<any>;
+            }) => void) | undefined;
+            $children?: {} | vue.VNodeChild | {
+                [x: `item.${string}`]: ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+                [x: `column.${string}`]: ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-group'?: ((arg: {
+                    item: Group<any>;
+                    count: number;
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-select'?: ((arg: {
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'item.data-table-select'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                'item.data-table-expand'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                item?: ((arg: {
+                    index: number;
+                    item: any;
+                    internalItem: DataTableItem<any>;
+                    isExpanded: (item: DataTableItem<any>) => boolean;
+                    toggleExpand: (item: DataTableItem<any>) => void;
+                    isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+                    toggleSelect: (item: SelectableItem) => void;
+                } & {
+                    columns: InternalDataTableHeader[];
+                } & {
+                    props: Record<string, any>;
+                } & {
+                    itemRef: Ref<HTMLElement | undefined>;
+                }) => vue.VNodeChild) | undefined;
+                loading?: (() => vue.VNodeChild) | undefined;
+                'group-header'?: ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
+                'no-data'?: (() => vue.VNodeChild) | undefined;
+                'expanded-row'?: ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+                headers?: ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
+                loader?: ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+                'column.data-table-select'?: ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                'column.data-table-expand'?: ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                top?: ((arg: VDataTableVirtualSlotProps) => vue.VNodeChild) | undefined;
+                bottom?: ((arg: VDataTableVirtualSlotProps) => vue.VNodeChild) | undefined;
+            };
+            'v-slots'?: {
+                [x: `item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+                [x: `column.${string}`]: false | ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-group'?: false | ((arg: {
+                    item: Group<any>;
+                    count: number;
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-select'?: false | ((arg: {
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'item.data-table-select'?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                'item.data-table-expand'?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                item?: false | ((arg: {
+                    index: number;
+                    item: any;
+                    internalItem: DataTableItem<any>;
+                    isExpanded: (item: DataTableItem<any>) => boolean;
+                    toggleExpand: (item: DataTableItem<any>) => void;
+                    isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+                    toggleSelect: (item: SelectableItem) => void;
+                } & {
+                    columns: InternalDataTableHeader[];
+                } & {
+                    props: Record<string, any>;
+                } & {
+                    itemRef: Ref<HTMLElement | undefined>;
+                }) => vue.VNodeChild) | undefined;
+                loading?: false | (() => vue.VNodeChild) | undefined;
+                'group-header'?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
+                'no-data'?: false | (() => vue.VNodeChild) | undefined;
+                'expanded-row'?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+                headers?: false | ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
+                loader?: false | ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+                'column.data-table-select'?: false | ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                'column.data-table-expand'?: false | ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                top?: false | ((arg: VDataTableVirtualSlotProps) => vue.VNodeChild) | undefined;
+                bottom?: false | ((arg: VDataTableVirtualSlotProps) => vue.VNodeChild) | undefined;
+            } | undefined;
+            "v-slot:data-table-group"?: false | ((arg: {
+                item: Group<any>;
+                count: number;
+                props: Record<string, unknown>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:data-table-select"?: false | ((arg: {
+                props: Record<string, unknown>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-select"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-expand"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item"?: false | ((arg: {
+                index: number;
+                item: any;
+                internalItem: DataTableItem<any>;
+                isExpanded: (item: DataTableItem<any>) => boolean;
+                toggleExpand: (item: DataTableItem<any>) => void;
+                isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+                toggleSelect: (item: SelectableItem) => void;
+            } & {
+                columns: InternalDataTableHeader[];
+            } & {
+                props: Record<string, any>;
+            } & {
+                itemRef: Ref<HTMLElement | undefined>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
+            "v-slot:group-header"?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
+            "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
+            "v-slot:expanded-row"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+            "v-slot:headers"?: false | ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:loader"?: false | ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:column.data-table-select"?: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:column.data-table-expand"?: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:top"?: false | ((arg: VDataTableVirtualSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:bottom"?: false | ((arg: VDataTableVirtualSlotProps) => vue.VNodeChild) | undefined;
+            "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
+            "onUpdate:expanded"?: ((value: any) => any) | undefined;
+            "onUpdate:sortBy"?: ((value: any) => any) | undefined;
+            "onUpdate:groupBy"?: ((value: any) => any) | undefined;
+            "onUpdate:options"?: ((value: any) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+            style: vue.StyleValue;
+            expanded: readonly string[];
+            tag: string;
+            sticky: boolean;
+            headers: vue.DeepReadonly<DataTableHeader[] | DataTableHeader[][]>;
+            noDataText: string;
+            loadingText: string;
+            sortBy: readonly SortItem[];
+            items: any[];
+            density: Density;
+            groupBy: readonly SortItem[];
+            modelValue: readonly any[];
+            valueComparator: typeof deepEqual;
+            selectStrategy: "all" | "page" | "single";
+            returnObject: boolean;
+            filterMode: FilterMode;
+            noFilter: boolean;
+            itemValue: SelectItemKey;
+            itemHeight: string | number;
+            hideNoData: boolean;
+            hover: boolean;
+            fixedHeader: boolean;
+            fixedFooter: boolean;
+            expandOnClick: boolean;
+            showExpand: boolean;
+            itemSelectable: SelectItemKey;
+            showSelect: boolean;
+            multiSort: boolean;
+            mustSort: boolean;
+            sortAscIcon: IconValue;
+            sortDescIcon: IconValue;
+        } & {
             search?: string | undefined;
-            key?: string | number | symbol | undefined;
             height?: string | number | undefined;
             width?: string | number | undefined;
             color?: string | undefined;
             loading?: string | boolean | undefined;
             class?: any;
+            theme?: string | undefined;
+            customFilter?: FilterFunction | undefined;
+            customKeyFilter?: FilterKeyFunctions | undefined;
+            filterKeys?: FilterKeys | undefined;
+            customKeySort?: Record<string, DataTableCompareFunction> | undefined;
+            rowHeight?: number | undefined;
+            'onClick:row'?: ((e: Event, value: {
+                item: any;
+                internalItem: DataTableItem<any>;
+            }) => void) | undefined;
+        } & {
             $children?: {} | vue.VNodeChild | {
                 [x: `item.${string}`]: ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
                 [x: `column.${string}`]: ((arg: {
@@ -3556,10 +4190,6 @@ declare const VDataTableVirtual: {
                 top?: ((arg: VDataTableVirtualSlotProps) => vue.VNodeChild) | undefined;
                 bottom?: ((arg: VDataTableVirtualSlotProps) => vue.VNodeChild) | undefined;
             };
-            ref?: vue.VNodeRef | undefined;
-            ref_for?: boolean | undefined;
-            ref_key?: string | undefined;
-            theme?: string | undefined;
             'v-slots'?: {
                 [x: `item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
                 [x: `column.${string}`]: false | ((arg: {
@@ -3626,46 +4256,28 @@ declare const VDataTableVirtual: {
                 top?: false | ((arg: VDataTableVirtualSlotProps) => vue.VNodeChild) | undefined;
                 bottom?: false | ((arg: VDataTableVirtualSlotProps) => vue.VNodeChild) | undefined;
             } | undefined;
-            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
-            "v-slot:loader"?: false | ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+        } & {
+            [x: `v-slot:item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+            [x: `v-slot:column.${string}`]: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:data-table-group"?: false | ((arg: {
+                item: Group<any>;
+                count: number;
+                props: Record<string, unknown>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:data-table-select"?: false | ((arg: {
+                props: Record<string, unknown>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-select"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-expand"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
             "v-slot:item"?: false | ((arg: {
                 index: number;
                 item: any;
@@ -3681,35 +4293,41 @@ declare const VDataTableVirtual: {
             } & {
                 itemRef: Ref<HTMLElement | undefined>;
             }) => vue.VNodeChild) | undefined;
-            customFilter?: FilterFunction | undefined;
-            customKeyFilter?: FilterKeyFunctions | undefined;
-            filterKeys?: FilterKeys | undefined;
+            "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
+            "v-slot:group-header"?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
             "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
+            "v-slot:expanded-row"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+            "v-slot:headers"?: false | ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:loader"?: false | ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:column.data-table-select"?: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:column.data-table-expand"?: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
             "v-slot:top"?: false | ((arg: VDataTableVirtualSlotProps) => vue.VNodeChild) | undefined;
             "v-slot:bottom"?: false | ((arg: VDataTableVirtualSlotProps) => vue.VNodeChild) | undefined;
+        } & {
+            "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
             "onUpdate:expanded"?: ((value: any) => any) | undefined;
-            customKeySort?: Record<string, DataTableCompareFunction> | undefined;
             "onUpdate:sortBy"?: ((value: any) => any) | undefined;
             "onUpdate:groupBy"?: ((value: any) => any) | undefined;
             "onUpdate:options"?: ((value: any) => any) | undefined;
-            "v-slot:headers"?: false | ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
-            "v-slot:data-table-group"?: false | ((arg: {
-                item: Group<any>;
-                count: number;
-                props: Record<string, unknown>;
-            }) => vue.VNodeChild) | undefined;
-            "v-slot:data-table-select"?: false | ((arg: {
-                props: Record<string, unknown>;
-            }) => vue.VNodeChild) | undefined;
-            rowHeight?: number | undefined;
-            'onClick:row'?: ((e: Event, value: {
-                item: any;
-                internalItem: DataTableItem<any>;
-            }) => void) | undefined;
-            "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
-            "v-slot:group-header"?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
-            "v-slot:expanded-row"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
-        };
+        }, "style" | "expanded" | "tag" | "sticky" | "headers" | "noDataText" | "loadingText" | "sortBy" | "items" | "density" | "groupBy" | "modelValue" | "valueComparator" | "selectStrategy" | "returnObject" | "filterMode" | "noFilter" | "itemValue" | "itemHeight" | "hideNoData" | "hover" | "fixedHeader" | "fixedFooter" | "expandOnClick" | "showExpand" | "itemSelectable" | "showSelect" | "multiSort" | "mustSort" | "sortAscIcon" | "sortDescIcon">;
         $attrs: {
             [x: string]: unknown;
         };
@@ -3831,6 +4449,7 @@ declare const VDataTableVirtual: {
             sortBy: readonly SortItem[];
             items: any[];
             density: Density;
+            groupBy: readonly SortItem[];
             modelValue: readonly any[];
             valueComparator: typeof deepEqual;
             selectStrategy: "all" | "page" | "single";
@@ -3847,7 +4466,6 @@ declare const VDataTableVirtual: {
             showExpand: boolean;
             itemSelectable: SelectItemKey;
             showSelect: boolean;
-            groupBy: readonly SortItem[];
             multiSort: boolean;
             mustSort: boolean;
             sortAscIcon: IconValue;
@@ -4090,6 +4708,7 @@ declare const VDataTableVirtual: {
             sortBy: readonly SortItem[];
             items: any[];
             density: Density;
+            groupBy: readonly SortItem[];
             modelValue: readonly any[];
             valueComparator: typeof deepEqual;
             selectStrategy: "all" | "page" | "single";
@@ -4106,7 +4725,6 @@ declare const VDataTableVirtual: {
             showExpand: boolean;
             itemSelectable: SelectItemKey;
             showSelect: boolean;
-            groupBy: readonly SortItem[];
             multiSort: boolean;
             mustSort: boolean;
             sortAscIcon: IconValue;
@@ -4241,6 +4859,7 @@ declare const VDataTableVirtual: {
         sortBy: readonly SortItem[];
         items: any[];
         density: Density;
+        groupBy: readonly SortItem[];
         modelValue: readonly any[];
         valueComparator: typeof deepEqual;
         selectStrategy: "all" | "page" | "single";
@@ -4257,7 +4876,6 @@ declare const VDataTableVirtual: {
         showExpand: boolean;
         itemSelectable: SelectItemKey;
         showSelect: boolean;
-        groupBy: readonly SortItem[];
         multiSort: boolean;
         mustSort: boolean;
         sortAscIcon: IconValue;
@@ -4498,6 +5116,7 @@ declare const VDataTableVirtual: {
     sortBy: readonly SortItem[];
     items: any[];
     density: Density;
+    groupBy: readonly SortItem[];
     modelValue: readonly any[];
     valueComparator: typeof deepEqual;
     selectStrategy: "all" | "page" | "single";
@@ -4514,7 +5133,6 @@ declare const VDataTableVirtual: {
     showExpand: boolean;
     itemSelectable: SelectItemKey;
     showSelect: boolean;
-    groupBy: readonly SortItem[];
     multiSort: boolean;
     mustSort: boolean;
     sortAscIcon: IconValue;
@@ -4757,6 +5375,7 @@ declare const VDataTableVirtual: {
     sortBy: readonly SortItem[];
     items: any[];
     density: Density;
+    groupBy: readonly SortItem[];
     modelValue: readonly any[];
     valueComparator: typeof deepEqual;
     selectStrategy: "all" | "page" | "single";
@@ -4773,7 +5392,6 @@ declare const VDataTableVirtual: {
     showExpand: boolean;
     itemSelectable: SelectItemKey;
     showSelect: boolean;
-    groupBy: readonly SortItem[];
     multiSort: boolean;
     mustSort: boolean;
     sortAscIcon: IconValue;
@@ -5096,7 +5714,54 @@ declare const VDataTableServer: {
     new (...args: any[]): {
         $: vue.ComponentInternalInstance;
         $data: {};
-        $props: {
+        $props: Partial<{
+            style: vue.StyleValue;
+            expanded: readonly string[];
+            tag: string;
+            page: string | number;
+            sticky: boolean;
+            headers: vue.DeepReadonly<DataTableHeader[] | DataTableHeader[][]>;
+            noDataText: string;
+            loadingText: string;
+            itemsPerPageText: string;
+            sortBy: readonly SortItem[];
+            pageText: string;
+            items: any[];
+            density: Density;
+            groupBy: readonly SortItem[];
+            modelValue: readonly any[];
+            valueComparator: typeof deepEqual;
+            selectStrategy: "all" | "page" | "single";
+            returnObject: boolean;
+            itemValue: SelectItemKey;
+            hideNoData: boolean;
+            hover: boolean;
+            nextIcon: string;
+            prevIcon: string;
+            firstIcon: string;
+            lastIcon: string;
+            fixedHeader: boolean;
+            fixedFooter: boolean;
+            expandOnClick: boolean;
+            showExpand: boolean;
+            itemSelectable: SelectItemKey;
+            showSelect: boolean;
+            multiSort: boolean;
+            mustSort: boolean;
+            itemsPerPage: string | number;
+            firstPageLabel: string;
+            prevPageLabel: string;
+            nextPageLabel: string;
+            lastPageLabel: string;
+            itemsPerPageOptions: readonly (number | {
+                title: string;
+                value: number;
+            })[];
+            showCurrentPage: boolean;
+            sortAscIcon: IconValue;
+            sortDescIcon: IconValue;
+        }> & Omit<{
+            [x: `v-slot:item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
             [x: `v-slot:column.${string}`]: false | ((arg: {
                 column: InternalDataTableHeader;
                 selectAll: (value: boolean) => void;
@@ -5107,59 +5772,334 @@ declare const VDataTableServer: {
                 allSelected: boolean;
                 getSortIcon: (column: InternalDataTableHeader) => IconValue;
             }) => vue.VNodeChild) | undefined;
-            [x: `v-slot:item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
-            style?: vue.StyleValue | undefined;
-            expanded?: readonly string[] | undefined;
-            tag?: string | undefined;
-            page?: string | number | undefined;
-            sticky?: boolean | undefined;
-            headers?: vue.DeepReadonly<DataTableHeader[] | DataTableHeader[][]> | undefined;
-            noDataText?: string | undefined;
-            loadingText?: string | undefined;
-            itemsPerPageText?: string | undefined;
-            sortBy?: readonly SortItem[] | undefined;
-            pageText?: string | undefined;
-            items?: any[] | undefined;
-            density?: Density | undefined;
-            modelValue?: readonly any[] | undefined;
-            valueComparator?: typeof deepEqual | undefined;
-            selectStrategy?: "all" | "page" | "single" | undefined;
-            returnObject?: boolean | undefined;
-            itemValue?: SelectItemKey;
-            hideNoData?: boolean | undefined;
-            hover?: boolean | undefined;
-            nextIcon?: string | undefined;
-            prevIcon?: string | undefined;
-            firstIcon?: string | undefined;
-            lastIcon?: string | undefined;
-            fixedHeader?: boolean | undefined;
-            fixedFooter?: boolean | undefined;
-            expandOnClick?: boolean | undefined;
-            showExpand?: boolean | undefined;
-            itemSelectable?: SelectItemKey;
-            showSelect?: boolean | undefined;
-            groupBy?: readonly SortItem[] | undefined;
-            multiSort?: boolean | undefined;
-            mustSort?: boolean | undefined;
-            itemsPerPage?: string | number | undefined;
-            firstPageLabel?: string | undefined;
-            prevPageLabel?: string | undefined;
-            nextPageLabel?: string | undefined;
-            lastPageLabel?: string | undefined;
-            itemsPerPageOptions?: readonly (number | {
+            style: vue.StyleValue;
+            expanded: readonly string[];
+            tag: string;
+            page: string | number;
+            sticky: boolean;
+            headers: vue.DeepReadonly<DataTableHeader[] | DataTableHeader[][]>;
+            noDataText: string;
+            loadingText: string;
+            itemsPerPageText: string;
+            sortBy: readonly SortItem[];
+            pageText: string;
+            items: any[];
+            density: Density;
+            groupBy: readonly SortItem[];
+            modelValue: readonly any[];
+            valueComparator: typeof deepEqual;
+            selectStrategy: "all" | "page" | "single";
+            returnObject: boolean;
+            itemValue: SelectItemKey;
+            hideNoData: boolean;
+            hover: boolean;
+            nextIcon: string;
+            prevIcon: string;
+            firstIcon: string;
+            lastIcon: string;
+            fixedHeader: boolean;
+            fixedFooter: boolean;
+            expandOnClick: boolean;
+            showExpand: boolean;
+            itemSelectable: SelectItemKey;
+            showSelect: boolean;
+            multiSort: boolean;
+            mustSort: boolean;
+            itemsPerPage: string | number;
+            itemsLength: string | number;
+            firstPageLabel: string;
+            prevPageLabel: string;
+            nextPageLabel: string;
+            lastPageLabel: string;
+            itemsPerPageOptions: readonly (number | {
+                title: string;
+                value: number;
+            })[];
+            showCurrentPage: boolean;
+            sortAscIcon: IconValue;
+            sortDescIcon: IconValue;
+            search?: string | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            color?: string | undefined;
+            loading?: string | boolean | undefined;
+            class?: any;
+            theme?: string | undefined;
+            customKeySort?: Record<string, DataTableCompareFunction> | undefined;
+            rowHeight?: number | undefined;
+            'onClick:row'?: ((e: Event, value: {
+                item: any;
+                internalItem: DataTableItem<any>;
+            }) => void) | undefined;
+            $children?: vue.VNodeChild | {
+                [x: `item.${string}`]: ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+                [x: `column.${string}`]: ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-group'?: ((arg: {
+                    item: Group<any>;
+                    count: number;
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-select'?: ((arg: {
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'item.data-table-select'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                'item.data-table-expand'?: ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                item?: ((arg: {
+                    index: number;
+                    item: any;
+                    internalItem: DataTableItem<any>;
+                    isExpanded: (item: DataTableItem<any>) => boolean;
+                    toggleExpand: (item: DataTableItem<any>) => void;
+                    isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+                    toggleSelect: (item: SelectableItem) => void;
+                } & {
+                    columns: InternalDataTableHeader[];
+                } & {
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+                loading?: (() => vue.VNodeChild) | undefined;
+                'group-header'?: ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
+                'no-data'?: (() => vue.VNodeChild) | undefined;
+                'expanded-row'?: ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+                headers?: ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
+                loader?: ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+                'column.data-table-select'?: ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                'column.data-table-expand'?: ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                default?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                colgroup?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                top?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                body?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                tbody?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                thead?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                tfoot?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                bottom?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                'footer.prepend'?: (() => vue.VNodeChild) | undefined;
+            } | ((arg: VDataTableSlotProps) => vue.VNodeChild);
+            'v-slots'?: {
+                [x: `item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+                [x: `column.${string}`]: false | ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-group'?: false | ((arg: {
+                    item: Group<any>;
+                    count: number;
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'data-table-select'?: false | ((arg: {
+                    props: Record<string, unknown>;
+                }) => vue.VNodeChild) | undefined;
+                'item.data-table-select'?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                'item.data-table-expand'?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+                item?: false | ((arg: {
+                    index: number;
+                    item: any;
+                    internalItem: DataTableItem<any>;
+                    isExpanded: (item: DataTableItem<any>) => boolean;
+                    toggleExpand: (item: DataTableItem<any>) => void;
+                    isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+                    toggleSelect: (item: SelectableItem) => void;
+                } & {
+                    columns: InternalDataTableHeader[];
+                } & {
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+                loading?: false | (() => vue.VNodeChild) | undefined;
+                'group-header'?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
+                'no-data'?: false | (() => vue.VNodeChild) | undefined;
+                'expanded-row'?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+                headers?: false | ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
+                loader?: false | ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+                'column.data-table-select'?: false | ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                'column.data-table-expand'?: false | ((arg: {
+                    column: InternalDataTableHeader;
+                    selectAll: (value: boolean) => void;
+                    isSorted: (column: InternalDataTableHeader) => boolean;
+                    toggleSort: (column: InternalDataTableHeader) => void;
+                    sortBy: readonly SortItem[];
+                    someSelected: boolean;
+                    allSelected: boolean;
+                    getSortIcon: (column: InternalDataTableHeader) => IconValue;
+                }) => vue.VNodeChild) | undefined;
+                default?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                colgroup?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                top?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                body?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                tbody?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                thead?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                tfoot?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                bottom?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+                'footer.prepend'?: false | (() => vue.VNodeChild) | undefined;
+            } | undefined;
+            "v-slot:data-table-group"?: false | ((arg: {
+                item: Group<any>;
+                count: number;
+                props: Record<string, unknown>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:data-table-select"?: false | ((arg: {
+                props: Record<string, unknown>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-select"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-expand"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item"?: false | ((arg: {
+                index: number;
+                item: any;
+                internalItem: DataTableItem<any>;
+                isExpanded: (item: DataTableItem<any>) => boolean;
+                toggleExpand: (item: DataTableItem<any>) => void;
+                isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+                toggleSelect: (item: SelectableItem) => void;
+            } & {
+                columns: InternalDataTableHeader[];
+            } & {
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
+            "v-slot:group-header"?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
+            "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
+            "v-slot:expanded-row"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+            "v-slot:headers"?: false | ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:loader"?: false | ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:column.data-table-select"?: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:column.data-table-expand"?: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:default"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:colgroup"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:top"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:body"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:tbody"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:thead"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:tfoot"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:bottom"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:footer.prepend"?: false | (() => vue.VNodeChild) | undefined;
+            "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
+            "onUpdate:expanded"?: ((options: any) => any) | undefined;
+            "onUpdate:sortBy"?: ((sortBy: any) => any) | undefined;
+            "onUpdate:groupBy"?: ((value: any) => any) | undefined;
+            "onUpdate:page"?: ((page: number) => any) | undefined;
+            "onUpdate:itemsPerPage"?: ((page: number) => any) | undefined;
+            "onUpdate:options"?: ((options: any) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+            style: vue.StyleValue;
+            expanded: readonly string[];
+            tag: string;
+            page: string | number;
+            sticky: boolean;
+            headers: vue.DeepReadonly<DataTableHeader[] | DataTableHeader[][]>;
+            noDataText: string;
+            loadingText: string;
+            itemsPerPageText: string;
+            sortBy: readonly SortItem[];
+            pageText: string;
+            items: any[];
+            density: Density;
+            groupBy: readonly SortItem[];
+            modelValue: readonly any[];
+            valueComparator: typeof deepEqual;
+            selectStrategy: "all" | "page" | "single";
+            returnObject: boolean;
+            itemValue: SelectItemKey;
+            hideNoData: boolean;
+            hover: boolean;
+            nextIcon: string;
+            prevIcon: string;
+            firstIcon: string;
+            lastIcon: string;
+            fixedHeader: boolean;
+            fixedFooter: boolean;
+            expandOnClick: boolean;
+            showExpand: boolean;
+            itemSelectable: SelectItemKey;
+            showSelect: boolean;
+            multiSort: boolean;
+            mustSort: boolean;
+            itemsPerPage: string | number;
+            itemsLength: string | number;
+            firstPageLabel: string;
+            prevPageLabel: string;
+            nextPageLabel: string;
+            lastPageLabel: string;
+            itemsPerPageOptions: readonly (number | {
                 title: string;
                 value: number;
-            })[] | undefined;
-            showCurrentPage?: boolean | undefined;
-            sortAscIcon?: IconValue | undefined;
-            sortDescIcon?: IconValue | undefined;
+            })[];
+            showCurrentPage: boolean;
+            sortAscIcon: IconValue;
+            sortDescIcon: IconValue;
+        } & {
             search?: string | undefined;
-            key?: string | number | symbol | undefined;
             height?: string | number | undefined;
             width?: string | number | undefined;
             color?: string | undefined;
             loading?: string | boolean | undefined;
             class?: any;
+            theme?: string | undefined;
+            customKeySort?: Record<string, DataTableCompareFunction> | undefined;
+            rowHeight?: number | undefined;
+            'onClick:row'?: ((e: Event, value: {
+                item: any;
+                internalItem: DataTableItem<any>;
+            }) => void) | undefined;
+        } & {
             $children?: vue.VNodeChild | {
                 [x: `item.${string}`]: ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
                 [x: `column.${string}`]: ((arg: {
@@ -5231,11 +6171,6 @@ declare const VDataTableServer: {
                 bottom?: ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
                 'footer.prepend'?: (() => vue.VNodeChild) | undefined;
             } | ((arg: VDataTableSlotProps) => vue.VNodeChild);
-            ref?: vue.VNodeRef | undefined;
-            ref_for?: boolean | undefined;
-            ref_key?: string | undefined;
-            theme?: string | undefined;
-            "v-slot:default"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
             'v-slots'?: {
                 [x: `item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
                 [x: `column.${string}`]: false | ((arg: {
@@ -5307,46 +6242,28 @@ declare const VDataTableServer: {
                 bottom?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
                 'footer.prepend'?: false | (() => vue.VNodeChild) | undefined;
             } | undefined;
-            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
-                [key: string]: any;
-            }>) => void)[] | undefined;
-            "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
-            "v-slot:loader"?: false | ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+        } & {
+            [x: `v-slot:item.${string}`]: false | ((arg: ItemKeySlot) => vue.VNodeChild) | undefined;
+            [x: `v-slot:column.${string}`]: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:data-table-group"?: false | ((arg: {
+                item: Group<any>;
+                count: number;
+                props: Record<string, unknown>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:data-table-select"?: false | ((arg: {
+                props: Record<string, unknown>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-select"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
+            "v-slot:item.data-table-expand"?: false | ((arg: Omit<ItemKeySlot, "value">) => vue.VNodeChild) | undefined;
             "v-slot:item"?: false | ((arg: {
                 index: number;
                 item: any;
@@ -5360,41 +6277,50 @@ declare const VDataTableServer: {
             } & {
                 props: Record<string, any>;
             }) => vue.VNodeChild) | undefined;
+            "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
+            "v-slot:group-header"?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
             "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
+            "v-slot:expanded-row"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+            "v-slot:headers"?: false | ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:loader"?: false | ((arg: LoaderSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:column.data-table-select"?: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:column.data-table-expand"?: false | ((arg: {
+                column: InternalDataTableHeader;
+                selectAll: (value: boolean) => void;
+                isSorted: (column: InternalDataTableHeader) => boolean;
+                toggleSort: (column: InternalDataTableHeader) => void;
+                sortBy: readonly SortItem[];
+                someSelected: boolean;
+                allSelected: boolean;
+                getSortIcon: (column: InternalDataTableHeader) => IconValue;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:default"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:colgroup"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
             "v-slot:top"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:body"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:tbody"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:thead"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:tfoot"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
             "v-slot:bottom"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
+            "v-slot:footer.prepend"?: false | (() => vue.VNodeChild) | undefined;
+        } & {
+            "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
             "onUpdate:expanded"?: ((options: any) => any) | undefined;
-            customKeySort?: Record<string, DataTableCompareFunction> | undefined;
             "onUpdate:sortBy"?: ((sortBy: any) => any) | undefined;
             "onUpdate:groupBy"?: ((value: any) => any) | undefined;
             "onUpdate:page"?: ((page: number) => any) | undefined;
             "onUpdate:itemsPerPage"?: ((page: number) => any) | undefined;
-            itemsLength: string | number;
             "onUpdate:options"?: ((options: any) => any) | undefined;
-            "v-slot:headers"?: false | ((arg: HeadersSlotProps) => vue.VNodeChild) | undefined;
-            "v-slot:data-table-group"?: false | ((arg: {
-                item: Group<any>;
-                count: number;
-                props: Record<string, unknown>;
-            }) => vue.VNodeChild) | undefined;
-            "v-slot:data-table-select"?: false | ((arg: {
-                props: Record<string, unknown>;
-            }) => vue.VNodeChild) | undefined;
-            rowHeight?: number | undefined;
-            'onClick:row'?: ((e: Event, value: {
-                item: any;
-                internalItem: DataTableItem<any>;
-            }) => void) | undefined;
-            "v-slot:loading"?: false | (() => vue.VNodeChild) | undefined;
-            "v-slot:group-header"?: false | ((arg: GroupHeaderSlot) => vue.VNodeChild) | undefined;
-            "v-slot:expanded-row"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
-            "v-slot:body"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
-            "v-slot:colgroup"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
-            "v-slot:tbody"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
-            "v-slot:tfoot"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
-            "v-slot:thead"?: false | ((arg: VDataTableSlotProps) => vue.VNodeChild) | undefined;
-            "v-slot:footer.prepend"?: false | (() => vue.VNodeChild) | undefined;
-        };
+        }, "style" | "expanded" | "tag" | "page" | "sticky" | "headers" | "noDataText" | "loadingText" | "itemsPerPageText" | "sortBy" | "pageText" | "items" | "density" | "groupBy" | "modelValue" | "valueComparator" | "selectStrategy" | "returnObject" | "itemValue" | "hideNoData" | "hover" | "nextIcon" | "prevIcon" | "firstIcon" | "lastIcon" | "fixedHeader" | "fixedFooter" | "expandOnClick" | "showExpand" | "itemSelectable" | "showSelect" | "multiSort" | "mustSort" | "itemsPerPage" | "firstPageLabel" | "prevPageLabel" | "nextPageLabel" | "lastPageLabel" | "itemsPerPageOptions" | "showCurrentPage" | "sortAscIcon" | "sortDescIcon">;
         $attrs: {
             [x: string]: unknown;
         };
@@ -5538,6 +6464,7 @@ declare const VDataTableServer: {
             pageText: string;
             items: any[];
             density: Density;
+            groupBy: readonly SortItem[];
             modelValue: readonly any[];
             valueComparator: typeof deepEqual;
             selectStrategy: "all" | "page" | "single";
@@ -5555,7 +6482,6 @@ declare const VDataTableServer: {
             showExpand: boolean;
             itemSelectable: SelectItemKey;
             showSelect: boolean;
-            groupBy: readonly SortItem[];
             multiSort: boolean;
             mustSort: boolean;
             itemsPerPage: string | number;
@@ -5828,6 +6754,7 @@ declare const VDataTableServer: {
             pageText: string;
             items: any[];
             density: Density;
+            groupBy: readonly SortItem[];
             modelValue: readonly any[];
             valueComparator: typeof deepEqual;
             selectStrategy: "all" | "page" | "single";
@@ -5845,7 +6772,6 @@ declare const VDataTableServer: {
             showExpand: boolean;
             itemSelectable: SelectItemKey;
             showSelect: boolean;
-            groupBy: readonly SortItem[];
             multiSort: boolean;
             mustSort: boolean;
             itemsPerPage: string | number;
@@ -6012,6 +6938,7 @@ declare const VDataTableServer: {
         pageText: string;
         items: any[];
         density: Density;
+        groupBy: readonly SortItem[];
         modelValue: readonly any[];
         valueComparator: typeof deepEqual;
         selectStrategy: "all" | "page" | "single";
@@ -6029,7 +6956,6 @@ declare const VDataTableServer: {
         showExpand: boolean;
         itemSelectable: SelectItemKey;
         showSelect: boolean;
-        groupBy: readonly SortItem[];
         multiSort: boolean;
         mustSort: boolean;
         itemsPerPage: string | number;
@@ -6298,6 +7224,7 @@ declare const VDataTableServer: {
     pageText: string;
     items: any[];
     density: Density;
+    groupBy: readonly SortItem[];
     modelValue: readonly any[];
     valueComparator: typeof deepEqual;
     selectStrategy: "all" | "page" | "single";
@@ -6315,7 +7242,6 @@ declare const VDataTableServer: {
     showExpand: boolean;
     itemSelectable: SelectItemKey;
     showSelect: boolean;
-    groupBy: readonly SortItem[];
     multiSort: boolean;
     mustSort: boolean;
     itemsPerPage: string | number;
@@ -6588,6 +7514,7 @@ declare const VDataTableServer: {
     pageText: string;
     items: any[];
     density: Density;
+    groupBy: readonly SortItem[];
     modelValue: readonly any[];
     valueComparator: typeof deepEqual;
     selectStrategy: "all" | "page" | "single";
@@ -6605,7 +7532,6 @@ declare const VDataTableServer: {
     showExpand: boolean;
     itemSelectable: SelectItemKey;
     showSelect: boolean;
-    groupBy: readonly SortItem[];
     multiSort: boolean;
     mustSort: boolean;
     itemsPerPage: string | number;