morghulis 3.1.0 → 3.1.2

package/dist/types/components/table/simple/types.d.ts

@@ -1,184 +1,46 @@
 import type { Component, Ref } from "vue";
-import { type CSSProperties, type VNode } from "vue";
-import { type ElTooltipProps, type Sort, type TreeNode } from "element-plus";
-import { MetaView } from "../../../hooks/use-mata/types";
-import { Orders } from "../../../hooks/use-query/types";
-/**
- * style function
- */
-type RowClassNameFn = (data: {
-    row: any;
-    rowIndex: number;
-}) => string;
-type RowStyleFn = (data: {
-    row: any;
-    rowIndex: number;
-}) => CSSProperties;
-type CellClassNameFn = (data: {
-    row: any;
-    column: any;
-    rowIndex: number;
-    columnIndex: number;
-}) => string;
-type CellStyleFn = (data: {
-    row: any;
-    column: any;
-    rowIndex: number;
-    columnIndex: number;
-}) => CSSProperties;
-type HeaderRowClassNameFn = (data: {
-    row: any;
-    rowIndex: number;
-}) => string;
-type HeaderRowStyleFn = (data: {
-    row: any;
-    rowIndex: number;
-}) => CSSProperties;
-type HeaderCellClassNameFn = (data: {
-    row: any;
-    column: any;
-    rowIndex: number;
-    columnIndex: number;
-}) => string;
-type HeaderCellStyleFn = (data: {
-    row: any;
-    column: any;
-    rowIndex: number;
-    columnIndex: number;
-}) => CSSProperties;
+import { type VNode } from "vue";
+import type { MetaView } from "../../../hooks/use-mata/types";
+import type { DataItem, Orders } from "../../../hooks/use-query/types";
 /**
  * control function
  */
-type RowKeyFn = (row: any) => string;
-type SpanMethodFn = (data: {
-    row: any;
-    column: any;
-    rowIndex: number;
-    columnIndex: number;
-}) => number[] | {
-    rowspan: number;
-    colspan: number;
-} | void;
-type TooltipFormatterFn = (data: {
-    row: any;
-    column: any;
-    cellValue: any;
-}) => VNode | string;
-type SummaryMethodFn = (data: {
+export type SummaryMethodFn = (data: {
     columns: any[];
     data: any[];
 }) => (VNode | string)[];
-type LoadFn = (row: any, treeNode: TreeNode, resolve: (data: any[]) => void) => void;
-export interface TableProps {
+export type MTableProps = {
     data: any[];
-    height?: number | string;
-    maxHeight?: number | string;
-    stripe?: boolean;
-    border?: boolean;
-    size?: '' | 'large' | 'default' | 'small';
-    fit?: boolean;
-    showHeader?: boolean;
-    highlightCurrentRow?: boolean;
-    currentRowKey?: string | number;
-    rowClassName?: RowClassNameFn | string;
-    rowStyle?: RowStyleFn | CSSProperties;
-    cellClassName?: CellClassNameFn | string;
-    cellStyle?: CellStyleFn | CSSProperties;
-    headerRowClassName?: HeaderRowClassNameFn | string;
-    headerRowStyle?: HeaderRowStyleFn | CSSProperties;
-    headerCellClassName?: HeaderCellClassNameFn | string;
-    headerCellStyle?: HeaderCellStyleFn | CSSProperties;
-    rowKey?: RowKeyFn | string;
-    emptyText?: string;
-    defaultExpandAll?: boolean;
-    expandRowKeys?: string[];
-    defaultSort?: Sort;
-    tooltipEffect?: 'dark' | 'light';
-    tooltipOptions?: Pick<ElTooltipProps, 'effect' | 'enterable' | 'hideAfter' | 'offset' | 'placement' | 'popperClass' | 'popperOptions' | 'showAfter' | 'showArrow'>;
-    appendFilterPanelTo?: string;
-    showSummary?: boolean;
-    sumText?: string;
-    summaryMethod?: SummaryMethodFn;
-    spanMethod?: SpanMethodFn;
-    selectOnIndeterminate?: boolean;
-    indent?: number;
-    lazy?: boolean;
-    load?: LoadFn;
-    treeProps?: {
-        hasChildren?: string;
-        children?: string;
-        checkStrictly?: boolean;
-    };
-    tableLayout?: 'fixed' | 'auto';
-    scrollbarAlwaysOn?: boolean;
-    showOverflowTooltip?: boolean;
-    flexible?: boolean;
-    scrollbarTabindex?: string | number;
-    allowDragLastColumn?: boolean;
-    tooltipFormatter?: TooltipFormatterFn;
-    preserveExpandedContent?: boolean;
-}
-export type MTableProps = TableProps & {
-    loading?: boolean;
     view: MetaView;
-    orders?: Orders;
     buttons?: MTableButton[];
     columns?: MTableColumn[];
+    rowKey?: string;
+    admin?: boolean;
+    loading?: boolean;
+    tableSize?: '' | 'large' | 'default' | 'small';
+    orders?: Orders;
     sortCallback?: (newIndex: number, oldIndex: number) => void;
     orderCallback?: (prop: string, dir: 1 | -1) => void;
-};
-export type MTablePopperType = 'meta' | 'search' | 'field' | 'cell' | 'index' | null | undefined;
-export type MTablePopper = {
-    vRef: {
-        getBoundingClientRect: () => {
-            x: number;
-            y: number;
-        };
-    };
-    visible: boolean;
-    type: MTablePopperType;
-    data: any;
-    placement?: 'left' | 'right' | 'top' | 'bottom' | null | string;
-};
-export type MTableButton = {
-    size?: 'default' | 'small' | 'large' | "";
-    handler?: (row: any, event?: Event) => void;
-    title?: string | Function;
-    type?: "success" | "info" | "warning" | "danger" | 'primary' | Function;
-    link?: boolean | Function;
-    plain?: boolean | Function;
-    text?: boolean | Function;
-    round?: boolean | Function;
-    circle?: boolean | Function;
-    disabled?: boolean | Function;
-    dark?: boolean | Function;
-    color?: string | Function;
-    tag?: string | Function;
-    icon?: string | Function;
-    dialog?: Ref;
+    showSummary?: boolean;
+    sumText?: string;
+    summaryMethod?: SummaryMethodFn;
 };
 export type MTableColumn = {
     label: string;
     component: Component;
     width?: string | number;
 };
-export declare const mTablePropsDefaults: {
-    border: boolean;
-    fit: boolean;
-    showHeader: boolean;
-    highlightCurrentRow: boolean;
-    headerCellClassName: string;
-    showOverflowTooltip: boolean;
-};
-export declare const mTableTooltipOptions: {
-    placement: string;
-    popperClass: string;
-    enterable: boolean;
-    effect: string;
-    hideAfter: number;
-    offset: number;
-    popperOptions: {};
-    showAfter: number;
-    showArrow: boolean;
+type MTableButtonTypeFn = (row: DataItem) => "success" | "info" | "warning" | "danger" | 'primary';
+type MTableButtonSizeFn = (row: DataItem) => 'default' | 'small' | 'large' | "";
+type MTableButtonBoolFn = (row: DataItem) => boolean;
+type MTableButtonStrFn = (row: DataItem) => string;
+export type MTableButton = {
+    label?: string;
+    size?: 'default' | 'small' | 'large' | "" | MTableButtonSizeFn;
+    type?: "success" | "info" | "warning" | "danger" | 'primary' | MTableButtonTypeFn;
+    disabled?: boolean | MTableButtonBoolFn;
+    icon?: string | MTableButtonStrFn;
+    dialog?: Ref;
+    handler?: (row: any, event?: Event, btn?: MTableButton) => void;
 };
 export {};

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

@@ -1,11 +1,10 @@
 import type { MetaField, MetaView } from "../../../../hooks/use-mata/types";
 import { Orders } from "../../../../hooks/use-query/types";
 type __VLS_Props = {
+    admin?: boolean;
     view: MetaView;
     field: MetaField;
     orders?: Orders;
-    searchable: boolean;
-    metaEnable: boolean;
 };
 declare var __VLS_14: {};
 type __VLS_Slots = {} & {

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

@@ -1,16 +1,15 @@
-declare const _default: import("vue").DefineComponent<{
-    disabled?: any;
-    selection?: any;
-}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+import { DataItem } from "../../../../hooks/use-query/types";
+type __VLS_Props = {
+    admin?: boolean;
+    selection: DataItem[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     check: (...args: any[]) => void;
     meta: (...args: any[]) => void;
     uncheck: (...args: any[]) => void;
-}, string, import("vue").PublicProps, Readonly<{
-    disabled?: any;
-    selection?: any;
-}> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onCheck?: ((...args: any[]) => any) | undefined;
     onMeta?: ((...args: any[]) => any) | undefined;
     onUncheck?: ((...args: any[]) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/types/components/table/upload/DTableUpload.vue.d.ts

@@ -0,0 +1,11 @@
+import { MetaView } from "../../../hooks/use-mata/types";
+type __VLS_Props = {
+    admin?: boolean;
+    view: MetaView;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    confirm: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onConfirm?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/components/table/upload/control/DTableUploadActivator.vue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    output: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onOutput?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/table/upload/control/DTableUploadButtons.vue.d.ts

@@ -0,0 +1,12 @@
+declare const _default: import("vue").DefineComponent<{
+    data?: any;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    clear: (...args: any[]) => void;
+    confirm: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<{
+    data?: any;
+}> & Readonly<{
+    onClear?: ((...args: any[]) => any) | undefined;
+    onConfirm?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/table/{simple/buttons/MTableButtons.vue.d.ts → upload/control/DTableUploadController.vue.d.ts}

@@ -1,14 +1,16 @@
-import { MTableButton } from "../types";
+import { MetaView } from "../../../../hooks/use-mata/types";
 import { DataItem } from "../../../../hooks/use-query/types";
 type __VLS_Props = {
-    buttons: MTableButton[];
-    item: DataItem;
+    admin?: boolean;
+    view: MetaView;
+    data: DataItem[];
+    useKey: boolean;
 };
 declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    click: (...args: any[]) => void;
-    width: (...args: any[]) => void;
+    view: (...args: any[]) => void;
+    "update:useKey": (...args: any[]) => void;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onClick?: ((...args: any[]) => any) | undefined;
-    onWidth?: ((...args: any[]) => any) | undefined;
+    onView?: ((...args: any[]) => any) | undefined;
+    "onUpdate:useKey"?: ((...args: any[]) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/types/components/table/upload/types.d.ts

@@ -0,0 +1,5 @@
+export type UploadParam = {
+    type: 'upload' | 'update';
+    hasId: boolean;
+    hasSort: boolean;
+};

package/dist/types/components/table/virtual/VTable.vue.d.ts

@@ -2,11 +2,33 @@ import { DataItem } from "../../../hooks/use-query/types";
 import { MetaView } from "../../../hooks/use-mata/types";
 import { MTableButton, MTableColumn } from "../simple/types";
 type __VLS_Props = {
+    loading?: boolean;
     title?: string;
     data: DataItem[];
     view: MetaView;
     buttons?: MTableButton[];
     columns?: MTableColumn[];
 };
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare function getSelection(): any;
+declare var __VLS_7: {}, __VLS_9: {}, __VLS_11: {}, __VLS_13: {}, __VLS_15: {};
+type __VLS_Slots = {} & {
+    empty?: (props: typeof __VLS_7) => any;
+} & {
+    header?: (props: typeof __VLS_9) => any;
+} & {
+    'header-tool'?: (props: typeof __VLS_11) => any;
+} & {
+    'header-cell'?: (props: typeof __VLS_13) => any;
+} & {
+    cell?: (props: typeof __VLS_15) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    getSelection: typeof getSelection;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & 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/components/tree/data/DTree.vue.d.ts

@@ -0,0 +1,6 @@
+import { DTreeProps } from "./types";
+declare const _default: import("vue").DefineComponent<DTreeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DTreeProps> & Readonly<{}>, {
+    root: number;
+    labelKey: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/components/tree/data/hook.d.ts

@@ -0,0 +1,109 @@
+import { Ref } from "vue";
+import { DTreeProps } from "./types";
+import { TreeItem, TreeMapping } from "../../../hooks/use-query/types";
+import { MetaView } from "../../../hooks/use-mata/types";
+export declare function useDTree(tree: Ref, props: DTreeProps): {
+    status: {
+        loading: boolean;
+        payload: any;
+    };
+    selection: import("vue").ComputedRef<any[]>;
+    options: Ref<{
+        [x: string]: any;
+        pid: number | string;
+        isLeaf: boolean;
+        children: /*elided*/ any[];
+        id?: import("../../../hooks/use-query/types").DataItemId | undefined;
+    }[], TreeItem[] | {
+        [x: string]: any;
+        pid: number | string;
+        isLeaf: boolean;
+        children: /*elided*/ any[];
+        id?: import("../../../hooks/use-query/types").DataItemId | undefined;
+    }[]>;
+    mapping: Ref<TreeMapping, TreeMapping>;
+    view: Ref<{
+        id?: number | undefined;
+        fields?: {
+            [key: string]: import("../../../hooks/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("../../../hooks/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;
+    }>;
+    config: Ref<{
+        includes?: {
+            [x: string]: any;
+            id?: import("../../../hooks/use-query/types").DataItemId | undefined;
+        } | undefined;
+        excludes?: {
+            [x: string]: any;
+            id?: import("../../../hooks/use-query/types").DataItemId | undefined;
+        } | undefined;
+        orders?: import("../../../hooks/use-query/types").Orders | undefined;
+        page?: number | undefined;
+        size?: number | undefined;
+        root?: number | undefined;
+        finder?: import("../../../hooks/use-query/types").Finder | undefined;
+    }, import("../../../hooks/use-query/types").QueryConfig | {
+        includes?: {
+            [x: string]: any;
+            id?: import("../../../hooks/use-query/types").DataItemId | undefined;
+        } | undefined;
+        excludes?: {
+            [x: string]: any;
+            id?: import("../../../hooks/use-query/types").DataItemId | undefined;
+        } | undefined;
+        orders?: import("../../../hooks/use-query/types").Orders | undefined;
+        page?: number | undefined;
+        size?: number | undefined;
+        root?: number | undefined;
+        finder?: import("../../../hooks/use-query/types").Finder | undefined;
+    }>;
+    query: import("vue").ComputedRef<import("../../../hooks/use-query/types").Query>;
+    meta: import("vue").ComputedRef<import("../../../hooks/use-mata/types").Meta>;
+    load: () => void;
+    reload: () => void;
+    save_many: (array: import("../../../hooks/use-query/types").DataItem[]) => void;
+    delete_one: (id: string | number) => Promise<boolean>;
+};

package/dist/types/components/tree/data/slots/DTreePop.vue.d.ts

@@ -0,0 +1,8 @@
+import { TreeItem } from "../../../../hooks/use-query/types";
+import { MetaView } from "../../../../hooks/use-mata/types";
+type __VLS_Props = {
+    data: TreeItem | MetaView;
+    type: 'index' | 'meta';
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/components/tree/data/types.d.ts

@@ -0,0 +1,10 @@
+import { QueryConfig } from "../../../hooks/use-query/types";
+import { Meta } from "../../../hooks/use-mata/types";
+import { MTableButton } from "../../table/simple/types";
+export type DTreeProps = {
+    buttons?: MTableButton[];
+    labelKey?: string;
+    treeSize?: '' | 'large' | 'default' | 'small';
+    accordion?: boolean;
+    expandAll?: boolean;
+} & QueryConfig & Meta;

package/dist/types/components/tree/simple/MTree.vue.d.ts

@@ -0,0 +1,31 @@
+import { MTreeProps } from "./types";
+declare function getSelection(): any[];
+declare var __VLS_14: {}, __VLS_16: {}, __VLS_26: {}, __VLS_28: {}, __VLS_30: {
+    type: import("../../wrapper/types.js").MWrapperPopperType;
+    data: any;
+};
+type __VLS_Slots = {} & {
+    header?: (props: typeof __VLS_14) => any;
+} & {
+    'header-tool'?: (props: typeof __VLS_16) => any;
+} & {
+    footer?: (props: typeof __VLS_26) => any;
+} & {
+    'footer-tool'?: (props: typeof __VLS_28) => any;
+} & {
+    pop?: (props: typeof __VLS_30) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<MTreeProps, {
+    setSelection: (keys: any[]) => void;
+    getSelection: typeof getSelection;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MTreeProps> & Readonly<{}>, {
+    labelKey: string;
+    nodeKey: string;
+}, {}, {}, {}, 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/components/tree/simple/hook.d.ts

@@ -0,0 +1,21 @@
+import { Ref } from "vue";
+import { MTreeProps } from "./types";
+import { TreeItem } from "../../../hooks/use-query/types";
+import { TreeNode } from "../types";
+export declare function useMTree(tree: Ref, wrapper: Ref, props: MTreeProps): {
+    text: Ref<string, string>;
+    selection: Ref<any[], any[]>;
+    toggleExpandAll: (expanded: boolean) => void;
+    handleClick: (data: TreeItem, node: TreeNode, _: any, event: Event) => void;
+    setSelection: (keys: any[]) => void;
+    handleSelect: (data: TreeItem, info: {
+        checkedNodes: TreeItem[];
+    }) => void;
+    handleCollapse: (data: TreeItem, node: TreeNode) => void;
+    allow_drag: () => boolean;
+    allow_drop: (draggingNode: TreeNode, dropNode: TreeNode, type: "prev" | "inner" | "next") => boolean;
+    handleNodeDrop: (draggingNode: TreeNode, dropNode: TreeNode, dropType: "before" | "after" | "inner", event: Event) => void;
+    handleContextmenu: (event: PointerEvent, data: TreeItem) => void;
+    handleFilter: (value: string, data: any, node: any) => boolean;
+    toggleAllSelection: (flag: boolean) => void;
+};

package/dist/types/components/tree/simple/tool.d.ts

@@ -0,0 +1,4 @@
+export declare const mTreePropsDefaults: {
+    nodeKey: string;
+    labelKey: string;
+};

package/dist/types/components/tree/simple/types.d.ts

@@ -0,0 +1,18 @@
+import { MTableButton } from "../../table/simple/types";
+import { TreeItem, TreeMapping } from "../../../hooks/use-query/types";
+import { MetaView } from "../../../hooks/use-mata/types";
+export type MTreeProps = {
+    data: TreeItem[];
+    root: string | number;
+    view: MetaView;
+    mapping: TreeMapping;
+    buttons?: MTableButton[];
+    nodeKey?: string;
+    labelKey?: string;
+    admin?: boolean;
+    loading?: boolean;
+    sortCallback?: Function;
+    treeSize?: '' | 'large' | 'default' | 'small';
+    accordion?: boolean;
+    expandAll?: boolean;
+};

package/dist/types/components/tree/simple/widgets/MTreeExpand.vue.d.ts

@@ -0,0 +1,12 @@
+type __VLS_Props = {
+    admin?: boolean;
+    selection: any[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    meta: (...args: any[]) => void;
+    expand: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onMeta?: ((...args: any[]) => any) | undefined;
+    onExpand?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/components/tree/simple/widgets/MTreeIcon.vue.d.ts

@@ -0,0 +1,11 @@
+import { TreeItem } from "../../../../hooks/use-query/types";
+import { TreeNode } from "../../types";
+type __VLS_Props = {
+    data: TreeItem;
+    node: TreeNode;
+    selection: any[];
+    labelKey: string;
+    text: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/components/tree/tool.d.ts

@@ -0,0 +1,7 @@
+import { TreeItem, TreeMapping } from "../../hooks/use-query/types";
+export declare function listToTree(nodes: TreeItem[], root_id?: number): {
+    options: TreeItem[];
+    mapping: TreeMapping;
+    root_name: any;
+    root: TreeItem;
+};

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

@@ -0,0 +1,20 @@
+import { TreeItem, TreeMapping } from "../../hooks/use-query/types";
+export type TreeNode = {
+    expanded: boolean;
+    data: TreeItem;
+    childNodes: TreeNode[];
+    checked: boolean;
+    isLeaf: boolean;
+    id: string | number;
+    indeterminate: boolean;
+    canFocus: boolean;
+};
+export declare class TreeModel {
+    nodes: TreeItem[];
+    root_id: number | string;
+    root: TreeItem;
+    options: TreeItem[];
+    root_name: string;
+    mapping: TreeMapping;
+    constructor(nodes: TreeItem[], root_id?: number);
+}

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

@@ -0,0 +1,33 @@
+import { MWrapperPopperType } from "./types";
+type __VLS_Props = {
+    loading?: boolean;
+};
+declare function showPopover(event: PointerEvent, type: MWrapperPopperType, data?: any, placement?: string): void;
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_9: {}, __VLS_15: {
+    type: MWrapperPopperType;
+    data: any;
+};
+type __VLS_Slots = {} & {
+    header?: (props: typeof __VLS_1) => any;
+} & {
+    'header-tool'?: (props: typeof __VLS_3) => any;
+} & {
+    default?: (props: typeof __VLS_5) => any;
+} & {
+    footer?: (props: typeof __VLS_7) => any;
+} & {
+    'footer-tool'?: (props: typeof __VLS_9) => any;
+} & {
+    pop?: (props: typeof __VLS_15) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    showPopover: typeof showPopover;
+    closePopover: () => boolean;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & 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;
+    };
+};