@mantine-vue/table 2.2.0

package/lib/components/MVT_TableSlots.d.ts

@@ -0,0 +1,103 @@
+import { type Slots, type VNodeChild } from 'vue';
+import { type MVT_Cell, type MVT_Column, type MVT_InternalFilterOption, type MVT_Node, type MVT_Row, type MVT_RowData, type MVT_TableInstance } from '../types';
+/**
+ * Scoped named slots supported on `<MantineVueTable>`.
+ *
+ * Each slot mirrors the equivalent `renderX` table option and receives the same
+ * scoped argument object. A provided named slot takes precedence over the option
+ * (see {@link renderMVT_Renderable})
+ *
+ * ```vue
+ * <MantineVueTable :table="table">
+ *   <template #detailPanel="{ row }">Age: {{ row.original.age }}</template>
+ *   <template #rowActionMenuItems="{ row }">
+ *     <MenuItem @click="() => edit(row)">Edit</MenuItem>
+ *   </template>
+ * </MantineVueTable>
+ * ```
+ */
+export interface MVT_TableSlots<TData extends MVT_RowData = MVT_RowData> {
+    bottomToolbar?: (arg: {
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    bottomToolbarCustomActions?: (arg: {
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    columnActionsMenuItems?: (arg: {
+        column: MVT_Column<TData>;
+        internalColumnMenuItems: MVT_Node;
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    columnFilterModeMenuItems?: (arg: {
+        column: MVT_Column<TData>;
+        internalFilterOptions: MVT_InternalFilterOption[];
+        onSelectFilterMode: (filterMode: string) => void;
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    createRowModalContent?: (arg: {
+        internalEditComponents: MVT_Node[];
+        row: MVT_Row<TData>;
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    detailPanel?: (arg: {
+        internalEditComponents: MVT_Node[];
+        row: MVT_Row<TData>;
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    editRowModalContent?: (arg: {
+        internalEditComponents: MVT_Node[];
+        row: MVT_Row<TData>;
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    emptyRowsFallback?: (arg: {
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    globalFilterModeMenuItems?: (arg: {
+        internalFilterOptions: MVT_InternalFilterOption[];
+        onSelectFilterMode: (filterMode: string) => void;
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    rowActionMenuItems?: (arg: {
+        renderedRowIndex?: number;
+        row: MVT_Row<TData>;
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    rowActions?: (arg: {
+        cell: MVT_Cell<TData>;
+        renderedRowIndex?: number;
+        row: MVT_Row<TData>;
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    toolbarAlertBannerContent?: (arg: {
+        groupedAlert: MVT_Node | null;
+        selectedAlert: MVT_Node | null;
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    toolbarInternalActions?: (arg: {
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    topToolbar?: (arg: {
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+    topToolbarCustomActions?: (arg: {
+        table: MVT_TableInstance<TData>;
+    }) => VNodeChild;
+}
+/** Union of the named-slot keys `<MantineVueTable>` understands. */
+export type MVT_TableSlotName = keyof MVT_TableSlots;
+/**
+ * Provide the top-level `<MantineVueTable>` slots to every descendant section.
+ * Called once, from the root component's `setup`.
+ */
+export declare const provideMVT_Slots: (slots: Slots) => void;
+/**
+ * Inject the top-level `<MantineVueTable>` slots inside a deep section
+ * component (detail panel, row/column action menus, toolbars, …).
+ */
+export declare const useMVT_Slots: () => Slots;
+/**
+ * Resolve a renderable section. A named slot takes precedence over the
+ * equivalent `renderX` option/prop; both receive the same scoped argument, so a
+ * section can be customized either way with identical semantics.
+ */
+export declare const renderMVT_Renderable: <TArg extends Record<string, any>>(slot: ((arg: TArg) => VNodeChild) | undefined, renderProp: ((arg: TArg) => VNodeChild) | MVT_Node | undefined, arg: TArg) => VNodeChild;

package/lib/components/MantineVueTable.d.ts

@@ -0,0 +1,18 @@
+import { type PropType, type SlotsType } from 'vue';
+import { type MVT_RowData } from '../types';
+import { type MVT_TableSlots } from './MVT_TableSlots';
+export declare const MantineVueTable: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    table: {
+        type: PropType<object>;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    table: {
+        type: PropType<object>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    table: object;
+}, SlotsType<MVT_TableSlots<MVT_RowData>>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/components/body/MVT_TableBody.d.ts

@@ -0,0 +1,64 @@
+import { type PropType } from 'vue';
+import { type MVT_ColumnVirtualizer, type MVT_RowData, type MVT_TableInstance } from '../../types';
+export declare const MVT_TableBody: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    columnVirtualizer: {
+        type: PropType<MVT_ColumnVirtualizer>;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    tableProps: {
+        type: PropType<Record<string, any>>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    columnVirtualizer: {
+        type: PropType<MVT_ColumnVirtualizer>;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    tableProps: {
+        type: PropType<Record<string, any>>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    columnVirtualizer: MVT_ColumnVirtualizer;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const Memo_MVT_TableBody: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    columnVirtualizer: {
+        type: PropType<MVT_ColumnVirtualizer>;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    tableProps: {
+        type: PropType<Record<string, any>>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    columnVirtualizer: {
+        type: PropType<MVT_ColumnVirtualizer>;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    tableProps: {
+        type: PropType<Record<string, any>>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    columnVirtualizer: MVT_ColumnVirtualizer;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/components/body/MVT_TableBodyCell.d.ts

@@ -0,0 +1,136 @@
+import { type PropType, type Ref } from 'vue';
+import { type MVT_Cell, type MVT_RowData, type MVT_TableInstance, type MVT_VirtualItem } from '../../types';
+export declare const MVT_TableBodyCell: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    cell: {
+        type: PropType<MVT_Cell<MVT_RowData>>;
+        required: true;
+    };
+    numRows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    renderedColumnIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    renderedRowIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rowRef: {
+        type: PropType<Ref<HTMLTableRowElement | null>>;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    virtualCell: {
+        type: PropType<MVT_VirtualItem>;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    cell: {
+        type: PropType<MVT_Cell<MVT_RowData>>;
+        required: true;
+    };
+    numRows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    renderedColumnIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    renderedRowIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rowRef: {
+        type: PropType<Ref<HTMLTableRowElement | null>>;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    virtualCell: {
+        type: PropType<MVT_VirtualItem>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    rowRef: Ref<HTMLTableRowElement | null, HTMLTableRowElement | null>;
+    renderedRowIndex: number;
+    renderedColumnIndex: number;
+    numRows: number;
+    virtualCell: import("@tanstack/virtual-core").VirtualItem;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const Memo_MVT_TableBodyCell: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    cell: {
+        type: PropType<MVT_Cell<MVT_RowData>>;
+        required: true;
+    };
+    numRows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    renderedColumnIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    renderedRowIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rowRef: {
+        type: PropType<Ref<HTMLTableRowElement | null>>;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    virtualCell: {
+        type: PropType<MVT_VirtualItem>;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    cell: {
+        type: PropType<MVT_Cell<MVT_RowData>>;
+        required: true;
+    };
+    numRows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    renderedColumnIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    renderedRowIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rowRef: {
+        type: PropType<Ref<HTMLTableRowElement | null>>;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    virtualCell: {
+        type: PropType<MVT_VirtualItem>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    rowRef: Ref<HTMLTableRowElement | null, HTMLTableRowElement | null>;
+    renderedRowIndex: number;
+    renderedColumnIndex: number;
+    numRows: number;
+    virtualCell: import("@tanstack/virtual-core").VirtualItem;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/components/body/MVT_TableBodyCellValue.d.ts

@@ -0,0 +1,40 @@
+import { type PropType } from 'vue';
+import { type MVT_Cell, type MVT_RowData, type MVT_TableInstance } from '../../types';
+export declare const MVT_TableBodyCellValue: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    cell: {
+        type: PropType<MVT_Cell<MVT_RowData>>;
+        required: true;
+    };
+    renderedColumnIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    renderedRowIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+}>, () => import("vue").VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    cell: {
+        type: PropType<MVT_Cell<MVT_RowData>>;
+        required: true;
+    };
+    renderedColumnIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    renderedRowIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    renderedRowIndex: number;
+    renderedColumnIndex: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/components/body/MVT_TableBodyEmptyRow.d.ts

@@ -0,0 +1,42 @@
+import { type PropType } from 'vue';
+import { type MVT_ColumnVirtualizer, type MVT_RowData, type MVT_TableInstance } from '../../types';
+export declare const MVT_TableBodyEmptyRow: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    columnVirtualizer: {
+        type: PropType<MVT_ColumnVirtualizer>;
+        default: undefined;
+    };
+    numRows: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    tableProps: {
+        type: PropType<Record<string, any>>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    columnVirtualizer: {
+        type: PropType<MVT_ColumnVirtualizer>;
+        default: undefined;
+    };
+    numRows: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    tableProps: {
+        type: PropType<Record<string, any>>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    numRows: number;
+    columnVirtualizer: MVT_ColumnVirtualizer;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/components/body/MVT_TableBodyRow.d.ts

@@ -0,0 +1,170 @@
+import { type PropType } from 'vue';
+import { type MVT_ColumnVirtualizer, type MVT_Row, type MVT_RowData, type MVT_RowVirtualizer, type MVT_TableInstance, type MVT_VirtualItem } from '../../types';
+export declare const MVT_TableBodyRow: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    columnVirtualizer: {
+        type: PropType<MVT_ColumnVirtualizer>;
+        default: undefined;
+    };
+    numRows: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    pinnedRowIds: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    renderedRowIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    row: {
+        type: PropType<MVT_Row<MVT_RowData>>;
+        required: true;
+    };
+    rowVirtualizer: {
+        type: PropType<MVT_RowVirtualizer>;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    tableProps: {
+        type: PropType<Record<string, any>>;
+        required: true;
+    };
+    virtualRow: {
+        type: PropType<MVT_VirtualItem>;
+        default: undefined;
+    };
+}>, () => (false | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | undefined)[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    columnVirtualizer: {
+        type: PropType<MVT_ColumnVirtualizer>;
+        default: undefined;
+    };
+    numRows: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    pinnedRowIds: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    renderedRowIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    row: {
+        type: PropType<MVT_Row<MVT_RowData>>;
+        required: true;
+    };
+    rowVirtualizer: {
+        type: PropType<MVT_RowVirtualizer>;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    tableProps: {
+        type: PropType<Record<string, any>>;
+        required: true;
+    };
+    virtualRow: {
+        type: PropType<MVT_VirtualItem>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    renderedRowIndex: number;
+    numRows: number;
+    rowVirtualizer: MVT_RowVirtualizer;
+    virtualRow: import("@tanstack/virtual-core").VirtualItem;
+    columnVirtualizer: MVT_ColumnVirtualizer;
+    pinnedRowIds: string[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const Memo_MVT_TableBodyRow: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    columnVirtualizer: {
+        type: PropType<MVT_ColumnVirtualizer>;
+        default: undefined;
+    };
+    numRows: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    pinnedRowIds: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    renderedRowIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    row: {
+        type: PropType<MVT_Row<MVT_RowData>>;
+        required: true;
+    };
+    rowVirtualizer: {
+        type: PropType<MVT_RowVirtualizer>;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    tableProps: {
+        type: PropType<Record<string, any>>;
+        required: true;
+    };
+    virtualRow: {
+        type: PropType<MVT_VirtualItem>;
+        default: undefined;
+    };
+}>, () => (false | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | undefined)[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    columnVirtualizer: {
+        type: PropType<MVT_ColumnVirtualizer>;
+        default: undefined;
+    };
+    numRows: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    pinnedRowIds: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    renderedRowIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    row: {
+        type: PropType<MVT_Row<MVT_RowData>>;
+        required: true;
+    };
+    rowVirtualizer: {
+        type: PropType<MVT_RowVirtualizer>;
+        default: undefined;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+    tableProps: {
+        type: PropType<Record<string, any>>;
+        required: true;
+    };
+    virtualRow: {
+        type: PropType<MVT_VirtualItem>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    renderedRowIndex: number;
+    numRows: number;
+    rowVirtualizer: MVT_RowVirtualizer;
+    virtualRow: import("@tanstack/virtual-core").VirtualItem;
+    columnVirtualizer: MVT_ColumnVirtualizer;
+    pinnedRowIds: string[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/components/body/MVT_TableBodyRowGrabHandle.d.ts

@@ -0,0 +1,31 @@
+import { type PropType, type Ref } from 'vue';
+import type { MVT_Row, MVT_RowData, MVT_TableInstance } from '../../types';
+export declare const MVT_TableBodyRowGrabHandle: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    row: {
+        type: PropType<MVT_Row<MVT_RowData>>;
+        required: true;
+    };
+    rowRef: {
+        type: PropType<Ref<HTMLTableRowElement | null>>;
+        required: true;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    row: {
+        type: PropType<MVT_Row<MVT_RowData>>;
+        required: true;
+    };
+    rowRef: {
+        type: PropType<Ref<HTMLTableRowElement | null>>;
+        required: true;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/components/body/MVT_TableBodyRowPinButton.d.ts

@@ -0,0 +1,23 @@
+import { type PropType } from 'vue';
+import type { MVT_Row, MVT_RowData, MVT_TableInstance } from '../../types';
+export declare const MVT_TableBodyRowPinButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    row: {
+        type: PropType<MVT_Row<MVT_RowData>>;
+        required: true;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    row: {
+        type: PropType<MVT_Row<MVT_RowData>>;
+        required: true;
+    };
+    table: {
+        type: PropType<MVT_TableInstance<MVT_RowData>>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;