@una-ui/nuxt 0.52.1 → 0.53.0

package/dist/runtime/components/data/table/Table.vue

@@ -1,20 +1,4 @@
-<script setup lang="ts" generic="TData, TValue">
-import type {
-  ColumnFiltersState,
-  ColumnOrderState,
-  ColumnPinningState,
-  ExpandedState,
-  GroupingState,
-  Header,
-  PaginationState,
-  Row,
-  RowSelectionState,
-  SortingState,
-  Table,
-  VisibilityState,
-} from '@tanstack/vue-table'
-import type { NTableProps } from '../../../types'
-
+<script setup>
 import {
   FlexRender,
   getCoreRowModel,
@@ -22,146 +6,190 @@ import {
   getFilteredRowModel,
   getPaginationRowModel,
   getSortedRowModel,
-  useVueTable,
-} from '@tanstack/vue-table'
-
-import { computed, h } from 'vue'
-
-import { cn, valueUpdater } from '../../../utils'
-import Button from '../../elements/Button.vue'
-import Checkbox from '../../forms/Checkbox.vue'
-import Input from '../../forms/Input.vue'
-import ScrollArea from '../../scroll-area/ScrollArea.vue'
-import TableBody from './TableBody.vue'
-import TableCell from './TableCell.vue'
-import TableEmpty from './TableEmpty.vue'
-import TableFooter from './TableFooter.vue'
-import TableHead from './TableHead.vue'
-import TableHeader from './TableHeader.vue'
-import TableLoading from './TableLoading.vue'
-import TableRow from './TableRow.vue'
-
-const props = withDefaults(defineProps <NTableProps<TData, TValue>>(), {
-  enableMultiRowSelection: true,
-  enableSortingRemoval: true,
-})
-
-const emit = defineEmits<{
-  select: [row: TData]
-  selectAll: [rows: TData[]]
-  expand: [row: TData]
-  row: [event: Event, row: TData]
-}>()
-
-const slots = defineSlots()
-
-const rowSelection = defineModel<RowSelectionState>('rowSelection')
-const sorting = defineModel<SortingState>('sorting')
-const columnVisibility = defineModel<VisibilityState>('columnVisibility')
-const columnFilters = defineModel<ColumnFiltersState>('columnFilters')
-const globalFilter = defineModel<string>('globalFilter')
-const columnOrder = defineModel<ColumnOrderState>('columnOrder')
-const columnPinning = defineModel<ColumnPinningState>('columnPinning')
-const expanded = defineModel<ExpandedState>('expanded')
-const grouping = defineModel<GroupingState>('grouping')
-const pagination = defineModel<PaginationState>('pagination', {
+  useVueTable
+} from "@tanstack/vue-table";
+import { computed, h } from "vue";
+import { cn, valueUpdater } from "../../../utils";
+import Button from "../../elements/Button.vue";
+import Checkbox from "../../forms/Checkbox.vue";
+import Input from "../../forms/Input.vue";
+import ScrollArea from "../../scroll-area/ScrollArea.vue";
+import TableBody from "./TableBody.vue";
+import TableCell from "./TableCell.vue";
+import TableEmpty from "./TableEmpty.vue";
+import TableFooter from "./TableFooter.vue";
+import TableHead from "./TableHead.vue";
+import TableHeader from "./TableHeader.vue";
+import TableLoading from "./TableLoading.vue";
+import TableRow from "./TableRow.vue";
+const props = defineProps({
+  class: { type: null, required: false },
+  state: { type: Object, required: false },
+  onStateChange: { type: Function, required: false },
+  renderFallbackValue: { type: null, required: false },
+  data: { type: Array, required: true },
+  columns: { type: Array, required: true },
+  rowId: { type: String, required: false },
+  autoResetAll: { type: Boolean, required: false },
+  enableRowSelection: { type: Boolean, required: false },
+  enableMultiRowSelection: { type: Boolean, required: false, default: true },
+  enableSubRowSelection: { type: Boolean, required: false },
+  enableColumnFilters: { type: Boolean, required: false },
+  manualFiltering: { type: Boolean, required: false },
+  enableSorting: { type: Boolean, required: false },
+  enableMultiSort: { type: Boolean, required: false },
+  enableMultiRemove: { type: Boolean, required: false },
+  enableSortingRemoval: { type: Boolean, required: false, default: true },
+  manualSorting: { type: Boolean, required: false },
+  maxMultiSortColCount: { type: Number, required: false },
+  manualPagination: { type: Boolean, required: false },
+  pageCount: { type: Number, required: false },
+  rowCount: { type: Number, required: false },
+  autoResetPageIndex: { type: Boolean, required: false },
+  sortingFns: { type: Object, required: false },
+  sortDescFirst: { type: Boolean, required: false },
+  isMultiSortEvent: { type: Function, required: false },
+  _tableHead: { type: Object, required: false },
+  _tableHeader: { type: Object, required: false },
+  _tableFooter: { type: Object, required: false },
+  _tableBody: { type: Object, required: false },
+  _tableCaption: { type: Object, required: false },
+  _tableRow: { type: [Object, Function], required: false },
+  _tableCell: { type: Object, required: false },
+  _tableEmpty: { type: Object, required: false },
+  _tableLoading: { type: Object, required: false },
+  _scrollArea: { type: Object, required: false },
+  loading: { type: Boolean, required: false },
+  una: { type: Object, required: false },
+  _features: { type: Array, required: false },
+  debugAll: { type: Boolean, required: false },
+  debugCells: { type: Boolean, required: false },
+  debugColumns: { type: Boolean, required: false },
+  debugHeaders: { type: Boolean, required: false },
+  debugRows: { type: Boolean, required: false },
+  debugTable: { type: Boolean, required: false },
+  defaultColumn: { type: Object, required: false },
+  getRowId: { type: Function, required: false },
+  getSubRows: { type: Function, required: false },
+  initialState: { type: Object, required: false },
+  mergeOptions: { type: Function, required: false },
+  meta: { type: Object, required: false }
+});
+const emit = defineEmits(["select", "selectAll", "expand", "row"]);
+const slots = defineSlots();
+const rowSelection = defineModel("rowSelection", { type: Object });
+const sorting = defineModel("sorting", { type: Array });
+const columnVisibility = defineModel("columnVisibility", { type: Object });
+const columnFilters = defineModel("columnFilters", { type: Array });
+const globalFilter = defineModel("globalFilter", { type: String });
+const columnOrder = defineModel("columnOrder", { type: Array });
+const columnPinning = defineModel("columnPinning", { type: Object });
+const expanded = defineModel("expanded", { type: [Boolean, Object] });
+const grouping = defineModel("grouping", { type: Array });
+const pagination = defineModel("pagination", { type: Object, ...{
   default: () => ({
     pageIndex: 0,
-    pageSize: 10,
-  }),
-})
-
+    pageSize: 10
+  })
+} });
 const columnsWithMisc = computed(() => {
-  let data = []
-
-  // add selection column
-  data = props.enableRowSelection
-    ? [
-        {
-          accessorKey: 'selection',
-          header: props.enableMultiRowSelection
-            ? ({ table }: { table: Table<TData> }) => h(Checkbox, {
-                'modelValue': table.getIsAllPageRowsSelected() || (table.getIsSomePageRowsSelected() && 'indeterminate'),
-                'onUpdate:modelValue': (value: boolean | 'indeterminate' | null) => {
-                  table.toggleAllPageRowsSelected(!!value)
-                  emit('selectAll', table.getRowModel().rows.map(row => row.original))
-                },
-                'areaLabel': 'Select all rows',
-                'onClick': (event: Event) => {
-                  event.stopPropagation()
-                },
-              })
-            : '',
-          cell: ({ row }: { row: Row<TData> }) => h(Checkbox, {
-            'modelValue': row.getIsSelected() ?? false,
-            'onUpdate:modelValue': (value: boolean | 'indeterminate' | null) => {
-              row.toggleSelected(!!value)
-              emit('select', row.original)
-            },
-            'areaLabel': 'Select row',
-            'onClick': (event: Event) => {
-              event.stopPropagation()
-            },
-          }),
-          enableSorting: false,
+  let data = [];
+  data = props.enableRowSelection ? [
+    {
+      accessorKey: "selection",
+      header: props.enableMultiRowSelection ? ({ table: table2 }) => h(Checkbox, {
+        "modelValue": table2.getIsAllPageRowsSelected() || table2.getIsSomePageRowsSelected() && "indeterminate",
+        "onUpdate:modelValue": (value) => {
+          table2.toggleAllPageRowsSelected(!!value);
+          emit("selectAll", table2.getRowModel().rows.map((row) => row.original));
         },
-        ...props.columns,
-      ]
-    : props.columns
-
-  // add expanded column
-  data = slots.expanded
-    ? [
-        {
-          accessorKey: 'expanded',
-          header: '',
-          cell: ({ row }: any) => h(Button, {
-            size: 'xs',
-            icon: true,
-            square: true,
-            btn: 'ghost-gray',
-            label: 'i-radix-icons-chevron-down',
-            onClick: () => {
-              row.toggleExpanded()
-              emit('expand', row)
-            },
-            una: {
-              btnIconLabel: cn(
-                'transform transition-transform duration-200',
-                row.getIsExpanded() ? '-rotate-180' : 'rotate-0',
-              ),
-            },
-          }),
-          enableSorting: false,
-          enableHiding: false,
+        "areaLabel": "Select all rows",
+        "onClick": (event) => {
+          event.stopPropagation();
+        }
+      }) : "",
+      cell: ({ row }) => h(Checkbox, {
+        "modelValue": row.getIsSelected() ?? false,
+        "onUpdate:modelValue": (value) => {
+          row.toggleSelected(!!value);
+          emit("select", row.original);
         },
-        ...data,
-      ]
-    : data
-
-  return data
-})
-
+        "areaLabel": "Select row",
+        "onClick": (event) => {
+          event.stopPropagation();
+        }
+      }),
+      enableSorting: false
+    },
+    ...props.columns
+  ] : props.columns;
+  data = slots.expanded ? [
+    {
+      accessorKey: "expanded",
+      header: "",
+      cell: ({ row }) => h(Button, {
+        size: "xs",
+        icon: true,
+        square: true,
+        btn: "ghost-gray",
+        label: "i-radix-icons-chevron-down",
+        onClick: () => {
+          row.toggleExpanded();
+          emit("expand", row);
+        },
+        una: {
+          btnIconLabel: cn(
+            "transform transition-transform duration-200",
+            row.getIsExpanded() ? "-rotate-180" : "rotate-0"
+          )
+        }
+      }),
+      enableSorting: false,
+      enableHiding: false
+    },
+    ...data
+  ] : data;
+  return data;
+});
 const table = useVueTable({
   get data() {
-    return props.data ?? []
+    return props.data ?? [];
   },
   get columns() {
-    return columnsWithMisc.value ?? []
+    return columnsWithMisc.value ?? [];
   },
   state: {
-    get sorting() { return sorting.value },
-    get columnFilters() { return columnFilters.value },
-    get globalFilter() { return globalFilter.value },
-    get rowSelection() { return rowSelection.value },
-    get columnVisibility() { return columnVisibility.value },
-    get pagination() { return pagination.value },
-    get columnOrder() { return columnOrder.value },
-    get columnPinning() { return columnPinning.value },
-    get expanded() { return expanded.value },
-    get grouping() { return grouping.value },
+    get sorting() {
+      return sorting.value;
+    },
+    get columnFilters() {
+      return columnFilters.value;
+    },
+    get globalFilter() {
+      return globalFilter.value;
+    },
+    get rowSelection() {
+      return rowSelection.value;
+    },
+    get columnVisibility() {
+      return columnVisibility.value;
+    },
+    get pagination() {
+      return pagination.value;
+    },
+    get columnOrder() {
+      return columnOrder.value;
+    },
+    get columnPinning() {
+      return columnPinning.value;
+    },
+    get expanded() {
+      return expanded.value;
+    },
+    get grouping() {
+      return grouping.value;
+    }
   },
-
   enableMultiRowSelection: props.enableMultiRowSelection,
   enableSubRowSelection: props.enableSubRowSelection,
   autoResetAll: props.autoResetAll,
@@ -180,46 +208,40 @@ const table = useVueTable({
   maxMultiSortColCount: props.maxMultiSortColCount,
   sortingFns: props.sortingFns,
   isMultiSortEvent: props.isMultiSortEvent,
-
   getCoreRowModel: getCoreRowModel(),
   getSortedRowModel: getSortedRowModel(),
   getFilteredRowModel: getFilteredRowModel(),
   getPaginationRowModel: getPaginationRowModel(),
-  getRowId: (row: any) => props.rowId ? row[props.rowId] : row.id,
+  getRowId: (row) => props.rowId ? row[props.rowId] : row.id,
   getExpandedRowModel: getExpandedRowModel(),
-
-  onSortingChange: updaterOrValue => valueUpdater(updaterOrValue, sorting),
-  onRowSelectionChange: updaterOrValue => valueUpdater(updaterOrValue, rowSelection),
-  onColumnVisibilityChange: updaterOrValue => valueUpdater(updaterOrValue, columnVisibility),
-  onColumnFiltersChange: updaterOrValue => valueUpdater(updaterOrValue, columnFilters),
-  onGlobalFilterChange: updaterOrValue => valueUpdater(updaterOrValue, globalFilter),
-  onPaginationChange: updaterOrValue => valueUpdater(updaterOrValue, pagination),
-  onColumnOrderChange: updaterOrValue => valueUpdater(updaterOrValue, columnOrder),
-  onColumnPinningChange: updaterOrValue => valueUpdater(updaterOrValue, columnPinning),
-  onExpandedChange: updaterOrValue => valueUpdater(updaterOrValue, expanded),
-  onGroupingChange: updaterOrValue => valueUpdater(updaterOrValue, grouping),
-})
-
-function getHeaderColumnFiltersCount(headers: Header<unknown, unknown>[]): number {
-  let count = 0
+  onSortingChange: (updaterOrValue) => valueUpdater(updaterOrValue, sorting),
+  onRowSelectionChange: (updaterOrValue) => valueUpdater(updaterOrValue, rowSelection),
+  onColumnVisibilityChange: (updaterOrValue) => valueUpdater(updaterOrValue, columnVisibility),
+  onColumnFiltersChange: (updaterOrValue) => valueUpdater(updaterOrValue, columnFilters),
+  onGlobalFilterChange: (updaterOrValue) => valueUpdater(updaterOrValue, globalFilter),
+  onPaginationChange: (updaterOrValue) => valueUpdater(updaterOrValue, pagination),
+  onColumnOrderChange: (updaterOrValue) => valueUpdater(updaterOrValue, columnOrder),
+  onColumnPinningChange: (updaterOrValue) => valueUpdater(updaterOrValue, columnPinning),
+  onExpandedChange: (updaterOrValue) => valueUpdater(updaterOrValue, expanded),
+  onGroupingChange: (updaterOrValue) => valueUpdater(updaterOrValue, grouping)
+});
+function getHeaderColumnFiltersCount(headers) {
+  let count = 0;
   headers.forEach((header) => {
     if (header.column.columnDef.enableColumnFilter)
-      count++
-  })
-
-  return count
+      count++;
+  });
+  return count;
 }
-
-function getRowAttrs(data?: TData) {
-  if (typeof props._tableRow === 'function') {
-    return props._tableRow(data)
+function getRowAttrs(data) {
+  if (typeof props._tableRow === "function") {
+    return props._tableRow(data);
   }
-  return props._tableRow
+  return props._tableRow;
 }
-
 defineExpose({
-  ...table,
-})
+  ...table
+});
 </script>
 
 <template>
@@ -234,10 +256,10 @@ defineExpose({
       <table
         v-bind="$attrs"
         :class="cn(
-          'table',
-          props.una?.table,
-          props.class,
-        )"
+  'table',
+  props.una?.table,
+  props.class
+)"
       >
         <!-- header -->
         <TableHeader
@@ -261,16 +283,14 @@ defineExpose({
                 v-bind="{ ...props._tableHead, ...header.column.columnDef.meta }"
               >
                 <Button
-                  v-if="header.column.columnDef.enableSorting || (header.column.columnDef.enableSorting !== false && enableSorting)"
+                  v-if="header.column.columnDef.enableSorting || header.column.columnDef.enableSorting !== false && enableSorting"
                   btn="ghost-gray"
                   size="sm"
                   class="font-normal -ml-1em"
                   :una="{
-                    btnTrailing: 'text-sm',
-                  }"
-                  :trailing="header.column.getIsSorted() === 'asc'
-                    ? 'i-lucide-arrow-up-wide-narrow' : header.column.getIsSorted() === 'desc'
-                      ? 'i-lucide-arrow-down-narrow-wide' : 'i-lucide-arrow-up-down'"
+  btnTrailing: 'text-sm'
+}"
+                  :trailing="header.column.getIsSorted() === 'asc' ? 'i-lucide-arrow-up-wide-narrow' : header.column.getIsSorted() === 'desc' ? 'i-lucide-arrow-down-narrow-wide' : 'i-lucide-arrow-up-down'"
                   @click="header.column.getToggleSortingHandler()?.($event)"
                 >
                   <slot
@@ -320,13 +340,13 @@ defineExpose({
                   v-bind="{ ...props._tableHead, ...header.column.columnDef.meta }"
                 >
                   <slot
-                    v-if="header.id !== 'selection' && ((header.column.columnDef.enableColumnFilter !== false && enableColumnFilters) || header.column.columnDef.enableColumnFilter)"
+                    v-if="header.id !== 'selection' && (header.column.columnDef.enableColumnFilter !== false && enableColumnFilters || header.column.columnDef.enableColumnFilter)"
                     :name="`${header.id}-filter`"
                     :column="header.column"
                   >
                     <Input
                       class="w-auto"
-                      :model-value="header.column.getFilterValue() as string"
+                      :model-value="header.column.getFilterValue()"
                       :placeholder="header.column.columnDef.header"
                       @update:model-value="header.column.setFilterValue($event)"
                     />

package/dist/runtime/components/data/table/Table.vue.d.ts

@@ -0,0 +1,184 @@
+import type { ColumnFiltersState, ColumnOrderState, ColumnPinningState, ExpandedState, GroupingState, Header, PaginationState, Row, RowSelectionState, SortingState, VisibilityState } from '@tanstack/vue-table';
+import type { NTableProps } from '../../../types/index.js';
+declare const _default: <TData, TValue>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onSelect?: ((row: TData) => any) | undefined;
+        readonly onRow?: ((event: Event, row: TData) => any) | undefined;
+        readonly "onUpdate:rowSelection"?: ((value: RowSelectionState | undefined) => any) | undefined;
+        readonly "onUpdate:sorting"?: ((value: SortingState | undefined) => any) | undefined;
+        readonly "onUpdate:columnVisibility"?: ((value: VisibilityState | undefined) => any) | undefined;
+        readonly "onUpdate:columnFilters"?: ((value: ColumnFiltersState | undefined) => any) | undefined;
+        readonly "onUpdate:globalFilter"?: ((value: string | undefined) => any) | undefined;
+        readonly "onUpdate:columnOrder"?: ((value: ColumnOrderState | undefined) => any) | undefined;
+        readonly "onUpdate:columnPinning"?: ((value: ColumnPinningState | undefined) => any) | undefined;
+        readonly "onUpdate:expanded"?: ((value: ExpandedState | undefined) => any) | undefined;
+        readonly "onUpdate:grouping"?: ((value: GroupingState | undefined) => any) | undefined;
+        readonly "onUpdate:pagination"?: ((value: PaginationState) => any) | undefined;
+        readonly onSelectAll?: ((rows: TData[]) => any) | undefined;
+        readonly onExpand?: ((row: TData) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onSelect" | "onRow" | "onUpdate:rowSelection" | "onUpdate:sorting" | "onUpdate:columnVisibility" | "onUpdate:columnFilters" | "onUpdate:globalFilter" | "onUpdate:columnOrder" | "onUpdate:columnPinning" | "onUpdate:expanded" | "onUpdate:grouping" | "onUpdate:pagination" | "onSelectAll" | "onExpand"> & (NTableProps<TData, TValue> & {
+        rowSelection?: RowSelectionState;
+        sorting?: SortingState;
+        columnVisibility?: VisibilityState;
+        columnFilters?: ColumnFiltersState;
+        globalFilter?: string;
+        columnOrder?: ColumnOrderState;
+        columnPinning?: ColumnPinningState;
+        expanded?: ExpandedState;
+        grouping?: GroupingState;
+        pagination?: PaginationState;
+    }) & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        _features: readonly import("@tanstack/vue-table").TableFeature[];
+        _getAllFlatColumnsById: () => Record<string, import("@tanstack/vue-table").Column<any, unknown>>;
+        _getColumnDefs: () => import("@tanstack/vue-table").ColumnDef<any, unknown>[];
+        _getCoreRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        _getDefaultColumnDef: () => Partial<import("@tanstack/vue-table").ColumnDef<any, unknown>>;
+        _getRowId: (_: any, index: number, parent?: Row<any> | undefined) => string;
+        _queue: (cb: () => void) => void;
+        getAllColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getAllFlatColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getAllLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getColumn: (columnId: string) => import("@tanstack/vue-table").Column<any, unknown> | undefined;
+        getCoreRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getRow: (id: string, searchAll?: boolean) => Row<any>;
+        getRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getState: () => import("@tanstack/vue-table").TableState;
+        initialState: import("@tanstack/vue-table").TableState;
+        options: import("@tanstack/vue-table").RequiredKeys<import("@tanstack/vue-table").TableOptionsResolved<any>, "state">;
+        reset: () => void;
+        setOptions: (newOptions: import("@tanstack/vue-table").Updater<import("@tanstack/vue-table").TableOptionsResolved<any>>) => void;
+        setState: (updater: import("@tanstack/vue-table").Updater<import("@tanstack/vue-table").TableState>) => void;
+        getHeaderGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getLeftHeaderGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getCenterHeaderGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getRightHeaderGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getFooterGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getLeftFooterGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getCenterFooterGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getRightFooterGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getFlatHeaders: () => Header<any, unknown>[];
+        getLeftFlatHeaders: () => Header<any, unknown>[];
+        getCenterFlatHeaders: () => Header<any, unknown>[];
+        getRightFlatHeaders: () => Header<any, unknown>[];
+        getLeafHeaders: () => Header<any, unknown>[];
+        getLeftLeafHeaders: () => Header<any, unknown>[];
+        getCenterLeafHeaders: () => Header<any, unknown>[];
+        getRightLeafHeaders: () => Header<any, unknown>[];
+        getCenterVisibleLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getIsAllColumnsVisible: () => boolean;
+        getIsSomeColumnsVisible: () => boolean;
+        getLeftVisibleLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getRightVisibleLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void;
+        getVisibleFlatColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getVisibleLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        resetColumnVisibility: (defaultState?: boolean) => void;
+        setColumnVisibility: (updater: import("@tanstack/vue-table").Updater<VisibilityState>) => void;
+        toggleAllColumnsVisible: (value?: boolean) => void;
+        _getOrderColumnsFn: () => (columns: import("@tanstack/vue-table").Column<any, unknown>[]) => import("@tanstack/vue-table").Column<any, unknown>[];
+        resetColumnOrder: (defaultState?: boolean) => void;
+        setColumnOrder: (updater: import("@tanstack/vue-table").Updater<ColumnOrderState>) => void;
+        getCenterLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getIsSomeColumnsPinned: (position?: import("@tanstack/vue-table").ColumnPinningPosition) => boolean;
+        getLeftLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getRightLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        resetColumnPinning: (defaultState?: boolean) => void;
+        setColumnPinning: (updater: import("@tanstack/vue-table").Updater<ColumnPinningState>) => void;
+        _getPinnedRows: (visiblePinnedRows: Row<any>[], pinnedRowIds: Array<string> | undefined, position: "top" | "bottom") => Row<any>[];
+        getBottomRows: () => Row<any>[];
+        getCenterRows: () => Row<any>[];
+        getIsSomeRowsPinned: (position?: import("@tanstack/vue-table").RowPinningPosition) => boolean;
+        getTopRows: () => Row<any>[];
+        resetRowPinning: (defaultState?: boolean) => void;
+        setRowPinning: (updater: import("@tanstack/vue-table").Updater<import("@tanstack/vue-table").RowPinningState>) => void;
+        _getFilteredRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        getFilteredRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getPreFilteredRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        resetColumnFilters: (defaultState?: boolean) => void;
+        resetGlobalFilter: (defaultState?: boolean) => void;
+        setColumnFilters: (updater: import("@tanstack/vue-table").Updater<ColumnFiltersState>) => void;
+        setGlobalFilter: (updater: import("@tanstack/vue-table").Updater<any>) => void;
+        getGlobalAutoFilterFn: () => import("@tanstack/vue-table").FilterFn<any> | undefined;
+        getGlobalFilterFn: () => import("@tanstack/vue-table").FilterFn<any> | undefined;
+        _getGlobalFacetedMinMaxValues?: () => undefined | [number, number];
+        _getGlobalFacetedRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        _getGlobalFacetedUniqueValues?: () => Map<any, number>;
+        getGlobalFacetedMinMaxValues: () => undefined | [number, number];
+        getGlobalFacetedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getGlobalFacetedUniqueValues: () => Map<any, number>;
+        _getSortedRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        getPreSortedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getSortedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        resetSorting: (defaultState?: boolean) => void;
+        setSorting: (updater: import("@tanstack/vue-table").Updater<SortingState>) => void;
+        _getGroupedRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        getGroupedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getPreGroupedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        resetGrouping: (defaultState?: boolean) => void;
+        setGrouping: (updater: import("@tanstack/vue-table").Updater<GroupingState>) => void;
+        getCenterTotalSize: () => number;
+        getLeftTotalSize: () => number;
+        getRightTotalSize: () => number;
+        getTotalSize: () => number;
+        resetColumnSizing: (defaultState?: boolean) => void;
+        resetHeaderSizeInfo: (defaultState?: boolean) => void;
+        setColumnSizing: (updater: import("@tanstack/vue-table").Updater<import("@tanstack/vue-table").ColumnSizingState>) => void;
+        setColumnSizingInfo: (updater: import("@tanstack/vue-table").Updater<import("@tanstack/vue-table").ColumnSizingInfoState>) => void;
+        _autoResetExpanded: () => void;
+        _getExpandedRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        getCanSomeRowsExpand: () => boolean;
+        getExpandedDepth: () => number;
+        getExpandedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getIsAllRowsExpanded: () => boolean;
+        getIsSomeRowsExpanded: () => boolean;
+        getPreExpandedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getToggleAllRowsExpandedHandler: () => (event: unknown) => void;
+        resetExpanded: (defaultState?: boolean) => void;
+        setExpanded: (updater: import("@tanstack/vue-table").Updater<ExpandedState>) => void;
+        toggleAllRowsExpanded: (expanded?: boolean) => void;
+        _autoResetPageIndex: () => void;
+        _getPaginationRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        getCanNextPage: () => boolean;
+        getCanPreviousPage: () => boolean;
+        getPageCount: () => number;
+        getRowCount: () => number;
+        getPageOptions: () => number[];
+        getPaginationRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getPrePaginationRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        nextPage: () => void;
+        previousPage: () => void;
+        firstPage: () => void;
+        lastPage: () => void;
+        resetPageIndex: (defaultState?: boolean) => void;
+        resetPageSize: (defaultState?: boolean) => void;
+        resetPagination: (defaultState?: boolean) => void;
+        setPageCount: (updater: import("@tanstack/vue-table").Updater<number>) => void;
+        setPageIndex: (updater: import("@tanstack/vue-table").Updater<number>) => void;
+        setPageSize: (updater: import("@tanstack/vue-table").Updater<number>) => void;
+        setPagination: (updater: import("@tanstack/vue-table").Updater<PaginationState>) => void;
+        getFilteredSelectedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getGroupedSelectedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getIsAllPageRowsSelected: () => boolean;
+        getIsAllRowsSelected: () => boolean;
+        getIsSomePageRowsSelected: () => boolean;
+        getIsSomeRowsSelected: () => boolean;
+        getPreSelectedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getSelectedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void;
+        getToggleAllRowsSelectedHandler: () => (event: unknown) => void;
+        resetRowSelection: (defaultState?: boolean) => void;
+        setRowSelection: (updater: import("@tanstack/vue-table").Updater<RowSelectionState>) => void;
+        toggleAllPageRowsSelected: (value?: boolean) => void;
+        toggleAllRowsSelected: (value?: boolean) => void;
+    }>): void;
+    attrs: any;
+    slots: __VLS_Slots;
+    emit: (((evt: "select", row: TData) => void) & ((evt: "row", event: Event, row: TData) => void) & ((evt: "selectAll", rows: TData[]) => void) & ((evt: "expand", row: TData) => void)) & (((evt: "update:rowSelection", value: RowSelectionState | undefined) => void) & ((evt: "update:sorting", value: SortingState | undefined) => void) & ((evt: "update:columnVisibility", value: VisibilityState | undefined) => void) & ((evt: "update:columnFilters", value: ColumnFiltersState | undefined) => void) & ((evt: "update:globalFilter", value: string | undefined) => void) & ((evt: "update:columnOrder", value: ColumnOrderState | undefined) => void) & ((evt: "update:columnPinning", value: ColumnPinningState | undefined) => void) & ((evt: "update:expanded", value: ExpandedState | undefined) => void) & ((evt: "update:grouping", value: GroupingState | undefined) => void) & ((evt: "update:pagination", value: PaginationState) => void));
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};