@vuetify/nightly 3.6.14-master.2024-08-04 → 3.6.14-master.2024-08-13

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

@@ -1,5 +1,7 @@
 import * as vue from 'vue';
-import { ComponentPropsOptions, ExtractPropTypes, VNodeChild, VNode, ComponentPublicInstance, PropType, Ref, JSXComponent, UnwrapRef } from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, VNodeChild, VNode, ComponentPublicInstance, PropType, JSXComponent, Ref, UnwrapRef, DeepReadonly } from 'vue';
+
+type ClassValue = any;
 
 type SlotsToProps<U extends RawSlots, T = MakeInternalSlots<U>> = {
     $children?: (VNodeChild | (T extends {
@@ -33,7 +35,7 @@ interface FilterPropsOptions<PropsOptions extends Readonly<ComponentPropsOptions
 declare function deepEqual(a: any, b: any): boolean;
 type SelectItemKey<T = Record<string, any>> = boolean | null | undefined | string | readonly (string | number)[] | ((item: T, fallback?: any) => any);
 type EventProp<T extends any[] = any[], F = (...args: T) => void> = F;
-declare const EventProp: <T extends any[] = any[]>() => PropType<(...args: T) => void>;
+declare const EventProp: <T extends any[] = any[]>() => PropType<EventProp<T>>;
 type TemplateRef = {
     (target: Element | ComponentPublicInstance | null): void;
     value: HTMLElement | ComponentPublicInstance | null | undefined;
@@ -45,6 +47,13 @@ interface LoaderSlotProps {
     isActive: boolean;
 }
 
+declare const breakpoints: readonly ["sm", "md", "lg", "xl", "xxl"];
+type Breakpoint = typeof breakpoints[number];
+type DisplayBreakpoint = 'xs' | Breakpoint;
+
+type IconValue = string | (string | [path: string, opacity: number])[] | JSXComponent;
+declare const IconValue: PropType<IconValue>;
+
 type ExpandProps = {
     expandOnClick: boolean;
     expanded: readonly string[];
@@ -112,7 +121,7 @@ declare function provideGroupBy(options: {
     toggleGroup: (group: Group) => void;
     opened: Ref<Set<string> & Omit<Set<string>, keyof Set<any>>>;
     groupBy: Ref<readonly SortItem[]>;
-    extractRows: <T extends GroupableItem<any>>(items: readonly (T | Group<T>)[]) => T[];
+    extractRows: <T extends GroupableItem>(items: readonly (T | Group<T>)[]) => T[];
     isGroupOpen: (group: Group) => boolean;
 };
 
@@ -216,13 +225,6 @@ declare function provideSelection(props: SelectionProps, { allItems, currentPage
     showSelectAll: vue.ComputedRef<boolean>;
 };
 
-declare const breakpoints: readonly ["sm", "md", "lg", "xl", "xxl"];
-type Breakpoint = typeof breakpoints[number];
-type DisplayBreakpoint = 'xs' | Breakpoint;
-
-type IconValue = string | (string | [path: string, opacity: number])[] | JSXComponent;
-declare const IconValue: PropType<IconValue>;
-
 type HeadersSlotProps = {
     headers: InternalDataTableHeader[][];
     columns: InternalDataTableHeader[];
@@ -327,21 +329,11 @@ declare const VDataTableHeaders: {
         sortAscIcon: IconValue;
         sortDescIcon: IconValue;
     }, true, {}, vue.SlotsType<Partial<{
-        [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        headers: (arg: HeadersSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+        headers: (arg: HeadersSlotProps) => vue.VNode[];
+        loader: (arg: LoaderSlotProps) => vue.VNode[];
+        'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+        'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
     }>>, {
         P: {};
         B: {};
@@ -390,9 +382,9 @@ declare const VDataTableHeaders: {
         sortAscIcon: IconValue;
         sortDescIcon: IconValue;
     }>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
 } & vue.ComponentOptionsBase<{
     mobile: boolean | null;
     sticky: boolean;
@@ -434,21 +426,11 @@ declare const VDataTableHeaders: {
     sortAscIcon: IconValue;
     sortDescIcon: IconValue;
 }, {}, string, vue.SlotsType<Partial<{
-    [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    headers: (arg: HeadersSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+    headers: (arg: HeadersSlotProps) => vue.VNode[];
+    loader: (arg: LoaderSlotProps) => vue.VNode[];
+    'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+    'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
 }>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
     loading: (StringConstructor | BooleanConstructor)[];
     mobile: {
@@ -555,24 +537,12 @@ declare const VDataTableRow: {
     }, {
         mobile: boolean | null;
     }, true, {}, vue.SlotsType<Partial<{
-        [x: `item.${string}`]: (arg: ItemKeySlot<unknown>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'item.data-table-select': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'item.data-table-expand': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        [x: `item.${string}`]: (arg: ItemKeySlot<unknown>) => vue.VNode[];
+        [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+        'item.data-table-select': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode[];
+        'item.data-table-expand': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode[];
+        'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+        'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
     }>>, {
         P: {};
         B: {};
@@ -591,9 +561,9 @@ declare const VDataTableRow: {
     }, {}, {}, {}, {}, {
         mobile: boolean | null;
     }>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
 } & vue.ComponentOptionsBase<{
     mobile: boolean | null;
 } & {
@@ -605,38 +575,23 @@ declare const VDataTableRow: {
 }, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<Record<string, any>, "item" | "$children" | "v-slots" | "cellProps" | `v-slot:header.${string}` | `v-slot:item.${string}`>, string, {
     mobile: boolean | null;
 }, {}, string, vue.SlotsType<Partial<{
-    [x: `item.${string}`]: (arg: ItemKeySlot<unknown>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'item.data-table-select': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'item.data-table-expand': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    [x: `item.${string}`]: (arg: ItemKeySlot<unknown>) => vue.VNode[];
+    [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+    'item.data-table-select': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode[];
+    'item.data-table-expand': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode[];
+    'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+    'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
 }>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T>(props: {
-    item?: DataTableItem<T> | undefined;
-    cellProps?: CellProps<T> | undefined;
-}, slots: VDataTableRowSlots<T>) => GenericProps<{
-    item?: DataTableItem<T> | undefined;
-    cellProps?: CellProps<T> | undefined;
-}, VDataTableRowSlots<T>>) & FilterPropsOptions<{
+    item?: DataTableItem<T>;
+    cellProps?: CellProps<T>;
+}, slots: VDataTableRowSlots<T>) => GenericProps<typeof props, typeof slots>) & FilterPropsOptions<{
     mobile: {
         type: PropType<boolean | null>;
         default: boolean;
     };
     mobileBreakpoint: PropType<number | DisplayBreakpoint>;
     index: NumberConstructor;
-    item: PropType<DataTableItem<any>>;
+    item: PropType<DataTableItem>;
     cellProps: PropType<CellProps<any>>;
     onClick: PropType<(args_0: MouseEvent) => void>;
     onContextmenu: PropType<(args_0: MouseEvent) => void>;
@@ -648,7 +603,7 @@ declare const VDataTableRow: {
     };
     mobileBreakpoint: PropType<number | DisplayBreakpoint>;
     index: NumberConstructor;
-    item: PropType<DataTableItem<any>>;
+    item: PropType<DataTableItem>;
     cellProps: PropType<CellProps<any>>;
     onClick: PropType<(args_0: MouseEvent) => void>;
     onContextmenu: PropType<(args_0: MouseEvent) => void>;
@@ -692,63 +647,37 @@ declare const VDataTableRows: {
         loadingText: string;
         hideNoData: boolean;
     }, true, {}, vue.SlotsType<Partial<{
-        [x: `item.${string}`]: (arg: ItemKeySlot<unknown>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        [x: `item.${string}`]: (arg: ItemKeySlot<unknown>) => vue.VNode[];
+        [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
         'data-table-group': (arg: {
-            item: Group<any>;
+            item: Group;
             count: number;
             props: Record<string, unknown>;
-        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        }) => vue.VNode[];
         'data-table-select': (arg: {
             props: Record<string, unknown>;
-        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'item.data-table-select': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'item.data-table-expand': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        }) => vue.VNode[];
+        'item.data-table-select': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode[];
+        'item.data-table-expand': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode[];
+        'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+        'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
         item: (arg: {
             index: number;
             item: unknown;
             internalItem: DataTableItem<unknown>;
-            isExpanded: (item: DataTableItem<any>) => boolean;
-            toggleExpand: (item: DataTableItem<any>) => void;
-            isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
-            toggleSelect: (item: SelectableItem) => void;
+            isExpanded: ReturnType<typeof provideExpanded>["isExpanded"];
+            toggleExpand: ReturnType<typeof provideExpanded>["toggleExpand"];
+            isSelected: ReturnType<typeof provideSelection>["isSelected"];
+            toggleSelect: ReturnType<typeof provideSelection>["toggleSelect"];
         } & {
             columns: InternalDataTableHeader[];
         } & {
             props: Record<string, any>;
-        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        loading: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'group-header': (arg: GroupHeaderSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'no-data': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'expanded-row': (arg: ItemSlot<unknown>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        }) => vue.VNode[];
+        loading: () => vue.VNode[];
+        'group-header': (arg: GroupHeaderSlot) => vue.VNode[];
+        'no-data': () => vue.VNode[];
+        'expanded-row': (arg: ItemSlot<unknown>) => vue.VNode[];
     }>>, {
         P: {};
         B: {};
@@ -772,9 +701,9 @@ declare const VDataTableRows: {
         loadingText: string;
         hideNoData: boolean;
     }>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
 } & vue.ComponentOptionsBase<{
     mobile: boolean | null;
     noDataText: string;
@@ -791,68 +720,40 @@ declare const VDataTableRows: {
     loadingText: string;
     hideNoData: boolean;
 }, {}, string, vue.SlotsType<Partial<{
-    [x: `item.${string}`]: (arg: ItemKeySlot<unknown>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    [x: `item.${string}`]: (arg: ItemKeySlot<unknown>) => vue.VNode[];
+    [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
     'data-table-group': (arg: {
-        item: Group<any>;
+        item: Group;
         count: number;
         props: Record<string, unknown>;
-    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    }) => vue.VNode[];
     'data-table-select': (arg: {
         props: Record<string, unknown>;
-    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'item.data-table-select': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'item.data-table-expand': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    }) => vue.VNode[];
+    'item.data-table-select': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode[];
+    'item.data-table-expand': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode[];
+    'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+    'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
     item: (arg: {
         index: number;
         item: unknown;
         internalItem: DataTableItem<unknown>;
-        isExpanded: (item: DataTableItem<any>) => boolean;
-        toggleExpand: (item: DataTableItem<any>) => void;
-        isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
-        toggleSelect: (item: SelectableItem) => void;
+        isExpanded: ReturnType<typeof provideExpanded>["isExpanded"];
+        toggleExpand: ReturnType<typeof provideExpanded>["toggleExpand"];
+        isSelected: ReturnType<typeof provideSelection>["isSelected"];
+        toggleSelect: ReturnType<typeof provideSelection>["toggleSelect"];
     } & {
         columns: InternalDataTableHeader[];
     } & {
         props: Record<string, any>;
-    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    loading: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'group-header': (arg: GroupHeaderSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'no-data': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'expanded-row': (arg: ItemSlot<unknown>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    }) => vue.VNode[];
+    loading: () => vue.VNode[];
+    'group-header': (arg: GroupHeaderSlot) => vue.VNode[];
+    'no-data': () => vue.VNode[];
+    'expanded-row': (arg: ItemSlot<unknown>) => vue.VNode[];
 }>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T>(props: {
-    items?: readonly (DataTableItem<T> | Group<T>)[] | undefined;
-}, slots: VDataTableRowsSlots<T>) => GenericProps<{
-    items?: readonly (DataTableItem<T> | Group<T>)[] | undefined;
-}, VDataTableRowsSlots<T>>) & FilterPropsOptions<{
+    items?: readonly (DataTableItem<T> | Group<T>)[];
+}, slots: VDataTableRowsSlots<T>) => GenericProps<typeof props, typeof slots>) & FilterPropsOptions<{
     mobile: {
         type: PropType<boolean | null>;
         default: boolean;
@@ -865,7 +766,7 @@ declare const VDataTableRows: {
     };
     hideNoData: BooleanConstructor;
     items: {
-        type: PropType<readonly (Group<any> | DataTableItem<any>)[]>;
+        type: PropType<readonly (DataTableItem | Group)[]>;
         default: () => never[];
     };
     noDataText: {
@@ -887,7 +788,7 @@ declare const VDataTableRows: {
     };
     hideNoData: BooleanConstructor;
     items: {
-        type: PropType<readonly (Group<any> | DataTableItem<any>)[]>;
+        type: PropType<readonly (DataTableItem | Group)[]>;
         default: () => never[];
     };
     noDataText: {
@@ -939,9 +840,9 @@ type ItemType$2<T> = T extends readonly (infer U)[] ? U : never;
 declare const VDataTable: {
     new (...args: any[]): vue.CreateComponentPublicInstance<{
         page: string | number;
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -1008,19 +909,19 @@ declare const VDataTable: {
         "onUpdate:options"?: ((value: any) => any) | undefined;
         "onUpdate:currentItems"?: ((value: any) => any) | undefined;
     }, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
-        'update:modelValue': (value: any[]) => boolean;
-        'update:page': (value: number) => boolean;
-        'update:itemsPerPage': (value: number) => boolean;
-        'update:sortBy': (value: any) => boolean;
-        'update:options': (value: any) => boolean;
-        'update:groupBy': (value: any) => boolean;
-        'update:expanded': (value: any) => boolean;
-        'update:currentItems': (value: any) => boolean;
-    }, "$children" | "headers" | "v-slot:default" | "v-slots" | "modelValue" | "items" | "update:modelValue" | "v-slot:loader" | "v-slot:item" | "itemValue" | "v-slot:no-data" | "cellProps" | "itemSelectable" | "rowProps" | "v-slot:headers" | `v-slot:header.${string}` | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row" | "v-slot:top" | "v-slot:bottom" | "v-slot:body" | "v-slot:colgroup" | "v-slot:tbody" | "v-slot:tfoot" | "v-slot:thead" | "v-slot:body.prepend" | "v-slot:body.append" | "v-slot:footer.prepend">, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        'update:modelValue': (value: any[]) => true;
+        'update:page': (value: number) => true;
+        'update:itemsPerPage': (value: number) => true;
+        'update:sortBy': (value: any) => true;
+        'update:options': (value: any) => true;
+        'update:groupBy': (value: any) => true;
+        'update:expanded': (value: any) => true;
+        'update:currentItems': (value: any) => true;
+    }, "$children" | "headers" | "v-slots" | "v-slot:default" | "modelValue" | "items" | "update:modelValue" | "v-slot:loader" | "v-slot:item" | "itemValue" | "v-slot:no-data" | "cellProps" | "itemSelectable" | "rowProps" | "v-slot:headers" | `v-slot:header.${string}` | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row" | "v-slot:top" | "v-slot:bottom" | "v-slot:body" | "v-slot:colgroup" | "v-slot:tbody" | "v-slot:tfoot" | "v-slot:thead" | "v-slot:body.prepend" | "v-slot:body.append" | "v-slot:footer.prepend">, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
         page: string | number;
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -1088,9 +989,9 @@ declare const VDataTable: {
         "onUpdate:currentItems"?: ((value: any) => any) | undefined;
     }, {
         page: string | number;
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -1135,102 +1036,50 @@ declare const VDataTable: {
         hideDefaultFooter: boolean;
         hideDefaultHeader: boolean;
     }, true, {}, vue.SlotsType<Partial<{
-        [x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        [x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode[];
+        [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
         'data-table-group': (arg: {
-            item: Group<any>;
+            item: Group;
             count: number;
             props: Record<string, unknown>;
-        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        }) => vue.VNode[];
         'data-table-select': (arg: {
             props: Record<string, unknown>;
-        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'item.data-table-select': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        }) => vue.VNode[];
+        'item.data-table-select': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode[];
+        'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode[];
+        'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+        'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
         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;
+            isExpanded: ReturnType<typeof provideExpanded>["isExpanded"];
+            toggleExpand: ReturnType<typeof provideExpanded>["toggleExpand"];
+            isSelected: ReturnType<typeof provideSelection>["isSelected"];
+            toggleSelect: ReturnType<typeof provideSelection>["toggleSelect"];
         } & {
             columns: InternalDataTableHeader[];
         } & {
             props: Record<string, any>;
-        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        loading: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'group-header': (arg: GroupHeaderSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'no-data': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'expanded-row': (arg: ItemSlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        headers: (arg: HeadersSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        default: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        colgroup: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        top: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        body: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        tbody: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        thead: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        tfoot: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        bottom: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'body.prepend': (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'body.append': (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'footer.prepend': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        }) => vue.VNode[];
+        loading: () => vue.VNode[];
+        'group-header': (arg: GroupHeaderSlot) => vue.VNode[];
+        'no-data': () => vue.VNode[];
+        'expanded-row': (arg: ItemSlot<any>) => vue.VNode[];
+        headers: (arg: HeadersSlotProps) => vue.VNode[];
+        loader: (arg: LoaderSlotProps) => vue.VNode[];
+        default: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        colgroup: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        top: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        body: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        tbody: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        thead: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        tfoot: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        bottom: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        'body.prepend': (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        'body.append': (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        'footer.prepend': () => vue.VNode[];
     }>>, {
         P: {};
         B: {};
@@ -1240,9 +1089,9 @@ declare const VDataTable: {
         Defaults: {};
     }, {
         page: string | number;
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -1310,9 +1159,9 @@ declare const VDataTable: {
         "onUpdate:currentItems"?: ((value: any) => any) | undefined;
     }, {}, {}, {}, {}, {
         page: string | number;
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -1357,14 +1206,14 @@ declare const VDataTable: {
         hideDefaultFooter: boolean;
         hideDefaultHeader: boolean;
     }>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
 } & vue.ComponentOptionsBase<{
     page: string | number;
+    expanded: readonly string[];
     style: vue.StyleValue;
     mobile: boolean | null;
-    expanded: readonly string[];
     tag: string;
     sticky: boolean;
     noDataText: string;
@@ -1431,19 +1280,19 @@ declare const VDataTable: {
     "onUpdate:options"?: ((value: any) => any) | undefined;
     "onUpdate:currentItems"?: ((value: any) => any) | undefined;
 }, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
-    'update:modelValue': (value: any[]) => boolean;
-    'update:page': (value: number) => boolean;
-    'update:itemsPerPage': (value: number) => boolean;
-    'update:sortBy': (value: any) => boolean;
-    'update:options': (value: any) => boolean;
-    'update:groupBy': (value: any) => boolean;
-    'update:expanded': (value: any) => boolean;
-    'update:currentItems': (value: any) => boolean;
-}, "$children" | "headers" | "v-slot:default" | "v-slots" | "modelValue" | "items" | "update:modelValue" | "v-slot:loader" | "v-slot:item" | "itemValue" | "v-slot:no-data" | "cellProps" | "itemSelectable" | "rowProps" | "v-slot:headers" | `v-slot:header.${string}` | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row" | "v-slot:top" | "v-slot:bottom" | "v-slot:body" | "v-slot:colgroup" | "v-slot:tbody" | "v-slot:tfoot" | "v-slot:thead" | "v-slot:body.prepend" | "v-slot:body.append" | "v-slot:footer.prepend">, string, {
+    'update:modelValue': (value: any[]) => true;
+    'update:page': (value: number) => true;
+    'update:itemsPerPage': (value: number) => true;
+    'update:sortBy': (value: any) => true;
+    'update:options': (value: any) => true;
+    'update:groupBy': (value: any) => true;
+    'update:expanded': (value: any) => true;
+    'update:currentItems': (value: any) => true;
+}, "$children" | "headers" | "v-slots" | "v-slot:default" | "modelValue" | "items" | "update:modelValue" | "v-slot:loader" | "v-slot:item" | "itemValue" | "v-slot:no-data" | "cellProps" | "itemSelectable" | "rowProps" | "v-slot:headers" | `v-slot:header.${string}` | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row" | "v-slot:top" | "v-slot:bottom" | "v-slot:body" | "v-slot:colgroup" | "v-slot:tbody" | "v-slot:tfoot" | "v-slot:thead" | "v-slot:body.prepend" | "v-slot:body.append" | "v-slot:footer.prepend">, string, {
     page: string | number;
+    expanded: readonly string[];
     style: vue.StyleValue;
     mobile: boolean | null;
-    expanded: readonly string[];
     tag: string;
     sticky: boolean;
     noDataText: string;
@@ -1488,165 +1337,60 @@ declare const VDataTable: {
     hideDefaultFooter: boolean;
     hideDefaultHeader: boolean;
 }, {}, string, vue.SlotsType<Partial<{
-    [x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    [x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode[];
+    [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
     'data-table-group': (arg: {
-        item: Group<any>;
+        item: Group;
         count: number;
         props: Record<string, unknown>;
-    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    }) => vue.VNode[];
     'data-table-select': (arg: {
         props: Record<string, unknown>;
-    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'item.data-table-select': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    }) => vue.VNode[];
+    'item.data-table-select': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode[];
+    'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode[];
+    'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+    'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
     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;
+        isExpanded: ReturnType<typeof provideExpanded>["isExpanded"];
+        toggleExpand: ReturnType<typeof provideExpanded>["toggleExpand"];
+        isSelected: ReturnType<typeof provideSelection>["isSelected"];
+        toggleSelect: ReturnType<typeof provideSelection>["toggleSelect"];
     } & {
         columns: InternalDataTableHeader[];
     } & {
         props: Record<string, any>;
-    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    loading: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'group-header': (arg: GroupHeaderSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'no-data': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'expanded-row': (arg: ItemSlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    headers: (arg: HeadersSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    default: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    colgroup: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    top: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    body: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    tbody: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    thead: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    tfoot: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    bottom: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'body.prepend': (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'body.append': (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'footer.prepend': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    }) => vue.VNode[];
+    loading: () => vue.VNode[];
+    'group-header': (arg: GroupHeaderSlot) => vue.VNode[];
+    'no-data': () => vue.VNode[];
+    'expanded-row': (arg: ItemSlot<any>) => vue.VNode[];
+    headers: (arg: HeadersSlotProps) => vue.VNode[];
+    loader: (arg: LoaderSlotProps) => vue.VNode[];
+    default: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    colgroup: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    top: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    body: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    tbody: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    thead: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    tfoot: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    bottom: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    'body.prepend': (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    'body.append': (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    'footer.prepend': () => vue.VNode[];
 }>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T extends readonly any[], V>(props: {
-    items?: T | undefined;
-    itemValue?: SelectItemKey<ItemType$2<T>>;
-    rowProps?: RowProps<ItemType$2<T>> | undefined;
-    cellProps?: CellProps<ItemType$2<T>> | undefined;
-    itemSelectable?: SelectItemKey<ItemType$2<T>>;
-    headers?: readonly {
-        readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-        readonly value?: SelectItemKey<ItemType$2<T>>;
-        readonly title?: string | undefined;
-        readonly fixed?: boolean | undefined;
-        readonly align?: "center" | "end" | "start" | undefined;
-        readonly width?: string | number | undefined;
-        readonly minWidth?: string | undefined;
-        readonly maxWidth?: string | undefined;
-        readonly nowrap?: boolean | undefined;
-        readonly headerProps?: {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly sortable?: boolean | undefined;
-        readonly sort?: DataTableCompareFunction<any> | undefined;
-        readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-        readonly filter?: FilterFunction | undefined;
-        readonly mobile?: boolean | undefined;
-        readonly children?: readonly any[] | undefined;
-    }[] | undefined;
-    modelValue?: V | undefined;
-    'onUpdate:modelValue'?: ((value: V) => void) | undefined;
-}, slots: VDataTableSlots<ItemType$2<T>>) => GenericProps<{
-    items?: T | undefined;
+    items?: T;
     itemValue?: SelectItemKey<ItemType$2<T>>;
-    rowProps?: RowProps<ItemType$2<T>> | undefined;
-    cellProps?: CellProps<ItemType$2<T>> | undefined;
+    rowProps?: RowProps<ItemType$2<T>>;
+    cellProps?: CellProps<ItemType$2<T>>;
     itemSelectable?: SelectItemKey<ItemType$2<T>>;
-    headers?: readonly {
-        readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-        readonly value?: SelectItemKey<ItemType$2<T>>;
-        readonly title?: string | undefined;
-        readonly fixed?: boolean | undefined;
-        readonly align?: "center" | "end" | "start" | undefined;
-        readonly width?: string | number | undefined;
-        readonly minWidth?: string | undefined;
-        readonly maxWidth?: string | undefined;
-        readonly nowrap?: boolean | undefined;
-        readonly headerProps?: {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly sortable?: boolean | undefined;
-        readonly sort?: DataTableCompareFunction<any> | undefined;
-        readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-        readonly filter?: FilterFunction | undefined;
-        readonly mobile?: boolean | undefined;
-        readonly children?: readonly any[] | undefined;
-    }[] | undefined;
-    modelValue?: V | undefined;
-    'onUpdate:modelValue'?: ((value: V) => void) | undefined;
-}, VDataTableSlots<ItemType$2<T>>>) & FilterPropsOptions<{
+    headers?: DeepReadonly<DataTableHeader<ItemType$2<T>>[]>;
+    modelValue?: V;
+    "onUpdate:modelValue"?: (value: V) => void;
+}, slots: VDataTableSlots<ItemType$2<T>>) => GenericProps<typeof props, typeof slots>) & FilterPropsOptions<{
     prevIcon: {
         type: vue.PropType<IconValue>;
         default: string;
@@ -1716,7 +1460,7 @@ declare const VDataTable: {
         default: string;
         validator: (v: any) => boolean;
     };
-    class: vue.PropType<any>;
+    class: vue.PropType<ClassValue>;
     style: {
         type: vue.PropType<vue.StyleValue>;
         default: null;
@@ -1754,7 +1498,7 @@ declare const VDataTable: {
     mustSort: BooleanConstructor;
     showSelect: BooleanConstructor;
     selectStrategy: {
-        type: vue.PropType<"all" | "page" | "single">;
+        type: vue.PropType<"single" | "page" | "all">;
         default: string;
     };
     modelValue: {
@@ -1766,7 +1510,7 @@ declare const VDataTable: {
         default: typeof deepEqual;
     };
     items: {
-        type: vue.PropType<any[]>;
+        type: vue.PropType<DataTableItemProps["items"]>;
         default: () => never[];
     };
     itemValue: {
@@ -1780,51 +1524,7 @@ declare const VDataTable: {
     rowProps: vue.PropType<RowProps<any>>;
     cellProps: vue.PropType<CellProps<any>>;
     returnObject: BooleanConstructor;
-    headers: vue.PropType<readonly {
-        readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-        readonly value?: SelectItemKey<Record<string, any>>;
-        readonly title?: string | undefined;
-        readonly fixed?: boolean | undefined;
-        readonly align?: "center" | "end" | "start" | undefined;
-        readonly width?: string | number | undefined;
-        readonly minWidth?: string | undefined;
-        readonly maxWidth?: string | undefined;
-        readonly nowrap?: boolean | undefined;
-        readonly headerProps?: {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly sortable?: boolean | undefined;
-        readonly sort?: DataTableCompareFunction<any> | undefined;
-        readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-        readonly filter?: FilterFunction | undefined;
-        readonly mobile?: boolean | undefined;
-        readonly children?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-            readonly value?: SelectItemKey<Record<string, any>>;
-            readonly title?: string | undefined;
-            readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
-            readonly minWidth?: string | undefined;
-            readonly maxWidth?: string | undefined;
-            readonly nowrap?: boolean | undefined;
-            readonly headerProps?: {
-                readonly [x: string]: any;
-            } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-                readonly [x: string]: any;
-            } | undefined;
-            readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-            readonly filter?: FilterFunction | undefined;
-            readonly mobile?: boolean | undefined;
-            readonly children?: readonly any[] | undefined;
-        }[] | undefined;
-    }[]>;
+    headers: vue.PropType<DeepReadonly<DataTableHeader[]>>;
     groupBy: {
         type: vue.PropType<readonly SortItem[]>;
         default: () => never[];
@@ -1927,7 +1627,7 @@ declare const VDataTable: {
         default: string;
         validator: (v: any) => boolean;
     };
-    class: vue.PropType<any>;
+    class: vue.PropType<ClassValue>;
     style: {
         type: vue.PropType<vue.StyleValue>;
         default: null;
@@ -1965,7 +1665,7 @@ declare const VDataTable: {
     mustSort: BooleanConstructor;
     showSelect: BooleanConstructor;
     selectStrategy: {
-        type: vue.PropType<"all" | "page" | "single">;
+        type: vue.PropType<"single" | "page" | "all">;
         default: string;
     };
     modelValue: {
@@ -1977,7 +1677,7 @@ declare const VDataTable: {
         default: typeof deepEqual;
     };
     items: {
-        type: vue.PropType<any[]>;
+        type: vue.PropType<DataTableItemProps["items"]>;
         default: () => never[];
     };
     itemValue: {
@@ -1991,51 +1691,7 @@ declare const VDataTable: {
     rowProps: vue.PropType<RowProps<any>>;
     cellProps: vue.PropType<CellProps<any>>;
     returnObject: BooleanConstructor;
-    headers: vue.PropType<readonly {
-        readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-        readonly value?: SelectItemKey<Record<string, any>>;
-        readonly title?: string | undefined;
-        readonly fixed?: boolean | undefined;
-        readonly align?: "center" | "end" | "start" | undefined;
-        readonly width?: string | number | undefined;
-        readonly minWidth?: string | undefined;
-        readonly maxWidth?: string | undefined;
-        readonly nowrap?: boolean | undefined;
-        readonly headerProps?: {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly sortable?: boolean | undefined;
-        readonly sort?: DataTableCompareFunction<any> | undefined;
-        readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-        readonly filter?: FilterFunction | undefined;
-        readonly mobile?: boolean | undefined;
-        readonly children?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-            readonly value?: SelectItemKey<Record<string, any>>;
-            readonly title?: string | undefined;
-            readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
-            readonly minWidth?: string | undefined;
-            readonly maxWidth?: string | undefined;
-            readonly nowrap?: boolean | undefined;
-            readonly headerProps?: {
-                readonly [x: string]: any;
-            } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-                readonly [x: string]: any;
-            } | undefined;
-            readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-            readonly filter?: FilterFunction | undefined;
-            readonly mobile?: boolean | undefined;
-            readonly children?: readonly any[] | undefined;
-        }[] | undefined;
-    }[]>;
+    headers: vue.PropType<DeepReadonly<DataTableHeader[]>>;
     groupBy: {
         type: vue.PropType<readonly SortItem[]>;
         default: () => never[];
@@ -2139,9 +1795,7 @@ declare const VDataTableFooter: {
         })[];
         showCurrentPage: boolean;
     }, true, {}, vue.SlotsType<Partial<{
-        prepend: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        prepend: () => vue.VNode[];
     }>>, {
         P: {};
         B: {};
@@ -2191,9 +1845,9 @@ declare const VDataTableFooter: {
         })[];
         showCurrentPage: boolean;
     }>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
 } & vue.ComponentOptionsBase<{
     itemsPerPageText: string;
     pageText: string;
@@ -2236,9 +1890,7 @@ declare const VDataTableFooter: {
     })[];
     showCurrentPage: boolean;
 }, {}, string, vue.SlotsType<Partial<{
-    prepend: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    prepend: () => vue.VNode[];
 }>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
     prevIcon: {
         type: PropType<IconValue>;
@@ -2360,9 +2012,9 @@ type VDataTableVirtualSlots<T> = VDataTableRowsSlots<T> & VDataTableHeadersSlots
 type ItemType$1<T> = T extends readonly (infer U)[] ? U : never;
 declare const VDataTableVirtual: {
     new (...args: any[]): vue.CreateComponentPublicInstance<{
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -2399,45 +2051,45 @@ declare const VDataTableVirtual: {
         loading?: string | boolean | undefined;
         class?: any;
         headers?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+            readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
             readonly value?: SelectItemKey<Record<string, any>>;
             readonly title?: string | undefined;
             readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
+            readonly align?: ("start" | "end" | "center") | undefined;
+            readonly width?: (number | string) | undefined;
             readonly minWidth?: string | undefined;
             readonly maxWidth?: string | undefined;
             readonly nowrap?: boolean | undefined;
             readonly headerProps?: {
                 readonly [x: string]: any;
             } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                 readonly [x: string]: any;
             } | undefined;
             readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+            readonly sort?: DataTableCompareFunction | undefined;
+            readonly sortRaw?: DataTableCompareFunction | undefined;
             readonly filter?: FilterFunction | undefined;
             readonly mobile?: boolean | undefined;
             readonly children?: readonly {
-                readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+                readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
                 readonly value?: SelectItemKey<Record<string, any>>;
                 readonly title?: string | undefined;
                 readonly fixed?: boolean | undefined;
-                readonly align?: "center" | "end" | "start" | undefined;
-                readonly width?: string | number | undefined;
+                readonly align?: ("start" | "end" | "center") | undefined;
+                readonly width?: (number | string) | undefined;
                 readonly minWidth?: string | undefined;
                 readonly maxWidth?: string | undefined;
                 readonly nowrap?: boolean | undefined;
                 readonly headerProps?: {
                     readonly [x: string]: any;
                 } | undefined;
-                readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+                readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                     readonly [x: string]: any;
                 } | undefined;
                 readonly sortable?: boolean | undefined;
-                readonly sort?: DataTableCompareFunction<any> | undefined;
-                readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+                readonly sort?: DataTableCompareFunction | undefined;
+                readonly sortRaw?: DataTableCompareFunction | undefined;
                 readonly filter?: FilterFunction | undefined;
                 readonly mobile?: boolean | undefined;
                 readonly children?: readonly any[] | undefined;
@@ -2456,15 +2108,15 @@ declare const VDataTableVirtual: {
         "onUpdate:expanded"?: ((value: any) => any) | undefined;
         "onUpdate:options"?: ((value: any) => any) | undefined;
     }, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
-        'update:modelValue': (value: any[]) => boolean;
-        'update:sortBy': (value: any) => boolean;
-        'update:options': (value: any) => boolean;
-        'update:groupBy': (value: any) => boolean;
-        'update:expanded': (value: any) => boolean;
+        'update:modelValue': (value: any[]) => true;
+        'update:sortBy': (value: any) => true;
+        'update:options': (value: any) => true;
+        'update:groupBy': (value: any) => true;
+        'update:expanded': (value: any) => true;
     }, "$children" | "v-slots" | "modelValue" | "items" | "update:modelValue" | "v-slot:loader" | "v-slot:item" | "itemValue" | "v-slot:no-data" | "cellProps" | "itemSelectable" | "rowProps" | "v-slot:headers" | `v-slot:header.${string}` | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row" | "v-slot:top" | "v-slot:bottom" | "v-slot:colgroup" | "v-slot:body.prepend" | "v-slot:body.append">, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -2501,45 +2153,45 @@ declare const VDataTableVirtual: {
         loading?: string | boolean | undefined;
         class?: any;
         headers?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+            readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
             readonly value?: SelectItemKey<Record<string, any>>;
             readonly title?: string | undefined;
             readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
+            readonly align?: ("start" | "end" | "center") | undefined;
+            readonly width?: (number | string) | undefined;
             readonly minWidth?: string | undefined;
             readonly maxWidth?: string | undefined;
             readonly nowrap?: boolean | undefined;
             readonly headerProps?: {
                 readonly [x: string]: any;
             } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                 readonly [x: string]: any;
             } | undefined;
             readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+            readonly sort?: DataTableCompareFunction | undefined;
+            readonly sortRaw?: DataTableCompareFunction | undefined;
             readonly filter?: FilterFunction | undefined;
             readonly mobile?: boolean | undefined;
             readonly children?: readonly {
-                readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+                readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
                 readonly value?: SelectItemKey<Record<string, any>>;
                 readonly title?: string | undefined;
                 readonly fixed?: boolean | undefined;
-                readonly align?: "center" | "end" | "start" | undefined;
-                readonly width?: string | number | undefined;
+                readonly align?: ("start" | "end" | "center") | undefined;
+                readonly width?: (number | string) | undefined;
                 readonly minWidth?: string | undefined;
                 readonly maxWidth?: string | undefined;
                 readonly nowrap?: boolean | undefined;
                 readonly headerProps?: {
                     readonly [x: string]: any;
                 } | undefined;
-                readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+                readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                     readonly [x: string]: any;
                 } | undefined;
                 readonly sortable?: boolean | undefined;
-                readonly sort?: DataTableCompareFunction<any> | undefined;
-                readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+                readonly sort?: DataTableCompareFunction | undefined;
+                readonly sortRaw?: DataTableCompareFunction | undefined;
                 readonly filter?: FilterFunction | undefined;
                 readonly mobile?: boolean | undefined;
                 readonly children?: readonly any[] | undefined;
@@ -2558,9 +2210,9 @@ declare const VDataTableVirtual: {
         "onUpdate:expanded"?: ((value: any) => any) | undefined;
         "onUpdate:options"?: ((value: any) => any) | undefined;
     }, {
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -2590,86 +2242,46 @@ declare const VDataTableVirtual: {
         hideDefaultFooter: boolean;
         hideDefaultHeader: boolean;
     }, true, {}, vue.SlotsType<Partial<{
-        [x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        [x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode[];
+        [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
         'data-table-group': (arg: {
-            item: Group<any>;
+            item: Group;
             count: number;
             props: Record<string, unknown>;
-        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        }) => vue.VNode[];
         'data-table-select': (arg: {
             props: Record<string, unknown>;
-        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'item.data-table-select': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        }) => vue.VNode[];
+        'item.data-table-select': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode[];
+        'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode[];
+        'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+        'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
         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;
+            isExpanded: ReturnType<typeof provideExpanded>["isExpanded"];
+            toggleExpand: ReturnType<typeof provideExpanded>["toggleExpand"];
+            isSelected: ReturnType<typeof provideSelection>["isSelected"];
+            toggleSelect: ReturnType<typeof provideSelection>["toggleSelect"];
         } & {
             columns: InternalDataTableHeader[];
         } & {
             props: Record<string, any>;
         } & {
             itemRef: TemplateRef;
-        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        loading: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'group-header': (arg: GroupHeaderSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'no-data': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'expanded-row': (arg: ItemSlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        headers: (arg: HeadersSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        colgroup: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        top: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        bottom: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'body.prepend': (arg: VDataTableVirtualSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'body.append': (arg: VDataTableVirtualSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        }) => vue.VNode[];
+        loading: () => vue.VNode[];
+        'group-header': (arg: GroupHeaderSlot) => vue.VNode[];
+        'no-data': () => vue.VNode[];
+        'expanded-row': (arg: ItemSlot<any>) => vue.VNode[];
+        headers: (arg: HeadersSlotProps) => vue.VNode[];
+        loader: (arg: LoaderSlotProps) => vue.VNode[];
+        colgroup: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode[];
+        top: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode[];
+        bottom: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode[];
+        'body.prepend': (arg: VDataTableVirtualSlotProps<any>) => vue.VNode[];
+        'body.append': (arg: VDataTableVirtualSlotProps<any>) => vue.VNode[];
     }>>, {
         P: {};
         B: {};
@@ -2678,9 +2290,9 @@ declare const VDataTableVirtual: {
         M: {};
         Defaults: {};
     }, {
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -2717,45 +2329,45 @@ declare const VDataTableVirtual: {
         loading?: string | boolean | undefined;
         class?: any;
         headers?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+            readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
             readonly value?: SelectItemKey<Record<string, any>>;
             readonly title?: string | undefined;
             readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
+            readonly align?: ("start" | "end" | "center") | undefined;
+            readonly width?: (number | string) | undefined;
             readonly minWidth?: string | undefined;
             readonly maxWidth?: string | undefined;
             readonly nowrap?: boolean | undefined;
             readonly headerProps?: {
                 readonly [x: string]: any;
             } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                 readonly [x: string]: any;
             } | undefined;
             readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+            readonly sort?: DataTableCompareFunction | undefined;
+            readonly sortRaw?: DataTableCompareFunction | undefined;
             readonly filter?: FilterFunction | undefined;
             readonly mobile?: boolean | undefined;
             readonly children?: readonly {
-                readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+                readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
                 readonly value?: SelectItemKey<Record<string, any>>;
                 readonly title?: string | undefined;
                 readonly fixed?: boolean | undefined;
-                readonly align?: "center" | "end" | "start" | undefined;
-                readonly width?: string | number | undefined;
+                readonly align?: ("start" | "end" | "center") | undefined;
+                readonly width?: (number | string) | undefined;
                 readonly minWidth?: string | undefined;
                 readonly maxWidth?: string | undefined;
                 readonly nowrap?: boolean | undefined;
                 readonly headerProps?: {
                     readonly [x: string]: any;
                 } | undefined;
-                readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+                readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                     readonly [x: string]: any;
                 } | undefined;
                 readonly sortable?: boolean | undefined;
-                readonly sort?: DataTableCompareFunction<any> | undefined;
-                readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+                readonly sort?: DataTableCompareFunction | undefined;
+                readonly sortRaw?: DataTableCompareFunction | undefined;
                 readonly filter?: FilterFunction | undefined;
                 readonly mobile?: boolean | undefined;
                 readonly children?: readonly any[] | undefined;
@@ -2774,9 +2386,9 @@ declare const VDataTableVirtual: {
         "onUpdate:expanded"?: ((value: any) => any) | undefined;
         "onUpdate:options"?: ((value: any) => any) | undefined;
     }, {}, {}, {}, {}, {
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -2806,13 +2418,13 @@ declare const VDataTableVirtual: {
         hideDefaultFooter: boolean;
         hideDefaultHeader: boolean;
     }>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
 } & vue.ComponentOptionsBase<{
+    expanded: readonly string[];
     style: vue.StyleValue;
     mobile: boolean | null;
-    expanded: readonly string[];
     tag: string;
     sticky: boolean;
     noDataText: string;
@@ -2849,45 +2461,45 @@ declare const VDataTableVirtual: {
     loading?: string | boolean | undefined;
     class?: any;
     headers?: readonly {
-        readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+        readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
         readonly value?: SelectItemKey<Record<string, any>>;
         readonly title?: string | undefined;
         readonly fixed?: boolean | undefined;
-        readonly align?: "center" | "end" | "start" | undefined;
-        readonly width?: string | number | undefined;
+        readonly align?: ("start" | "end" | "center") | undefined;
+        readonly width?: (number | string) | undefined;
         readonly minWidth?: string | undefined;
         readonly maxWidth?: string | undefined;
         readonly nowrap?: boolean | undefined;
         readonly headerProps?: {
             readonly [x: string]: any;
         } | undefined;
-        readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+        readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
             readonly [x: string]: any;
         } | undefined;
         readonly sortable?: boolean | undefined;
-        readonly sort?: DataTableCompareFunction<any> | undefined;
-        readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+        readonly sort?: DataTableCompareFunction | undefined;
+        readonly sortRaw?: DataTableCompareFunction | undefined;
         readonly filter?: FilterFunction | undefined;
         readonly mobile?: boolean | undefined;
         readonly children?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+            readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
             readonly value?: SelectItemKey<Record<string, any>>;
             readonly title?: string | undefined;
             readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
+            readonly align?: ("start" | "end" | "center") | undefined;
+            readonly width?: (number | string) | undefined;
             readonly minWidth?: string | undefined;
             readonly maxWidth?: string | undefined;
             readonly nowrap?: boolean | undefined;
             readonly headerProps?: {
                 readonly [x: string]: any;
             } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                 readonly [x: string]: any;
             } | undefined;
             readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+            readonly sort?: DataTableCompareFunction | undefined;
+            readonly sortRaw?: DataTableCompareFunction | undefined;
             readonly filter?: FilterFunction | undefined;
             readonly mobile?: boolean | undefined;
             readonly children?: readonly any[] | undefined;
@@ -2906,15 +2518,15 @@ declare const VDataTableVirtual: {
     "onUpdate:expanded"?: ((value: any) => any) | undefined;
     "onUpdate:options"?: ((value: any) => any) | undefined;
 }, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
-    'update:modelValue': (value: any[]) => boolean;
-    'update:sortBy': (value: any) => boolean;
-    'update:options': (value: any) => boolean;
-    'update:groupBy': (value: any) => boolean;
-    'update:expanded': (value: any) => boolean;
+    'update:modelValue': (value: any[]) => true;
+    'update:sortBy': (value: any) => true;
+    'update:options': (value: any) => true;
+    'update:groupBy': (value: any) => true;
+    'update:expanded': (value: any) => true;
 }, "$children" | "v-slots" | "modelValue" | "items" | "update:modelValue" | "v-slot:loader" | "v-slot:item" | "itemValue" | "v-slot:no-data" | "cellProps" | "itemSelectable" | "rowProps" | "v-slot:headers" | `v-slot:header.${string}` | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row" | "v-slot:top" | "v-slot:bottom" | "v-slot:colgroup" | "v-slot:body.prepend" | "v-slot:body.append">, string, {
+    expanded: readonly string[];
     style: vue.StyleValue;
     mobile: boolean | null;
-    expanded: readonly string[];
     tag: string;
     sticky: boolean;
     noDataText: string;
@@ -2944,103 +2556,55 @@ declare const VDataTableVirtual: {
     hideDefaultFooter: boolean;
     hideDefaultHeader: boolean;
 }, {}, string, vue.SlotsType<Partial<{
-    [x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    [x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode[];
+    [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
     'data-table-group': (arg: {
-        item: Group<any>;
+        item: Group;
         count: number;
         props: Record<string, unknown>;
-    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    }) => vue.VNode[];
     'data-table-select': (arg: {
         props: Record<string, unknown>;
-    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'item.data-table-select': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    }) => vue.VNode[];
+    'item.data-table-select': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode[];
+    'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode[];
+    'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+    'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
     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;
+        isExpanded: ReturnType<typeof provideExpanded>["isExpanded"];
+        toggleExpand: ReturnType<typeof provideExpanded>["toggleExpand"];
+        isSelected: ReturnType<typeof provideSelection>["isSelected"];
+        toggleSelect: ReturnType<typeof provideSelection>["toggleSelect"];
     } & {
         columns: InternalDataTableHeader[];
     } & {
         props: Record<string, any>;
     } & {
         itemRef: TemplateRef;
-    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    loading: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'group-header': (arg: GroupHeaderSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'no-data': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'expanded-row': (arg: ItemSlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    headers: (arg: HeadersSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    colgroup: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    top: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    bottom: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'body.prepend': (arg: VDataTableVirtualSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'body.append': (arg: VDataTableVirtualSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    }) => vue.VNode[];
+    loading: () => vue.VNode[];
+    'group-header': (arg: GroupHeaderSlot) => vue.VNode[];
+    'no-data': () => vue.VNode[];
+    'expanded-row': (arg: ItemSlot<any>) => vue.VNode[];
+    headers: (arg: HeadersSlotProps) => vue.VNode[];
+    loader: (arg: LoaderSlotProps) => vue.VNode[];
+    colgroup: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode[];
+    top: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode[];
+    bottom: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode[];
+    'body.prepend': (arg: VDataTableVirtualSlotProps<any>) => vue.VNode[];
+    'body.append': (arg: VDataTableVirtualSlotProps<any>) => vue.VNode[];
 }>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T extends readonly any[], V>(props: {
-    items?: T | undefined;
+    items?: T;
     itemValue?: SelectItemKey<ItemType$1<T>>;
-    rowProps?: RowProps<ItemType$1<T>> | undefined;
-    cellProps?: CellProps<ItemType$1<T>> | undefined;
+    rowProps?: RowProps<ItemType$1<T>>;
+    cellProps?: CellProps<ItemType$1<T>>;
     itemSelectable?: SelectItemKey<ItemType$1<T>>;
-    modelValue?: V | undefined;
-    'onUpdate:modelValue'?: ((value: V) => void) | undefined;
-}, slots: VDataTableVirtualSlots<ItemType$1<T>>) => GenericProps<{
-    items?: T | undefined;
-    itemValue?: SelectItemKey<ItemType$1<T>>;
-    rowProps?: RowProps<ItemType$1<T>> | undefined;
-    cellProps?: CellProps<ItemType$1<T>> | undefined;
-    itemSelectable?: SelectItemKey<ItemType$1<T>>;
-    modelValue?: V | undefined;
-    'onUpdate:modelValue'?: ((value: V) => void) | undefined;
-}, VDataTableVirtualSlots<ItemType$1<T>>>) & FilterPropsOptions<{
+    modelValue?: V;
+    "onUpdate:modelValue"?: (value: V) => void;
+}, slots: VDataTableVirtualSlots<ItemType$1<T>>) => GenericProps<typeof props, typeof slots>) & FilterPropsOptions<{
     customFilter: vue.PropType<FilterFunction>;
     customKeyFilter: vue.PropType<FilterKeyFunctions>;
     filterKeys: vue.PropType<FilterKeys>;
@@ -3068,7 +2632,7 @@ declare const VDataTableVirtual: {
         default: string;
         validator: (v: any) => boolean;
     };
-    class: vue.PropType<any>;
+    class: vue.PropType<ClassValue>;
     style: {
         type: vue.PropType<vue.StyleValue>;
         default: null;
@@ -3105,7 +2669,7 @@ declare const VDataTableVirtual: {
     mustSort: BooleanConstructor;
     showSelect: BooleanConstructor;
     selectStrategy: {
-        type: vue.PropType<"all" | "page" | "single">;
+        type: vue.PropType<"single" | "page" | "all">;
         default: string;
     };
     modelValue: {
@@ -3117,7 +2681,7 @@ declare const VDataTableVirtual: {
         default: typeof deepEqual;
     };
     items: {
-        type: vue.PropType<any[]>;
+        type: vue.PropType<DataTableItemProps["items"]>;
         default: () => never[];
     };
     itemValue: {
@@ -3131,51 +2695,7 @@ declare const VDataTableVirtual: {
     rowProps: vue.PropType<RowProps<any>>;
     cellProps: vue.PropType<CellProps<any>>;
     returnObject: BooleanConstructor;
-    headers: vue.PropType<readonly {
-        readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-        readonly value?: SelectItemKey<Record<string, any>>;
-        readonly title?: string | undefined;
-        readonly fixed?: boolean | undefined;
-        readonly align?: "center" | "end" | "start" | undefined;
-        readonly width?: string | number | undefined;
-        readonly minWidth?: string | undefined;
-        readonly maxWidth?: string | undefined;
-        readonly nowrap?: boolean | undefined;
-        readonly headerProps?: {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly sortable?: boolean | undefined;
-        readonly sort?: DataTableCompareFunction<any> | undefined;
-        readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-        readonly filter?: FilterFunction | undefined;
-        readonly mobile?: boolean | undefined;
-        readonly children?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-            readonly value?: SelectItemKey<Record<string, any>>;
-            readonly title?: string | undefined;
-            readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
-            readonly minWidth?: string | undefined;
-            readonly maxWidth?: string | undefined;
-            readonly nowrap?: boolean | undefined;
-            readonly headerProps?: {
-                readonly [x: string]: any;
-            } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-                readonly [x: string]: any;
-            } | undefined;
-            readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-            readonly filter?: FilterFunction | undefined;
-            readonly mobile?: boolean | undefined;
-            readonly children?: readonly any[] | undefined;
-        }[] | undefined;
-    }[]>;
+    headers: vue.PropType<vue.DeepReadonly<DataTableHeader[]>>;
     expandOnClick: BooleanConstructor;
     showExpand: BooleanConstructor;
     expanded: {
@@ -3224,7 +2744,7 @@ declare const VDataTableVirtual: {
         default: string;
         validator: (v: any) => boolean;
     };
-    class: vue.PropType<any>;
+    class: vue.PropType<ClassValue>;
     style: {
         type: vue.PropType<vue.StyleValue>;
         default: null;
@@ -3261,7 +2781,7 @@ declare const VDataTableVirtual: {
     mustSort: BooleanConstructor;
     showSelect: BooleanConstructor;
     selectStrategy: {
-        type: vue.PropType<"all" | "page" | "single">;
+        type: vue.PropType<"single" | "page" | "all">;
         default: string;
     };
     modelValue: {
@@ -3273,7 +2793,7 @@ declare const VDataTableVirtual: {
         default: typeof deepEqual;
     };
     items: {
-        type: vue.PropType<any[]>;
+        type: vue.PropType<DataTableItemProps["items"]>;
         default: () => never[];
     };
     itemValue: {
@@ -3287,51 +2807,7 @@ declare const VDataTableVirtual: {
     rowProps: vue.PropType<RowProps<any>>;
     cellProps: vue.PropType<CellProps<any>>;
     returnObject: BooleanConstructor;
-    headers: vue.PropType<readonly {
-        readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-        readonly value?: SelectItemKey<Record<string, any>>;
-        readonly title?: string | undefined;
-        readonly fixed?: boolean | undefined;
-        readonly align?: "center" | "end" | "start" | undefined;
-        readonly width?: string | number | undefined;
-        readonly minWidth?: string | undefined;
-        readonly maxWidth?: string | undefined;
-        readonly nowrap?: boolean | undefined;
-        readonly headerProps?: {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly sortable?: boolean | undefined;
-        readonly sort?: DataTableCompareFunction<any> | undefined;
-        readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-        readonly filter?: FilterFunction | undefined;
-        readonly mobile?: boolean | undefined;
-        readonly children?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-            readonly value?: SelectItemKey<Record<string, any>>;
-            readonly title?: string | undefined;
-            readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
-            readonly minWidth?: string | undefined;
-            readonly maxWidth?: string | undefined;
-            readonly nowrap?: boolean | undefined;
-            readonly headerProps?: {
-                readonly [x: string]: any;
-            } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-                readonly [x: string]: any;
-            } | undefined;
-            readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-            readonly filter?: FilterFunction | undefined;
-            readonly mobile?: boolean | undefined;
-            readonly children?: readonly any[] | undefined;
-        }[] | undefined;
-    }[]>;
+    headers: vue.PropType<vue.DeepReadonly<DataTableHeader[]>>;
     expandOnClick: BooleanConstructor;
     showExpand: BooleanConstructor;
     expanded: {
@@ -3359,9 +2835,9 @@ type ItemType<T> = T extends readonly (infer U)[] ? U : never;
 declare const VDataTableServer: {
     new (...args: any[]): vue.CreateComponentPublicInstance<{
         page: string | number;
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -3412,45 +2888,45 @@ declare const VDataTableServer: {
         loading?: string | boolean | undefined;
         class?: any;
         headers?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+            readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
             readonly value?: SelectItemKey<Record<string, any>>;
             readonly title?: string | undefined;
             readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
+            readonly align?: ("start" | "end" | "center") | undefined;
+            readonly width?: (number | string) | undefined;
             readonly minWidth?: string | undefined;
             readonly maxWidth?: string | undefined;
             readonly nowrap?: boolean | undefined;
             readonly headerProps?: {
                 readonly [x: string]: any;
             } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                 readonly [x: string]: any;
             } | undefined;
             readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+            readonly sort?: DataTableCompareFunction | undefined;
+            readonly sortRaw?: DataTableCompareFunction | undefined;
             readonly filter?: FilterFunction | undefined;
             readonly mobile?: boolean | undefined;
             readonly children?: readonly {
-                readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+                readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
                 readonly value?: SelectItemKey<Record<string, any>>;
                 readonly title?: string | undefined;
                 readonly fixed?: boolean | undefined;
-                readonly align?: "center" | "end" | "start" | undefined;
-                readonly width?: string | number | undefined;
+                readonly align?: ("start" | "end" | "center") | undefined;
+                readonly width?: (number | string) | undefined;
                 readonly minWidth?: string | undefined;
                 readonly maxWidth?: string | undefined;
                 readonly nowrap?: boolean | undefined;
                 readonly headerProps?: {
                     readonly [x: string]: any;
                 } | undefined;
-                readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+                readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                     readonly [x: string]: any;
                 } | undefined;
                 readonly sortable?: boolean | undefined;
-                readonly sort?: DataTableCompareFunction<any> | undefined;
-                readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+                readonly sort?: DataTableCompareFunction | undefined;
+                readonly sortRaw?: DataTableCompareFunction | undefined;
                 readonly filter?: FilterFunction | undefined;
                 readonly mobile?: boolean | undefined;
                 readonly children?: readonly any[] | undefined;
@@ -3468,18 +2944,18 @@ declare const VDataTableServer: {
         "onUpdate:itemsPerPage"?: ((page: number) => any) | undefined;
         "onUpdate:options"?: ((options: any) => any) | undefined;
     }, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
-        'update:modelValue': (value: any[]) => boolean;
-        'update:page': (page: number) => boolean;
-        'update:itemsPerPage': (page: number) => boolean;
-        'update:sortBy': (sortBy: any) => boolean;
-        'update:options': (options: any) => boolean;
-        'update:expanded': (options: any) => boolean;
-        'update:groupBy': (value: any) => boolean;
-    }, "$children" | "v-slot:default" | "v-slots" | "modelValue" | "items" | "update:modelValue" | "v-slot:loader" | "v-slot:item" | "itemValue" | "v-slot:no-data" | "cellProps" | "itemSelectable" | "rowProps" | "v-slot:headers" | `v-slot:header.${string}` | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row" | "v-slot:top" | "v-slot:bottom" | "v-slot:body" | "v-slot:colgroup" | "v-slot:tbody" | "v-slot:tfoot" | "v-slot:thead" | "v-slot:body.prepend" | "v-slot:body.append" | "v-slot:footer.prepend">, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        'update:modelValue': (value: any[]) => true;
+        'update:page': (page: number) => true;
+        'update:itemsPerPage': (page: number) => true;
+        'update:sortBy': (sortBy: any) => true;
+        'update:options': (options: any) => true;
+        'update:expanded': (options: any) => true;
+        'update:groupBy': (value: any) => true;
+    }, "$children" | "v-slots" | "v-slot:default" | "modelValue" | "items" | "update:modelValue" | "v-slot:loader" | "v-slot:item" | "itemValue" | "v-slot:no-data" | "cellProps" | "itemSelectable" | "rowProps" | "v-slot:headers" | `v-slot:header.${string}` | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row" | "v-slot:top" | "v-slot:bottom" | "v-slot:body" | "v-slot:colgroup" | "v-slot:tbody" | "v-slot:tfoot" | "v-slot:thead" | "v-slot:body.prepend" | "v-slot:body.append" | "v-slot:footer.prepend">, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
         page: string | number;
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -3530,45 +3006,45 @@ declare const VDataTableServer: {
         loading?: string | boolean | undefined;
         class?: any;
         headers?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+            readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
             readonly value?: SelectItemKey<Record<string, any>>;
             readonly title?: string | undefined;
             readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
+            readonly align?: ("start" | "end" | "center") | undefined;
+            readonly width?: (number | string) | undefined;
             readonly minWidth?: string | undefined;
             readonly maxWidth?: string | undefined;
             readonly nowrap?: boolean | undefined;
             readonly headerProps?: {
                 readonly [x: string]: any;
             } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                 readonly [x: string]: any;
             } | undefined;
             readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+            readonly sort?: DataTableCompareFunction | undefined;
+            readonly sortRaw?: DataTableCompareFunction | undefined;
             readonly filter?: FilterFunction | undefined;
             readonly mobile?: boolean | undefined;
             readonly children?: readonly {
-                readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+                readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
                 readonly value?: SelectItemKey<Record<string, any>>;
                 readonly title?: string | undefined;
                 readonly fixed?: boolean | undefined;
-                readonly align?: "center" | "end" | "start" | undefined;
-                readonly width?: string | number | undefined;
+                readonly align?: ("start" | "end" | "center") | undefined;
+                readonly width?: (number | string) | undefined;
                 readonly minWidth?: string | undefined;
                 readonly maxWidth?: string | undefined;
                 readonly nowrap?: boolean | undefined;
                 readonly headerProps?: {
                     readonly [x: string]: any;
                 } | undefined;
-                readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+                readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                     readonly [x: string]: any;
                 } | undefined;
                 readonly sortable?: boolean | undefined;
-                readonly sort?: DataTableCompareFunction<any> | undefined;
-                readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+                readonly sort?: DataTableCompareFunction | undefined;
+                readonly sortRaw?: DataTableCompareFunction | undefined;
                 readonly filter?: FilterFunction | undefined;
                 readonly mobile?: boolean | undefined;
                 readonly children?: readonly any[] | undefined;
@@ -3587,9 +3063,9 @@ declare const VDataTableServer: {
         "onUpdate:options"?: ((options: any) => any) | undefined;
     }, {
         page: string | number;
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -3632,102 +3108,50 @@ declare const VDataTableServer: {
         hideDefaultFooter: boolean;
         hideDefaultHeader: boolean;
     }, true, {}, vue.SlotsType<Partial<{
-        [x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        [x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode[];
+        [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
         'data-table-group': (arg: {
-            item: Group<any>;
+            item: Group;
             count: number;
             props: Record<string, unknown>;
-        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        }) => vue.VNode[];
         'data-table-select': (arg: {
             props: Record<string, unknown>;
-        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'item.data-table-select': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        }) => vue.VNode[];
+        'item.data-table-select': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode[];
+        'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode[];
+        'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+        'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
         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;
+            isExpanded: ReturnType<typeof provideExpanded>["isExpanded"];
+            toggleExpand: ReturnType<typeof provideExpanded>["toggleExpand"];
+            isSelected: ReturnType<typeof provideSelection>["isSelected"];
+            toggleSelect: ReturnType<typeof provideSelection>["toggleSelect"];
         } & {
             columns: InternalDataTableHeader[];
         } & {
             props: Record<string, any>;
-        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        loading: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'group-header': (arg: GroupHeaderSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'no-data': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'expanded-row': (arg: ItemSlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        headers: (arg: HeadersSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        default: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        colgroup: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        top: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        body: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        tbody: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        thead: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        tfoot: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        bottom: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'body.prepend': (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'body.append': (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-        'footer.prepend': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
+        }) => vue.VNode[];
+        loading: () => vue.VNode[];
+        'group-header': (arg: GroupHeaderSlot) => vue.VNode[];
+        'no-data': () => vue.VNode[];
+        'expanded-row': (arg: ItemSlot<any>) => vue.VNode[];
+        headers: (arg: HeadersSlotProps) => vue.VNode[];
+        loader: (arg: LoaderSlotProps) => vue.VNode[];
+        default: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        colgroup: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        top: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        body: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        tbody: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        thead: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        tfoot: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        bottom: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        'body.prepend': (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        'body.append': (arg: VDataTableSlotProps<any>) => vue.VNode[];
+        'footer.prepend': () => vue.VNode[];
     }>>, {
         P: {};
         B: {};
@@ -3737,9 +3161,9 @@ declare const VDataTableServer: {
         Defaults: {};
     }, {
         page: string | number;
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -3790,45 +3214,45 @@ declare const VDataTableServer: {
         loading?: string | boolean | undefined;
         class?: any;
         headers?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+            readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
             readonly value?: SelectItemKey<Record<string, any>>;
             readonly title?: string | undefined;
             readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
+            readonly align?: ("start" | "end" | "center") | undefined;
+            readonly width?: (number | string) | undefined;
             readonly minWidth?: string | undefined;
             readonly maxWidth?: string | undefined;
             readonly nowrap?: boolean | undefined;
             readonly headerProps?: {
                 readonly [x: string]: any;
             } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                 readonly [x: string]: any;
             } | undefined;
             readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+            readonly sort?: DataTableCompareFunction | undefined;
+            readonly sortRaw?: DataTableCompareFunction | undefined;
             readonly filter?: FilterFunction | undefined;
             readonly mobile?: boolean | undefined;
             readonly children?: readonly {
-                readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+                readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
                 readonly value?: SelectItemKey<Record<string, any>>;
                 readonly title?: string | undefined;
                 readonly fixed?: boolean | undefined;
-                readonly align?: "center" | "end" | "start" | undefined;
-                readonly width?: string | number | undefined;
+                readonly align?: ("start" | "end" | "center") | undefined;
+                readonly width?: (number | string) | undefined;
                 readonly minWidth?: string | undefined;
                 readonly maxWidth?: string | undefined;
                 readonly nowrap?: boolean | undefined;
                 readonly headerProps?: {
                     readonly [x: string]: any;
                 } | undefined;
-                readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+                readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                     readonly [x: string]: any;
                 } | undefined;
                 readonly sortable?: boolean | undefined;
-                readonly sort?: DataTableCompareFunction<any> | undefined;
-                readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+                readonly sort?: DataTableCompareFunction | undefined;
+                readonly sortRaw?: DataTableCompareFunction | undefined;
                 readonly filter?: FilterFunction | undefined;
                 readonly mobile?: boolean | undefined;
                 readonly children?: readonly any[] | undefined;
@@ -3847,9 +3271,9 @@ declare const VDataTableServer: {
         "onUpdate:options"?: ((options: any) => any) | undefined;
     }, {}, {}, {}, {}, {
         page: string | number;
+        expanded: readonly string[];
         style: vue.StyleValue;
         mobile: boolean | null;
-        expanded: readonly string[];
         tag: string;
         sticky: boolean;
         noDataText: string;
@@ -3892,14 +3316,14 @@ declare const VDataTableServer: {
         hideDefaultFooter: boolean;
         hideDefaultHeader: boolean;
     }>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
 } & vue.ComponentOptionsBase<{
     page: string | number;
+    expanded: readonly string[];
     style: vue.StyleValue;
     mobile: boolean | null;
-    expanded: readonly string[];
     tag: string;
     sticky: boolean;
     noDataText: string;
@@ -3950,45 +3374,45 @@ declare const VDataTableServer: {
     loading?: string | boolean | undefined;
     class?: any;
     headers?: readonly {
-        readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+        readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
         readonly value?: SelectItemKey<Record<string, any>>;
         readonly title?: string | undefined;
         readonly fixed?: boolean | undefined;
-        readonly align?: "center" | "end" | "start" | undefined;
-        readonly width?: string | number | undefined;
+        readonly align?: ("start" | "end" | "center") | undefined;
+        readonly width?: (number | string) | undefined;
         readonly minWidth?: string | undefined;
         readonly maxWidth?: string | undefined;
         readonly nowrap?: boolean | undefined;
         readonly headerProps?: {
             readonly [x: string]: any;
         } | undefined;
-        readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+        readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
             readonly [x: string]: any;
         } | undefined;
         readonly sortable?: boolean | undefined;
-        readonly sort?: DataTableCompareFunction<any> | undefined;
-        readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+        readonly sort?: DataTableCompareFunction | undefined;
+        readonly sortRaw?: DataTableCompareFunction | undefined;
         readonly filter?: FilterFunction | undefined;
         readonly mobile?: boolean | undefined;
         readonly children?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
+            readonly key?: ("data-table-group" | "data-table-select" | "data-table-expand" | (string & {})) | undefined;
             readonly value?: SelectItemKey<Record<string, any>>;
             readonly title?: string | undefined;
             readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
+            readonly align?: ("start" | "end" | "center") | undefined;
+            readonly width?: (number | string) | undefined;
             readonly minWidth?: string | undefined;
             readonly maxWidth?: string | undefined;
             readonly nowrap?: boolean | undefined;
             readonly headerProps?: {
                 readonly [x: string]: any;
             } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
+            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>) | {
                 readonly [x: string]: any;
             } | undefined;
             readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
+            readonly sort?: DataTableCompareFunction | undefined;
+            readonly sortRaw?: DataTableCompareFunction | undefined;
             readonly filter?: FilterFunction | undefined;
             readonly mobile?: boolean | undefined;
             readonly children?: readonly any[] | undefined;
@@ -4006,18 +3430,18 @@ declare const VDataTableServer: {
     "onUpdate:itemsPerPage"?: ((page: number) => any) | undefined;
     "onUpdate:options"?: ((options: any) => any) | undefined;
 }, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
-    'update:modelValue': (value: any[]) => boolean;
-    'update:page': (page: number) => boolean;
-    'update:itemsPerPage': (page: number) => boolean;
-    'update:sortBy': (sortBy: any) => boolean;
-    'update:options': (options: any) => boolean;
-    'update:expanded': (options: any) => boolean;
-    'update:groupBy': (value: any) => boolean;
-}, "$children" | "v-slot:default" | "v-slots" | "modelValue" | "items" | "update:modelValue" | "v-slot:loader" | "v-slot:item" | "itemValue" | "v-slot:no-data" | "cellProps" | "itemSelectable" | "rowProps" | "v-slot:headers" | `v-slot:header.${string}` | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row" | "v-slot:top" | "v-slot:bottom" | "v-slot:body" | "v-slot:colgroup" | "v-slot:tbody" | "v-slot:tfoot" | "v-slot:thead" | "v-slot:body.prepend" | "v-slot:body.append" | "v-slot:footer.prepend">, string, {
+    'update:modelValue': (value: any[]) => true;
+    'update:page': (page: number) => true;
+    'update:itemsPerPage': (page: number) => true;
+    'update:sortBy': (sortBy: any) => true;
+    'update:options': (options: any) => true;
+    'update:expanded': (options: any) => true;
+    'update:groupBy': (value: any) => true;
+}, "$children" | "v-slots" | "v-slot:default" | "modelValue" | "items" | "update:modelValue" | "v-slot:loader" | "v-slot:item" | "itemValue" | "v-slot:no-data" | "cellProps" | "itemSelectable" | "rowProps" | "v-slot:headers" | `v-slot:header.${string}` | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row" | "v-slot:top" | "v-slot:bottom" | "v-slot:body" | "v-slot:colgroup" | "v-slot:tbody" | "v-slot:tfoot" | "v-slot:thead" | "v-slot:body.prepend" | "v-slot:body.append" | "v-slot:footer.prepend">, string, {
     page: string | number;
+    expanded: readonly string[];
     style: vue.StyleValue;
     mobile: boolean | null;
-    expanded: readonly string[];
     tag: string;
     sticky: boolean;
     noDataText: string;
@@ -4060,119 +3484,59 @@ declare const VDataTableServer: {
     hideDefaultFooter: boolean;
     hideDefaultHeader: boolean;
 }, {}, string, vue.SlotsType<Partial<{
-    [x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    [x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode[];
+    [x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
     'data-table-group': (arg: {
-        item: Group<any>;
+        item: Group;
         count: number;
         props: Record<string, unknown>;
-    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    }) => vue.VNode[];
     'data-table-select': (arg: {
         props: Record<string, unknown>;
-    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'item.data-table-select': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    }) => vue.VNode[];
+    'item.data-table-select': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode[];
+    'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode[];
+    'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
+    'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode[];
     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;
+        isExpanded: ReturnType<typeof provideExpanded>["isExpanded"];
+        toggleExpand: ReturnType<typeof provideExpanded>["toggleExpand"];
+        isSelected: ReturnType<typeof provideSelection>["isSelected"];
+        toggleSelect: ReturnType<typeof provideSelection>["toggleSelect"];
     } & {
         columns: InternalDataTableHeader[];
     } & {
         props: Record<string, any>;
-    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    loading: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'group-header': (arg: GroupHeaderSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'no-data': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'expanded-row': (arg: ItemSlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    headers: (arg: HeadersSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    default: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    colgroup: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    top: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    body: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    tbody: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    thead: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    tfoot: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    bottom: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'body.prepend': (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'body.append': (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-    'footer.prepend': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
+    }) => vue.VNode[];
+    loading: () => vue.VNode[];
+    'group-header': (arg: GroupHeaderSlot) => vue.VNode[];
+    'no-data': () => vue.VNode[];
+    'expanded-row': (arg: ItemSlot<any>) => vue.VNode[];
+    headers: (arg: HeadersSlotProps) => vue.VNode[];
+    loader: (arg: LoaderSlotProps) => vue.VNode[];
+    default: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    colgroup: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    top: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    body: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    tbody: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    thead: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    tfoot: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    bottom: (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    'body.prepend': (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    'body.append': (arg: VDataTableSlotProps<any>) => vue.VNode[];
+    'footer.prepend': () => vue.VNode[];
 }>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T extends readonly any[], V>(props: {
-    items?: T | undefined;
-    itemValue?: SelectItemKey<ItemType<T>>;
-    rowProps?: RowProps<ItemType<T>> | undefined;
-    cellProps?: CellProps<ItemType<T>> | undefined;
-    itemSelectable?: SelectItemKey<ItemType<T>>;
-    modelValue?: V | undefined;
-    'onUpdate:modelValue'?: ((value: V) => void) | undefined;
-}, slots: VDataTableSlots<ItemType<T>>) => GenericProps<{
-    items?: T | undefined;
+    items?: T;
     itemValue?: SelectItemKey<ItemType<T>>;
-    rowProps?: RowProps<ItemType<T>> | undefined;
-    cellProps?: CellProps<ItemType<T>> | undefined;
+    rowProps?: RowProps<ItemType<T>>;
+    cellProps?: CellProps<ItemType<T>>;
     itemSelectable?: SelectItemKey<ItemType<T>>;
-    modelValue?: V | undefined;
-    'onUpdate:modelValue'?: ((value: V) => void) | undefined;
-}, VDataTableSlots<ItemType<T>>>) & FilterPropsOptions<{
+    modelValue?: V;
+    "onUpdate:modelValue"?: (value: V) => void;
+}, slots: VDataTableSlots<ItemType<T>>) => GenericProps<typeof props, typeof slots>) & FilterPropsOptions<{
     prevIcon: {
         type: vue.PropType<IconValue>;
         default: string;
@@ -4234,7 +3598,7 @@ declare const VDataTableServer: {
         default: string;
         validator: (v: any) => boolean;
     };
-    class: vue.PropType<any>;
+    class: vue.PropType<ClassValue>;
     style: {
         type: vue.PropType<vue.StyleValue>;
         default: null;
@@ -4272,7 +3636,7 @@ declare const VDataTableServer: {
     mustSort: BooleanConstructor;
     showSelect: BooleanConstructor;
     selectStrategy: {
-        type: vue.PropType<"all" | "page" | "single">;
+        type: vue.PropType<"single" | "page" | "all">;
         default: string;
     };
     modelValue: {
@@ -4284,7 +3648,7 @@ declare const VDataTableServer: {
         default: typeof deepEqual;
     };
     items: {
-        type: vue.PropType<any[]>;
+        type: vue.PropType<DataTableItemProps["items"]>;
         default: () => never[];
     };
     itemValue: {
@@ -4298,51 +3662,7 @@ declare const VDataTableServer: {
     rowProps: vue.PropType<RowProps<any>>;
     cellProps: vue.PropType<CellProps<any>>;
     returnObject: BooleanConstructor;
-    headers: vue.PropType<readonly {
-        readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-        readonly value?: SelectItemKey<Record<string, any>>;
-        readonly title?: string | undefined;
-        readonly fixed?: boolean | undefined;
-        readonly align?: "center" | "end" | "start" | undefined;
-        readonly width?: string | number | undefined;
-        readonly minWidth?: string | undefined;
-        readonly maxWidth?: string | undefined;
-        readonly nowrap?: boolean | undefined;
-        readonly headerProps?: {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly sortable?: boolean | undefined;
-        readonly sort?: DataTableCompareFunction<any> | undefined;
-        readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-        readonly filter?: FilterFunction | undefined;
-        readonly mobile?: boolean | undefined;
-        readonly children?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-            readonly value?: SelectItemKey<Record<string, any>>;
-            readonly title?: string | undefined;
-            readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
-            readonly minWidth?: string | undefined;
-            readonly maxWidth?: string | undefined;
-            readonly nowrap?: boolean | undefined;
-            readonly headerProps?: {
-                readonly [x: string]: any;
-            } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-                readonly [x: string]: any;
-            } | undefined;
-            readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-            readonly filter?: FilterFunction | undefined;
-            readonly mobile?: boolean | undefined;
-            readonly children?: readonly any[] | undefined;
-        }[] | undefined;
-    }[]>;
+    headers: vue.PropType<vue.DeepReadonly<DataTableHeader[]>>;
     groupBy: {
         type: vue.PropType<readonly SortItem[]>;
         default: () => never[];
@@ -4441,7 +3761,7 @@ declare const VDataTableServer: {
         default: string;
         validator: (v: any) => boolean;
     };
-    class: vue.PropType<any>;
+    class: vue.PropType<ClassValue>;
     style: {
         type: vue.PropType<vue.StyleValue>;
         default: null;
@@ -4479,7 +3799,7 @@ declare const VDataTableServer: {
     mustSort: BooleanConstructor;
     showSelect: BooleanConstructor;
     selectStrategy: {
-        type: vue.PropType<"all" | "page" | "single">;
+        type: vue.PropType<"single" | "page" | "all">;
         default: string;
     };
     modelValue: {
@@ -4491,7 +3811,7 @@ declare const VDataTableServer: {
         default: typeof deepEqual;
     };
     items: {
-        type: vue.PropType<any[]>;
+        type: vue.PropType<DataTableItemProps["items"]>;
         default: () => never[];
     };
     itemValue: {
@@ -4505,51 +3825,7 @@ declare const VDataTableServer: {
     rowProps: vue.PropType<RowProps<any>>;
     cellProps: vue.PropType<CellProps<any>>;
     returnObject: BooleanConstructor;
-    headers: vue.PropType<readonly {
-        readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-        readonly value?: SelectItemKey<Record<string, any>>;
-        readonly title?: string | undefined;
-        readonly fixed?: boolean | undefined;
-        readonly align?: "center" | "end" | "start" | undefined;
-        readonly width?: string | number | undefined;
-        readonly minWidth?: string | undefined;
-        readonly maxWidth?: string | undefined;
-        readonly nowrap?: boolean | undefined;
-        readonly headerProps?: {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-            readonly [x: string]: any;
-        } | undefined;
-        readonly sortable?: boolean | undefined;
-        readonly sort?: DataTableCompareFunction<any> | undefined;
-        readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-        readonly filter?: FilterFunction | undefined;
-        readonly mobile?: boolean | undefined;
-        readonly children?: readonly {
-            readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
-            readonly value?: SelectItemKey<Record<string, any>>;
-            readonly title?: string | undefined;
-            readonly fixed?: boolean | undefined;
-            readonly align?: "center" | "end" | "start" | undefined;
-            readonly width?: string | number | undefined;
-            readonly minWidth?: string | undefined;
-            readonly maxWidth?: string | undefined;
-            readonly nowrap?: boolean | undefined;
-            readonly headerProps?: {
-                readonly [x: string]: any;
-            } | undefined;
-            readonly cellProps?: ((data: Pick<ItemKeySlot<any>, "index" | "item" | "value" | "internalItem">) => Record<string, any>) | {
-                readonly [x: string]: any;
-            } | undefined;
-            readonly sortable?: boolean | undefined;
-            readonly sort?: DataTableCompareFunction<any> | undefined;
-            readonly sortRaw?: DataTableCompareFunction<any> | undefined;
-            readonly filter?: FilterFunction | undefined;
-            readonly mobile?: boolean | undefined;
-            readonly children?: readonly any[] | undefined;
-        }[] | undefined;
-    }[]>;
+    headers: vue.PropType<vue.DeepReadonly<DataTableHeader[]>>;
     groupBy: {
         type: vue.PropType<readonly SortItem[]>;
         default: () => never[];