morghulis 3.1.0 → 3.1.2

package/dist/types/components/wrapper/types.d.ts

@@ -0,0 +1 @@
+export type MWrapperPopperType = 'meta' | 'search' | 'field' | 'cell' | 'index';

package/dist/types/hooks/use-admin/index.d.ts

@@ -0,0 +1,4 @@
+export declare function useAdmin(): {
+    isAdmin: import("vue").Ref<boolean, boolean>;
+    admin: import("vue").Ref<boolean, boolean>;
+};

package/dist/types/hooks/use-channel/index.d.ts

@@ -1,5 +1,10 @@
-import { MorghulisChannelConfig, MorghulisChannelSimple } from "./types";
-export declare function useMChannel(auth?: boolean): {
-    register: (handler: string, channel?: MorghulisChannelConfig, socketURL?: string) => MorghulisChannelSimple;
-    getChannel: (handler: string) => MorghulisChannelSimple;
+import { Ref } from "vue";
+import { ChannelParam } from "./types";
+export declare function useMChannel(param: Ref<ChannelParam>, auth?: boolean): {
+    activate: (data: any) => void;
+    channels: import("./types").ChannelContainer;
+    status: {
+        loading: boolean;
+        payload: any;
+    };
 };

package/dist/types/hooks/use-channel/types.d.ts

@@ -1,22 +1,41 @@
-import { Ref } from "vue";
-export type MorghulisChannelConfig = {
+import { Reactive } from "vue";
+import { AxiosInstance } from "axios";
+export type ChannelConfig = {
+    url?: string;
     onStart?: () => void;
     onStop?: () => void;
     onProceed?: (payload: any) => void;
 };
-export type MorghulisChannelSimple = {
-    loading: Ref<boolean>;
-    payload: Ref<any>;
-    activate: (body: any) => void;
+export type ChannelParam = {
+    handlerKey: string;
+    channelKey: string;
+    config: ChannelConfig;
 };
-export type MorghulisChannel = {
-    payload: Ref<any>;
-    loading: Ref<boolean>;
-    activate: (body: any) => void;
-    $start: () => void;
-    $stop: () => void;
-    $proceed: (payload: any) => void;
-};
-export type MorghulisChannels = {
-    [key: string]: MorghulisChannel;
+export type ChannelStatus = {
+    loading: boolean;
+    payload: any;
 };
+/**
+ * handler is just the entity
+ */
+export declare class ChannelContainer {
+    container: {
+        [handlerKey: string]: {
+            [channelKey: string]: Channel;
+        };
+    };
+    constructor();
+    getChannel(handlerKey: string, channelKey: string): Channel;
+    destroy(handlerKey: string, channelKey: string): void;
+    register(handlerKey: string, channelKey: string | undefined, config: ChannelConfig, status: Reactive<ChannelStatus>): void;
+    execute(request: AxiosInstance, handlerKey: string, channelKey: string, data: any): void;
+}
+export declare class Channel {
+    config: ChannelConfig;
+    private status;
+    constructor(config: ChannelConfig, status: Reactive<ChannelStatus>);
+    ready(loading?: boolean, payload?: any): void;
+    start(): void;
+    stop(): void;
+    proceed(data: any): void;
+}

package/dist/types/hooks/use-dao/index.d.ts

@@ -1,20 +1,169 @@
 import { type Ref } from "vue";
 import { type Meta, MetaView } from "../use-mata/types";
-import { MorghulisChannelConfig } from "../use-channel/types";
-import { DataItem, IQuery, Query } from "../use-query/types";
-export declare function useDao(meta: Meta, auth?: boolean): {
+import { ChannelConfig } from "../use-channel/types";
+import { DataItem, DataItemId, IQuery, Query, QueryConfig, QueryInfo, TreeItem, TreeMapping } from "../use-query/types";
+import { TreeModel } from "../../components/tree/types";
+export type QueryDaoParams = {
+    isTree?: boolean;
+    callback: (ids?: DataItemId[]) => void;
+};
+export declare function useQueryDao(props: QueryConfig & Meta, selection: Ref<any[]>, params: QueryDaoParams): {
+    isAdmin: Ref<boolean, boolean>;
+    admin: Ref<boolean, boolean>;
+    config: Ref<{
+        includes?: {
+            [x: string]: any;
+            id?: DataItemId | undefined;
+        } | undefined;
+        excludes?: {
+            [x: string]: any;
+            id?: DataItemId | undefined;
+        } | undefined;
+        orders?: import("../use-query/types").Orders | undefined;
+        page?: number | undefined;
+        size?: number | undefined;
+        root?: number | undefined;
+        finder?: import("../use-query/types").Finder | undefined;
+    }, QueryConfig | {
+        includes?: {
+            [x: string]: any;
+            id?: DataItemId | undefined;
+        } | undefined;
+        excludes?: {
+            [x: string]: any;
+            id?: DataItemId | undefined;
+        } | undefined;
+        orders?: import("../use-query/types").Orders | undefined;
+        page?: number | undefined;
+        size?: number | undefined;
+        root?: number | undefined;
+        finder?: import("../use-query/types").Finder | undefined;
+    }>;
+    query: import("vue").ComputedRef<Query>;
+    meta: import("vue").ComputedRef<Meta>;
+    switchAdmin: () => void;
+    load: () => void;
+    reload: () => void;
+    status: {
+        loading: boolean;
+        payload: any;
+    };
+    find_many: (query: Query | IQuery, code?: string) => Promise<{
+        results: DataItem[];
+        total?: number;
+    }>;
+    save_one: (item: DataItem) => Promise<{
+        item: DataItem;
+    }>;
+    delete_one: (id: string | number) => Promise<boolean>;
+    find_one: (id: string | number) => Promise<{
+        item: DataItem;
+    }>;
+    delete_many: (query: Query | IQuery) => Promise<boolean>;
+    update_many: (query: Query | IQuery, template: DataItem) => Promise<boolean>;
+    load_view: (code?: string) => Promise<MetaView>;
+    save_many: (array: DataItem[]) => void;
+    find_tree: (query: Query | IQuery) => Promise<TreeModel>;
+    view: Ref<{
+        id?: number | undefined;
+        fields?: {
+            [key: string]: import("../use-mata/types").MetaField;
+        } | undefined;
+        entity?: string | undefined;
+        code?: string | undefined;
+        meta_name?: string | undefined;
+        view_name?: string | undefined;
+        form_width?: number | undefined;
+        form_height?: number | undefined;
+        table_width?: number | undefined;
+        table_height?: number | undefined;
+        enable?: boolean | undefined;
+        show_header?: boolean | undefined;
+        allow_batch?: boolean | undefined;
+        allow_search?: boolean | undefined;
+        allow_sort?: boolean | undefined;
+        allow_pop?: boolean | undefined;
+        allow_insert?: boolean | undefined;
+        allow_edit?: boolean | undefined;
+        allow_remove?: boolean | undefined;
+        allow_download?: boolean | undefined;
+        allow_upload?: boolean | undefined;
+    }, MetaView | {
+        id?: number | undefined;
+        fields?: {
+            [key: string]: import("../use-mata/types").MetaField;
+        } | undefined;
+        entity?: string | undefined;
+        code?: string | undefined;
+        meta_name?: string | undefined;
+        view_name?: string | undefined;
+        form_width?: number | undefined;
+        form_height?: number | undefined;
+        table_width?: number | undefined;
+        table_height?: number | undefined;
+        enable?: boolean | undefined;
+        show_header?: boolean | undefined;
+        allow_batch?: boolean | undefined;
+        allow_search?: boolean | undefined;
+        allow_sort?: boolean | undefined;
+        allow_pop?: boolean | undefined;
+        allow_insert?: boolean | undefined;
+        allow_edit?: boolean | undefined;
+        allow_remove?: boolean | undefined;
+        allow_download?: boolean | undefined;
+        allow_upload?: boolean | undefined;
+    }>;
+    results: Ref<{
+        [x: string]: any;
+        id?: DataItemId | undefined;
+    }[], DataItem[] | {
+        [x: string]: any;
+        id?: DataItemId | undefined;
+    }[]>;
+    info: Ref<{
+        current: number;
+        total: number;
+    }, QueryInfo | {
+        current: number;
+        total: number;
+    }>;
+    options: Ref<{
+        [x: string]: any;
+        pid: number | string;
+        isLeaf: boolean;
+        children: /*elided*/ any[];
+        id?: DataItemId | undefined;
+    }[], TreeItem[] | {
+        [x: string]: any;
+        pid: number | string;
+        isLeaf: boolean;
+        children: /*elided*/ any[];
+        id?: DataItemId | undefined;
+    }[]>;
+    mapping: Ref<TreeMapping, TreeMapping>;
+    remove: () => void;
+    clip: () => void;
+    clone: () => void;
+    collect: (callback: (item: DataItem) => void) => void;
+};
+export declare function useDao(meta: Meta, channelConfig?: ChannelConfig): {
+    channels: import("../use-channel/types").ChannelContainer;
     meta: Ref<{
         db: import("../use-mata/types").MetaDatabase;
         entity: string;
         code?: string | undefined;
+        lock?: boolean | undefined;
     }, Meta | {
         db: import("../use-mata/types").MetaDatabase;
         entity: string;
         code?: string | undefined;
+        lock?: boolean | undefined;
     }>;
-    loading: import("vue").ComputedRef<boolean>;
-    payload: Ref<any, any>;
-    find_many: (query: Query | IQuery) => Promise<{
+    status: {
+        loading: boolean;
+        payload: any;
+    };
+    find_many: (query: Query | IQuery, code?: string) => Promise<{
         results: DataItem[];
         total?: number;
     }>;
@@ -27,16 +176,21 @@ export declare function useDao(meta: Meta, auth?: boolean): {
     }>;
     delete_many: (query: Query | IQuery) => Promise<boolean>;
     update_many: (query: Query | IQuery, template: DataItem) => Promise<boolean>;
-    load_view: () => Promise<MetaView>;
+    load_view: (code?: string) => Promise<MetaView>;
     save_many: (array: DataItem[]) => void;
+    find_tree: (query: Query | IQuery) => Promise<TreeModel>;
 };
 /**
  * http和socket的loading冲突问题
  */
-export declare function useMDao(meta: Ref<Meta>, channelConfig?: MorghulisChannelConfig, auth?: boolean): {
-    loading: import("vue").ComputedRef<boolean>;
-    payload: Ref<any, any>;
-    find_many: (query: Query | IQuery) => Promise<{
+export declare function useMDao(meta: Ref<Meta>, channelConfig?: ChannelConfig, auth?: boolean): {
+    find_tree: (query: Query | IQuery) => Promise<TreeModel>;
+    channels: import("../use-channel/types").ChannelContainer;
+    status: {
+        loading: boolean;
+        payload: any;
+    };
+    find_many: (query: Query | IQuery, code?: string) => Promise<{
         results: DataItem[];
         total?: number;
     }>;
@@ -49,6 +203,6 @@ export declare function useMDao(meta: Ref<Meta>, channelConfig?: MorghulisChanne
     }>;
     delete_many: (query: Query | IQuery) => Promise<boolean>;
     update_many: (query: Query | IQuery, template: DataItem) => Promise<boolean>;
-    load_view: () => Promise<MetaView>;
+    load_view: (code?: string) => Promise<MetaView>;
     save_many: (array: DataItem[]) => void;
 };

package/dist/types/hooks/use-dao/tool.d.ts

@@ -0,0 +1,2 @@
+import { MetaView } from "../use-mata/types";
+export declare function viewAuth(view: MetaView, admin?: boolean): void;

package/dist/types/hooks/use-dao/types.d.ts

@@ -1,10 +1,10 @@
 import { DataItem, Query } from "../use-query/types";
 import { MetaView } from "../use-mata/types";
 import { ComputedRef } from "vue";
-import { MorghulisChannelConfig } from "../use-channel/types";
+import { ChannelConfig } from "../use-channel/types";
 export type DaoConfig = {
     auth?: boolean;
-    channel: MorghulisChannelConfig;
+    channel: ChannelConfig;
 };
 export type DaoPayload = {
     results: DataItem[];

package/dist/types/hooks/use-mata/types.d.ts

@@ -3,6 +3,7 @@ export type Meta = {
     db: MetaDatabase;
     entity: string;
     code?: string;
+    lock?: boolean;
 };
 export type MetaView = {
     id?: number;
@@ -36,30 +37,32 @@ export type NumberField = 'IntegerField' | 'FloatField' | 'BigIntegerField' | 'D
 export type DateField = 'DateField' | 'DateTimeField' | 'TimeField';
 export type SpecialField = 'JSONField' | 'FileField';
 export type ReadonlyField = 'UUIDField' | 'BigAutoField' | 'Custom';
+export type MetaFieldDomain = SimpleField | ManyField | RefField | SpecialField | ReadonlyField | NumberField | DateField;
 export type MetaField = {
+    id?: string | number;
     prop?: string;
     label?: string;
     name?: string;
-    domain?: SimpleField | ManyField | RefField | SpecialField | ReadonlyField | NumberField | DateField;
+    domain?: MetaFieldDomain;
     tool?: string;
     refer?: MetaRefer;
     format?: MetaFormat;
     unit?: string | null;
+    align?: 'left' | 'center' | 'right';
+    fixed?: '' | 'left' | 'right';
+    header_color?: string | null;
+    cell_color?: string | null;
+    span?: number;
+    column_width?: number;
     not_null?: boolean;
-    read_only?: boolean;
-    sortable?: boolean;
+    allow_sort?: boolean;
+    allow_edit?: boolean;
     allow_search?: boolean;
     allow_download?: boolean;
     allow_upload?: boolean;
     allow_update?: boolean;
-    column_width?: number;
-    align?: 'left' | 'center' | 'right';
-    fixed?: '' | 'left' | 'right';
-    header_color?: string | null;
-    cell_color?: string | null;
     edit_on_table?: boolean;
     hide_on_table?: boolean;
-    span?: number;
     hide_on_form?: boolean;
     hide_on_form_edit?: boolean;
     hide_on_form_insert?: boolean;

package/dist/types/hooks/use-morghulis/types.d.ts

@@ -1,5 +1,5 @@
 import { Ref } from "vue";
-import { MorghulisChannels } from "../use-channel/types";
+import { ChannelContainer } from "../use-channel/types";
 export type MorghulisOptions = {
     baseURL?: string;
     minioURL?: string;
@@ -7,6 +7,6 @@ export type MorghulisOptions = {
 export type MorghulisCore = {
     status: Ref<string>;
     open: () => void;
-    channels: MorghulisChannels;
+    channels: ChannelContainer;
     options: MorghulisOptions;
 };

package/dist/types/hooks/use-paster/index.d.ts

@@ -0,0 +1,5 @@
+export declare function usePaster(): {
+    openPaster: (callback: (text: string) => void) => void;
+    pending: import("vue").Ref<boolean, boolean>;
+    getClipboardData: (callback: (text: string) => void) => void;
+};

package/dist/types/hooks/use-paster/tool.d.ts

@@ -0,0 +1,7 @@
+import { Aoa, AoaMap } from "./types";
+import { UploadFile } from "element-plus";
+import { MetaView } from "../use-mata/types";
+import { DataItem } from "../use-query/types";
+export declare function textToAoa(text: string): string[][];
+export declare function excelToAoa(file: UploadFile, callback: (mapping: AoaMap) => void): void;
+export declare function AoaToDataItems(aoa: Aoa, view: MetaView): DataItem[];

package/dist/types/hooks/use-paster/types.d.ts

@@ -0,0 +1,4 @@
+export type Aoa = any[][];
+export type AoaMap = {
+    [name: string]: Aoa;
+};

package/dist/types/hooks/use-query/index.d.ts

@@ -1,3 +1,35 @@
-import { Finder, Query, QueryConfig } from "./types";
-import { ComputedRef, Ref } from "vue";
-export declare function useMQuery(config?: Ref<QueryConfig>, finder?: Ref<Finder>): ComputedRef<Query>;
+import { QueryConfig } from "./types";
+import { Meta } from "../use-mata/types";
+export declare function useQuery(props: QueryConfig & Meta): {
+    config: import("vue").Ref<{
+        includes?: {
+            [x: string]: any;
+            id?: import("./types").DataItemId | undefined;
+        } | undefined;
+        excludes?: {
+            [x: string]: any;
+            id?: import("./types").DataItemId | undefined;
+        } | undefined;
+        orders?: import("./types").Orders | undefined;
+        page?: number | undefined;
+        size?: number | undefined;
+        root?: number | undefined;
+        finder?: import("./types").Finder | undefined;
+    }, QueryConfig | {
+        includes?: {
+            [x: string]: any;
+            id?: import("./types").DataItemId | undefined;
+        } | undefined;
+        excludes?: {
+            [x: string]: any;
+            id?: import("./types").DataItemId | undefined;
+        } | undefined;
+        orders?: import("./types").Orders | undefined;
+        page?: number | undefined;
+        size?: number | undefined;
+        root?: number | undefined;
+        finder?: import("./types").Finder | undefined;
+    }>;
+    query: import("vue").ComputedRef<import("./types").Query>;
+    meta: import("vue").ComputedRef<Meta>;
+};

package/dist/types/hooks/use-query/tool.d.ts

@@ -1,4 +1,8 @@
-import { Query, SearchParam } from "./types";
+import { DataItem, Query, QueryConfig, SearchParam } from "./types";
+import _ from "lodash";
 import { MetaView } from "../use-mata/types";
-export declare function queryFinder(query: Query, view: MetaView): void;
+export declare function transformQuery(config?: QueryConfig): Query;
+export declare function clearCondition(cond?: DataItem): _.Omit<DataItem, string>;
+export declare function getTemplate(includes?: DataItem): Pick<DataItem, string>;
+export declare function convertQuery(query: Query, view: MetaView): Query;
 export declare function checkFinder(param: SearchParam): boolean;

package/dist/types/hooks/use-query/types.d.ts

@@ -2,7 +2,15 @@ export type DataItem = {
     id?: DataItemId;
     [key: string]: any;
 };
-type DataItemId = string | number;
+export type TreeItem = {
+    pid: number | string;
+    isLeaf: boolean;
+    children: TreeItem[];
+} & DataItem;
+export type TreeMapping = {
+    [id: string | number]: TreeItem;
+};
+export type DataItemId = string | number;
 export type Orders = {
     [key: string]: 1 | -1;
 };
@@ -10,12 +18,18 @@ export type Condition = {
     includes?: DataItem;
     excludes?: DataItem;
 };
+export type QueryInfo = {
+    current: number;
+    total: number;
+};
 export type QueryConfig = {
     includes?: DataItem;
     excludes?: DataItem;
     orders?: Orders;
     page?: number;
     size?: number;
+    root?: number;
+    finder?: Finder;
 };
 export type Query = {
     condition: Condition;
@@ -25,6 +39,7 @@ export type Query = {
     template: DataItem;
     search: Condition[];
     finder: Finder;
+    root?: number;
 };
 export type IQuery = {
     condition?: Condition;
@@ -34,6 +49,7 @@ export type IQuery = {
     template?: DataItem;
     search?: Condition[];
     finder?: Finder;
+    root?: number;
 };
 export type Finder = {
     [key: string]: SearchParam;
@@ -45,4 +61,3 @@ export type SearchParam = {
     suffix: 'contains' | 'exact' | 'startswith' | 'endswith' | 'gt' | 'lt' | 'isnull';
     value: any;
 };
-export {};

package/dist/types/hooks/use-sortable/index.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from "vue";
+import { MTableProps } from "../../components/table/simple/types";
+export declare function useTableSortable(table: Ref, props: MTableProps): void;

package/dist/types/index.d.ts

@@ -4,15 +4,17 @@ import { useMRequest } from "./hooks/use-request";
 import { useMChannel } from "./hooks/use-channel";
 import { useMSockets } from "./hooks/use-socket";
 import { MorghulisOptions } from "./hooks/use-morghulis/types";
-import type { MorghulisChannelConfig } from "./hooks/use-channel/types";
 import MDialog from "./components/dialog/MDialog.vue";
 import MApp from "./MApp.vue";
 import MTable from "./components/table/simple/MTable.vue";
 import DTable from "./components/table/data/DTable.vue";
 import VTable from './components/table/virtual/VTable.vue';
 import MForm from "./components/form/MForm.vue";
+import type { DataItem, Query } from "./hooks/use-query/types";
+import MTree from "./components/tree/simple/MTree.vue";
+import type { MetaField, MetaView } from "./hooks/use-mata/types";
 import type { MTableButton, MTableColumn } from "./components/table/simple/types";
-import type { Query } from "./hooks/use-query/types";
+import type { ChannelConfig } from "./hooks/use-channel/types";
 declare module "vue" {
     interface GlobalComponents {
         MApp: typeof MApp;
@@ -21,9 +23,10 @@ declare module "vue" {
         DTable: typeof DTable;
         VTable: typeof VTable;
         MForm: typeof MForm;
+        MTree: typeof MTree;
     }
 }
 declare const createMorghulis: (options?: MorghulisOptions) => {
     install(Vue: App): void;
 };
-export { MApp, MDialog, MTable, DTable, VTable, MForm, createMorghulis, useMRequest, useMChannel, useMSockets, MorghulisChannelConfig, MTableButton, MTableColumn, Query };
+export { MApp, MDialog, MTable, DTable, VTable, MForm, MTree, createMorghulis, useMRequest, useMChannel, useMSockets, ChannelConfig, MTableButton, MTableColumn, DataItem, Query, MetaView, MetaField };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "morghulis",
-  "version": "3.1.0",
+  "version": "3.1.2",
   "type": "module",
   "files": [
     "dist"
@@ -25,18 +25,20 @@
     "@fortawesome/fontawesome-svg-core": "^6.7.2",
     "@fortawesome/free-solid-svg-icons": "^6.7.2",
     "@fortawesome/vue-fontawesome": "^3.0.8",
+    "@vueuse/core": "^13.1.0",
     "axios": "^1.8.1",
-    "nprogress": "^0.2.0",
-    "sortablejs": "^1.15.6",
     "element-plus": "^2.9.8",
     "js-cookie": "^3.0.5",
-    "vue": "^3.5.13"
+    "nprogress": "^0.2.0",
+    "sortablejs": "^1.15.6",
+    "vue": "^3.5.13",
+    "xlsx": "^0.18.5"
   },
   "devDependencies": {
-    "@types/nprogress": "^0.2.3",
-    "@types/sortablejs": "^1.15.8",
     "@types/js-cookie": "^3.0.6",
     "@types/node": "^22.14.0",
+    "@types/nprogress": "^0.2.3",
+    "@types/sortablejs": "^1.15.8",
     "@vitejs/plugin-vue": "^5.2.3",
     "typescript": "~5.8.0",
     "vite": "^6.2.4",

package/dist/types/components/table/simple/widgets/MTablePopover.vue.d.ts

@@ -1,16 +0,0 @@
-import { MTablePopper } from "../types";
-declare var __VLS_6: {
-    type: import("../types").MTablePopperType;
-    data: any;
-};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_6) => any;
-};
-declare const __VLS_component: import("vue").DefineComponent<MTablePopper, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MTablePopper> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

package/dist/types/hooks/use-channel/tools.d.ts

@@ -1,3 +0,0 @@
-import type { MorghulisChannel, MorghulisChannelConfig } from "./types";
-import { AxiosInstance } from "axios";
-export declare function createChannel(request: AxiosInstance, url: string, channel?: MorghulisChannelConfig): MorghulisChannel;

package/dist/types/hooks/use-table/simple/index.d.ts

@@ -1,40 +0,0 @@
-import { type Ref } from "vue";
-import { MTablePopperType, MTableProps } from "../../../components/table/simple/types";
-export declare function useMTable(table: Ref, props: MTableProps): {
-    handleOrder: (prop: string, dir: 1 | -1) => void;
-    check: (flag: boolean) => void;
-    visible: import("vue").ComputedRef<{
-        popover: {
-            meta: boolean;
-            search: boolean;
-            field: boolean;
-            index: boolean;
-            cell: boolean;
-        };
-        header: boolean;
-        footer: boolean;
-    }>;
-    popover: {
-        vRef: {
-            getBoundingClientRect: () => {
-                x: number;
-                y: number;
-            };
-        };
-        visible: boolean;
-        type: MTablePopperType;
-        data: any;
-        placement?: "left" | "right" | "top" | "bottom" | null | string | undefined;
-    };
-    selection: import("vue").ComputedRef<any>;
-    tableCellClassName: (data: any) => "m-table-cell" | "m-table-index" | "m-table-custom";
-    tableRowClassName: (payload: any) => "" | "m-table-current" | "m-table-highlight";
-    handleCellClick: (row: object, column: any, cell: any, event: any) => void;
-    handleCellContextMenu: (row: any, column: any, cell: any, event: any) => void;
-    showPopover: (event: {
-        clientX: number;
-        clientY: number;
-    }, type: MTablePopperType, data?: any, placement?: string) => void;
-    closePopover: () => boolean;
-    setSelection: (keys: any[]) => void;
-};